linux/drivers/scsi/isci/port.c
<<
>>
Prefs
   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(unsigned long data)
 773{
 774        struct sci_timer *tmr = (struct sci_timer *)data;
 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}
1771