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.
7 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
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.
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.
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.
26 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
27 * All rights reserved.
29 * Redistribution and use in source and binary forms, with or without
30 * modification, are permitted provided that the following conditions
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
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.
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.
60 #define SCIC_SDS_PORT_HARD_RESET_TIMEOUT (1000)
61 #define SCU_DUMMY_INDEX (0xFFFF)
63 static void isci_port_change_state(struct isci_port *iport, enum isci_status status)
67 dev_dbg(&iport->isci_host->pdev->dev,
68 "%s: iport = %p, state = 0x%x\n",
69 __func__, iport, status);
71 /* XXX pointless lock */
72 spin_lock_irqsave(&iport->state_lock, flags);
73 iport->status = status;
74 spin_unlock_irqrestore(&iport->state_lock, flags);
77 static void sci_port_get_protocols(struct isci_port *iport, struct sci_phy_proto *proto)
82 for (index = 0; index < SCI_MAX_PHYS; index++) {
83 struct isci_phy *iphy = iport->phy_table[index];
87 sci_phy_get_protocols(iphy, proto);
91 static u32 sci_port_get_phys(struct isci_port *iport)
97 for (index = 0; index < SCI_MAX_PHYS; index++)
98 if (iport->phy_table[index])
105 * sci_port_get_properties() - This method simply returns the properties
106 * regarding the port, such as: physical index, protocols, sas address, etc.
107 * @port: this parameter specifies the port for which to retrieve the physical
109 * @properties: This parameter specifies the properties structure into which to
110 * copy the requested information.
112 * Indicate if the user specified a valid port. SCI_SUCCESS This value is
113 * returned if the specified port was valid. SCI_FAILURE_INVALID_PORT This
114 * value is returned if the specified port is not valid. When this value is
115 * returned, no data is copied to the properties output parameter.
117 static enum sci_status sci_port_get_properties(struct isci_port *iport,
118 struct sci_port_properties *prop)
120 if (!iport || iport->logical_port_index == SCIC_SDS_DUMMY_PORT)
121 return SCI_FAILURE_INVALID_PORT;
123 prop->index = iport->logical_port_index;
124 prop->phy_mask = sci_port_get_phys(iport);
125 sci_port_get_sas_address(iport, &prop->local.sas_address);
126 sci_port_get_protocols(iport, &prop->local.protocols);
127 sci_port_get_attached_sas_address(iport, &prop->remote.sas_address);
132 static void sci_port_bcn_enable(struct isci_port *iport)
134 struct isci_phy *iphy;
138 for (i = 0; i < ARRAY_SIZE(iport->phy_table); i++) {
139 iphy = iport->phy_table[i];
142 val = readl(&iphy->link_layer_registers->link_layer_control);
143 /* clear the bit by writing 1. */
144 writel(val, &iphy->link_layer_registers->link_layer_control);
148 static void isci_port_bc_change_received(struct isci_host *ihost,
149 struct isci_port *iport,
150 struct isci_phy *iphy)
152 dev_dbg(&ihost->pdev->dev,
153 "%s: isci_phy = %p, sas_phy = %p\n",
154 __func__, iphy, &iphy->sas_phy);
156 ihost->sas_ha.notify_port_event(&iphy->sas_phy, PORTE_BROADCAST_RCVD);
157 sci_port_bcn_enable(iport);
160 static void isci_port_link_up(struct isci_host *isci_host,
161 struct isci_port *iport,
162 struct isci_phy *iphy)
165 struct sci_port_properties properties;
166 unsigned long success = true;
168 BUG_ON(iphy->isci_port != NULL);
170 iphy->isci_port = iport;
172 dev_dbg(&isci_host->pdev->dev,
173 "%s: isci_port = %p\n",
176 spin_lock_irqsave(&iphy->sas_phy.frame_rcvd_lock, flags);
178 isci_port_change_state(iphy->isci_port, isci_starting);
180 sci_port_get_properties(iport, &properties);
182 if (iphy->protocol == SCIC_SDS_PHY_PROTOCOL_SATA) {
183 u64 attached_sas_address;
185 iphy->sas_phy.oob_mode = SATA_OOB_MODE;
186 iphy->sas_phy.frame_rcvd_size = sizeof(struct dev_to_host_fis);
189 * For direct-attached SATA devices, the SCI core will
190 * automagically assign a SAS address to the end device
191 * for the purpose of creating a port. This SAS address
192 * will not be the same as assigned to the PHY and needs
193 * to be obtained from struct sci_port_properties properties.
195 attached_sas_address = properties.remote.sas_address.high;
196 attached_sas_address <<= 32;
197 attached_sas_address |= properties.remote.sas_address.low;
198 swab64s(&attached_sas_address);
200 memcpy(&iphy->sas_phy.attached_sas_addr,
201 &attached_sas_address, sizeof(attached_sas_address));
202 } else if (iphy->protocol == SCIC_SDS_PHY_PROTOCOL_SAS) {
203 iphy->sas_phy.oob_mode = SAS_OOB_MODE;
204 iphy->sas_phy.frame_rcvd_size = sizeof(struct sas_identify_frame);
206 /* Copy the attached SAS address from the IAF */
207 memcpy(iphy->sas_phy.attached_sas_addr,
208 iphy->frame_rcvd.iaf.sas_addr, SAS_ADDR_SIZE);
210 dev_err(&isci_host->pdev->dev, "%s: unkown target\n", __func__);
214 iphy->sas_phy.phy->negotiated_linkrate = sci_phy_linkrate(iphy);
216 spin_unlock_irqrestore(&iphy->sas_phy.frame_rcvd_lock, flags);
218 /* Notify libsas that we have an address frame, if indeed
219 * we've found an SSP, SMP, or STP target */
221 isci_host->sas_ha.notify_port_event(&iphy->sas_phy,
227 * isci_port_link_down() - This function is called by the sci core when a link
229 * @isci_host: This parameter specifies the isci host object.
230 * @phy: This parameter specifies the isci phy with the active link.
231 * @port: This parameter specifies the isci port with the active link.
234 static void isci_port_link_down(struct isci_host *isci_host,
235 struct isci_phy *isci_phy,
236 struct isci_port *isci_port)
238 struct isci_remote_device *isci_device;
240 dev_dbg(&isci_host->pdev->dev,
241 "%s: isci_port = %p\n", __func__, isci_port);
245 /* check to see if this is the last phy on this port. */
246 if (isci_phy->sas_phy.port &&
247 isci_phy->sas_phy.port->num_phys == 1) {
248 /* change the state for all devices on this port. The
249 * next task sent to this device will be returned as
250 * SAS_TASK_UNDELIVERED, and the scsi mid layer will
253 list_for_each_entry(isci_device,
254 &isci_port->remote_dev_list,
256 dev_dbg(&isci_host->pdev->dev,
257 "%s: isci_device = %p\n",
258 __func__, isci_device);
259 set_bit(IDEV_GONE, &isci_device->flags);
261 isci_port_change_state(isci_port, isci_stopping);
265 /* Notify libsas of the borken link, this will trigger calls to our
266 * isci_port_deformed and isci_dev_gone functions.
268 sas_phy_disconnected(&isci_phy->sas_phy);
269 isci_host->sas_ha.notify_phy_event(&isci_phy->sas_phy,
270 PHYE_LOSS_OF_SIGNAL);
272 isci_phy->isci_port = NULL;
274 dev_dbg(&isci_host->pdev->dev,
275 "%s: isci_port = %p - Done\n", __func__, isci_port);
280 * isci_port_ready() - This function is called by the sci core when a link
282 * @isci_host: This parameter specifies the isci host object.
283 * @port: This parameter specifies the sci port with the active link.
286 static void isci_port_ready(struct isci_host *isci_host, struct isci_port *isci_port)
288 dev_dbg(&isci_host->pdev->dev,
289 "%s: isci_port = %p\n", __func__, isci_port);
291 complete_all(&isci_port->start_complete);
292 isci_port_change_state(isci_port, isci_ready);
297 * isci_port_not_ready() - This function is called by the sci core when a link
298 * is not ready. All remote devices on this link will be removed if they are
299 * in the stopping state.
300 * @isci_host: This parameter specifies the isci host object.
301 * @port: This parameter specifies the sci port with the active link.
304 static void isci_port_not_ready(struct isci_host *isci_host, struct isci_port *isci_port)
306 dev_dbg(&isci_host->pdev->dev,
307 "%s: isci_port = %p\n", __func__, isci_port);
310 static void isci_port_stop_complete(struct isci_host *ihost,
311 struct isci_port *iport,
312 enum sci_status completion_status)
314 dev_dbg(&ihost->pdev->dev, "Port stop complete\n");
318 static bool is_port_ready_state(enum sci_port_states state)
322 case SCI_PORT_SUB_WAITING:
323 case SCI_PORT_SUB_OPERATIONAL:
324 case SCI_PORT_SUB_CONFIGURING:
331 /* flag dummy rnc hanling when exiting a ready state */
332 static void port_state_machine_change(struct isci_port *iport,
333 enum sci_port_states state)
335 struct sci_base_state_machine *sm = &iport->sm;
336 enum sci_port_states old_state = sm->current_state_id;
338 if (is_port_ready_state(old_state) && !is_port_ready_state(state))
339 iport->ready_exit = true;
341 sci_change_state(sm, state);
342 iport->ready_exit = false;
346 * isci_port_hard_reset_complete() - This function is called by the sci core
347 * when the hard reset complete notification has been received.
348 * @port: This parameter specifies the sci port with the active link.
349 * @completion_status: This parameter specifies the core status for the reset
353 static void isci_port_hard_reset_complete(struct isci_port *isci_port,
354 enum sci_status completion_status)
356 dev_dbg(&isci_port->isci_host->pdev->dev,
357 "%s: isci_port = %p, completion_status=%x\n",
358 __func__, isci_port, completion_status);
360 /* Save the status of the hard reset from the port. */
361 isci_port->hard_reset_status = completion_status;
363 if (completion_status != SCI_SUCCESS) {
365 /* The reset failed. The port state is now SCI_PORT_FAILED. */
366 if (isci_port->active_phy_mask == 0) {
368 /* Generate the link down now to the host, since it
369 * was intercepted by the hard reset state machine when
370 * it really happened.
372 isci_port_link_down(isci_port->isci_host,
373 &isci_port->isci_host->phys[
374 isci_port->last_active_phy],
377 /* Advance the port state so that link state changes will be
380 port_state_machine_change(isci_port, SCI_PORT_SUB_WAITING);
383 complete_all(&isci_port->hard_reset_complete);
386 /* This method will return a true value if the specified phy can be assigned to
387 * this port The following is a list of phys for each port that are allowed: -
388 * Port 0 - 3 2 1 0 - Port 1 - 1 - Port 2 - 3 2 - Port 3 - 3 This method
389 * doesn't preclude all configurations. It merely ensures that a phy is part
390 * of the allowable set of phy identifiers for that port. For example, one
391 * could assign phy 3 to port 0 and no other phys. Please refer to
392 * sci_port_is_phy_mask_valid() for information regarding whether the
393 * phy_mask for a port can be supported. bool true if this is a valid phy
394 * assignment for the port false if this is not a valid phy assignment for the
397 bool sci_port_is_valid_phy_assignment(struct isci_port *iport, u32 phy_index)
399 struct isci_host *ihost = iport->owning_controller;
400 struct sci_user_parameters *user = &ihost->user_parameters;
402 /* Initialize to invalid value. */
403 u32 existing_phy_index = SCI_MAX_PHYS;
406 if ((iport->physical_port_index == 1) && (phy_index != 1))
409 if (iport->physical_port_index == 3 && phy_index != 3)
412 if (iport->physical_port_index == 2 &&
413 (phy_index == 0 || phy_index == 1))
416 for (index = 0; index < SCI_MAX_PHYS; index++)
417 if (iport->phy_table[index] && index != phy_index)
418 existing_phy_index = index;
420 /* Ensure that all of the phys in the port are capable of
421 * operating at the same maximum link rate.
423 if (existing_phy_index < SCI_MAX_PHYS &&
424 user->phys[phy_index].max_speed_generation !=
425 user->phys[existing_phy_index].max_speed_generation)
433 * @sci_port: This is the port object for which to determine if the phy mask
436 * This method will return a true value if the port's phy mask can be supported
437 * by the SCU. The following is a list of valid PHY mask configurations for
438 * each port: - Port 0 - [[3 2] 1] 0 - Port 1 - [1] - Port 2 - [[3] 2]
439 * - Port 3 - [3] This method returns a boolean indication specifying if the
440 * phy mask can be supported. true if this is a valid phy assignment for the
441 * port false if this is not a valid phy assignment for the port
443 static bool sci_port_is_phy_mask_valid(
444 struct isci_port *iport,
447 if (iport->physical_port_index == 0) {
448 if (((phy_mask & 0x0F) == 0x0F)
449 || ((phy_mask & 0x03) == 0x03)
450 || ((phy_mask & 0x01) == 0x01)
453 } else if (iport->physical_port_index == 1) {
454 if (((phy_mask & 0x02) == 0x02)
457 } else if (iport->physical_port_index == 2) {
458 if (((phy_mask & 0x0C) == 0x0C)
459 || ((phy_mask & 0x04) == 0x04)
462 } else if (iport->physical_port_index == 3) {
463 if (((phy_mask & 0x08) == 0x08)
472 * This method retrieves a currently active (i.e. connected) phy contained in
473 * the port. Currently, the lowest order phy that is connected is returned.
474 * This method returns a pointer to a SCIS_SDS_PHY object. NULL This value is
475 * returned if there are no currently active (i.e. connected to a remote end
476 * point) phys contained in the port. All other values specify a struct sci_phy
477 * object that is active in the port.
479 static struct isci_phy *sci_port_get_a_connected_phy(struct isci_port *iport)
482 struct isci_phy *iphy;
484 for (index = 0; index < SCI_MAX_PHYS; index++) {
485 /* Ensure that the phy is both part of the port and currently
486 * connected to the remote end-point.
488 iphy = iport->phy_table[index];
489 if (iphy && sci_port_active_phy(iport, iphy))
496 static enum sci_status sci_port_set_phy(struct isci_port *iport, struct isci_phy *iphy)
498 /* Check to see if we can add this phy to a port
499 * that means that the phy is not part of a port and that the port does
500 * not already have a phy assinged to the phy index.
502 if (!iport->phy_table[iphy->phy_index] &&
503 !phy_get_non_dummy_port(iphy) &&
504 sci_port_is_valid_phy_assignment(iport, iphy->phy_index)) {
505 /* Phy is being added in the stopped state so we are in MPC mode
506 * make logical port index = physical port index
508 iport->logical_port_index = iport->physical_port_index;
509 iport->phy_table[iphy->phy_index] = iphy;
510 sci_phy_set_port(iphy, iport);
518 static enum sci_status sci_port_clear_phy(struct isci_port *iport, struct isci_phy *iphy)
520 /* Make sure that this phy is part of this port */
521 if (iport->phy_table[iphy->phy_index] == iphy &&
522 phy_get_non_dummy_port(iphy) == iport) {
523 struct isci_host *ihost = iport->owning_controller;
525 /* Yep it is assigned to this port so remove it */
526 sci_phy_set_port(iphy, &ihost->ports[SCI_MAX_PORTS]);
527 iport->phy_table[iphy->phy_index] = NULL;
534 void sci_port_get_sas_address(struct isci_port *iport, struct sci_sas_address *sas)
540 for (index = 0; index < SCI_MAX_PHYS; index++)
541 if (iport->phy_table[index])
542 sci_phy_get_sas_address(iport->phy_table[index], sas);
545 void sci_port_get_attached_sas_address(struct isci_port *iport, struct sci_sas_address *sas)
547 struct isci_phy *iphy;
550 * Ensure that the phy is both part of the port and currently
551 * connected to the remote end-point.
553 iphy = sci_port_get_a_connected_phy(iport);
555 if (iphy->protocol != SCIC_SDS_PHY_PROTOCOL_SATA) {
556 sci_phy_get_attached_sas_address(iphy, sas);
558 sci_phy_get_sas_address(iphy, sas);
559 sas->low += iphy->phy_index;
568 * sci_port_construct_dummy_rnc() - create dummy rnc for si workaround
570 * @sci_port: logical port on which we need to create the remote node context
571 * @rni: remote node index for this remote node context.
573 * This routine will construct a dummy remote node context data structure
574 * This structure will be posted to the hardware to work around a scheduler
575 * error in the hardware.
577 static void sci_port_construct_dummy_rnc(struct isci_port *iport, u16 rni)
579 union scu_remote_node_context *rnc;
581 rnc = &iport->owning_controller->remote_node_context_table[rni];
583 memset(rnc, 0, sizeof(union scu_remote_node_context));
585 rnc->ssp.remote_sas_address_hi = 0;
586 rnc->ssp.remote_sas_address_lo = 0;
588 rnc->ssp.remote_node_index = rni;
589 rnc->ssp.remote_node_port_width = 1;
590 rnc->ssp.logical_port_index = iport->physical_port_index;
592 rnc->ssp.nexus_loss_timer_enable = false;
593 rnc->ssp.check_bit = false;
594 rnc->ssp.is_valid = true;
595 rnc->ssp.is_remote_node_context = true;
596 rnc->ssp.function_number = 0;
597 rnc->ssp.arbitration_wait_time = 0;
601 * construct a dummy task context data structure. This
602 * structure will be posted to the hardwre to work around a scheduler error
605 static void sci_port_construct_dummy_task(struct isci_port *iport, u16 tag)
607 struct isci_host *ihost = iport->owning_controller;
608 struct scu_task_context *task_context;
610 task_context = &ihost->task_context_table[ISCI_TAG_TCI(tag)];
611 memset(task_context, 0, sizeof(struct scu_task_context));
613 task_context->initiator_request = 1;
614 task_context->connection_rate = 1;
615 task_context->logical_port_index = iport->physical_port_index;
616 task_context->protocol_type = SCU_TASK_CONTEXT_PROTOCOL_SSP;
617 task_context->task_index = ISCI_TAG_TCI(tag);
618 task_context->valid = SCU_TASK_CONTEXT_VALID;
619 task_context->context_type = SCU_TASK_CONTEXT_TYPE;
620 task_context->remote_node_index = iport->reserved_rni;
621 task_context->do_not_dma_ssp_good_response = 1;
622 task_context->task_phase = 0x01;
625 static void sci_port_destroy_dummy_resources(struct isci_port *iport)
627 struct isci_host *ihost = iport->owning_controller;
629 if (iport->reserved_tag != SCI_CONTROLLER_INVALID_IO_TAG)
630 isci_free_tag(ihost, iport->reserved_tag);
632 if (iport->reserved_rni != SCU_DUMMY_INDEX)
633 sci_remote_node_table_release_remote_node_index(&ihost->available_remote_nodes,
634 1, iport->reserved_rni);
636 iport->reserved_rni = SCU_DUMMY_INDEX;
637 iport->reserved_tag = SCI_CONTROLLER_INVALID_IO_TAG;
640 void sci_port_setup_transports(struct isci_port *iport, u32 device_id)
644 for (index = 0; index < SCI_MAX_PHYS; index++) {
645 if (iport->active_phy_mask & (1 << index))
646 sci_phy_setup_transport(iport->phy_table[index], device_id);
650 static void sci_port_activate_phy(struct isci_port *iport, struct isci_phy *iphy,
653 struct isci_host *ihost = iport->owning_controller;
655 if (iphy->protocol != SCIC_SDS_PHY_PROTOCOL_SATA)
656 sci_phy_resume(iphy);
658 iport->active_phy_mask |= 1 << iphy->phy_index;
660 sci_controller_clear_invalid_phy(ihost, iphy);
662 if (do_notify_user == true)
663 isci_port_link_up(ihost, iport, iphy);
666 void sci_port_deactivate_phy(struct isci_port *iport, struct isci_phy *iphy,
669 struct isci_host *ihost = iport->owning_controller;
671 iport->active_phy_mask &= ~(1 << iphy->phy_index);
672 if (!iport->active_phy_mask)
673 iport->last_active_phy = iphy->phy_index;
675 iphy->max_negotiated_speed = SAS_LINK_RATE_UNKNOWN;
677 /* Re-assign the phy back to the LP as if it were a narrow port for APC
678 * mode. For MPC mode, the phy will remain in the port.
680 if (iport->owning_controller->oem_parameters.controller.mode_type ==
681 SCIC_PORT_AUTOMATIC_CONFIGURATION_MODE)
682 writel(iphy->phy_index,
683 &iport->port_pe_configuration_register[iphy->phy_index]);
685 if (do_notify_user == true)
686 isci_port_link_down(ihost, iphy, iport);
689 static void sci_port_invalid_link_up(struct isci_port *iport, struct isci_phy *iphy)
691 struct isci_host *ihost = iport->owning_controller;
694 * Check to see if we have alreay reported this link as bad and if
695 * not go ahead and tell the SCI_USER that we have discovered an
698 if ((ihost->invalid_phy_mask & (1 << iphy->phy_index)) == 0) {
699 ihost->invalid_phy_mask |= 1 << iphy->phy_index;
700 dev_warn(&ihost->pdev->dev, "Invalid link up!\n");
705 * sci_port_general_link_up_handler - phy can be assigned to port?
706 * @sci_port: sci_port object for which has a phy that has gone link up.
707 * @sci_phy: This is the struct isci_phy object that has gone link up.
708 * @do_notify_user: This parameter specifies whether to inform the user (via
709 * sci_port_link_up()) as to the fact that a new phy as become ready.
711 * Determine if this phy can be assigned to this
712 * port . If the phy is not a valid PHY for
713 * this port then the function will notify the user. A PHY can only be
714 * part of a port if it's attached SAS ADDRESS is the same as all other PHYs in
715 * the same port. none
717 static void sci_port_general_link_up_handler(struct isci_port *iport,
718 struct isci_phy *iphy,
721 struct sci_sas_address port_sas_address;
722 struct sci_sas_address phy_sas_address;
724 sci_port_get_attached_sas_address(iport, &port_sas_address);
725 sci_phy_get_attached_sas_address(iphy, &phy_sas_address);
727 /* If the SAS address of the new phy matches the SAS address of
728 * other phys in the port OR this is the first phy in the port,
729 * then activate the phy and allow it to be used for operations
732 if ((phy_sas_address.high == port_sas_address.high &&
733 phy_sas_address.low == port_sas_address.low) ||
734 iport->active_phy_mask == 0) {
735 struct sci_base_state_machine *sm = &iport->sm;
737 sci_port_activate_phy(iport, iphy, do_notify_user);
738 if (sm->current_state_id == SCI_PORT_RESETTING)
739 port_state_machine_change(iport, SCI_PORT_READY);
741 sci_port_invalid_link_up(iport, iphy);
747 * This method returns false if the port only has a single phy object assigned.
748 * If there are no phys or more than one phy then the method will return
750 * @sci_port: The port for which the wide port condition is to be checked.
752 * bool true Is returned if this is a wide ported port. false Is returned if
753 * this is a narrow port.
755 static bool sci_port_is_wide(struct isci_port *iport)
760 for (index = 0; index < SCI_MAX_PHYS; index++) {
761 if (iport->phy_table[index] != NULL) {
766 return phy_count != 1;
770 * This method is called by the PHY object when the link is detected. if the
771 * port wants the PHY to continue on to the link up state then the port
772 * layer must return true. If the port object returns false the phy object
773 * must halt its attempt to go link up.
774 * @sci_port: The port associated with the phy object.
775 * @sci_phy: The phy object that is trying to go link up.
777 * true if the phy object can continue to the link up condition. true Is
778 * returned if this phy can continue to the ready state. false Is returned if
779 * can not continue on to the ready state. This notification is in place for
780 * wide ports and direct attached phys. Since there are no wide ported SATA
781 * devices this could become an invalid port configuration.
783 bool sci_port_link_detected(
784 struct isci_port *iport,
785 struct isci_phy *iphy)
787 if ((iport->logical_port_index != SCIC_SDS_DUMMY_PORT) &&
788 (iphy->protocol == SCIC_SDS_PHY_PROTOCOL_SATA) &&
789 sci_port_is_wide(iport)) {
790 sci_port_invalid_link_up(iport, iphy);
798 static void port_timeout(unsigned long data)
800 struct sci_timer *tmr = (struct sci_timer *)data;
801 struct isci_port *iport = container_of(tmr, typeof(*iport), timer);
802 struct isci_host *ihost = iport->owning_controller;
806 spin_lock_irqsave(&ihost->scic_lock, flags);
811 current_state = iport->sm.current_state_id;
813 if (current_state == SCI_PORT_RESETTING) {
814 /* if the port is still in the resetting state then the timeout
815 * fired before the reset completed.
817 port_state_machine_change(iport, SCI_PORT_FAILED);
818 } else if (current_state == SCI_PORT_STOPPED) {
819 /* if the port is stopped then the start request failed In this
820 * case stay in the stopped state.
822 dev_err(sciport_to_dev(iport),
823 "%s: SCIC Port 0x%p failed to stop before tiemout.\n",
826 } else if (current_state == SCI_PORT_STOPPING) {
827 /* if the port is still stopping then the stop has not completed */
828 isci_port_stop_complete(iport->owning_controller,
830 SCI_FAILURE_TIMEOUT);
832 /* The port is in the ready state and we have a timer
833 * reporting a timeout this should not happen.
835 dev_err(sciport_to_dev(iport),
836 "%s: SCIC Port 0x%p is processing a timeout operation "
837 "in state %d.\n", __func__, iport, current_state);
841 spin_unlock_irqrestore(&ihost->scic_lock, flags);
844 /* --------------------------------------------------------------------------- */
847 * This function updates the hardwares VIIT entry for this port.
851 static void sci_port_update_viit_entry(struct isci_port *iport)
853 struct sci_sas_address sas_address;
855 sci_port_get_sas_address(iport, &sas_address);
857 writel(sas_address.high,
858 &iport->viit_registers->initiator_sas_address_hi);
859 writel(sas_address.low,
860 &iport->viit_registers->initiator_sas_address_lo);
862 /* This value get cleared just in case its not already cleared */
863 writel(0, &iport->viit_registers->reserved);
865 /* We are required to update the status register last */
866 writel(SCU_VIIT_ENTRY_ID_VIIT |
867 SCU_VIIT_IPPT_INITIATOR |
868 ((1 << iport->physical_port_index) << SCU_VIIT_ENTRY_LPVIE_SHIFT) |
869 SCU_VIIT_STATUS_ALL_VALID,
870 &iport->viit_registers->status);
873 enum sas_linkrate sci_port_get_max_allowed_speed(struct isci_port *iport)
876 struct isci_phy *iphy;
877 enum sas_linkrate max_allowed_speed = SAS_LINK_RATE_6_0_GBPS;
880 * Loop through all of the phys in this port and find the phy with the
881 * lowest maximum link rate. */
882 for (index = 0; index < SCI_MAX_PHYS; index++) {
883 iphy = iport->phy_table[index];
884 if (iphy && sci_port_active_phy(iport, iphy) &&
885 iphy->max_negotiated_speed < max_allowed_speed)
886 max_allowed_speed = iphy->max_negotiated_speed;
889 return max_allowed_speed;
892 static void sci_port_suspend_port_task_scheduler(struct isci_port *iport)
894 u32 pts_control_value;
896 pts_control_value = readl(&iport->port_task_scheduler_registers->control);
897 pts_control_value |= SCU_PTSxCR_GEN_BIT(SUSPEND);
898 writel(pts_control_value, &iport->port_task_scheduler_registers->control);
902 * sci_port_post_dummy_request() - post dummy/workaround request
903 * @sci_port: port to post task
905 * Prevent the hardware scheduler from posting new requests to the front
906 * of the scheduler queue causing a starvation problem for currently
910 static void sci_port_post_dummy_request(struct isci_port *iport)
912 struct isci_host *ihost = iport->owning_controller;
913 u16 tag = iport->reserved_tag;
914 struct scu_task_context *tc;
917 tc = &ihost->task_context_table[ISCI_TAG_TCI(tag)];
920 command = SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
921 iport->physical_port_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT |
924 sci_controller_post_request(ihost, command);
928 * This routine will abort the dummy request. This will alow the hardware to
929 * power down parts of the silicon to save power.
931 * @sci_port: The port on which the task must be aborted.
934 static void sci_port_abort_dummy_request(struct isci_port *iport)
936 struct isci_host *ihost = iport->owning_controller;
937 u16 tag = iport->reserved_tag;
938 struct scu_task_context *tc;
941 tc = &ihost->task_context_table[ISCI_TAG_TCI(tag)];
944 command = SCU_CONTEXT_COMMAND_REQUEST_POST_TC_ABORT |
945 iport->physical_port_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT |
948 sci_controller_post_request(ihost, command);
953 * @sci_port: This is the struct isci_port object to resume.
955 * This method will resume the port task scheduler for this port object. none
958 sci_port_resume_port_task_scheduler(struct isci_port *iport)
960 u32 pts_control_value;
962 pts_control_value = readl(&iport->port_task_scheduler_registers->control);
963 pts_control_value &= ~SCU_PTSxCR_GEN_BIT(SUSPEND);
964 writel(pts_control_value, &iport->port_task_scheduler_registers->control);
967 static void sci_port_ready_substate_waiting_enter(struct sci_base_state_machine *sm)
969 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
971 sci_port_suspend_port_task_scheduler(iport);
973 iport->not_ready_reason = SCIC_PORT_NOT_READY_NO_ACTIVE_PHYS;
975 if (iport->active_phy_mask != 0) {
976 /* At least one of the phys on the port is ready */
977 port_state_machine_change(iport,
978 SCI_PORT_SUB_OPERATIONAL);
982 static void sci_port_ready_substate_operational_enter(struct sci_base_state_machine *sm)
985 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
986 struct isci_host *ihost = iport->owning_controller;
988 isci_port_ready(ihost, iport);
990 for (index = 0; index < SCI_MAX_PHYS; index++) {
991 if (iport->phy_table[index]) {
992 writel(iport->physical_port_index,
993 &iport->port_pe_configuration_register[
994 iport->phy_table[index]->phy_index]);
998 sci_port_update_viit_entry(iport);
1000 sci_port_resume_port_task_scheduler(iport);
1003 * Post the dummy task for the port so the hardware can schedule
1006 sci_port_post_dummy_request(iport);
1009 static void sci_port_invalidate_dummy_remote_node(struct isci_port *iport)
1011 struct isci_host *ihost = iport->owning_controller;
1012 u8 phys_index = iport->physical_port_index;
1013 union scu_remote_node_context *rnc;
1014 u16 rni = iport->reserved_rni;
1017 rnc = &ihost->remote_node_context_table[rni];
1019 rnc->ssp.is_valid = false;
1021 /* ensure the preceding tc abort request has reached the
1022 * controller and give it ample time to act before posting the rnc
1025 readl(&ihost->smu_registers->interrupt_status); /* flush */
1028 command = SCU_CONTEXT_COMMAND_POST_RNC_INVALIDATE |
1029 phys_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT | rni;
1031 sci_controller_post_request(ihost, command);
1036 * @object: This is the object which is cast to a struct isci_port object.
1038 * This method will perform the actions required by the struct isci_port on
1039 * exiting the SCI_PORT_SUB_OPERATIONAL. This function reports
1040 * the port not ready and suspends the port task scheduler. none
1042 static void sci_port_ready_substate_operational_exit(struct sci_base_state_machine *sm)
1044 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
1045 struct isci_host *ihost = iport->owning_controller;
1048 * Kill the dummy task for this port if it has not yet posted
1049 * the hardware will treat this as a NOP and just return abort
1052 sci_port_abort_dummy_request(iport);
1054 isci_port_not_ready(ihost, iport);
1056 if (iport->ready_exit)
1057 sci_port_invalidate_dummy_remote_node(iport);
1060 static void sci_port_ready_substate_configuring_enter(struct sci_base_state_machine *sm)
1062 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
1063 struct isci_host *ihost = iport->owning_controller;
1065 if (iport->active_phy_mask == 0) {
1066 isci_port_not_ready(ihost, iport);
1068 port_state_machine_change(iport,
1069 SCI_PORT_SUB_WAITING);
1070 } else if (iport->started_request_count == 0)
1071 port_state_machine_change(iport,
1072 SCI_PORT_SUB_OPERATIONAL);
1075 static void sci_port_ready_substate_configuring_exit(struct sci_base_state_machine *sm)
1077 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
1079 sci_port_suspend_port_task_scheduler(iport);
1080 if (iport->ready_exit)
1081 sci_port_invalidate_dummy_remote_node(iport);
1084 enum sci_status sci_port_start(struct isci_port *iport)
1086 struct isci_host *ihost = iport->owning_controller;
1087 enum sci_status status = SCI_SUCCESS;
1088 enum sci_port_states state;
1091 state = iport->sm.current_state_id;
1092 if (state != SCI_PORT_STOPPED) {
1093 dev_warn(sciport_to_dev(iport),
1094 "%s: in wrong state: %d\n", __func__, state);
1095 return SCI_FAILURE_INVALID_STATE;
1098 if (iport->assigned_device_count > 0) {
1099 /* TODO This is a start failure operation because
1100 * there are still devices assigned to this port.
1101 * There must be no devices assigned to a port on a
1104 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
1107 if (iport->reserved_rni == SCU_DUMMY_INDEX) {
1108 u16 rni = sci_remote_node_table_allocate_remote_node(
1109 &ihost->available_remote_nodes, 1);
1111 if (rni != SCU_DUMMY_INDEX)
1112 sci_port_construct_dummy_rnc(iport, rni);
1114 status = SCI_FAILURE_INSUFFICIENT_RESOURCES;
1115 iport->reserved_rni = rni;
1118 if (iport->reserved_tag == SCI_CONTROLLER_INVALID_IO_TAG) {
1121 tag = isci_alloc_tag(ihost);
1122 if (tag == SCI_CONTROLLER_INVALID_IO_TAG)
1123 status = SCI_FAILURE_INSUFFICIENT_RESOURCES;
1125 sci_port_construct_dummy_task(iport, tag);
1126 iport->reserved_tag = tag;
1129 if (status == SCI_SUCCESS) {
1130 phy_mask = sci_port_get_phys(iport);
1133 * There are one or more phys assigned to this port. Make sure
1134 * the port's phy mask is in fact legal and supported by the
1137 if (sci_port_is_phy_mask_valid(iport, phy_mask) == true) {
1138 port_state_machine_change(iport,
1143 status = SCI_FAILURE;
1146 if (status != SCI_SUCCESS)
1147 sci_port_destroy_dummy_resources(iport);
1152 enum sci_status sci_port_stop(struct isci_port *iport)
1154 enum sci_port_states state;
1156 state = iport->sm.current_state_id;
1158 case SCI_PORT_STOPPED:
1160 case SCI_PORT_SUB_WAITING:
1161 case SCI_PORT_SUB_OPERATIONAL:
1162 case SCI_PORT_SUB_CONFIGURING:
1163 case SCI_PORT_RESETTING:
1164 port_state_machine_change(iport,
1168 dev_warn(sciport_to_dev(iport),
1169 "%s: in wrong state: %d\n", __func__, state);
1170 return SCI_FAILURE_INVALID_STATE;
1174 static enum sci_status sci_port_hard_reset(struct isci_port *iport, u32 timeout)
1176 enum sci_status status = SCI_FAILURE_INVALID_PHY;
1177 struct isci_phy *iphy = NULL;
1178 enum sci_port_states state;
1181 state = iport->sm.current_state_id;
1182 if (state != SCI_PORT_SUB_OPERATIONAL) {
1183 dev_warn(sciport_to_dev(iport),
1184 "%s: in wrong state: %d\n", __func__, state);
1185 return SCI_FAILURE_INVALID_STATE;
1188 /* Select a phy on which we can send the hard reset request. */
1189 for (phy_index = 0; phy_index < SCI_MAX_PHYS && !iphy; phy_index++) {
1190 iphy = iport->phy_table[phy_index];
1191 if (iphy && !sci_port_active_phy(iport, iphy)) {
1193 * We found a phy but it is not ready select
1200 /* If we have a phy then go ahead and start the reset procedure */
1203 status = sci_phy_reset(iphy);
1205 if (status != SCI_SUCCESS)
1208 sci_mod_timer(&iport->timer, timeout);
1209 iport->not_ready_reason = SCIC_PORT_NOT_READY_HARD_RESET_REQUESTED;
1211 port_state_machine_change(iport, SCI_PORT_RESETTING);
1216 * sci_port_add_phy() -
1217 * @sci_port: This parameter specifies the port in which the phy will be added.
1218 * @sci_phy: This parameter is the phy which is to be added to the port.
1220 * This method will add a PHY to the selected port. This method returns an
1221 * enum sci_status. SCI_SUCCESS the phy has been added to the port. Any other
1222 * status is a failure to add the phy to the port.
1224 enum sci_status sci_port_add_phy(struct isci_port *iport,
1225 struct isci_phy *iphy)
1227 enum sci_status status;
1228 enum sci_port_states state;
1230 state = iport->sm.current_state_id;
1232 case SCI_PORT_STOPPED: {
1233 struct sci_sas_address port_sas_address;
1235 /* Read the port assigned SAS Address if there is one */
1236 sci_port_get_sas_address(iport, &port_sas_address);
1238 if (port_sas_address.high != 0 && port_sas_address.low != 0) {
1239 struct sci_sas_address phy_sas_address;
1241 /* Make sure that the PHY SAS Address matches the SAS Address
1244 sci_phy_get_sas_address(iphy, &phy_sas_address);
1246 if (port_sas_address.high != phy_sas_address.high ||
1247 port_sas_address.low != phy_sas_address.low)
1248 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
1250 return sci_port_set_phy(iport, iphy);
1252 case SCI_PORT_SUB_WAITING:
1253 case SCI_PORT_SUB_OPERATIONAL:
1254 status = sci_port_set_phy(iport, iphy);
1256 if (status != SCI_SUCCESS)
1259 sci_port_general_link_up_handler(iport, iphy, true);
1260 iport->not_ready_reason = SCIC_PORT_NOT_READY_RECONFIGURING;
1261 port_state_machine_change(iport, SCI_PORT_SUB_CONFIGURING);
1264 case SCI_PORT_SUB_CONFIGURING:
1265 status = sci_port_set_phy(iport, iphy);
1267 if (status != SCI_SUCCESS)
1269 sci_port_general_link_up_handler(iport, iphy, true);
1271 /* Re-enter the configuring state since this may be the last phy in
1274 port_state_machine_change(iport,
1275 SCI_PORT_SUB_CONFIGURING);
1278 dev_warn(sciport_to_dev(iport),
1279 "%s: in wrong state: %d\n", __func__, state);
1280 return SCI_FAILURE_INVALID_STATE;
1285 * sci_port_remove_phy() -
1286 * @sci_port: This parameter specifies the port in which the phy will be added.
1287 * @sci_phy: This parameter is the phy which is to be added to the port.
1289 * This method will remove the PHY from the selected PORT. This method returns
1290 * an enum sci_status. SCI_SUCCESS the phy has been removed from the port. Any
1291 * other status is a failure to add the phy to the port.
1293 enum sci_status sci_port_remove_phy(struct isci_port *iport,
1294 struct isci_phy *iphy)
1296 enum sci_status status;
1297 enum sci_port_states state;
1299 state = iport->sm.current_state_id;
1302 case SCI_PORT_STOPPED:
1303 return sci_port_clear_phy(iport, iphy);
1304 case SCI_PORT_SUB_OPERATIONAL:
1305 status = sci_port_clear_phy(iport, iphy);
1306 if (status != SCI_SUCCESS)
1309 sci_port_deactivate_phy(iport, iphy, true);
1310 iport->not_ready_reason = SCIC_PORT_NOT_READY_RECONFIGURING;
1311 port_state_machine_change(iport,
1312 SCI_PORT_SUB_CONFIGURING);
1314 case SCI_PORT_SUB_CONFIGURING:
1315 status = sci_port_clear_phy(iport, iphy);
1317 if (status != SCI_SUCCESS)
1319 sci_port_deactivate_phy(iport, iphy, true);
1321 /* Re-enter the configuring state since this may be the last phy in
1324 port_state_machine_change(iport,
1325 SCI_PORT_SUB_CONFIGURING);
1328 dev_warn(sciport_to_dev(iport),
1329 "%s: in wrong state: %d\n", __func__, state);
1330 return SCI_FAILURE_INVALID_STATE;
1334 enum sci_status sci_port_link_up(struct isci_port *iport,
1335 struct isci_phy *iphy)
1337 enum sci_port_states state;
1339 state = iport->sm.current_state_id;
1341 case SCI_PORT_SUB_WAITING:
1342 /* Since this is the first phy going link up for the port we
1343 * can just enable it and continue
1345 sci_port_activate_phy(iport, iphy, true);
1347 port_state_machine_change(iport,
1348 SCI_PORT_SUB_OPERATIONAL);
1350 case SCI_PORT_SUB_OPERATIONAL:
1351 sci_port_general_link_up_handler(iport, iphy, true);
1353 case SCI_PORT_RESETTING:
1354 /* TODO We should make sure that the phy that has gone
1355 * link up is the same one on which we sent the reset. It is
1356 * possible that the phy on which we sent the reset is not the
1357 * one that has gone link up and we want to make sure that
1358 * phy being reset comes back. Consider the case where a
1359 * reset is sent but before the hardware processes the reset it
1360 * get a link up on the port because of a hot plug event.
1361 * because of the reset request this phy will go link down
1362 * almost immediately.
1365 /* In the resetting state we don't notify the user regarding
1366 * link up and link down notifications.
1368 sci_port_general_link_up_handler(iport, iphy, false);
1371 dev_warn(sciport_to_dev(iport),
1372 "%s: in wrong state: %d\n", __func__, state);
1373 return SCI_FAILURE_INVALID_STATE;
1377 enum sci_status sci_port_link_down(struct isci_port *iport,
1378 struct isci_phy *iphy)
1380 enum sci_port_states state;
1382 state = iport->sm.current_state_id;
1384 case SCI_PORT_SUB_OPERATIONAL:
1385 sci_port_deactivate_phy(iport, iphy, true);
1387 /* If there are no active phys left in the port, then
1388 * transition the port to the WAITING state until such time
1389 * as a phy goes link up
1391 if (iport->active_phy_mask == 0)
1392 port_state_machine_change(iport,
1393 SCI_PORT_SUB_WAITING);
1395 case SCI_PORT_RESETTING:
1396 /* In the resetting state we don't notify the user regarding
1397 * link up and link down notifications. */
1398 sci_port_deactivate_phy(iport, iphy, false);
1401 dev_warn(sciport_to_dev(iport),
1402 "%s: in wrong state: %d\n", __func__, state);
1403 return SCI_FAILURE_INVALID_STATE;
1407 enum sci_status sci_port_start_io(struct isci_port *iport,
1408 struct isci_remote_device *idev,
1409 struct isci_request *ireq)
1411 enum sci_port_states state;
1413 state = iport->sm.current_state_id;
1415 case SCI_PORT_SUB_WAITING:
1416 return SCI_FAILURE_INVALID_STATE;
1417 case SCI_PORT_SUB_OPERATIONAL:
1418 iport->started_request_count++;
1421 dev_warn(sciport_to_dev(iport),
1422 "%s: in wrong state: %d\n", __func__, state);
1423 return SCI_FAILURE_INVALID_STATE;
1427 enum sci_status sci_port_complete_io(struct isci_port *iport,
1428 struct isci_remote_device *idev,
1429 struct isci_request *ireq)
1431 enum sci_port_states state;
1433 state = iport->sm.current_state_id;
1435 case SCI_PORT_STOPPED:
1436 dev_warn(sciport_to_dev(iport),
1437 "%s: in wrong state: %d\n", __func__, state);
1438 return SCI_FAILURE_INVALID_STATE;
1439 case SCI_PORT_STOPPING:
1440 sci_port_decrement_request_count(iport);
1442 if (iport->started_request_count == 0)
1443 port_state_machine_change(iport,
1446 case SCI_PORT_READY:
1447 case SCI_PORT_RESETTING:
1448 case SCI_PORT_FAILED:
1449 case SCI_PORT_SUB_WAITING:
1450 case SCI_PORT_SUB_OPERATIONAL:
1451 sci_port_decrement_request_count(iport);
1453 case SCI_PORT_SUB_CONFIGURING:
1454 sci_port_decrement_request_count(iport);
1455 if (iport->started_request_count == 0) {
1456 port_state_machine_change(iport,
1457 SCI_PORT_SUB_OPERATIONAL);
1464 static void sci_port_enable_port_task_scheduler(struct isci_port *iport)
1466 u32 pts_control_value;
1468 /* enable the port task scheduler in a suspended state */
1469 pts_control_value = readl(&iport->port_task_scheduler_registers->control);
1470 pts_control_value |= SCU_PTSxCR_GEN_BIT(ENABLE) | SCU_PTSxCR_GEN_BIT(SUSPEND);
1471 writel(pts_control_value, &iport->port_task_scheduler_registers->control);
1474 static void sci_port_disable_port_task_scheduler(struct isci_port *iport)
1476 u32 pts_control_value;
1478 pts_control_value = readl(&iport->port_task_scheduler_registers->control);
1479 pts_control_value &=
1480 ~(SCU_PTSxCR_GEN_BIT(ENABLE) | SCU_PTSxCR_GEN_BIT(SUSPEND));
1481 writel(pts_control_value, &iport->port_task_scheduler_registers->control);
1484 static void sci_port_post_dummy_remote_node(struct isci_port *iport)
1486 struct isci_host *ihost = iport->owning_controller;
1487 u8 phys_index = iport->physical_port_index;
1488 union scu_remote_node_context *rnc;
1489 u16 rni = iport->reserved_rni;
1492 rnc = &ihost->remote_node_context_table[rni];
1493 rnc->ssp.is_valid = true;
1495 command = SCU_CONTEXT_COMMAND_POST_RNC_32 |
1496 phys_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT | rni;
1498 sci_controller_post_request(ihost, command);
1500 /* ensure hardware has seen the post rnc command and give it
1501 * ample time to act before sending the suspend
1503 readl(&ihost->smu_registers->interrupt_status); /* flush */
1506 command = SCU_CONTEXT_COMMAND_POST_RNC_SUSPEND_TX_RX |
1507 phys_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT | rni;
1509 sci_controller_post_request(ihost, command);
1512 static void sci_port_stopped_state_enter(struct sci_base_state_machine *sm)
1514 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
1516 if (iport->sm.previous_state_id == SCI_PORT_STOPPING) {
1518 * If we enter this state becasuse of a request to stop
1519 * the port then we want to disable the hardwares port
1520 * task scheduler. */
1521 sci_port_disable_port_task_scheduler(iport);
1525 static void sci_port_stopped_state_exit(struct sci_base_state_machine *sm)
1527 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
1529 /* Enable and suspend the port task scheduler */
1530 sci_port_enable_port_task_scheduler(iport);
1533 static void sci_port_ready_state_enter(struct sci_base_state_machine *sm)
1535 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
1536 struct isci_host *ihost = iport->owning_controller;
1539 prev_state = iport->sm.previous_state_id;
1540 if (prev_state == SCI_PORT_RESETTING)
1541 isci_port_hard_reset_complete(iport, SCI_SUCCESS);
1543 isci_port_not_ready(ihost, iport);
1545 /* Post and suspend the dummy remote node context for this port. */
1546 sci_port_post_dummy_remote_node(iport);
1548 /* Start the ready substate machine */
1549 port_state_machine_change(iport,
1550 SCI_PORT_SUB_WAITING);
1553 static void sci_port_resetting_state_exit(struct sci_base_state_machine *sm)
1555 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
1557 sci_del_timer(&iport->timer);
1560 static void sci_port_stopping_state_exit(struct sci_base_state_machine *sm)
1562 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
1564 sci_del_timer(&iport->timer);
1566 sci_port_destroy_dummy_resources(iport);
1569 static void sci_port_failed_state_enter(struct sci_base_state_machine *sm)
1571 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
1573 isci_port_hard_reset_complete(iport, SCI_FAILURE_TIMEOUT);
1576 /* --------------------------------------------------------------------------- */
1578 static const struct sci_base_state sci_port_state_table[] = {
1579 [SCI_PORT_STOPPED] = {
1580 .enter_state = sci_port_stopped_state_enter,
1581 .exit_state = sci_port_stopped_state_exit
1583 [SCI_PORT_STOPPING] = {
1584 .exit_state = sci_port_stopping_state_exit
1586 [SCI_PORT_READY] = {
1587 .enter_state = sci_port_ready_state_enter,
1589 [SCI_PORT_SUB_WAITING] = {
1590 .enter_state = sci_port_ready_substate_waiting_enter,
1592 [SCI_PORT_SUB_OPERATIONAL] = {
1593 .enter_state = sci_port_ready_substate_operational_enter,
1594 .exit_state = sci_port_ready_substate_operational_exit
1596 [SCI_PORT_SUB_CONFIGURING] = {
1597 .enter_state = sci_port_ready_substate_configuring_enter,
1598 .exit_state = sci_port_ready_substate_configuring_exit
1600 [SCI_PORT_RESETTING] = {
1601 .exit_state = sci_port_resetting_state_exit
1603 [SCI_PORT_FAILED] = {
1604 .enter_state = sci_port_failed_state_enter,
1608 void sci_port_construct(struct isci_port *iport, u8 index,
1609 struct isci_host *ihost)
1611 sci_init_sm(&iport->sm, sci_port_state_table, SCI_PORT_STOPPED);
1613 iport->logical_port_index = SCIC_SDS_DUMMY_PORT;
1614 iport->physical_port_index = index;
1615 iport->active_phy_mask = 0;
1616 iport->last_active_phy = 0;
1617 iport->ready_exit = false;
1619 iport->owning_controller = ihost;
1621 iport->started_request_count = 0;
1622 iport->assigned_device_count = 0;
1624 iport->reserved_rni = SCU_DUMMY_INDEX;
1625 iport->reserved_tag = SCI_CONTROLLER_INVALID_IO_TAG;
1627 sci_init_timer(&iport->timer, port_timeout);
1629 iport->port_task_scheduler_registers = NULL;
1631 for (index = 0; index < SCI_MAX_PHYS; index++)
1632 iport->phy_table[index] = NULL;
1635 void isci_port_init(struct isci_port *iport, struct isci_host *ihost, int index)
1637 INIT_LIST_HEAD(&iport->remote_dev_list);
1638 INIT_LIST_HEAD(&iport->domain_dev_list);
1639 spin_lock_init(&iport->state_lock);
1640 init_completion(&iport->start_complete);
1641 iport->isci_host = ihost;
1642 isci_port_change_state(iport, isci_freed);
1646 * isci_port_get_state() - This function gets the status of the port object.
1647 * @isci_port: This parameter points to the isci_port object
1649 * status of the object as a isci_status enum.
1651 enum isci_status isci_port_get_state(
1652 struct isci_port *isci_port)
1654 return isci_port->status;
1657 void sci_port_broadcast_change_received(struct isci_port *iport, struct isci_phy *iphy)
1659 struct isci_host *ihost = iport->owning_controller;
1661 /* notify the user. */
1662 isci_port_bc_change_received(ihost, iport, iphy);
1665 int isci_port_perform_hard_reset(struct isci_host *ihost, struct isci_port *iport,
1666 struct isci_phy *iphy)
1668 unsigned long flags;
1669 enum sci_status status;
1670 int ret = TMF_RESP_FUNC_COMPLETE;
1672 dev_dbg(&ihost->pdev->dev, "%s: iport = %p\n",
1675 init_completion(&iport->hard_reset_complete);
1677 spin_lock_irqsave(&ihost->scic_lock, flags);
1679 #define ISCI_PORT_RESET_TIMEOUT SCIC_SDS_SIGNATURE_FIS_TIMEOUT
1680 status = sci_port_hard_reset(iport, ISCI_PORT_RESET_TIMEOUT);
1682 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1684 if (status == SCI_SUCCESS) {
1685 wait_for_completion(&iport->hard_reset_complete);
1687 dev_dbg(&ihost->pdev->dev,
1688 "%s: iport = %p; hard reset completion\n",
1691 if (iport->hard_reset_status != SCI_SUCCESS) {
1692 ret = TMF_RESP_FUNC_FAILED;
1694 dev_err(&ihost->pdev->dev,
1695 "%s: iport = %p; hard reset failed (0x%x)\n",
1696 __func__, iport, iport->hard_reset_status);
1699 ret = TMF_RESP_FUNC_FAILED;
1701 dev_err(&ihost->pdev->dev,
1702 "%s: iport = %p; sci_port_hard_reset call"
1704 __func__, iport, status);
1708 /* If the hard reset for the port has failed, consider this
1709 * the same as link failures on all phys in the port.
1711 if (ret != TMF_RESP_FUNC_COMPLETE) {
1713 dev_err(&ihost->pdev->dev,
1714 "%s: iport = %p; hard reset failed "
1715 "(0x%x) - driving explicit link fail for all phys\n",
1716 __func__, iport, iport->hard_reset_status);
1722 * isci_port_deformed() - This function is called by libsas when a port becomes
1724 * @phy: This parameter specifies the libsas phy with the inactive port.
1727 void isci_port_deformed(struct asd_sas_phy *phy)
1729 pr_debug("%s: sas_phy = %p\n", __func__, phy);
1733 * isci_port_formed() - This function is called by libsas when a port becomes
1735 * @phy: This parameter specifies the libsas phy with the active port.
1738 void isci_port_formed(struct asd_sas_phy *phy)
1740 pr_debug("%s: sas_phy = %p, sas_port = %p\n", __func__, phy, phy->port);