drivers/scsi/isci/port.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
port_state_name
sciport_to_dev
sci_port_get_protocols
sci_port_get_phys
sci_port_get_properties
sci_port_bcn_enable
isci_port_bc_change_received
isci_port_link_up
isci_port_link_down
is_port_ready_state
port_state_machine_change
isci_port_hard_reset_complete
sci_port_is_valid_phy_assignment
sci_port_is_phy_mask_valid
sci_port_get_a_connected_phy
sci_port_set_phy
sci_port_clear_phy
sci_port_get_sas_address
sci_port_get_attached_sas_address
sci_port_construct_dummy_rnc
sci_port_construct_dummy_task
sci_port_destroy_dummy_resources
sci_port_setup_transports
sci_port_resume_phy
sci_port_activate_phy
sci_port_deactivate_phy
sci_port_invalid_link_up
sci_port_general_link_up_handler
sci_port_is_wide
sci_port_link_detected
port_timeout
sci_port_update_viit_entry
sci_port_get_max_allowed_speed
sci_port_suspend_port_task_scheduler
sci_port_post_dummy_request
sci_port_abort_dummy_request
sci_port_resume_port_task_scheduler
sci_port_ready_substate_waiting_enter
scic_sds_port_ready_substate_waiting_exit
sci_port_ready_substate_operational_enter
sci_port_invalidate_dummy_remote_node
sci_port_ready_substate_operational_exit
sci_port_ready_substate_configuring_enter
sci_port_start
sci_port_stop
sci_port_hard_reset
sci_port_add_phy
sci_port_remove_phy
sci_port_link_up
sci_port_link_down
sci_port_start_io
sci_port_complete_io
sci_port_enable_port_task_scheduler
sci_port_disable_port_task_scheduler
sci_port_post_dummy_remote_node
sci_port_stopped_state_enter
sci_port_stopped_state_exit
sci_port_ready_state_enter
sci_port_resetting_state_exit
sci_port_stopping_state_exit
sci_port_failed_state_enter
sci_port_set_hang_detection_timeout
sci_port_construct
sci_port_broadcast_change_received
wait_port_reset
isci_port_perform_hard_reset
isci_ata_check_ready
isci_port_deformed
isci_port_formed
   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)
  65 const 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 
  73 static 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 
  88 static 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 
 102 static 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  */
 128 enum 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 
 143 static 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 
 159 static 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 
 171 static 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  */
 239 static 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 
 280 static 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 */
 294 static 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  */
 315 static 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  */
 362 bool 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  */
 408 static 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  */
 444 static 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 
 461 static 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 
 483 static 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 
 499 void 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 
 510 void 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  */
 542 static 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  */
 570 static 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 
 590 static 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 
 605 void 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 
 615 static 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 
 621 static 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 
 638 void 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 
 662 static 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  */
 688 static 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  */
 726 static 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  */
 754 bool 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 
 772 static 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 
 813 done:
 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  */
 824 static 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 
 846 enum 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 
 865 static 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  */
 883 static 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  */
 907 static 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  */
 930 static void
 931 sci_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 
 940 static 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 
 955 static 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 
 962 static 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 
 990 static 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  */
1023 static 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 
1042 static 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 
1056 enum 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 
1124 enum 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 
1146 static 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  */
1196 enum 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  */
1267 enum 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 
1308 enum 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 
1351 enum 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 
1381 enum 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 
1401 enum 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 
1438 static 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 
1448 static 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 
1458 static 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 
1486 static 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 
1499 static 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 
1507 static 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 
1528 static 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 
1535 static 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 
1544 static 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 
1551 void 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 
1576 static 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 
1606 void 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 
1635 void 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 
1643 static 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 
1648 int 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 
1694 int 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 
1719 void 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 
1744 void 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 }
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/scsi/isci/port.c

DEFINITIONS
