1/*
   2 * This file is provided under a dual BSD/GPLv2 license.  When using or
   3 * redistributing this file, you may do so under either license.
   4 *
   5 * GPL LICENSE SUMMARY
   6 *
   7 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
   8 *
   9 * This program is free software; you can redistribute it and/or modify
  10 * it under the terms of version 2 of the GNU General Public License as
  11 * published by the Free Software Foundation.
  12 *
  13 * This program is distributed in the hope that it will be useful, but
  14 * WITHOUT ANY WARRANTY; without even the implied warranty of
  15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 * General Public License for more details.
  17 *
  18 * You should have received a copy of the GNU General Public License
  19 * along with this program; if not, write to the Free Software
  20 * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  21 * The full GNU General Public License is included in this distribution
  22 * in the file called LICENSE.GPL.
  23 *
  24 * BSD LICENSE
  25 *
  26 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
  27 * All rights reserved.
  28 *
  29 * Redistribution and use in source and binary forms, with or without
  30 * modification, are permitted provided that the following conditions
  31 * are met:
  32 *
  33 *   * Redistributions of source code must retain the above copyright
  34 *     notice, this list of conditions and the following disclaimer.
  35 *   * Redistributions in binary form must reproduce the above copyright
  36 *     notice, this list of conditions and the following disclaimer in
  37 *     the documentation and/or other materials provided with the
  38 *     distribution.
  39 *   * Neither the name of Intel Corporation nor the names of its
  40 *     contributors may be used to endorse or promote products derived
  41 *     from this software without specific prior written permission.
  42 *
  43 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  44 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  45 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  46 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  47 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  48 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  49 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  50 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  51 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  52 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  53 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  54 */
  55
  56#include "isci.h"
  57#include "port.h"
  58#include "request.h"
  59
  60#define SCIC_SDS_PORT_HARD_RESET_TIMEOUT  (1000)
  61#define SCU_DUMMY_INDEX    (0xFFFF)
  62
  63#undef C
  64#define C(a) (#a)
  65const char *port_state_name(enum sci_port_states state)
  66{
  67	static const char * const strings[] = PORT_STATES;
  68
  69	return strings[state];
  70}
  71#undef C
  72
  73static struct device *sciport_to_dev(struct isci_port *iport)
  74{
  75	int i = iport->physical_port_index;
  76	struct isci_port *table;
  77	struct isci_host *ihost;
  78
  79	if (i == SCIC_SDS_DUMMY_PORT)
  80		i = SCI_MAX_PORTS+1;
  81
  82	table = iport - i;
  83	ihost = container_of(table, typeof(*ihost), ports[0]);
  84
  85	return &ihost->pdev->dev;
  86}
  87
  88static void sci_port_get_protocols(struct isci_port *iport, struct sci_phy_proto *proto)
  89{
  90	u8 index;
  91
  92	proto->all = 0;
  93	for (index = 0; index < SCI_MAX_PHYS; index++) {
  94		struct isci_phy *iphy = iport->phy_table[index];
  95
  96		if (!iphy)
  97			continue;
  98		sci_phy_get_protocols(iphy, proto);
  99	}
 100}
 101
 102static u32 sci_port_get_phys(struct isci_port *iport)
 103{
 104	u32 index;
 105	u32 mask;
 106
 107	mask = 0;
 108	for (index = 0; index < SCI_MAX_PHYS; index++)
 109		if (iport->phy_table[index])
 110			mask |= (1 << index);
 111
 112	return mask;
 113}
 114
 115/**
 116 * sci_port_get_properties() - This method simply returns the properties
 117 *    regarding the port, such as: physical index, protocols, sas address, etc.
 118 * @port: this parameter specifies the port for which to retrieve the physical
 119 *    index.
 120 * @properties: This parameter specifies the properties structure into which to
 121 *    copy the requested information.
 122 *
 123 * Indicate if the user specified a valid port. SCI_SUCCESS This value is
 124 * returned if the specified port was valid. SCI_FAILURE_INVALID_PORT This
 125 * value is returned if the specified port is not valid.  When this value is
 126 * returned, no data is copied to the properties output parameter.
 127 */
 128enum sci_status sci_port_get_properties(struct isci_port *iport,
 129						struct sci_port_properties *prop)
 130{
 131	if (!iport || iport->logical_port_index == SCIC_SDS_DUMMY_PORT)
 132		return SCI_FAILURE_INVALID_PORT;
 133
 134	prop->index = iport->logical_port_index;
 135	prop->phy_mask = sci_port_get_phys(iport);
 136	sci_port_get_sas_address(iport, &prop->local.sas_address);
 137	sci_port_get_protocols(iport, &prop->local.protocols);
 138	sci_port_get_attached_sas_address(iport, &prop->remote.sas_address);
 139
 140	return SCI_SUCCESS;
 141}
 142
 143static void sci_port_bcn_enable(struct isci_port *iport)
 144{
 145	struct isci_phy *iphy;
 146	u32 val;
 147	int i;
 148
 149	for (i = 0; i < ARRAY_SIZE(iport->phy_table); i++) {
 150		iphy = iport->phy_table[i];
 151		if (!iphy)
 152			continue;
 153		val = readl(&iphy->link_layer_registers->link_layer_control);
 154		/* clear the bit by writing 1. */
 155		writel(val, &iphy->link_layer_registers->link_layer_control);
 156	}
 157}
 158
 159static void isci_port_bc_change_received(struct isci_host *ihost,
 160					 struct isci_port *iport,
 161					 struct isci_phy *iphy)
 162{
 163	dev_dbg(&ihost->pdev->dev,
 164		"%s: isci_phy = %p, sas_phy = %p\n",
 165		__func__, iphy, &iphy->sas_phy);
 166
 167	ihost->sas_ha.notify_port_event(&iphy->sas_phy, PORTE_BROADCAST_RCVD);
 168	sci_port_bcn_enable(iport);
 169}
 170
 171static void isci_port_link_up(struct isci_host *isci_host,
 172			      struct isci_port *iport,
 173			      struct isci_phy *iphy)
 174{
 175	unsigned long flags;
 176	struct sci_port_properties properties;
 177	unsigned long success = true;
 178
 179	dev_dbg(&isci_host->pdev->dev,
 180		"%s: isci_port = %p\n",
 181		__func__, iport);
 182
 183	spin_lock_irqsave(&iphy->sas_phy.frame_rcvd_lock, flags);
 184
 185	sci_port_get_properties(iport, &properties);
 186
 187	if (iphy->protocol == SAS_PROTOCOL_SATA) {
 188		u64 attached_sas_address;
 189
 190		iphy->sas_phy.oob_mode = SATA_OOB_MODE;
 191		iphy->sas_phy.frame_rcvd_size = sizeof(struct dev_to_host_fis);
 192
 193		/*
 194		 * For direct-attached SATA devices, the SCI core will
 195		 * automagically assign a SAS address to the end device
 196		 * for the purpose of creating a port. This SAS address
 197		 * will not be the same as assigned to the PHY and needs
 198		 * to be obtained from struct sci_port_properties properties.
 199		 */
 200		attached_sas_address = properties.remote.sas_address.high;
 201		attached_sas_address <<= 32;
 202		attached_sas_address |= properties.remote.sas_address.low;
 203		swab64s(&attached_sas_address);
 204
 205		memcpy(&iphy->sas_phy.attached_sas_addr,
 206		       &attached_sas_address, sizeof(attached_sas_address));
 207	} else if (iphy->protocol == SAS_PROTOCOL_SSP) {
 208		iphy->sas_phy.oob_mode = SAS_OOB_MODE;
 209		iphy->sas_phy.frame_rcvd_size = sizeof(struct sas_identify_frame);
 210
 211		/* Copy the attached SAS address from the IAF */
 212		memcpy(iphy->sas_phy.attached_sas_addr,
 213		       iphy->frame_rcvd.iaf.sas_addr, SAS_ADDR_SIZE);
 214	} else {
 215		dev_err(&isci_host->pdev->dev, "%s: unknown target\n", __func__);
 216		success = false;
 217	}
 218
 219	iphy->sas_phy.phy->negotiated_linkrate = sci_phy_linkrate(iphy);
 220
 221	spin_unlock_irqrestore(&iphy->sas_phy.frame_rcvd_lock, flags);
 222
 223	/* Notify libsas that we have an address frame, if indeed
 224	 * we've found an SSP, SMP, or STP target */
 225	if (success)
 226		isci_host->sas_ha.notify_port_event(&iphy->sas_phy,
 227						    PORTE_BYTES_DMAED);
 228}
 229
 230
 231/**
 232 * isci_port_link_down() - This function is called by the sci core when a link
 233 *    becomes inactive.
 234 * @isci_host: This parameter specifies the isci host object.
 235 * @phy: This parameter specifies the isci phy with the active link.
 236 * @port: This parameter specifies the isci port with the active link.
 237 *
 238 */
 239static void isci_port_link_down(struct isci_host *isci_host,
 240				struct isci_phy *isci_phy,
 241				struct isci_port *isci_port)
 242{
 243	struct isci_remote_device *isci_device;
 244
 245	dev_dbg(&isci_host->pdev->dev,
 246		"%s: isci_port = %p\n", __func__, isci_port);
 247
 248	if (isci_port) {
 249
 250		/* check to see if this is the last phy on this port. */
 251		if (isci_phy->sas_phy.port &&
 252		    isci_phy->sas_phy.port->num_phys == 1) {
 253			/* change the state for all devices on this port.  The
 254			* next task sent to this device will be returned as
 255			* SAS_TASK_UNDELIVERED, and the scsi mid layer will
 256			* remove the target
 257			*/
 258			list_for_each_entry(isci_device,
 259					    &isci_port->remote_dev_list,
 260					    node) {
 261				dev_dbg(&isci_host->pdev->dev,
 262					"%s: isci_device = %p\n",
 263					__func__, isci_device);
 264				set_bit(IDEV_GONE, &isci_device->flags);
 265			}
 266		}
 267	}
 268
 269	/* Notify libsas of the borken link, this will trigger calls to our
 270	 * isci_port_deformed and isci_dev_gone functions.
 271	 */
 272	sas_phy_disconnected(&isci_phy->sas_phy);
 273	isci_host->sas_ha.notify_phy_event(&isci_phy->sas_phy,
 274					   PHYE_LOSS_OF_SIGNAL);
 275
 276	dev_dbg(&isci_host->pdev->dev,
 277		"%s: isci_port = %p - Done\n", __func__, isci_port);
 278}
 279
 280static bool is_port_ready_state(enum sci_port_states state)
 281{
 282	switch (state) {
 283	case SCI_PORT_READY:
 284	case SCI_PORT_SUB_WAITING:
 285	case SCI_PORT_SUB_OPERATIONAL:
 286	case SCI_PORT_SUB_CONFIGURING:
 287		return true;
 288	default:
 289		return false;
 290	}
 291}
 292
 293/* flag dummy rnc hanling when exiting a ready state */
 294static void port_state_machine_change(struct isci_port *iport,
 295				      enum sci_port_states state)
 296{
 297	struct sci_base_state_machine *sm = &iport->sm;
 298	enum sci_port_states old_state = sm->current_state_id;
 299
 300	if (is_port_ready_state(old_state) && !is_port_ready_state(state))
 301		iport->ready_exit = true;
 302
 303	sci_change_state(sm, state);
 304	iport->ready_exit = false;
 305}
 306
 307/**
 308 * isci_port_hard_reset_complete() - This function is called by the sci core
 309 *    when the hard reset complete notification has been received.
 310 * @port: This parameter specifies the sci port with the active link.
 311 * @completion_status: This parameter specifies the core status for the reset
 312 *    process.
 313 *
 314 */
 315static void isci_port_hard_reset_complete(struct isci_port *isci_port,
 316					  enum sci_status completion_status)
 317{
 318	struct isci_host *ihost = isci_port->owning_controller;
 319
 320	dev_dbg(&ihost->pdev->dev,
 321		"%s: isci_port = %p, completion_status=%x\n",
 322		     __func__, isci_port, completion_status);
 323
 324	/* Save the status of the hard reset from the port. */
 325	isci_port->hard_reset_status = completion_status;
 326
 327	if (completion_status != SCI_SUCCESS) {
 328
 329		/* The reset failed.  The port state is now SCI_PORT_FAILED. */
 330		if (isci_port->active_phy_mask == 0) {
 331			int phy_idx = isci_port->last_active_phy;
 332			struct isci_phy *iphy = &ihost->phys[phy_idx];
 333
 334			/* Generate the link down now to the host, since it
 335			 * was intercepted by the hard reset state machine when
 336			 * it really happened.
 337			 */
 338			isci_port_link_down(ihost, iphy, isci_port);
 339		}
 340		/* Advance the port state so that link state changes will be
 341		 * noticed.
 342		 */
 343		port_state_machine_change(isci_port, SCI_PORT_SUB_WAITING);
 344
 345	}
 346	clear_bit(IPORT_RESET_PENDING, &isci_port->state);
 347	wake_up(&ihost->eventq);
 348
 349}
 350
 351/* This method will return a true value if the specified phy can be assigned to
 352 * this port The following is a list of phys for each port that are allowed: -
 353 * Port 0 - 3 2 1 0 - Port 1 -     1 - Port 2 - 3 2 - Port 3 - 3 This method
 354 * doesn't preclude all configurations.  It merely ensures that a phy is part
 355 * of the allowable set of phy identifiers for that port.  For example, one
 356 * could assign phy 3 to port 0 and no other phys.  Please refer to
 357 * sci_port_is_phy_mask_valid() for information regarding whether the
 358 * phy_mask for a port can be supported. bool true if this is a valid phy
 359 * assignment for the port false if this is not a valid phy assignment for the
 360 * port
 361 */
 362bool sci_port_is_valid_phy_assignment(struct isci_port *iport, u32 phy_index)
 363{
 364	struct isci_host *ihost = iport->owning_controller;
 365	struct sci_user_parameters *user = &ihost->user_parameters;
 366
 367	/* Initialize to invalid value. */
 368	u32 existing_phy_index = SCI_MAX_PHYS;
 369	u32 index;
 370
 371	if ((iport->physical_port_index == 1) && (phy_index != 1))
 372		return false;
 373
 374	if (iport->physical_port_index == 3 && phy_index != 3)
 375		return false;
 376
 377	if (iport->physical_port_index == 2 &&
 378	    (phy_index == 0 || phy_index == 1))
 379		return false;
 380
 381	for (index = 0; index < SCI_MAX_PHYS; index++)
 382		if (iport->phy_table[index] && index != phy_index)
 383			existing_phy_index = index;
 384
 385	/* Ensure that all of the phys in the port are capable of
 386	 * operating at the same maximum link rate.
 387	 */
 388	if (existing_phy_index < SCI_MAX_PHYS &&
 389	    user->phys[phy_index].max_speed_generation !=
 390	    user->phys[existing_phy_index].max_speed_generation)
 391		return false;
 392
 393	return true;
 394}
 395
 396/**
 397 *
 398 * @sci_port: This is the port object for which to determine if the phy mask
 399 *    can be supported.
 400 *
 401 * This method will return a true value if the port's phy mask can be supported
 402 * by the SCU. The following is a list of valid PHY mask configurations for
 403 * each port: - Port 0 - [[3  2] 1] 0 - Port 1 -        [1] - Port 2 - [[3] 2]
 404 * - Port 3 -  [3] This method returns a boolean indication specifying if the
 405 * phy mask can be supported. true if this is a valid phy assignment for the
 406 * port false if this is not a valid phy assignment for the port
 407 */
 408static bool sci_port_is_phy_mask_valid(
 409	struct isci_port *iport,
 410	u32 phy_mask)
 411{
 412	if (iport->physical_port_index == 0) {
 413		if (((phy_mask & 0x0F) == 0x0F)
 414		    || ((phy_mask & 0x03) == 0x03)
 415		    || ((phy_mask & 0x01) == 0x01)
 416		    || (phy_mask == 0))
 417			return true;
 418	} else if (iport->physical_port_index == 1) {
 419		if (((phy_mask & 0x02) == 0x02)
 420		    || (phy_mask == 0))
 421			return true;
 422	} else if (iport->physical_port_index == 2) {
 423		if (((phy_mask & 0x0C) == 0x0C)
 424		    || ((phy_mask & 0x04) == 0x04)
 425		    || (phy_mask == 0))
 426			return true;
 427	} else if (iport->physical_port_index == 3) {
 428		if (((phy_mask & 0x08) == 0x08)
 429		    || (phy_mask == 0))
 430			return true;
 431	}
 432
 433	return false;
 434}
 435
 436/*
 437 * This method retrieves a currently active (i.e. connected) phy contained in
 438 * the port.  Currently, the lowest order phy that is connected is returned.
 439 * This method returns a pointer to a SCIS_SDS_PHY object. NULL This value is
 440 * returned if there are no currently active (i.e. connected to a remote end
 441 * point) phys contained in the port. All other values specify a struct sci_phy
 442 * object that is active in the port.
 443 */
 444static struct isci_phy *sci_port_get_a_connected_phy(struct isci_port *iport)
 445{
 446	u32 index;
 447	struct isci_phy *iphy;
 448
 449	for (index = 0; index < SCI_MAX_PHYS; index++) {
 450		/* Ensure that the phy is both part of the port and currently
 451		 * connected to the remote end-point.
 452		 */
 453		iphy = iport->phy_table[index];
 454		if (iphy && sci_port_active_phy(iport, iphy))
 455			return iphy;
 456	}
 457
 458	return NULL;
 459}
 460
 461static enum sci_status sci_port_set_phy(struct isci_port *iport, struct isci_phy *iphy)
 462{
 463	/* Check to see if we can add this phy to a port
 464	 * that means that the phy is not part of a port and that the port does
 465	 * not already have a phy assinged to the phy index.
 466	 */
 467	if (!iport->phy_table[iphy->phy_index] &&
 468	    !phy_get_non_dummy_port(iphy) &&
 469	    sci_port_is_valid_phy_assignment(iport, iphy->phy_index)) {
 470		/* Phy is being added in the stopped state so we are in MPC mode
 471		 * make logical port index = physical port index
 472		 */
 473		iport->logical_port_index = iport->physical_port_index;
 474		iport->phy_table[iphy->phy_index] = iphy;
 475		sci_phy_set_port(iphy, iport);
 476
 477		return SCI_SUCCESS;
 478	}
 479
 480	return SCI_FAILURE;
 481}
 482
 483static enum sci_status sci_port_clear_phy(struct isci_port *iport, struct isci_phy *iphy)
 484{
 485	/* Make sure that this phy is part of this port */
 486	if (iport->phy_table[iphy->phy_index] == iphy &&
 487	    phy_get_non_dummy_port(iphy) == iport) {
 488		struct isci_host *ihost = iport->owning_controller;
 489
 490		/* Yep it is assigned to this port so remove it */
 491		sci_phy_set_port(iphy, &ihost->ports[SCI_MAX_PORTS]);
 492		iport->phy_table[iphy->phy_index] = NULL;
 493		return SCI_SUCCESS;
 494	}
 495
 496	return SCI_FAILURE;
 497}
 498
 499void sci_port_get_sas_address(struct isci_port *iport, struct sci_sas_address *sas)
 500{
 501	u32 index;
 502
 503	sas->high = 0;
 504	sas->low  = 0;
 505	for (index = 0; index < SCI_MAX_PHYS; index++)
 506		if (iport->phy_table[index])
 507			sci_phy_get_sas_address(iport->phy_table[index], sas);
 508}
 509
 510void sci_port_get_attached_sas_address(struct isci_port *iport, struct sci_sas_address *sas)
 511{
 512	struct isci_phy *iphy;
 513
 514	/*
 515	 * Ensure that the phy is both part of the port and currently
 516	 * connected to the remote end-point.
 517	 */
 518	iphy = sci_port_get_a_connected_phy(iport);
 519	if (iphy) {
 520		if (iphy->protocol != SAS_PROTOCOL_SATA) {
 521			sci_phy_get_attached_sas_address(iphy, sas);
 522		} else {
 523			sci_phy_get_sas_address(iphy, sas);
 524			sas->low += iphy->phy_index;
 525		}
 526	} else {
 527		sas->high = 0;
 528		sas->low  = 0;
 529	}
 530}
 531
 532/**
 533 * sci_port_construct_dummy_rnc() - create dummy rnc for si workaround
 534 *
 535 * @sci_port: logical port on which we need to create the remote node context
 536 * @rni: remote node index for this remote node context.
 537 *
 538 * This routine will construct a dummy remote node context data structure
 539 * This structure will be posted to the hardware to work around a scheduler
 540 * error in the hardware.
 541 */
 542static void sci_port_construct_dummy_rnc(struct isci_port *iport, u16 rni)
 543{
 544	union scu_remote_node_context *rnc;
 545
 546	rnc = &iport->owning_controller->remote_node_context_table[rni];
 547
 548	memset(rnc, 0, sizeof(union scu_remote_node_context));
 549
 550	rnc->ssp.remote_sas_address_hi = 0;
 551	rnc->ssp.remote_sas_address_lo = 0;
 552
 553	rnc->ssp.remote_node_index = rni;
 554	rnc->ssp.remote_node_port_width = 1;
 555	rnc->ssp.logical_port_index = iport->physical_port_index;
 556
 557	rnc->ssp.nexus_loss_timer_enable = false;
 558	rnc->ssp.check_bit = false;
 559	rnc->ssp.is_valid = true;
 560	rnc->ssp.is_remote_node_context = true;
 561	rnc->ssp.function_number = 0;
 562	rnc->ssp.arbitration_wait_time = 0;
 563}
 564
 565/*
 566 * construct a dummy task context data structure.  This
 567 * structure will be posted to the hardwre to work around a scheduler error
 568 * in the hardware.
 569 */
 570static void sci_port_construct_dummy_task(struct isci_port *iport, u16 tag)
 571{
 572	struct isci_host *ihost = iport->owning_controller;
 573	struct scu_task_context *task_context;
 574
 575	task_context = &ihost->task_context_table[ISCI_TAG_TCI(tag)];
 576	memset(task_context, 0, sizeof(struct scu_task_context));
 577
 578	task_context->initiator_request = 1;
 579	task_context->connection_rate = 1;
 580	task_context->logical_port_index = iport->physical_port_index;
 581	task_context->protocol_type = SCU_TASK_CONTEXT_PROTOCOL_SSP;
 582	task_context->task_index = ISCI_TAG_TCI(tag);
 583	task_context->valid = SCU_TASK_CONTEXT_VALID;
 584	task_context->context_type = SCU_TASK_CONTEXT_TYPE;
 585	task_context->remote_node_index = iport->reserved_rni;
 586	task_context->do_not_dma_ssp_good_response = 1;
 587	task_context->task_phase = 0x01;
 588}
 589
 590static void sci_port_destroy_dummy_resources(struct isci_port *iport)
 591{
 592	struct isci_host *ihost = iport->owning_controller;
 593
 594	if (iport->reserved_tag != SCI_CONTROLLER_INVALID_IO_TAG)
 595		isci_free_tag(ihost, iport->reserved_tag);
 596
 597	if (iport->reserved_rni != SCU_DUMMY_INDEX)
 598		sci_remote_node_table_release_remote_node_index(&ihost->available_remote_nodes,
 599								     1, iport->reserved_rni);
 600
 601	iport->reserved_rni = SCU_DUMMY_INDEX;
 602	iport->reserved_tag = SCI_CONTROLLER_INVALID_IO_TAG;
 603}
 604
 605void sci_port_setup_transports(struct isci_port *iport, u32 device_id)
 606{
 607	u8 index;
 608
 609	for (index = 0; index < SCI_MAX_PHYS; index++) {
 610		if (iport->active_phy_mask & (1 << index))
 611			sci_phy_setup_transport(iport->phy_table[index], device_id);
 612	}
 613}
 614
 615static void sci_port_resume_phy(struct isci_port *iport, struct isci_phy *iphy)
 616{
 617	sci_phy_resume(iphy);
 618	iport->enabled_phy_mask |= 1 << iphy->phy_index;
 619}
 620
 621static void sci_port_activate_phy(struct isci_port *iport,
 622				  struct isci_phy *iphy,
 623				  u8 flags)
 624{
 625	struct isci_host *ihost = iport->owning_controller;
 626
 627	if (iphy->protocol != SAS_PROTOCOL_SATA && (flags & PF_RESUME))
 628		sci_phy_resume(iphy);
 629
 630	iport->active_phy_mask |= 1 << iphy->phy_index;
 631
 632	sci_controller_clear_invalid_phy(ihost, iphy);
 633
 634	if (flags & PF_NOTIFY)
 635		isci_port_link_up(ihost, iport, iphy);
 636}
 637
 638void sci_port_deactivate_phy(struct isci_port *iport, struct isci_phy *iphy,
 639			     bool do_notify_user)
 640{
 641	struct isci_host *ihost = iport->owning_controller;
 642
 643	iport->active_phy_mask &= ~(1 << iphy->phy_index);
 644	iport->enabled_phy_mask &= ~(1 << iphy->phy_index);
 645	if (!iport->active_phy_mask)
 646		iport->last_active_phy = iphy->phy_index;
 647
 648	iphy->max_negotiated_speed = SAS_LINK_RATE_UNKNOWN;
 649
 650	/* Re-assign the phy back to the LP as if it were a narrow port for APC
 651	 * mode. For MPC mode, the phy will remain in the port.
 652	 */
 653	if (iport->owning_controller->oem_parameters.controller.mode_type ==
 654		SCIC_PORT_AUTOMATIC_CONFIGURATION_MODE)
 655		writel(iphy->phy_index,
 656			&iport->port_pe_configuration_register[iphy->phy_index]);
 657
 658	if (do_notify_user == true)
 659		isci_port_link_down(ihost, iphy, iport);
 660}
 661
 662static void sci_port_invalid_link_up(struct isci_port *iport, struct isci_phy *iphy)
 663{
 664	struct isci_host *ihost = iport->owning_controller;
 665
 666	/*
 667	 * Check to see if we have alreay reported this link as bad and if
 668	 * not go ahead and tell the SCI_USER that we have discovered an
 669	 * invalid link.
 670	 */
 671	if ((ihost->invalid_phy_mask & (1 << iphy->phy_index)) == 0) {
 672		ihost->invalid_phy_mask |= 1 << iphy->phy_index;
 673		dev_warn(&ihost->pdev->dev, "Invalid link up!\n");
 674	}
 675}
 676
 677/**
 678 * sci_port_general_link_up_handler - phy can be assigned to port?
 679 * @sci_port: sci_port object for which has a phy that has gone link up.
 680 * @sci_phy: This is the struct isci_phy object that has gone link up.
 681 * @flags: PF_RESUME, PF_NOTIFY to sci_port_activate_phy
 682 *
 683 * Determine if this phy can be assigned to this port . If the phy is
 684 * not a valid PHY for this port then the function will notify the user.
 685 * A PHY can only be part of a port if it's attached SAS ADDRESS is the
 686 * same as all other PHYs in the same port.
 687 */
 688static void sci_port_general_link_up_handler(struct isci_port *iport,
 689					     struct isci_phy *iphy,
 690					     u8 flags)
 691{
 692	struct sci_sas_address port_sas_address;
 693	struct sci_sas_address phy_sas_address;
 694
 695	sci_port_get_attached_sas_address(iport, &port_sas_address);
 696	sci_phy_get_attached_sas_address(iphy, &phy_sas_address);
 697
 698	/* If the SAS address of the new phy matches the SAS address of
 699	 * other phys in the port OR this is the first phy in the port,
 700	 * then activate the phy and allow it to be used for operations
 701	 * in this port.
 702	 */
 703	if ((phy_sas_address.high == port_sas_address.high &&
 704	     phy_sas_address.low  == port_sas_address.low) ||
 705	    iport->active_phy_mask == 0) {
 706		struct sci_base_state_machine *sm = &iport->sm;
 707
 708		sci_port_activate_phy(iport, iphy, flags);
 709		if (sm->current_state_id == SCI_PORT_RESETTING)
 710			port_state_machine_change(iport, SCI_PORT_READY);
 711	} else
 712		sci_port_invalid_link_up(iport, iphy);
 713}
 714
 715
 716
 717/**
 718 * This method returns false if the port only has a single phy object assigned.
 719 *     If there are no phys or more than one phy then the method will return
 720 *    true.
 721 * @sci_port: The port for which the wide port condition is to be checked.
 722 *
 723 * bool true Is returned if this is a wide ported port. false Is returned if
 724 * this is a narrow port.
 725 */
 726static bool sci_port_is_wide(struct isci_port *iport)
 727{
 728	u32 index;
 729	u32 phy_count = 0;
 730
 731	for (index = 0; index < SCI_MAX_PHYS; index++) {
 732		if (iport->phy_table[index] != NULL) {
 733			phy_count++;
 734		}
 735	}
 736
 737	return phy_count != 1;
 738}
 739
 740/**
 741 * This method is called by the PHY object when the link is detected. if the
 742 *    port wants the PHY to continue on to the link up state then the port
 743 *    layer must return true.  If the port object returns false the phy object
 744 *    must halt its attempt to go link up.
 745 * @sci_port: The port associated with the phy object.
 746 * @sci_phy: The phy object that is trying to go link up.
 747 *
 748 * true if the phy object can continue to the link up condition. true Is
 749 * returned if this phy can continue to the ready state. false Is returned if
 750 * can not continue on to the ready state. This notification is in place for
 751 * wide ports and direct attached phys.  Since there are no wide ported SATA
 752 * devices this could become an invalid port configuration.
 753 */
 754bool sci_port_link_detected(struct isci_port *iport, struct isci_phy *iphy)
 755{
 756	if ((iport->logical_port_index != SCIC_SDS_DUMMY_PORT) &&
 757	    (iphy->protocol == SAS_PROTOCOL_SATA)) {
 758		if (sci_port_is_wide(iport)) {
 759			sci_port_invalid_link_up(iport, iphy);
 760			return false;
 761		} else {
 762			struct isci_host *ihost = iport->owning_controller;
 763			struct isci_port *dst_port = &(ihost->ports[iphy->phy_index]);
 764			writel(iphy->phy_index,
 765			       &dst_port->port_pe_configuration_register[iphy->phy_index]);
 766		}
 767	}
 768
 769	return true;
 770}
 771
 772static void port_timeout(struct timer_list *t)
 773{
 774	struct sci_timer *tmr = from_timer(tmr, t, timer);
 775	struct isci_port *iport = container_of(tmr, typeof(*iport), timer);
 776	struct isci_host *ihost = iport->owning_controller;
 777	unsigned long flags;
 778	u32 current_state;
 779
 780	spin_lock_irqsave(&ihost->scic_lock, flags);
 781
 782	if (tmr->cancel)
 783		goto done;
 784
 785	current_state = iport->sm.current_state_id;
 786
 787	if (current_state == SCI_PORT_RESETTING) {
 788		/* if the port is still in the resetting state then the timeout
 789		 * fired before the reset completed.
 790		 */
 791		port_state_machine_change(iport, SCI_PORT_FAILED);
 792	} else if (current_state == SCI_PORT_STOPPED) {
 793		/* if the port is stopped then the start request failed In this
 794		 * case stay in the stopped state.
 795		 */
 796		dev_err(sciport_to_dev(iport),
 797			"%s: SCIC Port 0x%p failed to stop before timeout.\n",
 798			__func__,
 799			iport);
 800	} else if (current_state == SCI_PORT_STOPPING) {
 801		dev_dbg(sciport_to_dev(iport),
 802			"%s: port%d: stop complete timeout\n",
 803			__func__, iport->physical_port_index);
 804	} else {
 805		/* The port is in the ready state and we have a timer
 806		 * reporting a timeout this should not happen.
 807		 */
 808		dev_err(sciport_to_dev(iport),
 809			"%s: SCIC Port 0x%p is processing a timeout operation "
 810			"in state %d.\n", __func__, iport, current_state);
 811	}
 812
 813done:
 814	spin_unlock_irqrestore(&ihost->scic_lock, flags);
 815}
 816
 817/* --------------------------------------------------------------------------- */
 818
 819/**
 820 * This function updates the hardwares VIIT entry for this port.
 821 *
 822 *
 823 */
 824static void sci_port_update_viit_entry(struct isci_port *iport)
 825{
 826	struct sci_sas_address sas_address;
 827
 828	sci_port_get_sas_address(iport, &sas_address);
 829
 830	writel(sas_address.high,
 831		&iport->viit_registers->initiator_sas_address_hi);
 832	writel(sas_address.low,
 833		&iport->viit_registers->initiator_sas_address_lo);
 834
 835	/* This value get cleared just in case its not already cleared */
 836	writel(0, &iport->viit_registers->reserved);
 837
 838	/* We are required to update the status register last */
 839	writel(SCU_VIIT_ENTRY_ID_VIIT |
 840	       SCU_VIIT_IPPT_INITIATOR |
 841	       ((1 << iport->physical_port_index) << SCU_VIIT_ENTRY_LPVIE_SHIFT) |
 842	       SCU_VIIT_STATUS_ALL_VALID,
 843	       &iport->viit_registers->status);
 844}
 845
 846enum sas_linkrate sci_port_get_max_allowed_speed(struct isci_port *iport)
 847{
 848	u16 index;
 849	struct isci_phy *iphy;
 850	enum sas_linkrate max_allowed_speed = SAS_LINK_RATE_6_0_GBPS;
 851
 852	/*
 853	 * Loop through all of the phys in this port and find the phy with the
 854	 * lowest maximum link rate. */
 855	for (index = 0; index < SCI_MAX_PHYS; index++) {
 856		iphy = iport->phy_table[index];
 857		if (iphy && sci_port_active_phy(iport, iphy) &&
 858		    iphy->max_negotiated_speed < max_allowed_speed)
 859			max_allowed_speed = iphy->max_negotiated_speed;
 860	}
 861
 862	return max_allowed_speed;
 863}
 864
 865static void sci_port_suspend_port_task_scheduler(struct isci_port *iport)
 866{
 867	u32 pts_control_value;
 868
 869	pts_control_value = readl(&iport->port_task_scheduler_registers->control);
 870	pts_control_value |= SCU_PTSxCR_GEN_BIT(SUSPEND);
 871	writel(pts_control_value, &iport->port_task_scheduler_registers->control);
 872}
 873
 874/**
 875 * sci_port_post_dummy_request() - post dummy/workaround request
 876 * @sci_port: port to post task
 877 *
 878 * Prevent the hardware scheduler from posting new requests to the front
 879 * of the scheduler queue causing a starvation problem for currently
 880 * ongoing requests.
 881 *
 882 */
 883static void sci_port_post_dummy_request(struct isci_port *iport)
 884{
 885	struct isci_host *ihost = iport->owning_controller;
 886	u16 tag = iport->reserved_tag;
 887	struct scu_task_context *tc;
 888	u32 command;
 889
 890	tc = &ihost->task_context_table[ISCI_TAG_TCI(tag)];
 891	tc->abort = 0;
 892
 893	command = SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
 894		  iport->physical_port_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT |
 895		  ISCI_TAG_TCI(tag);
 896
 897	sci_controller_post_request(ihost, command);
 898}
 899
 900/**
 901 * This routine will abort the dummy request.  This will alow the hardware to
 902 * power down parts of the silicon to save power.
 903 *
 904 * @sci_port: The port on which the task must be aborted.
 905 *
 906 */
 907static void sci_port_abort_dummy_request(struct isci_port *iport)
 908{
 909	struct isci_host *ihost = iport->owning_controller;
 910	u16 tag = iport->reserved_tag;
 911	struct scu_task_context *tc;
 912	u32 command;
 913
 914	tc = &ihost->task_context_table[ISCI_TAG_TCI(tag)];
 915	tc->abort = 1;
 916
 917	command = SCU_CONTEXT_COMMAND_REQUEST_POST_TC_ABORT |
 918		  iport->physical_port_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT |
 919		  ISCI_TAG_TCI(tag);
 920
 921	sci_controller_post_request(ihost, command);
 922}
 923
 924/**
 925 *
 926 * @sci_port: This is the struct isci_port object to resume.
 927 *
 928 * This method will resume the port task scheduler for this port object. none
 929 */
 930static void
 931sci_port_resume_port_task_scheduler(struct isci_port *iport)
 932{
 933	u32 pts_control_value;
 934
 935	pts_control_value = readl(&iport->port_task_scheduler_registers->control);
 936	pts_control_value &= ~SCU_PTSxCR_GEN_BIT(SUSPEND);
 937	writel(pts_control_value, &iport->port_task_scheduler_registers->control);
 938}
 939
 940static void sci_port_ready_substate_waiting_enter(struct sci_base_state_machine *sm)
 941{
 942	struct isci_port *iport = container_of(sm, typeof(*iport), sm);
 943
 944	sci_port_suspend_port_task_scheduler(iport);
 945
 946	iport->not_ready_reason = SCIC_PORT_NOT_READY_NO_ACTIVE_PHYS;
 947
 948	if (iport->active_phy_mask != 0) {
 949		/* At least one of the phys on the port is ready */
 950		port_state_machine_change(iport,
 951					  SCI_PORT_SUB_OPERATIONAL);
 952	}
 953}
 954
 955static void scic_sds_port_ready_substate_waiting_exit(
 956					struct sci_base_state_machine *sm)
 957{
 958	struct isci_port *iport = container_of(sm, typeof(*iport), sm);
 959	sci_port_resume_port_task_scheduler(iport);
 960}
 961
 962static void sci_port_ready_substate_operational_enter(struct sci_base_state_machine *sm)
 963{
 964	u32 index;
 965	struct isci_port *iport = container_of(sm, typeof(*iport), sm);
 966	struct isci_host *ihost = iport->owning_controller;
 967
 968	dev_dbg(&ihost->pdev->dev, "%s: port%d ready\n",
 969		__func__, iport->physical_port_index);
 970
 971	for (index = 0; index < SCI_MAX_PHYS; index++) {
 972		if (iport->phy_table[index]) {
 973			writel(iport->physical_port_index,
 974				&iport->port_pe_configuration_register[
 975					iport->phy_table[index]->phy_index]);
 976			if (((iport->active_phy_mask^iport->enabled_phy_mask) & (1 << index)) != 0)
 977				sci_port_resume_phy(iport, iport->phy_table[index]);
 978		}
 979	}
 980
 981	sci_port_update_viit_entry(iport);
 982
 983	/*
 984	 * Post the dummy task for the port so the hardware can schedule
 985	 * io correctly
 986	 */
 987	sci_port_post_dummy_request(iport);
 988}
 989
 990static void sci_port_invalidate_dummy_remote_node(struct isci_port *iport)
 991{
 992	struct isci_host *ihost = iport->owning_controller;
 993	u8 phys_index = iport->physical_port_index;
 994	union scu_remote_node_context *rnc;
 995	u16 rni = iport->reserved_rni;
 996	u32 command;
 997
 998	rnc = &ihost->remote_node_context_table[rni];
 999
1000	rnc->ssp.is_valid = false;
1001
1002	/* ensure the preceding tc abort request has reached the
1003	 * controller and give it ample time to act before posting the rnc
1004	 * invalidate
1005	 */
1006	readl(&ihost->smu_registers->interrupt_status); /* flush */
1007	udelay(10);
1008
1009	command = SCU_CONTEXT_COMMAND_POST_RNC_INVALIDATE |
1010		  phys_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT | rni;
1011
1012	sci_controller_post_request(ihost, command);
1013}
1014
1015/**
1016 *
1017 * @object: This is the object which is cast to a struct isci_port object.
1018 *
1019 * This method will perform the actions required by the struct isci_port on
1020 * exiting the SCI_PORT_SUB_OPERATIONAL. This function reports
1021 * the port not ready and suspends the port task scheduler. none
1022 */
1023static void sci_port_ready_substate_operational_exit(struct sci_base_state_machine *sm)
1024{
1025	struct isci_port *iport = container_of(sm, typeof(*iport), sm);
1026	struct isci_host *ihost = iport->owning_controller;
1027
1028	/*
1029	 * Kill the dummy task for this port if it has not yet posted
1030	 * the hardware will treat this as a NOP and just return abort
1031	 * complete.
1032	 */
1033	sci_port_abort_dummy_request(iport);
1034
1035	dev_dbg(&ihost->pdev->dev, "%s: port%d !ready\n",
1036		__func__, iport->physical_port_index);
1037
1038	if (iport->ready_exit)
1039		sci_port_invalidate_dummy_remote_node(iport);
1040}
1041
1042static void sci_port_ready_substate_configuring_enter(struct sci_base_state_machine *sm)
1043{
1044	struct isci_port *iport = container_of(sm, typeof(*iport), sm);
1045	struct isci_host *ihost = iport->owning_controller;
1046
1047	if (iport->active_phy_mask == 0) {
1048		dev_dbg(&ihost->pdev->dev, "%s: port%d !ready\n",
1049			__func__, iport->physical_port_index);
1050
1051		port_state_machine_change(iport, SCI_PORT_SUB_WAITING);
1052	} else
1053		port_state_machine_change(iport, SCI_PORT_SUB_OPERATIONAL);
1054}
1055
1056enum sci_status sci_port_start(struct isci_port *iport)
1057{
1058	struct isci_host *ihost = iport->owning_controller;
1059	enum sci_status status = SCI_SUCCESS;
1060	enum sci_port_states state;
1061	u32 phy_mask;
1062
1063	state = iport->sm.current_state_id;
1064	if (state != SCI_PORT_STOPPED) {
1065		dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
1066			 __func__, port_state_name(state));
1067		return SCI_FAILURE_INVALID_STATE;
1068	}
1069
1070	if (iport->assigned_device_count > 0) {
1071		/* TODO This is a start failure operation because
1072		 * there are still devices assigned to this port.
1073		 * There must be no devices assigned to a port on a
1074		 * start operation.
1075		 */
1076		return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
1077	}
1078
1079	if (iport->reserved_rni == SCU_DUMMY_INDEX) {
1080		u16 rni = sci_remote_node_table_allocate_remote_node(
1081				&ihost->available_remote_nodes, 1);
1082
1083		if (rni != SCU_DUMMY_INDEX)
1084			sci_port_construct_dummy_rnc(iport, rni);
1085		else
1086			status = SCI_FAILURE_INSUFFICIENT_RESOURCES;
1087		iport->reserved_rni = rni;
1088	}
1089
1090	if (iport->reserved_tag == SCI_CONTROLLER_INVALID_IO_TAG) {
1091		u16 tag;
1092
1093		tag = isci_alloc_tag(ihost);
1094		if (tag == SCI_CONTROLLER_INVALID_IO_TAG)
1095			status = SCI_FAILURE_INSUFFICIENT_RESOURCES;
1096		else
1097			sci_port_construct_dummy_task(iport, tag);
1098		iport->reserved_tag = tag;
1099	}
1100
1101	if (status == SCI_SUCCESS) {
1102		phy_mask = sci_port_get_phys(iport);
1103
1104		/*
1105		 * There are one or more phys assigned to this port.  Make sure
1106		 * the port's phy mask is in fact legal and supported by the
1107		 * silicon.
1108		 */
1109		if (sci_port_is_phy_mask_valid(iport, phy_mask) == true) {
1110			port_state_machine_change(iport,
1111						  SCI_PORT_READY);
1112
1113			return SCI_SUCCESS;
1114		}
1115		status = SCI_FAILURE;
1116	}
1117
1118	if (status != SCI_SUCCESS)
1119		sci_port_destroy_dummy_resources(iport);
1120
1121	return status;
1122}
1123
1124enum sci_status sci_port_stop(struct isci_port *iport)
1125{
1126	enum sci_port_states state;
1127
1128	state = iport->sm.current_state_id;
1129	switch (state) {
1130	case SCI_PORT_STOPPED:
1131		return SCI_SUCCESS;
1132	case SCI_PORT_SUB_WAITING:
1133	case SCI_PORT_SUB_OPERATIONAL:
1134	case SCI_PORT_SUB_CONFIGURING:
1135	case SCI_PORT_RESETTING:
1136		port_state_machine_change(iport,
1137					  SCI_PORT_STOPPING);
1138		return SCI_SUCCESS;
1139	default:
1140		dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
1141			 __func__, port_state_name(state));
1142		return SCI_FAILURE_INVALID_STATE;
1143	}
1144}
1145
1146static enum sci_status sci_port_hard_reset(struct isci_port *iport, u32 timeout)
1147{
1148	enum sci_status status = SCI_FAILURE_INVALID_PHY;
1149	struct isci_phy *iphy = NULL;
1150	enum sci_port_states state;
1151	u32 phy_index;
1152
1153	state = iport->sm.current_state_id;
1154	if (state != SCI_PORT_SUB_OPERATIONAL) {
1155		dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
1156			 __func__, port_state_name(state));
1157		return SCI_FAILURE_INVALID_STATE;
1158	}
1159
1160	/* Select a phy on which we can send the hard reset request. */
1161	for (phy_index = 0; phy_index < SCI_MAX_PHYS && !iphy; phy_index++) {
1162		iphy = iport->phy_table[phy_index];
1163		if (iphy && !sci_port_active_phy(iport, iphy)) {
1164			/*
1165			 * We found a phy but it is not ready select
1166			 * different phy
1167			 */
1168			iphy = NULL;
1169		}
1170	}
1171
1172	/* If we have a phy then go ahead and start the reset procedure */
1173	if (!iphy)
1174		return status;
1175	status = sci_phy_reset(iphy);
1176
1177	if (status != SCI_SUCCESS)
1178		return status;
1179
1180	sci_mod_timer(&iport->timer, timeout);
1181	iport->not_ready_reason = SCIC_PORT_NOT_READY_HARD_RESET_REQUESTED;
1182
1183	port_state_machine_change(iport, SCI_PORT_RESETTING);
1184	return SCI_SUCCESS;
1185}
1186
1187/**
1188 * sci_port_add_phy() -
1189 * @sci_port: This parameter specifies the port in which the phy will be added.
1190 * @sci_phy: This parameter is the phy which is to be added to the port.
1191 *
1192 * This method will add a PHY to the selected port. This method returns an
1193 * enum sci_status. SCI_SUCCESS the phy has been added to the port. Any other
1194 * status is a failure to add the phy to the port.
1195 */
1196enum sci_status sci_port_add_phy(struct isci_port *iport,
1197				      struct isci_phy *iphy)
1198{
1199	enum sci_status status;
1200	enum sci_port_states state;
1201
1202	sci_port_bcn_enable(iport);
1203
1204	state = iport->sm.current_state_id;
1205	switch (state) {
1206	case SCI_PORT_STOPPED: {
1207		struct sci_sas_address port_sas_address;
1208
1209		/* Read the port assigned SAS Address if there is one */
1210		sci_port_get_sas_address(iport, &port_sas_address);
1211
1212		if (port_sas_address.high != 0 && port_sas_address.low != 0) {
1213			struct sci_sas_address phy_sas_address;
1214
1215			/* Make sure that the PHY SAS Address matches the SAS Address
1216			 * for this port
1217			 */
1218			sci_phy_get_sas_address(iphy, &phy_sas_address);
1219
1220			if (port_sas_address.high != phy_sas_address.high ||
1221			    port_sas_address.low  != phy_sas_address.low)
1222				return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
1223		}
1224		return sci_port_set_phy(iport, iphy);
1225	}
1226	case SCI_PORT_SUB_WAITING:
1227	case SCI_PORT_SUB_OPERATIONAL:
1228		status = sci_port_set_phy(iport, iphy);
1229
1230		if (status != SCI_SUCCESS)
1231			return status;
1232
1233		sci_port_general_link_up_handler(iport, iphy, PF_NOTIFY|PF_RESUME);
1234		iport->not_ready_reason = SCIC_PORT_NOT_READY_RECONFIGURING;
1235		port_state_machine_change(iport, SCI_PORT_SUB_CONFIGURING);
1236
1237		return status;
1238	case SCI_PORT_SUB_CONFIGURING:
1239		status = sci_port_set_phy(iport, iphy);
1240
1241		if (status != SCI_SUCCESS)
1242			return status;
1243		sci_port_general_link_up_handler(iport, iphy, PF_NOTIFY);
1244
1245		/* Re-enter the configuring state since this may be the last phy in
1246		 * the port.
1247		 */
1248		port_state_machine_change(iport,
1249					  SCI_PORT_SUB_CONFIGURING);
1250		return SCI_SUCCESS;
1251	default:
1252		dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
1253			 __func__, port_state_name(state));
1254		return SCI_FAILURE_INVALID_STATE;
1255	}
1256}
1257
1258/**
1259 * sci_port_remove_phy() -
1260 * @sci_port: This parameter specifies the port in which the phy will be added.
1261 * @sci_phy: This parameter is the phy which is to be added to the port.
1262 *
1263 * This method will remove the PHY from the selected PORT. This method returns
1264 * an enum sci_status. SCI_SUCCESS the phy has been removed from the port. Any
1265 * other status is a failure to add the phy to the port.
1266 */
1267enum sci_status sci_port_remove_phy(struct isci_port *iport,
1268					 struct isci_phy *iphy)
1269{
1270	enum sci_status status;
1271	enum sci_port_states state;
1272
1273	state = iport->sm.current_state_id;
1274
1275	switch (state) {
1276	case SCI_PORT_STOPPED:
1277		return sci_port_clear_phy(iport, iphy);
1278	case SCI_PORT_SUB_OPERATIONAL:
1279		status = sci_port_clear_phy(iport, iphy);
1280		if (status != SCI_SUCCESS)
1281			return status;
1282
1283		sci_port_deactivate_phy(iport, iphy, true);
1284		iport->not_ready_reason = SCIC_PORT_NOT_READY_RECONFIGURING;
1285		port_state_machine_change(iport,
1286					  SCI_PORT_SUB_CONFIGURING);
1287		return SCI_SUCCESS;
1288	case SCI_PORT_SUB_CONFIGURING:
1289		status = sci_port_clear_phy(iport, iphy);
1290
1291		if (status != SCI_SUCCESS)
1292			return status;
1293		sci_port_deactivate_phy(iport, iphy, true);
1294
1295		/* Re-enter the configuring state since this may be the last phy in
1296		 * the port
1297		 */
1298		port_state_machine_change(iport,
1299					  SCI_PORT_SUB_CONFIGURING);
1300		return SCI_SUCCESS;
1301	default:
1302		dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
1303			 __func__, port_state_name(state));
1304		return SCI_FAILURE_INVALID_STATE;
1305	}
1306}
1307
1308enum sci_status sci_port_link_up(struct isci_port *iport,
1309				      struct isci_phy *iphy)
1310{
1311	enum sci_port_states state;
1312
1313	state = iport->sm.current_state_id;
1314	switch (state) {
1315	case SCI_PORT_SUB_WAITING:
1316		/* Since this is the first phy going link up for the port we
1317		 * can just enable it and continue
1318		 */
1319		sci_port_activate_phy(iport, iphy, PF_NOTIFY|PF_RESUME);
1320
1321		port_state_machine_change(iport,
1322					  SCI_PORT_SUB_OPERATIONAL);
1323		return SCI_SUCCESS;
1324	case SCI_PORT_SUB_OPERATIONAL:
1325		sci_port_general_link_up_handler(iport, iphy, PF_NOTIFY|PF_RESUME);
1326		return SCI_SUCCESS;
1327	case SCI_PORT_RESETTING:
1328		/* TODO We should  make  sure  that  the phy  that  has gone
1329		 * link up is the same one on which we sent the reset.  It is
1330		 * possible that the phy on which we sent  the reset is not the
1331		 * one that has  gone  link up  and we  want to make sure that
1332		 * phy being reset  comes  back.  Consider the case where a
1333		 * reset is sent but before the hardware processes the reset it
1334		 * get a link up on  the  port because of a hot plug event.
1335		 * because  of  the reset request this phy will go link down
1336		 * almost immediately.
1337		 */
1338
1339		/* In the resetting state we don't notify the user regarding
1340		 * link up and link down notifications.
1341		 */
1342		sci_port_general_link_up_handler(iport, iphy, PF_RESUME);
1343		return SCI_SUCCESS;
1344	default:
1345		dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
1346			 __func__, port_state_name(state));
1347		return SCI_FAILURE_INVALID_STATE;
1348	}
1349}
1350
1351enum sci_status sci_port_link_down(struct isci_port *iport,
1352					struct isci_phy *iphy)
1353{
1354	enum sci_port_states state;
1355
1356	state = iport->sm.current_state_id;
1357	switch (state) {
1358	case SCI_PORT_SUB_OPERATIONAL:
1359		sci_port_deactivate_phy(iport, iphy, true);
1360
1361		/* If there are no active phys left in the port, then
1362		 * transition the port to the WAITING state until such time
1363		 * as a phy goes link up
1364		 */
1365		if (iport->active_phy_mask == 0)
1366			port_state_machine_change(iport,
1367						  SCI_PORT_SUB_WAITING);
1368		return SCI_SUCCESS;
1369	case SCI_PORT_RESETTING:
1370		/* In the resetting state we don't notify the user regarding
1371		 * link up and link down notifications. */
1372		sci_port_deactivate_phy(iport, iphy, false);
1373		return SCI_SUCCESS;
1374	default:
1375		dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
1376			 __func__, port_state_name(state));
1377		return SCI_FAILURE_INVALID_STATE;
1378	}
1379}
1380
1381enum sci_status sci_port_start_io(struct isci_port *iport,
1382				  struct isci_remote_device *idev,
1383				  struct isci_request *ireq)
1384{
1385	enum sci_port_states state;
1386
1387	state = iport->sm.current_state_id;
1388	switch (state) {
1389	case SCI_PORT_SUB_WAITING:
1390		return SCI_FAILURE_INVALID_STATE;
1391	case SCI_PORT_SUB_OPERATIONAL:
1392		iport->started_request_count++;
1393		return SCI_SUCCESS;
1394	default:
1395		dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
1396			 __func__, port_state_name(state));
1397		return SCI_FAILURE_INVALID_STATE;
1398	}
1399}
1400
1401enum sci_status sci_port_complete_io(struct isci_port *iport,
1402				     struct isci_remote_device *idev,
1403				     struct isci_request *ireq)
1404{
1405	enum sci_port_states state;
1406
1407	state = iport->sm.current_state_id;
1408	switch (state) {
1409	case SCI_PORT_STOPPED:
1410		dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
1411			 __func__, port_state_name(state));
1412		return SCI_FAILURE_INVALID_STATE;
1413	case SCI_PORT_STOPPING:
1414		sci_port_decrement_request_count(iport);
1415
1416		if (iport->started_request_count == 0)
1417			port_state_machine_change(iport,
1418						  SCI_PORT_STOPPED);
1419		break;
1420	case SCI_PORT_READY:
1421	case SCI_PORT_RESETTING:
1422	case SCI_PORT_FAILED:
1423	case SCI_PORT_SUB_WAITING:
1424	case SCI_PORT_SUB_OPERATIONAL:
1425		sci_port_decrement_request_count(iport);
1426		break;
1427	case SCI_PORT_SUB_CONFIGURING:
1428		sci_port_decrement_request_count(iport);
1429		if (iport->started_request_count == 0) {
1430			port_state_machine_change(iport,
1431						  SCI_PORT_SUB_OPERATIONAL);
1432		}
1433		break;
1434	}
1435	return SCI_SUCCESS;
1436}
1437
1438static void sci_port_enable_port_task_scheduler(struct isci_port *iport)
1439{
1440	u32 pts_control_value;
1441
1442	 /* enable the port task scheduler in a suspended state */
1443	pts_control_value = readl(&iport->port_task_scheduler_registers->control);
1444	pts_control_value |= SCU_PTSxCR_GEN_BIT(ENABLE) | SCU_PTSxCR_GEN_BIT(SUSPEND);
1445	writel(pts_control_value, &iport->port_task_scheduler_registers->control);
1446}
1447
1448static void sci_port_disable_port_task_scheduler(struct isci_port *iport)
1449{
1450	u32 pts_control_value;
1451
1452	pts_control_value = readl(&iport->port_task_scheduler_registers->control);
1453	pts_control_value &=
1454		~(SCU_PTSxCR_GEN_BIT(ENABLE) | SCU_PTSxCR_GEN_BIT(SUSPEND));
1455	writel(pts_control_value, &iport->port_task_scheduler_registers->control);
1456}
1457
1458static void sci_port_post_dummy_remote_node(struct isci_port *iport)
1459{
1460	struct isci_host *ihost = iport->owning_controller;
1461	u8 phys_index = iport->physical_port_index;
1462	union scu_remote_node_context *rnc;
1463	u16 rni = iport->reserved_rni;
1464	u32 command;
1465
1466	rnc = &ihost->remote_node_context_table[rni];
1467	rnc->ssp.is_valid = true;
1468
1469	command = SCU_CONTEXT_COMMAND_POST_RNC_32 |
1470		  phys_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT | rni;
1471
1472	sci_controller_post_request(ihost, command);
1473
1474	/* ensure hardware has seen the post rnc command and give it
1475	 * ample time to act before sending the suspend
1476	 */
1477	readl(&ihost->smu_registers->interrupt_status); /* flush */
1478	udelay(10);
1479
1480	command = SCU_CONTEXT_COMMAND_POST_RNC_SUSPEND_TX_RX |
1481		  phys_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT | rni;
1482
1483	sci_controller_post_request(ihost, command);
1484}
1485
1486static void sci_port_stopped_state_enter(struct sci_base_state_machine *sm)
1487{
1488	struct isci_port *iport = container_of(sm, typeof(*iport), sm);
1489
1490	if (iport->sm.previous_state_id == SCI_PORT_STOPPING) {
1491		/*
1492		 * If we enter this state becasuse of a request to stop
1493		 * the port then we want to disable the hardwares port
1494		 * task scheduler. */
1495		sci_port_disable_port_task_scheduler(iport);
1496	}
1497}
1498
1499static void sci_port_stopped_state_exit(struct sci_base_state_machine *sm)
1500{
1501	struct isci_port *iport = container_of(sm, typeof(*iport), sm);
1502
1503	/* Enable and suspend the port task scheduler */
1504	sci_port_enable_port_task_scheduler(iport);
1505}
1506
1507static void sci_port_ready_state_enter(struct sci_base_state_machine *sm)
1508{
1509	struct isci_port *iport = container_of(sm, typeof(*iport), sm);
1510	struct isci_host *ihost = iport->owning_controller;
1511	u32 prev_state;
1512
1513	prev_state = iport->sm.previous_state_id;
1514	if (prev_state  == SCI_PORT_RESETTING)
1515		isci_port_hard_reset_complete(iport, SCI_SUCCESS);
1516	else
1517		dev_dbg(&ihost->pdev->dev, "%s: port%d !ready\n",
1518			__func__, iport->physical_port_index);
1519
1520	/* Post and suspend the dummy remote node context for this port. */
1521	sci_port_post_dummy_remote_node(iport);
1522
1523	/* Start the ready substate machine */
1524	port_state_machine_change(iport,
1525				  SCI_PORT_SUB_WAITING);
1526}
1527
1528static void sci_port_resetting_state_exit(struct sci_base_state_machine *sm)
1529{
1530	struct isci_port *iport = container_of(sm, typeof(*iport), sm);
1531
1532	sci_del_timer(&iport->timer);
1533}
1534
1535static void sci_port_stopping_state_exit(struct sci_base_state_machine *sm)
1536{
1537	struct isci_port *iport = container_of(sm, typeof(*iport), sm);
1538
1539	sci_del_timer(&iport->timer);
1540
1541	sci_port_destroy_dummy_resources(iport);
1542}
1543
1544static void sci_port_failed_state_enter(struct sci_base_state_machine *sm)
1545{
1546	struct isci_port *iport = container_of(sm, typeof(*iport), sm);
1547
1548	isci_port_hard_reset_complete(iport, SCI_FAILURE_TIMEOUT);
1549}
1550
1551void sci_port_set_hang_detection_timeout(struct isci_port *iport, u32 timeout)
1552{
1553	int phy_index;
1554	u32 phy_mask = iport->active_phy_mask;
1555
1556	if (timeout)
1557		++iport->hang_detect_users;
1558	else if (iport->hang_detect_users > 1)
1559		--iport->hang_detect_users;
1560	else
1561		iport->hang_detect_users = 0;
1562
1563	if (timeout || (iport->hang_detect_users == 0)) {
1564		for (phy_index = 0; phy_index < SCI_MAX_PHYS; phy_index++) {
1565			if ((phy_mask >> phy_index) & 1) {
1566				writel(timeout,
1567				       &iport->phy_table[phy_index]
1568					  ->link_layer_registers
1569					  ->link_layer_hang_detection_timeout);
1570			}
1571		}
1572	}
1573}
1574/* --------------------------------------------------------------------------- */
1575
1576static const struct sci_base_state sci_port_state_table[] = {
1577	[SCI_PORT_STOPPED] = {
1578		.enter_state = sci_port_stopped_state_enter,
1579		.exit_state  = sci_port_stopped_state_exit
1580	},
1581	[SCI_PORT_STOPPING] = {
1582		.exit_state  = sci_port_stopping_state_exit
1583	},
1584	[SCI_PORT_READY] = {
1585		.enter_state = sci_port_ready_state_enter,
1586	},
1587	[SCI_PORT_SUB_WAITING] = {
1588		.enter_state = sci_port_ready_substate_waiting_enter,
1589		.exit_state  = scic_sds_port_ready_substate_waiting_exit,
1590	},
1591	[SCI_PORT_SUB_OPERATIONAL] = {
1592		.enter_state = sci_port_ready_substate_operational_enter,
1593		.exit_state  = sci_port_ready_substate_operational_exit
1594	},
1595	[SCI_PORT_SUB_CONFIGURING] = {
1596		.enter_state = sci_port_ready_substate_configuring_enter
1597	},
1598	[SCI_PORT_RESETTING] = {
1599		.exit_state  = sci_port_resetting_state_exit
1600	},
1601	[SCI_PORT_FAILED] = {
1602		.enter_state = sci_port_failed_state_enter,
1603	}
1604};
1605
1606void sci_port_construct(struct isci_port *iport, u8 index,
1607			     struct isci_host *ihost)
1608{
1609	sci_init_sm(&iport->sm, sci_port_state_table, SCI_PORT_STOPPED);
1610
1611	iport->logical_port_index  = SCIC_SDS_DUMMY_PORT;
1612	iport->physical_port_index = index;
1613	iport->active_phy_mask     = 0;
1614	iport->enabled_phy_mask    = 0;
1615	iport->last_active_phy     = 0;
1616	iport->ready_exit	   = false;
1617
1618	iport->owning_controller = ihost;
1619
1620	iport->started_request_count = 0;
1621	iport->assigned_device_count = 0;
1622	iport->hang_detect_users = 0;
1623
1624	iport->reserved_rni = SCU_DUMMY_INDEX;
1625	iport->reserved_tag = SCI_CONTROLLER_INVALID_IO_TAG;
1626
1627	sci_init_timer(&iport->timer, port_timeout);
1628
1629	iport->port_task_scheduler_registers = NULL;
1630
1631	for (index = 0; index < SCI_MAX_PHYS; index++)
1632		iport->phy_table[index] = NULL;
1633}
1634
1635void sci_port_broadcast_change_received(struct isci_port *iport, struct isci_phy *iphy)
1636{
1637	struct isci_host *ihost = iport->owning_controller;
1638
1639	/* notify the user. */
1640	isci_port_bc_change_received(ihost, iport, iphy);
1641}
1642
1643static void wait_port_reset(struct isci_host *ihost, struct isci_port *iport)
1644{
1645	wait_event(ihost->eventq, !test_bit(IPORT_RESET_PENDING, &iport->state));
1646}
1647
1648int isci_port_perform_hard_reset(struct isci_host *ihost, struct isci_port *iport,
1649				 struct isci_phy *iphy)
1650{
1651	unsigned long flags;
1652	enum sci_status status;
1653	int ret = TMF_RESP_FUNC_COMPLETE;
1654
1655	dev_dbg(&ihost->pdev->dev, "%s: iport = %p\n",
1656		__func__, iport);
1657
1658	spin_lock_irqsave(&ihost->scic_lock, flags);
1659	set_bit(IPORT_RESET_PENDING, &iport->state);
1660
1661	#define ISCI_PORT_RESET_TIMEOUT SCIC_SDS_SIGNATURE_FIS_TIMEOUT
1662	status = sci_port_hard_reset(iport, ISCI_PORT_RESET_TIMEOUT);
1663
1664	spin_unlock_irqrestore(&ihost->scic_lock, flags);
1665
1666	if (status == SCI_SUCCESS) {
1667		wait_port_reset(ihost, iport);
1668
1669		dev_dbg(&ihost->pdev->dev,
1670			"%s: iport = %p; hard reset completion\n",
1671			__func__, iport);
1672
1673		if (iport->hard_reset_status != SCI_SUCCESS) {
1674			ret = TMF_RESP_FUNC_FAILED;
1675
1676			dev_err(&ihost->pdev->dev,
1677				"%s: iport = %p; hard reset failed (0x%x)\n",
1678				__func__, iport, iport->hard_reset_status);
1679		}
1680	} else {
1681		clear_bit(IPORT_RESET_PENDING, &iport->state);
1682		wake_up(&ihost->eventq);
1683		ret = TMF_RESP_FUNC_FAILED;
1684
1685		dev_err(&ihost->pdev->dev,
1686			"%s: iport = %p; sci_port_hard_reset call"
1687			" failed 0x%x\n",
1688			__func__, iport, status);
1689
1690	}
1691	return ret;
1692}
1693
1694int isci_ata_check_ready(struct domain_device *dev)
1695{
1696	struct isci_port *iport = dev->port->lldd_port;
1697	struct isci_host *ihost = dev_to_ihost(dev);
1698	struct isci_remote_device *idev;
1699	unsigned long flags;
1700	int rc = 0;
1701
1702	spin_lock_irqsave(&ihost->scic_lock, flags);
1703	idev = isci_lookup_device(dev);
1704	spin_unlock_irqrestore(&ihost->scic_lock, flags);
1705
1706	if (!idev)
1707		goto out;
1708
1709	if (test_bit(IPORT_RESET_PENDING, &iport->state))
1710		goto out;
1711
1712	rc = !!iport->active_phy_mask;
1713 out:
1714	isci_put_device(idev);
1715
1716	return rc;
1717}
1718
1719void isci_port_deformed(struct asd_sas_phy *phy)
1720{
1721	struct isci_host *ihost = phy->ha->lldd_ha;
1722	struct isci_port *iport = phy->port->lldd_port;
1723	unsigned long flags;
1724	int i;
1725
1726	/* we got a port notification on a port that was subsequently
1727	 * torn down and libsas is just now catching up
1728	 */
1729	if (!iport)
1730		return;
1731
1732	spin_lock_irqsave(&ihost->scic_lock, flags);
1733	for (i = 0; i < SCI_MAX_PHYS; i++) {
1734		if (iport->active_phy_mask & 1 << i)
1735			break;
1736	}
1737	spin_unlock_irqrestore(&ihost->scic_lock, flags);
1738
1739	if (i >= SCI_MAX_PHYS)
1740		dev_dbg(&ihost->pdev->dev, "%s: port: %ld\n",
1741			__func__, (long) (iport - &ihost->ports[0]));
1742}
1743
1744void isci_port_formed(struct asd_sas_phy *phy)
1745{
1746	struct isci_host *ihost = phy->ha->lldd_ha;
1747	struct isci_phy *iphy = to_iphy(phy);
1748	struct asd_sas_port *port = phy->port;
1749	struct isci_port *iport = NULL;
1750	unsigned long flags;
1751	int i;
1752
1753	/* initial ports are formed as the driver is still initializing,
1754	 * wait for that process to complete
1755	 */
1756	wait_for_start(ihost);
1757
1758	spin_lock_irqsave(&ihost->scic_lock, flags);
1759	for (i = 0; i < SCI_MAX_PORTS; i++) {
1760		iport = &ihost->ports[i];
1761		if (iport->active_phy_mask & 1 << iphy->phy_index)
1762			break;
1763	}
1764	spin_unlock_irqrestore(&ihost->scic_lock, flags);
1765
1766	if (i >= SCI_MAX_PORTS)
1767		iport = NULL;
1768
1769	port->lldd_port = iport;
1770}