blob: 7c6ac58a5c4c45c37af504f8e10bfa84cb7df3ee [file] [log] [blame]
Dan Williams6f231dd2011-07-02 22:56:22 -07001/*
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
Dan Williams6f231dd2011-07-02 22:56:22 -070056#include "isci.h"
Dan Williams6f231dd2011-07-02 22:56:22 -070057#include "port.h"
58#include "request.h"
Dan Williamse2f8db52011-05-10 02:28:46 -070059
60#define SCIC_SDS_PORT_HARD_RESET_TIMEOUT (1000)
61#define SCU_DUMMY_INDEX (0xFFFF)
Dan Williams6f231dd2011-07-02 22:56:22 -070062
Dan Williamse5313812011-05-07 10:11:43 -070063static void isci_port_change_state(struct isci_port *iport, enum isci_status status)
64{
65 unsigned long flags;
Dan Williams6f231dd2011-07-02 22:56:22 -070066
Dan Williamse5313812011-05-07 10:11:43 -070067 dev_dbg(&iport->isci_host->pdev->dev,
68 "%s: iport = %p, state = 0x%x\n",
69 __func__, iport, status);
Dan Williams6f231dd2011-07-02 22:56:22 -070070
Dan Williamse5313812011-05-07 10:11:43 -070071 /* XXX pointless lock */
72 spin_lock_irqsave(&iport->state_lock, flags);
73 iport->status = status;
74 spin_unlock_irqrestore(&iport->state_lock, flags);
75}
Dan Williams6f231dd2011-07-02 22:56:22 -070076
Dan Williams89a73012011-06-30 19:14:33 -070077static void sci_port_get_protocols(struct isci_port *iport, struct sci_phy_proto *proto)
Dan Williams6f231dd2011-07-02 22:56:22 -070078{
Dan Williamse2f8db52011-05-10 02:28:46 -070079 u8 index;
80
Dan Williams89a73012011-06-30 19:14:33 -070081 proto->all = 0;
Dan Williamse2f8db52011-05-10 02:28:46 -070082 for (index = 0; index < SCI_MAX_PHYS; index++) {
Dan Williams89a73012011-06-30 19:14:33 -070083 struct isci_phy *iphy = iport->phy_table[index];
84
85 if (!iphy)
86 continue;
87 sci_phy_get_protocols(iphy, proto);
Dan Williamse2f8db52011-05-10 02:28:46 -070088 }
Dan Williams6f231dd2011-07-02 22:56:22 -070089}
90
Dan Williams89a73012011-06-30 19:14:33 -070091static u32 sci_port_get_phys(struct isci_port *iport)
Dan Williams6f231dd2011-07-02 22:56:22 -070092{
Dan Williamse2f8db52011-05-10 02:28:46 -070093 u32 index;
94 u32 mask;
95
96 mask = 0;
Dan Williams89a73012011-06-30 19:14:33 -070097 for (index = 0; index < SCI_MAX_PHYS; index++)
98 if (iport->phy_table[index])
Dan Williamse2f8db52011-05-10 02:28:46 -070099 mask |= (1 << index);
Dan Williamse2f8db52011-05-10 02:28:46 -0700100
101 return mask;
Dan Williams6f231dd2011-07-02 22:56:22 -0700102}
103
Dan Williamse2f8db52011-05-10 02:28:46 -0700104/**
Dan Williams89a73012011-06-30 19:14:33 -0700105 * sci_port_get_properties() - This method simply returns the properties
Dan Williamse2f8db52011-05-10 02:28:46 -0700106 * regarding the port, such as: physical index, protocols, sas address, etc.
107 * @port: this parameter specifies the port for which to retrieve the physical
108 * index.
109 * @properties: This parameter specifies the properties structure into which to
110 * copy the requested information.
111 *
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.
116 */
Bartek Nowakowski7e629842012-01-04 01:33:20 -0800117enum sci_status sci_port_get_properties(struct isci_port *iport,
Dan Williams89a73012011-06-30 19:14:33 -0700118 struct sci_port_properties *prop)
Dan Williams6f231dd2011-07-02 22:56:22 -0700119{
Dan Williamsffe191c2011-06-29 13:09:25 -0700120 if (!iport || iport->logical_port_index == SCIC_SDS_DUMMY_PORT)
Dan Williamse2f8db52011-05-10 02:28:46 -0700121 return SCI_FAILURE_INVALID_PORT;
Dan Williams6f231dd2011-07-02 22:56:22 -0700122
Dan Williams89a73012011-06-30 19:14:33 -0700123 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);
Dan Williams6f231dd2011-07-02 22:56:22 -0700128
Dan Williamse2f8db52011-05-10 02:28:46 -0700129 return SCI_SUCCESS;
Dan Williams6f231dd2011-07-02 22:56:22 -0700130}
131
Dan Williams89a73012011-06-30 19:14:33 -0700132static void sci_port_bcn_enable(struct isci_port *iport)
Jeff Skirvin61aaff42011-06-21 12:16:33 -0700133{
Dan Williams85280952011-06-28 15:05:53 -0700134 struct isci_phy *iphy;
Jeff Skirvin61aaff42011-06-21 12:16:33 -0700135 u32 val;
136 int i;
137
Dan Williamsffe191c2011-06-29 13:09:25 -0700138 for (i = 0; i < ARRAY_SIZE(iport->phy_table); i++) {
139 iphy = iport->phy_table[i];
Dan Williams85280952011-06-28 15:05:53 -0700140 if (!iphy)
Jeff Skirvin61aaff42011-06-21 12:16:33 -0700141 continue;
Dan Williams85280952011-06-28 15:05:53 -0700142 val = readl(&iphy->link_layer_registers->link_layer_control);
Jeff Skirvin61aaff42011-06-21 12:16:33 -0700143 /* clear the bit by writing 1. */
Dan Williams85280952011-06-28 15:05:53 -0700144 writel(val, &iphy->link_layer_registers->link_layer_control);
Jeff Skirvin61aaff42011-06-21 12:16:33 -0700145 }
146}
147
Dan Williamsffe191c2011-06-29 13:09:25 -0700148static void isci_port_bc_change_received(struct isci_host *ihost,
149 struct isci_port *iport,
150 struct isci_phy *iphy)
Jeff Skirvin61aaff42011-06-21 12:16:33 -0700151{
Dan Williams52d74632011-10-27 15:05:37 -0700152 dev_dbg(&ihost->pdev->dev,
153 "%s: isci_phy = %p, sas_phy = %p\n",
154 __func__, iphy, &iphy->sas_phy);
Jeff Skirvin61aaff42011-06-21 12:16:33 -0700155
Dan Williams52d74632011-10-27 15:05:37 -0700156 ihost->sas_ha.notify_port_event(&iphy->sas_phy, PORTE_BROADCAST_RCVD);
Dan Williams89a73012011-06-30 19:14:33 -0700157 sci_port_bcn_enable(iport);
Jeff Skirvin61aaff42011-06-21 12:16:33 -0700158}
159
Dan Williamse2f8db52011-05-10 02:28:46 -0700160static void isci_port_link_up(struct isci_host *isci_host,
Dan Williamsffe191c2011-06-29 13:09:25 -0700161 struct isci_port *iport,
Dan Williams85280952011-06-28 15:05:53 -0700162 struct isci_phy *iphy)
Dan Williams6f231dd2011-07-02 22:56:22 -0700163{
164 unsigned long flags;
Dan Williams89a73012011-06-30 19:14:33 -0700165 struct sci_port_properties properties;
Dan Williams6f231dd2011-07-02 22:56:22 -0700166 unsigned long success = true;
167
Dan Williams85280952011-06-28 15:05:53 -0700168 BUG_ON(iphy->isci_port != NULL);
Bartosz Barcinski6cb4d6b2011-04-12 17:28:43 -0700169
Dan Williamsffe191c2011-06-29 13:09:25 -0700170 iphy->isci_port = iport;
Dan Williams6f231dd2011-07-02 22:56:22 -0700171
172 dev_dbg(&isci_host->pdev->dev,
173 "%s: isci_port = %p\n",
Dan Williamsffe191c2011-06-29 13:09:25 -0700174 __func__, iport);
Dan Williams6f231dd2011-07-02 22:56:22 -0700175
Dan Williams85280952011-06-28 15:05:53 -0700176 spin_lock_irqsave(&iphy->sas_phy.frame_rcvd_lock, flags);
Dan Williams6f231dd2011-07-02 22:56:22 -0700177
Dan Williams85280952011-06-28 15:05:53 -0700178 isci_port_change_state(iphy->isci_port, isci_starting);
Dan Williams6f231dd2011-07-02 22:56:22 -0700179
Dan Williams89a73012011-06-30 19:14:33 -0700180 sci_port_get_properties(iport, &properties);
Dan Williams6f231dd2011-07-02 22:56:22 -0700181
Dan Williams85280952011-06-28 15:05:53 -0700182 if (iphy->protocol == SCIC_SDS_PHY_PROTOCOL_SATA) {
Dan Williams150fc6f2011-02-25 10:25:21 -0800183 u64 attached_sas_address;
Dan Williams6f231dd2011-07-02 22:56:22 -0700184
Dan Williams85280952011-06-28 15:05:53 -0700185 iphy->sas_phy.oob_mode = SATA_OOB_MODE;
186 iphy->sas_phy.frame_rcvd_size = sizeof(struct dev_to_host_fis);
Dan Williams6f231dd2011-07-02 22:56:22 -0700187
188 /*
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
Dan Williams89a73012011-06-30 19:14:33 -0700193 * to be obtained from struct sci_port_properties properties.
Dan Williams6f231dd2011-07-02 22:56:22 -0700194 */
Dan Williams150fc6f2011-02-25 10:25:21 -0800195 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);
Dan Williams6f231dd2011-07-02 22:56:22 -0700199
Dan Williams85280952011-06-28 15:05:53 -0700200 memcpy(&iphy->sas_phy.attached_sas_addr,
Dan Williams150fc6f2011-02-25 10:25:21 -0800201 &attached_sas_address, sizeof(attached_sas_address));
Dan Williams85280952011-06-28 15:05:53 -0700202 } 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);
Dan Williams6f231dd2011-07-02 22:56:22 -0700205
206 /* Copy the attached SAS address from the IAF */
Dan Williams85280952011-06-28 15:05:53 -0700207 memcpy(iphy->sas_phy.attached_sas_addr,
208 iphy->frame_rcvd.iaf.sas_addr, SAS_ADDR_SIZE);
Dan Williams6f231dd2011-07-02 22:56:22 -0700209 } else {
210 dev_err(&isci_host->pdev->dev, "%s: unkown target\n", __func__);
211 success = false;
212 }
213
Dan Williams85280952011-06-28 15:05:53 -0700214 iphy->sas_phy.phy->negotiated_linkrate = sci_phy_linkrate(iphy);
Dan Williams83e51432011-02-18 09:25:13 -0800215
Dan Williams85280952011-06-28 15:05:53 -0700216 spin_unlock_irqrestore(&iphy->sas_phy.frame_rcvd_lock, flags);
Dan Williams6f231dd2011-07-02 22:56:22 -0700217
218 /* Notify libsas that we have an address frame, if indeed
219 * we've found an SSP, SMP, or STP target */
220 if (success)
Dan Williams85280952011-06-28 15:05:53 -0700221 isci_host->sas_ha.notify_port_event(&iphy->sas_phy,
Dan Williams6f231dd2011-07-02 22:56:22 -0700222 PORTE_BYTES_DMAED);
223}
224
225
226/**
227 * isci_port_link_down() - This function is called by the sci core when a link
228 * becomes inactive.
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.
232 *
233 */
Dan Williamse2f8db52011-05-10 02:28:46 -0700234static void isci_port_link_down(struct isci_host *isci_host,
235 struct isci_phy *isci_phy,
236 struct isci_port *isci_port)
Dan Williams6f231dd2011-07-02 22:56:22 -0700237{
238 struct isci_remote_device *isci_device;
239
240 dev_dbg(&isci_host->pdev->dev,
241 "%s: isci_port = %p\n", __func__, isci_port);
242
243 if (isci_port) {
244
245 /* check to see if this is the last phy on this port. */
Jeff Skirvin61aaff42011-06-21 12:16:33 -0700246 if (isci_phy->sas_phy.port &&
247 isci_phy->sas_phy.port->num_phys == 1) {
Jeff Skirvin61aaff42011-06-21 12:16:33 -0700248 /* 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
251 * remove the target
Dan Williams6f231dd2011-07-02 22:56:22 -0700252 */
253 list_for_each_entry(isci_device,
254 &isci_port->remote_dev_list,
255 node) {
256 dev_dbg(&isci_host->pdev->dev,
257 "%s: isci_device = %p\n",
258 __func__, isci_device);
Dan Williams209fae12011-06-13 17:39:44 -0700259 set_bit(IDEV_GONE, &isci_device->flags);
Dan Williams6f231dd2011-07-02 22:56:22 -0700260 }
Jeff Skirvincdd05f02011-09-28 18:47:56 -0700261 isci_port_change_state(isci_port, isci_stopping);
Dan Williams6f231dd2011-07-02 22:56:22 -0700262 }
Dan Williams6f231dd2011-07-02 22:56:22 -0700263 }
264
265 /* Notify libsas of the borken link, this will trigger calls to our
266 * isci_port_deformed and isci_dev_gone functions.
267 */
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);
271
272 isci_phy->isci_port = NULL;
273
274 dev_dbg(&isci_host->pdev->dev,
275 "%s: isci_port = %p - Done\n", __func__, isci_port);
276}
277
278
279/**
Dan Williams6f231dd2011-07-02 22:56:22 -0700280 * isci_port_ready() - This function is called by the sci core when a link
281 * becomes ready.
282 * @isci_host: This parameter specifies the isci host object.
283 * @port: This parameter specifies the sci port with the active link.
284 *
285 */
Dan Williamse2f8db52011-05-10 02:28:46 -0700286static void isci_port_ready(struct isci_host *isci_host, struct isci_port *isci_port)
Dan Williams6f231dd2011-07-02 22:56:22 -0700287{
288 dev_dbg(&isci_host->pdev->dev,
289 "%s: isci_port = %p\n", __func__, isci_port);
290
291 complete_all(&isci_port->start_complete);
292 isci_port_change_state(isci_port, isci_ready);
293 return;
294}
295
296/**
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.
302 *
303 */
Dan Williamse2f8db52011-05-10 02:28:46 -0700304static void isci_port_not_ready(struct isci_host *isci_host, struct isci_port *isci_port)
Dan Williams6f231dd2011-07-02 22:56:22 -0700305{
306 dev_dbg(&isci_host->pdev->dev,
307 "%s: isci_port = %p\n", __func__, isci_port);
308}
309
Dan Williamsd9dcb4b2011-06-30 17:38:32 -0700310static void isci_port_stop_complete(struct isci_host *ihost,
Dan Williamsffe191c2011-06-29 13:09:25 -0700311 struct isci_port *iport,
Dan Williamse2f8db52011-05-10 02:28:46 -0700312 enum sci_status completion_status)
313{
Dan Williamsd9dcb4b2011-06-30 17:38:32 -0700314 dev_dbg(&ihost->pdev->dev, "Port stop complete\n");
Dan Williamse2f8db52011-05-10 02:28:46 -0700315}
316
Jeff Skirvin8e35a132011-10-27 15:05:32 -0700317
318static bool is_port_ready_state(enum sci_port_states state)
319{
320 switch (state) {
321 case SCI_PORT_READY:
322 case SCI_PORT_SUB_WAITING:
323 case SCI_PORT_SUB_OPERATIONAL:
324 case SCI_PORT_SUB_CONFIGURING:
325 return true;
326 default:
327 return false;
328 }
329}
330
331/* flag dummy rnc hanling when exiting a ready state */
332static void port_state_machine_change(struct isci_port *iport,
333 enum sci_port_states state)
334{
335 struct sci_base_state_machine *sm = &iport->sm;
336 enum sci_port_states old_state = sm->current_state_id;
337
338 if (is_port_ready_state(old_state) && !is_port_ready_state(state))
339 iport->ready_exit = true;
340
341 sci_change_state(sm, state);
342 iport->ready_exit = false;
343}
344
Dan Williams6f231dd2011-07-02 22:56:22 -0700345/**
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
350 * process.
351 *
352 */
Dan Williamse2f8db52011-05-10 02:28:46 -0700353static void isci_port_hard_reset_complete(struct isci_port *isci_port,
354 enum sci_status completion_status)
Dan Williams6f231dd2011-07-02 22:56:22 -0700355{
356 dev_dbg(&isci_port->isci_host->pdev->dev,
357 "%s: isci_port = %p, completion_status=%x\n",
358 __func__, isci_port, completion_status);
359
360 /* Save the status of the hard reset from the port. */
361 isci_port->hard_reset_status = completion_status;
362
Jeff Skirvin8e35a132011-10-27 15:05:32 -0700363 if (completion_status != SCI_SUCCESS) {
364
365 /* The reset failed. The port state is now SCI_PORT_FAILED. */
366 if (isci_port->active_phy_mask == 0) {
367
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.
371 */
372 isci_port_link_down(isci_port->isci_host,
373 &isci_port->isci_host->phys[
374 isci_port->last_active_phy],
375 isci_port);
376 }
377 /* Advance the port state so that link state changes will be
378 * noticed.
379 */
380 port_state_machine_change(isci_port, SCI_PORT_SUB_WAITING);
381
382 }
Dan Williams6f231dd2011-07-02 22:56:22 -0700383 complete_all(&isci_port->hard_reset_complete);
384}
Dan Williams4393aa42011-03-31 13:10:44 -0700385
Dan Williamse2f8db52011-05-10 02:28:46 -0700386/* 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
Dan Williams89a73012011-06-30 19:14:33 -0700392 * sci_port_is_phy_mask_valid() for information regarding whether the
Dan Williamse2f8db52011-05-10 02:28:46 -0700393 * 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
395 * port
396 */
Dan Williams89a73012011-06-30 19:14:33 -0700397bool sci_port_is_valid_phy_assignment(struct isci_port *iport, u32 phy_index)
Dan Williamse2f8db52011-05-10 02:28:46 -0700398{
Dan Williams89a73012011-06-30 19:14:33 -0700399 struct isci_host *ihost = iport->owning_controller;
400 struct sci_user_parameters *user = &ihost->user_parameters;
401
Dan Williamse2f8db52011-05-10 02:28:46 -0700402 /* Initialize to invalid value. */
403 u32 existing_phy_index = SCI_MAX_PHYS;
404 u32 index;
405
Dan Williams89a73012011-06-30 19:14:33 -0700406 if ((iport->physical_port_index == 1) && (phy_index != 1))
Dan Williamse2f8db52011-05-10 02:28:46 -0700407 return false;
Dan Williamse2f8db52011-05-10 02:28:46 -0700408
Dan Williams89a73012011-06-30 19:14:33 -0700409 if (iport->physical_port_index == 3 && phy_index != 3)
Dan Williamse2f8db52011-05-10 02:28:46 -0700410 return false;
Dan Williamse2f8db52011-05-10 02:28:46 -0700411
Dan Williams89a73012011-06-30 19:14:33 -0700412 if (iport->physical_port_index == 2 &&
413 (phy_index == 0 || phy_index == 1))
Dan Williamse2f8db52011-05-10 02:28:46 -0700414 return false;
Dan Williamse2f8db52011-05-10 02:28:46 -0700415
Dan Williams89a73012011-06-30 19:14:33 -0700416 for (index = 0; index < SCI_MAX_PHYS; index++)
417 if (iport->phy_table[index] && index != phy_index)
Dan Williamse2f8db52011-05-10 02:28:46 -0700418 existing_phy_index = index;
Dan Williamse2f8db52011-05-10 02:28:46 -0700419
Dan Williams89a73012011-06-30 19:14:33 -0700420 /* Ensure that all of the phys in the port are capable of
421 * operating at the same maximum link rate.
422 */
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)
Dan Williamse2f8db52011-05-10 02:28:46 -0700426 return false;
427
428 return true;
429}
430
431/**
432 *
433 * @sci_port: This is the port object for which to determine if the phy mask
434 * can be supported.
435 *
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
442 */
Dan Williams89a73012011-06-30 19:14:33 -0700443static bool sci_port_is_phy_mask_valid(
Dan Williamsffe191c2011-06-29 13:09:25 -0700444 struct isci_port *iport,
Dan Williamse2f8db52011-05-10 02:28:46 -0700445 u32 phy_mask)
446{
Dan Williamsffe191c2011-06-29 13:09:25 -0700447 if (iport->physical_port_index == 0) {
Dan Williamse2f8db52011-05-10 02:28:46 -0700448 if (((phy_mask & 0x0F) == 0x0F)
449 || ((phy_mask & 0x03) == 0x03)
450 || ((phy_mask & 0x01) == 0x01)
451 || (phy_mask == 0))
452 return true;
Dan Williamsffe191c2011-06-29 13:09:25 -0700453 } else if (iport->physical_port_index == 1) {
Dan Williamse2f8db52011-05-10 02:28:46 -0700454 if (((phy_mask & 0x02) == 0x02)
455 || (phy_mask == 0))
456 return true;
Dan Williamsffe191c2011-06-29 13:09:25 -0700457 } else if (iport->physical_port_index == 2) {
Dan Williamse2f8db52011-05-10 02:28:46 -0700458 if (((phy_mask & 0x0C) == 0x0C)
459 || ((phy_mask & 0x04) == 0x04)
460 || (phy_mask == 0))
461 return true;
Dan Williamsffe191c2011-06-29 13:09:25 -0700462 } else if (iport->physical_port_index == 3) {
Dan Williamse2f8db52011-05-10 02:28:46 -0700463 if (((phy_mask & 0x08) == 0x08)
464 || (phy_mask == 0))
465 return true;
466 }
467
468 return false;
469}
470
Dan Williams85280952011-06-28 15:05:53 -0700471/*
Dan Williamse2f8db52011-05-10 02:28:46 -0700472 * 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
Dan Williams89a73012011-06-30 19:14:33 -0700476 * point) phys contained in the port. All other values specify a struct sci_phy
Dan Williamse2f8db52011-05-10 02:28:46 -0700477 * object that is active in the port.
478 */
Dan Williams89a73012011-06-30 19:14:33 -0700479static struct isci_phy *sci_port_get_a_connected_phy(struct isci_port *iport)
Dan Williams85280952011-06-28 15:05:53 -0700480{
Dan Williamse2f8db52011-05-10 02:28:46 -0700481 u32 index;
Dan Williams85280952011-06-28 15:05:53 -0700482 struct isci_phy *iphy;
Dan Williamse2f8db52011-05-10 02:28:46 -0700483
484 for (index = 0; index < SCI_MAX_PHYS; index++) {
Dan Williams85280952011-06-28 15:05:53 -0700485 /* Ensure that the phy is both part of the port and currently
486 * connected to the remote end-point.
487 */
Dan Williamsffe191c2011-06-29 13:09:25 -0700488 iphy = iport->phy_table[index];
Dan Williams89a73012011-06-30 19:14:33 -0700489 if (iphy && sci_port_active_phy(iport, iphy))
Dan Williams85280952011-06-28 15:05:53 -0700490 return iphy;
Dan Williamse2f8db52011-05-10 02:28:46 -0700491 }
492
493 return NULL;
494}
495
Dan Williams89a73012011-06-30 19:14:33 -0700496static enum sci_status sci_port_set_phy(struct isci_port *iport, struct isci_phy *iphy)
Dan Williamse2f8db52011-05-10 02:28:46 -0700497{
Dan Williams85280952011-06-28 15:05:53 -0700498 /* Check to see if we can add this phy to a port
Dan Williamse2f8db52011-05-10 02:28:46 -0700499 * that means that the phy is not part of a port and that the port does
Dan Williams85280952011-06-28 15:05:53 -0700500 * not already have a phy assinged to the phy index.
501 */
Dan Williamsffe191c2011-06-29 13:09:25 -0700502 if (!iport->phy_table[iphy->phy_index] &&
Dan Williams85280952011-06-28 15:05:53 -0700503 !phy_get_non_dummy_port(iphy) &&
Dan Williams89a73012011-06-30 19:14:33 -0700504 sci_port_is_valid_phy_assignment(iport, iphy->phy_index)) {
Dan Williams85280952011-06-28 15:05:53 -0700505 /* Phy is being added in the stopped state so we are in MPC mode
506 * make logical port index = physical port index
507 */
Dan Williamsffe191c2011-06-29 13:09:25 -0700508 iport->logical_port_index = iport->physical_port_index;
509 iport->phy_table[iphy->phy_index] = iphy;
Dan Williams89a73012011-06-30 19:14:33 -0700510 sci_phy_set_port(iphy, iport);
Dan Williamse2f8db52011-05-10 02:28:46 -0700511
512 return SCI_SUCCESS;
513 }
514
515 return SCI_FAILURE;
516}
517
Dan Williams89a73012011-06-30 19:14:33 -0700518static enum sci_status sci_port_clear_phy(struct isci_port *iport, struct isci_phy *iphy)
Dan Williamse2f8db52011-05-10 02:28:46 -0700519{
520 /* Make sure that this phy is part of this port */
Dan Williamsffe191c2011-06-29 13:09:25 -0700521 if (iport->phy_table[iphy->phy_index] == iphy &&
522 phy_get_non_dummy_port(iphy) == iport) {
Dan Williamsd9dcb4b2011-06-30 17:38:32 -0700523 struct isci_host *ihost = iport->owning_controller;
Dan Williamse2f8db52011-05-10 02:28:46 -0700524
525 /* Yep it is assigned to this port so remove it */
Dan Williams89a73012011-06-30 19:14:33 -0700526 sci_phy_set_port(iphy, &ihost->ports[SCI_MAX_PORTS]);
Dan Williamsffe191c2011-06-29 13:09:25 -0700527 iport->phy_table[iphy->phy_index] = NULL;
Dan Williamse2f8db52011-05-10 02:28:46 -0700528 return SCI_SUCCESS;
529 }
530
531 return SCI_FAILURE;
532}
533
Dan Williams89a73012011-06-30 19:14:33 -0700534void sci_port_get_sas_address(struct isci_port *iport, struct sci_sas_address *sas)
Dan Williamse2f8db52011-05-10 02:28:46 -0700535{
536 u32 index;
537
Dan Williams89a73012011-06-30 19:14:33 -0700538 sas->high = 0;
539 sas->low = 0;
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);
Dan Williamse2f8db52011-05-10 02:28:46 -0700543}
544
Dan Williams89a73012011-06-30 19:14:33 -0700545void sci_port_get_attached_sas_address(struct isci_port *iport, struct sci_sas_address *sas)
Dan Williamse2f8db52011-05-10 02:28:46 -0700546{
Dan Williams85280952011-06-28 15:05:53 -0700547 struct isci_phy *iphy;
Dan Williamse2f8db52011-05-10 02:28:46 -0700548
549 /*
550 * Ensure that the phy is both part of the port and currently
551 * connected to the remote end-point.
552 */
Dan Williams89a73012011-06-30 19:14:33 -0700553 iphy = sci_port_get_a_connected_phy(iport);
Dan Williams85280952011-06-28 15:05:53 -0700554 if (iphy) {
555 if (iphy->protocol != SCIC_SDS_PHY_PROTOCOL_SATA) {
Dan Williams89a73012011-06-30 19:14:33 -0700556 sci_phy_get_attached_sas_address(iphy, sas);
Dan Williamse2f8db52011-05-10 02:28:46 -0700557 } else {
Dan Williams89a73012011-06-30 19:14:33 -0700558 sci_phy_get_sas_address(iphy, sas);
559 sas->low += iphy->phy_index;
Dan Williamse2f8db52011-05-10 02:28:46 -0700560 }
561 } else {
Dan Williams89a73012011-06-30 19:14:33 -0700562 sas->high = 0;
563 sas->low = 0;
Dan Williamse2f8db52011-05-10 02:28:46 -0700564 }
565}
566
567/**
Dan Williams89a73012011-06-30 19:14:33 -0700568 * sci_port_construct_dummy_rnc() - create dummy rnc for si workaround
Dan Williamse2f8db52011-05-10 02:28:46 -0700569 *
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.
572 *
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.
576 */
Dan Williams89a73012011-06-30 19:14:33 -0700577static void sci_port_construct_dummy_rnc(struct isci_port *iport, u16 rni)
Dan Williamse2f8db52011-05-10 02:28:46 -0700578{
579 union scu_remote_node_context *rnc;
580
Dan Williamsffe191c2011-06-29 13:09:25 -0700581 rnc = &iport->owning_controller->remote_node_context_table[rni];
Dan Williamse2f8db52011-05-10 02:28:46 -0700582
583 memset(rnc, 0, sizeof(union scu_remote_node_context));
584
585 rnc->ssp.remote_sas_address_hi = 0;
586 rnc->ssp.remote_sas_address_lo = 0;
587
588 rnc->ssp.remote_node_index = rni;
589 rnc->ssp.remote_node_port_width = 1;
Dan Williamsffe191c2011-06-29 13:09:25 -0700590 rnc->ssp.logical_port_index = iport->physical_port_index;
Dan Williamse2f8db52011-05-10 02:28:46 -0700591
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;
598}
599
Dan Williamsdd047c82011-06-09 11:06:58 -0700600/*
601 * construct a dummy task context data structure. This
Dan Williamse2f8db52011-05-10 02:28:46 -0700602 * structure will be posted to the hardwre to work around a scheduler error
603 * in the hardware.
Dan Williamse2f8db52011-05-10 02:28:46 -0700604 */
Dan Williams89a73012011-06-30 19:14:33 -0700605static void sci_port_construct_dummy_task(struct isci_port *iport, u16 tag)
Dan Williamse2f8db52011-05-10 02:28:46 -0700606{
Dan Williamsd9dcb4b2011-06-30 17:38:32 -0700607 struct isci_host *ihost = iport->owning_controller;
Dan Williamse2f8db52011-05-10 02:28:46 -0700608 struct scu_task_context *task_context;
609
Dan Williamsd9dcb4b2011-06-30 17:38:32 -0700610 task_context = &ihost->task_context_table[ISCI_TAG_TCI(tag)];
Dan Williamse2f8db52011-05-10 02:28:46 -0700611 memset(task_context, 0, sizeof(struct scu_task_context));
612
Dan Williamse2f8db52011-05-10 02:28:46 -0700613 task_context->initiator_request = 1;
614 task_context->connection_rate = 1;
Dan Williamsffe191c2011-06-29 13:09:25 -0700615 task_context->logical_port_index = iport->physical_port_index;
Dan Williamse2f8db52011-05-10 02:28:46 -0700616 task_context->protocol_type = SCU_TASK_CONTEXT_PROTOCOL_SSP;
Dan Williamsdd047c82011-06-09 11:06:58 -0700617 task_context->task_index = ISCI_TAG_TCI(tag);
Dan Williamse2f8db52011-05-10 02:28:46 -0700618 task_context->valid = SCU_TASK_CONTEXT_VALID;
619 task_context->context_type = SCU_TASK_CONTEXT_TYPE;
Dan Williamsffe191c2011-06-29 13:09:25 -0700620 task_context->remote_node_index = iport->reserved_rni;
Dan Williamse2f8db52011-05-10 02:28:46 -0700621 task_context->do_not_dma_ssp_good_response = 1;
Dan Williamse2f8db52011-05-10 02:28:46 -0700622 task_context->task_phase = 0x01;
623}
624
Dan Williams89a73012011-06-30 19:14:33 -0700625static void sci_port_destroy_dummy_resources(struct isci_port *iport)
Dan Williamse2f8db52011-05-10 02:28:46 -0700626{
Dan Williamsd9dcb4b2011-06-30 17:38:32 -0700627 struct isci_host *ihost = iport->owning_controller;
Dan Williamse2f8db52011-05-10 02:28:46 -0700628
Dan Williamsffe191c2011-06-29 13:09:25 -0700629 if (iport->reserved_tag != SCI_CONTROLLER_INVALID_IO_TAG)
Dan Williamsd9dcb4b2011-06-30 17:38:32 -0700630 isci_free_tag(ihost, iport->reserved_tag);
Dan Williamse2f8db52011-05-10 02:28:46 -0700631
Dan Williamsffe191c2011-06-29 13:09:25 -0700632 if (iport->reserved_rni != SCU_DUMMY_INDEX)
Dan Williams89a73012011-06-30 19:14:33 -0700633 sci_remote_node_table_release_remote_node_index(&ihost->available_remote_nodes,
Dan Williamsffe191c2011-06-29 13:09:25 -0700634 1, iport->reserved_rni);
Dan Williamse2f8db52011-05-10 02:28:46 -0700635
Dan Williamsffe191c2011-06-29 13:09:25 -0700636 iport->reserved_rni = SCU_DUMMY_INDEX;
637 iport->reserved_tag = SCI_CONTROLLER_INVALID_IO_TAG;
Dan Williamse2f8db52011-05-10 02:28:46 -0700638}
639
Dan Williams89a73012011-06-30 19:14:33 -0700640void sci_port_setup_transports(struct isci_port *iport, u32 device_id)
Dan Williamse2f8db52011-05-10 02:28:46 -0700641{
642 u8 index;
643
644 for (index = 0; index < SCI_MAX_PHYS; index++) {
Dan Williamsffe191c2011-06-29 13:09:25 -0700645 if (iport->active_phy_mask & (1 << index))
Dan Williams89a73012011-06-30 19:14:33 -0700646 sci_phy_setup_transport(iport->phy_table[index], device_id);
Dan Williamse2f8db52011-05-10 02:28:46 -0700647 }
648}
649
Marcin Tomczak05b080f2012-01-04 01:33:41 -0800650static void sci_port_resume_phy(struct isci_port *iport, struct isci_phy *iphy)
651{
652 sci_phy_resume(iphy);
653 iport->enabled_phy_mask |= 1 << iphy->phy_index;
654}
655
656static void sci_port_activate_phy(struct isci_port *iport,
657 struct isci_phy *iphy,
658 u8 flags)
Dan Williamse2f8db52011-05-10 02:28:46 -0700659{
Dan Williamsd9dcb4b2011-06-30 17:38:32 -0700660 struct isci_host *ihost = iport->owning_controller;
Dan Williamse2f8db52011-05-10 02:28:46 -0700661
Marcin Tomczak05b080f2012-01-04 01:33:41 -0800662 if (iphy->protocol != SCIC_SDS_PHY_PROTOCOL_SATA && (flags & PF_RESUME))
Dan Williams89a73012011-06-30 19:14:33 -0700663 sci_phy_resume(iphy);
Dan Williamse2f8db52011-05-10 02:28:46 -0700664
Dan Williamsffe191c2011-06-29 13:09:25 -0700665 iport->active_phy_mask |= 1 << iphy->phy_index;
Dan Williamse2f8db52011-05-10 02:28:46 -0700666
Dan Williams89a73012011-06-30 19:14:33 -0700667 sci_controller_clear_invalid_phy(ihost, iphy);
Dan Williamse2f8db52011-05-10 02:28:46 -0700668
Marcin Tomczak05b080f2012-01-04 01:33:41 -0800669 if (flags & PF_NOTIFY)
Dan Williamsffe191c2011-06-29 13:09:25 -0700670 isci_port_link_up(ihost, iport, iphy);
Dan Williamse2f8db52011-05-10 02:28:46 -0700671}
672
Dan Williams89a73012011-06-30 19:14:33 -0700673void sci_port_deactivate_phy(struct isci_port *iport, struct isci_phy *iphy,
674 bool do_notify_user)
Dan Williamse2f8db52011-05-10 02:28:46 -0700675{
Dan Williams34a99152011-07-01 02:25:15 -0700676 struct isci_host *ihost = iport->owning_controller;
Dan Williamse2f8db52011-05-10 02:28:46 -0700677
Dan Williamsffe191c2011-06-29 13:09:25 -0700678 iport->active_phy_mask &= ~(1 << iphy->phy_index);
Marcin Tomczak05b080f2012-01-04 01:33:41 -0800679 iport->enabled_phy_mask &= ~(1 << iphy->phy_index);
Jeff Skirvin8e35a132011-10-27 15:05:32 -0700680 if (!iport->active_phy_mask)
681 iport->last_active_phy = iphy->phy_index;
Dan Williamse2f8db52011-05-10 02:28:46 -0700682
Dan Williams85280952011-06-28 15:05:53 -0700683 iphy->max_negotiated_speed = SAS_LINK_RATE_UNKNOWN;
Dan Williamse2f8db52011-05-10 02:28:46 -0700684
Marcin Tomczakd4ec1cf2012-01-04 01:33:15 -0800685 /* Re-assign the phy back to the LP as if it were a narrow port for APC
686 * mode. For MPC mode, the phy will remain in the port.
687 */
688 if (iport->owning_controller->oem_parameters.controller.mode_type ==
689 SCIC_PORT_AUTOMATIC_CONFIGURATION_MODE)
690 writel(iphy->phy_index,
691 &iport->port_pe_configuration_register[iphy->phy_index]);
Dan Williamse2f8db52011-05-10 02:28:46 -0700692
693 if (do_notify_user == true)
694 isci_port_link_down(ihost, iphy, iport);
695}
696
Dan Williams89a73012011-06-30 19:14:33 -0700697static void sci_port_invalid_link_up(struct isci_port *iport, struct isci_phy *iphy)
Dan Williamse2f8db52011-05-10 02:28:46 -0700698{
Dan Williamsd9dcb4b2011-06-30 17:38:32 -0700699 struct isci_host *ihost = iport->owning_controller;
Dan Williamse2f8db52011-05-10 02:28:46 -0700700
701 /*
702 * Check to see if we have alreay reported this link as bad and if
703 * not go ahead and tell the SCI_USER that we have discovered an
704 * invalid link.
705 */
Dan Williamsd9dcb4b2011-06-30 17:38:32 -0700706 if ((ihost->invalid_phy_mask & (1 << iphy->phy_index)) == 0) {
Dan Williams34a99152011-07-01 02:25:15 -0700707 ihost->invalid_phy_mask |= 1 << iphy->phy_index;
Dan Williamsd9dcb4b2011-06-30 17:38:32 -0700708 dev_warn(&ihost->pdev->dev, "Invalid link up!\n");
Dan Williamse2f8db52011-05-10 02:28:46 -0700709 }
710}
711
712/**
Dan Williams89a73012011-06-30 19:14:33 -0700713 * sci_port_general_link_up_handler - phy can be assigned to port?
714 * @sci_port: sci_port object for which has a phy that has gone link up.
Dan Williams85280952011-06-28 15:05:53 -0700715 * @sci_phy: This is the struct isci_phy object that has gone link up.
Marcin Tomczak05b080f2012-01-04 01:33:41 -0800716 * @flags: PF_RESUME, PF_NOTIFY to sci_port_activate_phy
Dan Williamse2f8db52011-05-10 02:28:46 -0700717 *
Marcin Tomczak05b080f2012-01-04 01:33:41 -0800718 * Determine if this phy can be assigned to this port . If the phy is
719 * not a valid PHY for this port then the function will notify the user.
720 * A PHY can only be part of a port if it's attached SAS ADDRESS is the
721 * same as all other PHYs in the same port.
Dan Williamse2f8db52011-05-10 02:28:46 -0700722 */
Dan Williams89a73012011-06-30 19:14:33 -0700723static void sci_port_general_link_up_handler(struct isci_port *iport,
Marcin Tomczak05b080f2012-01-04 01:33:41 -0800724 struct isci_phy *iphy,
725 u8 flags)
Dan Williamse2f8db52011-05-10 02:28:46 -0700726{
727 struct sci_sas_address port_sas_address;
728 struct sci_sas_address phy_sas_address;
729
Dan Williams89a73012011-06-30 19:14:33 -0700730 sci_port_get_attached_sas_address(iport, &port_sas_address);
731 sci_phy_get_attached_sas_address(iphy, &phy_sas_address);
Dan Williamse2f8db52011-05-10 02:28:46 -0700732
733 /* If the SAS address of the new phy matches the SAS address of
734 * other phys in the port OR this is the first phy in the port,
735 * then activate the phy and allow it to be used for operations
736 * in this port.
737 */
738 if ((phy_sas_address.high == port_sas_address.high &&
739 phy_sas_address.low == port_sas_address.low) ||
Dan Williamsffe191c2011-06-29 13:09:25 -0700740 iport->active_phy_mask == 0) {
741 struct sci_base_state_machine *sm = &iport->sm;
Dan Williamse2f8db52011-05-10 02:28:46 -0700742
Marcin Tomczak05b080f2012-01-04 01:33:41 -0800743 sci_port_activate_phy(iport, iphy, flags);
Edmund Nadolskie3013702011-06-02 00:10:43 +0000744 if (sm->current_state_id == SCI_PORT_RESETTING)
Dan Williamsffe191c2011-06-29 13:09:25 -0700745 port_state_machine_change(iport, SCI_PORT_READY);
Dan Williamse2f8db52011-05-10 02:28:46 -0700746 } else
Dan Williams89a73012011-06-30 19:14:33 -0700747 sci_port_invalid_link_up(iport, iphy);
Dan Williamse2f8db52011-05-10 02:28:46 -0700748}
749
750
751
752/**
753 * This method returns false if the port only has a single phy object assigned.
754 * If there are no phys or more than one phy then the method will return
755 * true.
756 * @sci_port: The port for which the wide port condition is to be checked.
757 *
758 * bool true Is returned if this is a wide ported port. false Is returned if
759 * this is a narrow port.
760 */
Dan Williams89a73012011-06-30 19:14:33 -0700761static bool sci_port_is_wide(struct isci_port *iport)
Dan Williamse2f8db52011-05-10 02:28:46 -0700762{
763 u32 index;
764 u32 phy_count = 0;
765
766 for (index = 0; index < SCI_MAX_PHYS; index++) {
Dan Williamsffe191c2011-06-29 13:09:25 -0700767 if (iport->phy_table[index] != NULL) {
Dan Williamse2f8db52011-05-10 02:28:46 -0700768 phy_count++;
769 }
770 }
771
772 return phy_count != 1;
773}
774
775/**
776 * This method is called by the PHY object when the link is detected. if the
777 * port wants the PHY to continue on to the link up state then the port
778 * layer must return true. If the port object returns false the phy object
779 * must halt its attempt to go link up.
780 * @sci_port: The port associated with the phy object.
781 * @sci_phy: The phy object that is trying to go link up.
782 *
783 * true if the phy object can continue to the link up condition. true Is
784 * returned if this phy can continue to the ready state. false Is returned if
785 * can not continue on to the ready state. This notification is in place for
786 * wide ports and direct attached phys. Since there are no wide ported SATA
787 * devices this could become an invalid port configuration.
788 */
Dan Williams89a73012011-06-30 19:14:33 -0700789bool sci_port_link_detected(
Dan Williamsffe191c2011-06-29 13:09:25 -0700790 struct isci_port *iport,
Dan Williams85280952011-06-28 15:05:53 -0700791 struct isci_phy *iphy)
Dan Williamse2f8db52011-05-10 02:28:46 -0700792{
Dan Williamsffe191c2011-06-29 13:09:25 -0700793 if ((iport->logical_port_index != SCIC_SDS_DUMMY_PORT) &&
Marcin Tomczak05b080f2012-01-04 01:33:41 -0800794 (iphy->protocol == SCIC_SDS_PHY_PROTOCOL_SATA)) {
795 if (sci_port_is_wide(iport)) {
796 sci_port_invalid_link_up(iport, iphy);
797 return false;
798 } else {
799 struct isci_host *ihost = iport->owning_controller;
800 struct isci_port *dst_port = &(ihost->ports[iphy->phy_index]);
801 writel(iphy->phy_index,
802 &dst_port->port_pe_configuration_register[iphy->phy_index]);
803 }
Dan Williamse2f8db52011-05-10 02:28:46 -0700804 }
805
806 return true;
807}
808
Edmund Nadolski5553ba22011-05-19 11:59:10 +0000809static void port_timeout(unsigned long data)
Dan Williamse2f8db52011-05-10 02:28:46 -0700810{
Edmund Nadolski5553ba22011-05-19 11:59:10 +0000811 struct sci_timer *tmr = (struct sci_timer *)data;
Dan Williamsffe191c2011-06-29 13:09:25 -0700812 struct isci_port *iport = container_of(tmr, typeof(*iport), timer);
Dan Williamsd9dcb4b2011-06-30 17:38:32 -0700813 struct isci_host *ihost = iport->owning_controller;
Edmund Nadolski5553ba22011-05-19 11:59:10 +0000814 unsigned long flags;
Dan Williamse2f8db52011-05-10 02:28:46 -0700815 u32 current_state;
816
Edmund Nadolski5553ba22011-05-19 11:59:10 +0000817 spin_lock_irqsave(&ihost->scic_lock, flags);
818
819 if (tmr->cancel)
820 goto done;
821
Dan Williamsffe191c2011-06-29 13:09:25 -0700822 current_state = iport->sm.current_state_id;
Dan Williamse2f8db52011-05-10 02:28:46 -0700823
Edmund Nadolskie3013702011-06-02 00:10:43 +0000824 if (current_state == SCI_PORT_RESETTING) {
Piotr Sawickie91f41e2011-05-11 23:52:21 +0000825 /* if the port is still in the resetting state then the timeout
826 * fired before the reset completed.
Dan Williamse2f8db52011-05-10 02:28:46 -0700827 */
Dan Williamsffe191c2011-06-29 13:09:25 -0700828 port_state_machine_change(iport, SCI_PORT_FAILED);
Edmund Nadolskie3013702011-06-02 00:10:43 +0000829 } else if (current_state == SCI_PORT_STOPPED) {
Piotr Sawickie91f41e2011-05-11 23:52:21 +0000830 /* if the port is stopped then the start request failed In this
831 * case stay in the stopped state.
Dan Williamse2f8db52011-05-10 02:28:46 -0700832 */
Dan Williamsffe191c2011-06-29 13:09:25 -0700833 dev_err(sciport_to_dev(iport),
Dan Williamse2f8db52011-05-10 02:28:46 -0700834 "%s: SCIC Port 0x%p failed to stop before tiemout.\n",
835 __func__,
Dan Williamsffe191c2011-06-29 13:09:25 -0700836 iport);
Edmund Nadolskie3013702011-06-02 00:10:43 +0000837 } else if (current_state == SCI_PORT_STOPPING) {
Piotr Sawickie91f41e2011-05-11 23:52:21 +0000838 /* if the port is still stopping then the stop has not completed */
Dan Williamsffe191c2011-06-29 13:09:25 -0700839 isci_port_stop_complete(iport->owning_controller,
840 iport,
Piotr Sawickie91f41e2011-05-11 23:52:21 +0000841 SCI_FAILURE_TIMEOUT);
Dan Williamse2f8db52011-05-10 02:28:46 -0700842 } else {
Piotr Sawickie91f41e2011-05-11 23:52:21 +0000843 /* The port is in the ready state and we have a timer
Dan Williamse2f8db52011-05-10 02:28:46 -0700844 * reporting a timeout this should not happen.
845 */
Dan Williamsffe191c2011-06-29 13:09:25 -0700846 dev_err(sciport_to_dev(iport),
Dan Williamse2f8db52011-05-10 02:28:46 -0700847 "%s: SCIC Port 0x%p is processing a timeout operation "
Dan Williamsffe191c2011-06-29 13:09:25 -0700848 "in state %d.\n", __func__, iport, current_state);
Dan Williamse2f8db52011-05-10 02:28:46 -0700849 }
Edmund Nadolski5553ba22011-05-19 11:59:10 +0000850
851done:
852 spin_unlock_irqrestore(&ihost->scic_lock, flags);
Dan Williamse2f8db52011-05-10 02:28:46 -0700853}
854
855/* --------------------------------------------------------------------------- */
856
857/**
858 * This function updates the hardwares VIIT entry for this port.
859 *
860 *
861 */
Dan Williams89a73012011-06-30 19:14:33 -0700862static void sci_port_update_viit_entry(struct isci_port *iport)
Dan Williamse2f8db52011-05-10 02:28:46 -0700863{
864 struct sci_sas_address sas_address;
865
Dan Williams89a73012011-06-30 19:14:33 -0700866 sci_port_get_sas_address(iport, &sas_address);
Dan Williamse2f8db52011-05-10 02:28:46 -0700867
868 writel(sas_address.high,
Dan Williamsffe191c2011-06-29 13:09:25 -0700869 &iport->viit_registers->initiator_sas_address_hi);
Dan Williamse2f8db52011-05-10 02:28:46 -0700870 writel(sas_address.low,
Dan Williamsffe191c2011-06-29 13:09:25 -0700871 &iport->viit_registers->initiator_sas_address_lo);
Dan Williamse2f8db52011-05-10 02:28:46 -0700872
873 /* This value get cleared just in case its not already cleared */
Dan Williamsffe191c2011-06-29 13:09:25 -0700874 writel(0, &iport->viit_registers->reserved);
Dan Williamse2f8db52011-05-10 02:28:46 -0700875
876 /* We are required to update the status register last */
877 writel(SCU_VIIT_ENTRY_ID_VIIT |
878 SCU_VIIT_IPPT_INITIATOR |
Dan Williamsffe191c2011-06-29 13:09:25 -0700879 ((1 << iport->physical_port_index) << SCU_VIIT_ENTRY_LPVIE_SHIFT) |
Dan Williamse2f8db52011-05-10 02:28:46 -0700880 SCU_VIIT_STATUS_ALL_VALID,
Dan Williamsffe191c2011-06-29 13:09:25 -0700881 &iport->viit_registers->status);
Dan Williamse2f8db52011-05-10 02:28:46 -0700882}
883
Dan Williams89a73012011-06-30 19:14:33 -0700884enum sas_linkrate sci_port_get_max_allowed_speed(struct isci_port *iport)
Dan Williamse2f8db52011-05-10 02:28:46 -0700885{
886 u16 index;
Dan Williams85280952011-06-28 15:05:53 -0700887 struct isci_phy *iphy;
Dan Williamse2f8db52011-05-10 02:28:46 -0700888 enum sas_linkrate max_allowed_speed = SAS_LINK_RATE_6_0_GBPS;
Dan Williamse2f8db52011-05-10 02:28:46 -0700889
890 /*
891 * Loop through all of the phys in this port and find the phy with the
892 * lowest maximum link rate. */
893 for (index = 0; index < SCI_MAX_PHYS; index++) {
Dan Williamsffe191c2011-06-29 13:09:25 -0700894 iphy = iport->phy_table[index];
Dan Williams89a73012011-06-30 19:14:33 -0700895 if (iphy && sci_port_active_phy(iport, iphy) &&
Dan Williams85280952011-06-28 15:05:53 -0700896 iphy->max_negotiated_speed < max_allowed_speed)
897 max_allowed_speed = iphy->max_negotiated_speed;
Dan Williamse2f8db52011-05-10 02:28:46 -0700898 }
899
900 return max_allowed_speed;
901}
902
Dan Williams89a73012011-06-30 19:14:33 -0700903static void sci_port_suspend_port_task_scheduler(struct isci_port *iport)
Dan Williamse2f8db52011-05-10 02:28:46 -0700904{
905 u32 pts_control_value;
906
Dan Williamsffe191c2011-06-29 13:09:25 -0700907 pts_control_value = readl(&iport->port_task_scheduler_registers->control);
Dan Williamse2f8db52011-05-10 02:28:46 -0700908 pts_control_value |= SCU_PTSxCR_GEN_BIT(SUSPEND);
Dan Williamsffe191c2011-06-29 13:09:25 -0700909 writel(pts_control_value, &iport->port_task_scheduler_registers->control);
Dan Williamse2f8db52011-05-10 02:28:46 -0700910}
911
912/**
Dan Williams89a73012011-06-30 19:14:33 -0700913 * sci_port_post_dummy_request() - post dummy/workaround request
Dan Williamse2f8db52011-05-10 02:28:46 -0700914 * @sci_port: port to post task
915 *
916 * Prevent the hardware scheduler from posting new requests to the front
917 * of the scheduler queue causing a starvation problem for currently
918 * ongoing requests.
919 *
920 */
Dan Williams89a73012011-06-30 19:14:33 -0700921static void sci_port_post_dummy_request(struct isci_port *iport)
Dan Williamse2f8db52011-05-10 02:28:46 -0700922{
Dan Williamsd9dcb4b2011-06-30 17:38:32 -0700923 struct isci_host *ihost = iport->owning_controller;
Dan Williamsffe191c2011-06-29 13:09:25 -0700924 u16 tag = iport->reserved_tag;
Dan Williams312e0c22011-06-28 13:47:09 -0700925 struct scu_task_context *tc;
926 u32 command;
Dan Williamse2f8db52011-05-10 02:28:46 -0700927
Dan Williamsd9dcb4b2011-06-30 17:38:32 -0700928 tc = &ihost->task_context_table[ISCI_TAG_TCI(tag)];
Dan Williams312e0c22011-06-28 13:47:09 -0700929 tc->abort = 0;
Dan Williamse2f8db52011-05-10 02:28:46 -0700930
931 command = SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
Dan Williamsffe191c2011-06-29 13:09:25 -0700932 iport->physical_port_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT |
Dan Williams312e0c22011-06-28 13:47:09 -0700933 ISCI_TAG_TCI(tag);
Dan Williamse2f8db52011-05-10 02:28:46 -0700934
Dan Williams89a73012011-06-30 19:14:33 -0700935 sci_controller_post_request(ihost, command);
Dan Williamse2f8db52011-05-10 02:28:46 -0700936}
937
938/**
939 * This routine will abort the dummy request. This will alow the hardware to
940 * power down parts of the silicon to save power.
941 *
942 * @sci_port: The port on which the task must be aborted.
943 *
944 */
Dan Williams89a73012011-06-30 19:14:33 -0700945static void sci_port_abort_dummy_request(struct isci_port *iport)
Dan Williamse2f8db52011-05-10 02:28:46 -0700946{
Dan Williamsd9dcb4b2011-06-30 17:38:32 -0700947 struct isci_host *ihost = iport->owning_controller;
Dan Williamsffe191c2011-06-29 13:09:25 -0700948 u16 tag = iport->reserved_tag;
Dan Williamse2f8db52011-05-10 02:28:46 -0700949 struct scu_task_context *tc;
950 u32 command;
951
Dan Williamsd9dcb4b2011-06-30 17:38:32 -0700952 tc = &ihost->task_context_table[ISCI_TAG_TCI(tag)];
Dan Williamse2f8db52011-05-10 02:28:46 -0700953 tc->abort = 1;
954
955 command = SCU_CONTEXT_COMMAND_REQUEST_POST_TC_ABORT |
Dan Williamsffe191c2011-06-29 13:09:25 -0700956 iport->physical_port_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT |
Dan Williams312e0c22011-06-28 13:47:09 -0700957 ISCI_TAG_TCI(tag);
Dan Williamse2f8db52011-05-10 02:28:46 -0700958
Dan Williams89a73012011-06-30 19:14:33 -0700959 sci_controller_post_request(ihost, command);
Dan Williamse2f8db52011-05-10 02:28:46 -0700960}
961
962/**
963 *
Dan Williamsffe191c2011-06-29 13:09:25 -0700964 * @sci_port: This is the struct isci_port object to resume.
Dan Williamse2f8db52011-05-10 02:28:46 -0700965 *
966 * This method will resume the port task scheduler for this port object. none
967 */
968static void
Dan Williams89a73012011-06-30 19:14:33 -0700969sci_port_resume_port_task_scheduler(struct isci_port *iport)
Dan Williamse2f8db52011-05-10 02:28:46 -0700970{
971 u32 pts_control_value;
972
Dan Williamsffe191c2011-06-29 13:09:25 -0700973 pts_control_value = readl(&iport->port_task_scheduler_registers->control);
Dan Williamse2f8db52011-05-10 02:28:46 -0700974 pts_control_value &= ~SCU_PTSxCR_GEN_BIT(SUSPEND);
Dan Williamsffe191c2011-06-29 13:09:25 -0700975 writel(pts_control_value, &iport->port_task_scheduler_registers->control);
Dan Williamse2f8db52011-05-10 02:28:46 -0700976}
977
Dan Williams89a73012011-06-30 19:14:33 -0700978static void sci_port_ready_substate_waiting_enter(struct sci_base_state_machine *sm)
Dan Williamse2f8db52011-05-10 02:28:46 -0700979{
Dan Williamsffe191c2011-06-29 13:09:25 -0700980 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
Dan Williamse2f8db52011-05-10 02:28:46 -0700981
Dan Williams89a73012011-06-30 19:14:33 -0700982 sci_port_suspend_port_task_scheduler(iport);
Dan Williamse2f8db52011-05-10 02:28:46 -0700983
Dan Williamsffe191c2011-06-29 13:09:25 -0700984 iport->not_ready_reason = SCIC_PORT_NOT_READY_NO_ACTIVE_PHYS;
Dan Williamse2f8db52011-05-10 02:28:46 -0700985
Dan Williamsffe191c2011-06-29 13:09:25 -0700986 if (iport->active_phy_mask != 0) {
Dan Williamse2f8db52011-05-10 02:28:46 -0700987 /* At least one of the phys on the port is ready */
Dan Williamsffe191c2011-06-29 13:09:25 -0700988 port_state_machine_change(iport,
Edmund Nadolskie3013702011-06-02 00:10:43 +0000989 SCI_PORT_SUB_OPERATIONAL);
Dan Williamse2f8db52011-05-10 02:28:46 -0700990 }
991}
992
Marcin Tomczak05b080f2012-01-04 01:33:41 -0800993static void scic_sds_port_ready_substate_waiting_exit(
994 struct sci_base_state_machine *sm)
995{
996 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
997 sci_port_resume_port_task_scheduler(iport);
998}
999
Dan Williams89a73012011-06-30 19:14:33 -07001000static void sci_port_ready_substate_operational_enter(struct sci_base_state_machine *sm)
Dan Williamse2f8db52011-05-10 02:28:46 -07001001{
1002 u32 index;
Dan Williamsffe191c2011-06-29 13:09:25 -07001003 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
Dan Williamsd9dcb4b2011-06-30 17:38:32 -07001004 struct isci_host *ihost = iport->owning_controller;
Dan Williamse2f8db52011-05-10 02:28:46 -07001005
Dan Williamse2f8db52011-05-10 02:28:46 -07001006 isci_port_ready(ihost, iport);
1007
1008 for (index = 0; index < SCI_MAX_PHYS; index++) {
Dan Williamsffe191c2011-06-29 13:09:25 -07001009 if (iport->phy_table[index]) {
1010 writel(iport->physical_port_index,
1011 &iport->port_pe_configuration_register[
1012 iport->phy_table[index]->phy_index]);
Marcin Tomczak05b080f2012-01-04 01:33:41 -08001013 if (((iport->active_phy_mask^iport->enabled_phy_mask) & (1 << index)) != 0)
1014 sci_port_resume_phy(iport, iport->phy_table[index]);
Dan Williamse2f8db52011-05-10 02:28:46 -07001015 }
1016 }
1017
Dan Williams89a73012011-06-30 19:14:33 -07001018 sci_port_update_viit_entry(iport);
Dan Williamse2f8db52011-05-10 02:28:46 -07001019
Dan Williamse2f8db52011-05-10 02:28:46 -07001020 /*
1021 * Post the dummy task for the port so the hardware can schedule
1022 * io correctly
1023 */
Dan Williams89a73012011-06-30 19:14:33 -07001024 sci_port_post_dummy_request(iport);
Dan Williamse2f8db52011-05-10 02:28:46 -07001025}
1026
Dan Williams89a73012011-06-30 19:14:33 -07001027static void sci_port_invalidate_dummy_remote_node(struct isci_port *iport)
Piotr Sawickie91f41e2011-05-11 23:52:21 +00001028{
Dan Williamsd9dcb4b2011-06-30 17:38:32 -07001029 struct isci_host *ihost = iport->owning_controller;
Dan Williamsffe191c2011-06-29 13:09:25 -07001030 u8 phys_index = iport->physical_port_index;
Piotr Sawickie91f41e2011-05-11 23:52:21 +00001031 union scu_remote_node_context *rnc;
Dan Williamsffe191c2011-06-29 13:09:25 -07001032 u16 rni = iport->reserved_rni;
Piotr Sawickie91f41e2011-05-11 23:52:21 +00001033 u32 command;
1034
Dan Williamsd9dcb4b2011-06-30 17:38:32 -07001035 rnc = &ihost->remote_node_context_table[rni];
Piotr Sawickie91f41e2011-05-11 23:52:21 +00001036
1037 rnc->ssp.is_valid = false;
1038
1039 /* ensure the preceding tc abort request has reached the
1040 * controller and give it ample time to act before posting the rnc
1041 * invalidate
1042 */
Dan Williamsd9dcb4b2011-06-30 17:38:32 -07001043 readl(&ihost->smu_registers->interrupt_status); /* flush */
Piotr Sawickie91f41e2011-05-11 23:52:21 +00001044 udelay(10);
1045
1046 command = SCU_CONTEXT_COMMAND_POST_RNC_INVALIDATE |
1047 phys_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT | rni;
1048
Dan Williams89a73012011-06-30 19:14:33 -07001049 sci_controller_post_request(ihost, command);
Piotr Sawickie91f41e2011-05-11 23:52:21 +00001050}
1051
Dan Williamse2f8db52011-05-10 02:28:46 -07001052/**
1053 *
Dan Williamsffe191c2011-06-29 13:09:25 -07001054 * @object: This is the object which is cast to a struct isci_port object.
Dan Williamse2f8db52011-05-10 02:28:46 -07001055 *
Dan Williamsffe191c2011-06-29 13:09:25 -07001056 * This method will perform the actions required by the struct isci_port on
Edmund Nadolskie3013702011-06-02 00:10:43 +00001057 * exiting the SCI_PORT_SUB_OPERATIONAL. This function reports
Dan Williamse2f8db52011-05-10 02:28:46 -07001058 * the port not ready and suspends the port task scheduler. none
1059 */
Dan Williams89a73012011-06-30 19:14:33 -07001060static void sci_port_ready_substate_operational_exit(struct sci_base_state_machine *sm)
Dan Williamse2f8db52011-05-10 02:28:46 -07001061{
Dan Williamsffe191c2011-06-29 13:09:25 -07001062 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
Dan Williamsd9dcb4b2011-06-30 17:38:32 -07001063 struct isci_host *ihost = iport->owning_controller;
Dan Williamse2f8db52011-05-10 02:28:46 -07001064
1065 /*
1066 * Kill the dummy task for this port if it has not yet posted
1067 * the hardware will treat this as a NOP and just return abort
1068 * complete.
1069 */
Dan Williams89a73012011-06-30 19:14:33 -07001070 sci_port_abort_dummy_request(iport);
Dan Williamse2f8db52011-05-10 02:28:46 -07001071
1072 isci_port_not_ready(ihost, iport);
Piotr Sawickie91f41e2011-05-11 23:52:21 +00001073
Dan Williamsffe191c2011-06-29 13:09:25 -07001074 if (iport->ready_exit)
Dan Williams89a73012011-06-30 19:14:33 -07001075 sci_port_invalidate_dummy_remote_node(iport);
Dan Williamse2f8db52011-05-10 02:28:46 -07001076}
1077
Dan Williams89a73012011-06-30 19:14:33 -07001078static void sci_port_ready_substate_configuring_enter(struct sci_base_state_machine *sm)
Dan Williamse2f8db52011-05-10 02:28:46 -07001079{
Dan Williamsffe191c2011-06-29 13:09:25 -07001080 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
Dan Williamsd9dcb4b2011-06-30 17:38:32 -07001081 struct isci_host *ihost = iport->owning_controller;
Dan Williamse2f8db52011-05-10 02:28:46 -07001082
Dan Williamsffe191c2011-06-29 13:09:25 -07001083 if (iport->active_phy_mask == 0) {
Dan Williamse2f8db52011-05-10 02:28:46 -07001084 isci_port_not_ready(ihost, iport);
1085
Marcin Tomczak05b080f2012-01-04 01:33:41 -08001086 port_state_machine_change(iport, SCI_PORT_SUB_WAITING);
1087 } else
1088 port_state_machine_change(iport, SCI_PORT_SUB_OPERATIONAL);
Dan Williamse2f8db52011-05-10 02:28:46 -07001089}
1090
Dan Williams89a73012011-06-30 19:14:33 -07001091enum sci_status sci_port_start(struct isci_port *iport)
Piotr Sawickid76f71d2011-05-11 23:52:26 +00001092{
Dan Williamsd9dcb4b2011-06-30 17:38:32 -07001093 struct isci_host *ihost = iport->owning_controller;
Piotr Sawickid76f71d2011-05-11 23:52:26 +00001094 enum sci_status status = SCI_SUCCESS;
Dan Williams89a73012011-06-30 19:14:33 -07001095 enum sci_port_states state;
Piotr Sawickid76f71d2011-05-11 23:52:26 +00001096 u32 phy_mask;
1097
Dan Williamsffe191c2011-06-29 13:09:25 -07001098 state = iport->sm.current_state_id;
Edmund Nadolskie3013702011-06-02 00:10:43 +00001099 if (state != SCI_PORT_STOPPED) {
Dan Williamsffe191c2011-06-29 13:09:25 -07001100 dev_warn(sciport_to_dev(iport),
Piotr Sawickid76f71d2011-05-11 23:52:26 +00001101 "%s: in wrong state: %d\n", __func__, state);
1102 return SCI_FAILURE_INVALID_STATE;
1103 }
1104
Dan Williamsffe191c2011-06-29 13:09:25 -07001105 if (iport->assigned_device_count > 0) {
Piotr Sawickid76f71d2011-05-11 23:52:26 +00001106 /* TODO This is a start failure operation because
1107 * there are still devices assigned to this port.
1108 * There must be no devices assigned to a port on a
1109 * start operation.
1110 */
1111 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
1112 }
1113
Dan Williamsffe191c2011-06-29 13:09:25 -07001114 if (iport->reserved_rni == SCU_DUMMY_INDEX) {
Dan Williams89a73012011-06-30 19:14:33 -07001115 u16 rni = sci_remote_node_table_allocate_remote_node(
Dan Williamsd9dcb4b2011-06-30 17:38:32 -07001116 &ihost->available_remote_nodes, 1);
Piotr Sawickid76f71d2011-05-11 23:52:26 +00001117
1118 if (rni != SCU_DUMMY_INDEX)
Dan Williams89a73012011-06-30 19:14:33 -07001119 sci_port_construct_dummy_rnc(iport, rni);
Piotr Sawickid76f71d2011-05-11 23:52:26 +00001120 else
1121 status = SCI_FAILURE_INSUFFICIENT_RESOURCES;
Dan Williamsffe191c2011-06-29 13:09:25 -07001122 iport->reserved_rni = rni;
Piotr Sawickid76f71d2011-05-11 23:52:26 +00001123 }
1124
Dan Williamsffe191c2011-06-29 13:09:25 -07001125 if (iport->reserved_tag == SCI_CONTROLLER_INVALID_IO_TAG) {
Dan Williams312e0c22011-06-28 13:47:09 -07001126 u16 tag;
Piotr Sawickid76f71d2011-05-11 23:52:26 +00001127
Dan Williams312e0c22011-06-28 13:47:09 -07001128 tag = isci_alloc_tag(ihost);
1129 if (tag == SCI_CONTROLLER_INVALID_IO_TAG)
Piotr Sawickid76f71d2011-05-11 23:52:26 +00001130 status = SCI_FAILURE_INSUFFICIENT_RESOURCES;
Dan Williams312e0c22011-06-28 13:47:09 -07001131 else
Dan Williams89a73012011-06-30 19:14:33 -07001132 sci_port_construct_dummy_task(iport, tag);
Dan Williamsffe191c2011-06-29 13:09:25 -07001133 iport->reserved_tag = tag;
Piotr Sawickid76f71d2011-05-11 23:52:26 +00001134 }
1135
1136 if (status == SCI_SUCCESS) {
Dan Williams89a73012011-06-30 19:14:33 -07001137 phy_mask = sci_port_get_phys(iport);
Piotr Sawickid76f71d2011-05-11 23:52:26 +00001138
1139 /*
1140 * There are one or more phys assigned to this port. Make sure
1141 * the port's phy mask is in fact legal and supported by the
1142 * silicon.
1143 */
Dan Williams89a73012011-06-30 19:14:33 -07001144 if (sci_port_is_phy_mask_valid(iport, phy_mask) == true) {
Dan Williamsffe191c2011-06-29 13:09:25 -07001145 port_state_machine_change(iport,
Edmund Nadolskie3013702011-06-02 00:10:43 +00001146 SCI_PORT_READY);
Piotr Sawickid76f71d2011-05-11 23:52:26 +00001147
1148 return SCI_SUCCESS;
1149 }
1150 status = SCI_FAILURE;
1151 }
1152
1153 if (status != SCI_SUCCESS)
Dan Williams89a73012011-06-30 19:14:33 -07001154 sci_port_destroy_dummy_resources(iport);
Piotr Sawickid76f71d2011-05-11 23:52:26 +00001155
1156 return status;
1157}
1158
Dan Williams89a73012011-06-30 19:14:33 -07001159enum sci_status sci_port_stop(struct isci_port *iport)
Piotr Sawicki8bc80d32011-05-11 23:52:31 +00001160{
Dan Williams89a73012011-06-30 19:14:33 -07001161 enum sci_port_states state;
Piotr Sawicki8bc80d32011-05-11 23:52:31 +00001162
Dan Williamsffe191c2011-06-29 13:09:25 -07001163 state = iport->sm.current_state_id;
Piotr Sawicki8bc80d32011-05-11 23:52:31 +00001164 switch (state) {
Edmund Nadolskie3013702011-06-02 00:10:43 +00001165 case SCI_PORT_STOPPED:
Piotr Sawicki8bc80d32011-05-11 23:52:31 +00001166 return SCI_SUCCESS;
Edmund Nadolskie3013702011-06-02 00:10:43 +00001167 case SCI_PORT_SUB_WAITING:
1168 case SCI_PORT_SUB_OPERATIONAL:
1169 case SCI_PORT_SUB_CONFIGURING:
1170 case SCI_PORT_RESETTING:
Dan Williamsffe191c2011-06-29 13:09:25 -07001171 port_state_machine_change(iport,
Edmund Nadolskie3013702011-06-02 00:10:43 +00001172 SCI_PORT_STOPPING);
Piotr Sawicki8bc80d32011-05-11 23:52:31 +00001173 return SCI_SUCCESS;
1174 default:
Dan Williamsffe191c2011-06-29 13:09:25 -07001175 dev_warn(sciport_to_dev(iport),
Piotr Sawicki8bc80d32011-05-11 23:52:31 +00001176 "%s: in wrong state: %d\n", __func__, state);
1177 return SCI_FAILURE_INVALID_STATE;
1178 }
1179}
1180
Dan Williams89a73012011-06-30 19:14:33 -07001181static enum sci_status sci_port_hard_reset(struct isci_port *iport, u32 timeout)
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001182{
1183 enum sci_status status = SCI_FAILURE_INVALID_PHY;
Dan Williams85280952011-06-28 15:05:53 -07001184 struct isci_phy *iphy = NULL;
Dan Williams89a73012011-06-30 19:14:33 -07001185 enum sci_port_states state;
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001186 u32 phy_index;
1187
Dan Williamsffe191c2011-06-29 13:09:25 -07001188 state = iport->sm.current_state_id;
Edmund Nadolskie3013702011-06-02 00:10:43 +00001189 if (state != SCI_PORT_SUB_OPERATIONAL) {
Dan Williamsffe191c2011-06-29 13:09:25 -07001190 dev_warn(sciport_to_dev(iport),
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001191 "%s: in wrong state: %d\n", __func__, state);
1192 return SCI_FAILURE_INVALID_STATE;
1193 }
1194
1195 /* Select a phy on which we can send the hard reset request. */
Dan Williams85280952011-06-28 15:05:53 -07001196 for (phy_index = 0; phy_index < SCI_MAX_PHYS && !iphy; phy_index++) {
Dan Williamsffe191c2011-06-29 13:09:25 -07001197 iphy = iport->phy_table[phy_index];
Dan Williams89a73012011-06-30 19:14:33 -07001198 if (iphy && !sci_port_active_phy(iport, iphy)) {
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001199 /*
1200 * We found a phy but it is not ready select
1201 * different phy
1202 */
Dan Williams85280952011-06-28 15:05:53 -07001203 iphy = NULL;
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001204 }
1205 }
1206
1207 /* If we have a phy then go ahead and start the reset procedure */
Dan Williams85280952011-06-28 15:05:53 -07001208 if (!iphy)
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001209 return status;
Dan Williams89a73012011-06-30 19:14:33 -07001210 status = sci_phy_reset(iphy);
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001211
1212 if (status != SCI_SUCCESS)
1213 return status;
1214
Dan Williamsffe191c2011-06-29 13:09:25 -07001215 sci_mod_timer(&iport->timer, timeout);
1216 iport->not_ready_reason = SCIC_PORT_NOT_READY_HARD_RESET_REQUESTED;
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001217
Dan Williamsffe191c2011-06-29 13:09:25 -07001218 port_state_machine_change(iport, SCI_PORT_RESETTING);
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001219 return SCI_SUCCESS;
1220}
1221
1222/**
Dan Williams89a73012011-06-30 19:14:33 -07001223 * sci_port_add_phy() -
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001224 * @sci_port: This parameter specifies the port in which the phy will be added.
1225 * @sci_phy: This parameter is the phy which is to be added to the port.
1226 *
1227 * This method will add a PHY to the selected port. This method returns an
1228 * enum sci_status. SCI_SUCCESS the phy has been added to the port. Any other
1229 * status is a failure to add the phy to the port.
1230 */
Dan Williams89a73012011-06-30 19:14:33 -07001231enum sci_status sci_port_add_phy(struct isci_port *iport,
Dan Williams85280952011-06-28 15:05:53 -07001232 struct isci_phy *iphy)
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001233{
1234 enum sci_status status;
Dan Williams89a73012011-06-30 19:14:33 -07001235 enum sci_port_states state;
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001236
Dan Williamsffe191c2011-06-29 13:09:25 -07001237 state = iport->sm.current_state_id;
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001238 switch (state) {
Edmund Nadolskie3013702011-06-02 00:10:43 +00001239 case SCI_PORT_STOPPED: {
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001240 struct sci_sas_address port_sas_address;
1241
1242 /* Read the port assigned SAS Address if there is one */
Dan Williams89a73012011-06-30 19:14:33 -07001243 sci_port_get_sas_address(iport, &port_sas_address);
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001244
1245 if (port_sas_address.high != 0 && port_sas_address.low != 0) {
1246 struct sci_sas_address phy_sas_address;
1247
1248 /* Make sure that the PHY SAS Address matches the SAS Address
1249 * for this port
1250 */
Dan Williams89a73012011-06-30 19:14:33 -07001251 sci_phy_get_sas_address(iphy, &phy_sas_address);
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001252
1253 if (port_sas_address.high != phy_sas_address.high ||
1254 port_sas_address.low != phy_sas_address.low)
1255 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
1256 }
Dan Williams89a73012011-06-30 19:14:33 -07001257 return sci_port_set_phy(iport, iphy);
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001258 }
Edmund Nadolskie3013702011-06-02 00:10:43 +00001259 case SCI_PORT_SUB_WAITING:
1260 case SCI_PORT_SUB_OPERATIONAL:
Dan Williams89a73012011-06-30 19:14:33 -07001261 status = sci_port_set_phy(iport, iphy);
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001262
1263 if (status != SCI_SUCCESS)
1264 return status;
1265
Marcin Tomczak05b080f2012-01-04 01:33:41 -08001266 sci_port_general_link_up_handler(iport, iphy, PF_NOTIFY|PF_RESUME);
Dan Williamsffe191c2011-06-29 13:09:25 -07001267 iport->not_ready_reason = SCIC_PORT_NOT_READY_RECONFIGURING;
1268 port_state_machine_change(iport, SCI_PORT_SUB_CONFIGURING);
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001269
1270 return status;
Edmund Nadolskie3013702011-06-02 00:10:43 +00001271 case SCI_PORT_SUB_CONFIGURING:
Dan Williams89a73012011-06-30 19:14:33 -07001272 status = sci_port_set_phy(iport, iphy);
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001273
1274 if (status != SCI_SUCCESS)
1275 return status;
Marcin Tomczak05b080f2012-01-04 01:33:41 -08001276 sci_port_general_link_up_handler(iport, iphy, PF_NOTIFY);
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001277
1278 /* Re-enter the configuring state since this may be the last phy in
1279 * the port.
1280 */
Dan Williamsffe191c2011-06-29 13:09:25 -07001281 port_state_machine_change(iport,
Edmund Nadolskie3013702011-06-02 00:10:43 +00001282 SCI_PORT_SUB_CONFIGURING);
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001283 return SCI_SUCCESS;
1284 default:
Dan Williamsffe191c2011-06-29 13:09:25 -07001285 dev_warn(sciport_to_dev(iport),
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001286 "%s: in wrong state: %d\n", __func__, state);
1287 return SCI_FAILURE_INVALID_STATE;
1288 }
1289}
1290
1291/**
Dan Williams89a73012011-06-30 19:14:33 -07001292 * sci_port_remove_phy() -
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001293 * @sci_port: This parameter specifies the port in which the phy will be added.
1294 * @sci_phy: This parameter is the phy which is to be added to the port.
1295 *
1296 * This method will remove the PHY from the selected PORT. This method returns
1297 * an enum sci_status. SCI_SUCCESS the phy has been removed from the port. Any
1298 * other status is a failure to add the phy to the port.
1299 */
Dan Williams89a73012011-06-30 19:14:33 -07001300enum sci_status sci_port_remove_phy(struct isci_port *iport,
Dan Williams85280952011-06-28 15:05:53 -07001301 struct isci_phy *iphy)
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001302{
1303 enum sci_status status;
Dan Williams89a73012011-06-30 19:14:33 -07001304 enum sci_port_states state;
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001305
Dan Williamsffe191c2011-06-29 13:09:25 -07001306 state = iport->sm.current_state_id;
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001307
1308 switch (state) {
Edmund Nadolskie3013702011-06-02 00:10:43 +00001309 case SCI_PORT_STOPPED:
Dan Williams89a73012011-06-30 19:14:33 -07001310 return sci_port_clear_phy(iport, iphy);
Edmund Nadolskie3013702011-06-02 00:10:43 +00001311 case SCI_PORT_SUB_OPERATIONAL:
Dan Williams89a73012011-06-30 19:14:33 -07001312 status = sci_port_clear_phy(iport, iphy);
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001313 if (status != SCI_SUCCESS)
1314 return status;
1315
Dan Williams89a73012011-06-30 19:14:33 -07001316 sci_port_deactivate_phy(iport, iphy, true);
Dan Williamsffe191c2011-06-29 13:09:25 -07001317 iport->not_ready_reason = SCIC_PORT_NOT_READY_RECONFIGURING;
1318 port_state_machine_change(iport,
Edmund Nadolskie3013702011-06-02 00:10:43 +00001319 SCI_PORT_SUB_CONFIGURING);
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001320 return SCI_SUCCESS;
Edmund Nadolskie3013702011-06-02 00:10:43 +00001321 case SCI_PORT_SUB_CONFIGURING:
Dan Williams89a73012011-06-30 19:14:33 -07001322 status = sci_port_clear_phy(iport, iphy);
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001323
1324 if (status != SCI_SUCCESS)
1325 return status;
Dan Williams89a73012011-06-30 19:14:33 -07001326 sci_port_deactivate_phy(iport, iphy, true);
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001327
1328 /* Re-enter the configuring state since this may be the last phy in
1329 * the port
1330 */
Dan Williamsffe191c2011-06-29 13:09:25 -07001331 port_state_machine_change(iport,
Edmund Nadolskie3013702011-06-02 00:10:43 +00001332 SCI_PORT_SUB_CONFIGURING);
Piotr Sawicki051266c2011-05-12 19:10:14 +00001333 return SCI_SUCCESS;
1334 default:
Dan Williamsffe191c2011-06-29 13:09:25 -07001335 dev_warn(sciport_to_dev(iport),
Piotr Sawicki051266c2011-05-12 19:10:14 +00001336 "%s: in wrong state: %d\n", __func__, state);
1337 return SCI_FAILURE_INVALID_STATE;
1338 }
1339}
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001340
Dan Williams89a73012011-06-30 19:14:33 -07001341enum sci_status sci_port_link_up(struct isci_port *iport,
Dan Williams85280952011-06-28 15:05:53 -07001342 struct isci_phy *iphy)
Piotr Sawicki051266c2011-05-12 19:10:14 +00001343{
Dan Williams89a73012011-06-30 19:14:33 -07001344 enum sci_port_states state;
Piotr Sawicki051266c2011-05-12 19:10:14 +00001345
Dan Williamsffe191c2011-06-29 13:09:25 -07001346 state = iport->sm.current_state_id;
Piotr Sawicki051266c2011-05-12 19:10:14 +00001347 switch (state) {
Edmund Nadolskie3013702011-06-02 00:10:43 +00001348 case SCI_PORT_SUB_WAITING:
Piotr Sawicki051266c2011-05-12 19:10:14 +00001349 /* Since this is the first phy going link up for the port we
1350 * can just enable it and continue
1351 */
Marcin Tomczak05b080f2012-01-04 01:33:41 -08001352 sci_port_activate_phy(iport, iphy, PF_NOTIFY|PF_RESUME);
Piotr Sawicki051266c2011-05-12 19:10:14 +00001353
Dan Williamsffe191c2011-06-29 13:09:25 -07001354 port_state_machine_change(iport,
Edmund Nadolskie3013702011-06-02 00:10:43 +00001355 SCI_PORT_SUB_OPERATIONAL);
Piotr Sawicki051266c2011-05-12 19:10:14 +00001356 return SCI_SUCCESS;
Edmund Nadolskie3013702011-06-02 00:10:43 +00001357 case SCI_PORT_SUB_OPERATIONAL:
Marcin Tomczak05b080f2012-01-04 01:33:41 -08001358 sci_port_general_link_up_handler(iport, iphy, PF_NOTIFY|PF_RESUME);
Piotr Sawicki051266c2011-05-12 19:10:14 +00001359 return SCI_SUCCESS;
Edmund Nadolskie3013702011-06-02 00:10:43 +00001360 case SCI_PORT_RESETTING:
Piotr Sawicki051266c2011-05-12 19:10:14 +00001361 /* TODO We should make sure that the phy that has gone
1362 * link up is the same one on which we sent the reset. It is
1363 * possible that the phy on which we sent the reset is not the
1364 * one that has gone link up and we want to make sure that
1365 * phy being reset comes back. Consider the case where a
1366 * reset is sent but before the hardware processes the reset it
1367 * get a link up on the port because of a hot plug event.
1368 * because of the reset request this phy will go link down
1369 * almost immediately.
1370 */
1371
1372 /* In the resetting state we don't notify the user regarding
1373 * link up and link down notifications.
1374 */
Marcin Tomczak05b080f2012-01-04 01:33:41 -08001375 sci_port_general_link_up_handler(iport, iphy, PF_RESUME);
Piotr Sawicki051266c2011-05-12 19:10:14 +00001376 return SCI_SUCCESS;
1377 default:
Dan Williamsffe191c2011-06-29 13:09:25 -07001378 dev_warn(sciport_to_dev(iport),
Piotr Sawicki051266c2011-05-12 19:10:14 +00001379 "%s: in wrong state: %d\n", __func__, state);
1380 return SCI_FAILURE_INVALID_STATE;
1381 }
1382}
1383
Dan Williams89a73012011-06-30 19:14:33 -07001384enum sci_status sci_port_link_down(struct isci_port *iport,
Dan Williams85280952011-06-28 15:05:53 -07001385 struct isci_phy *iphy)
Piotr Sawicki051266c2011-05-12 19:10:14 +00001386{
Dan Williams89a73012011-06-30 19:14:33 -07001387 enum sci_port_states state;
Piotr Sawicki051266c2011-05-12 19:10:14 +00001388
Dan Williamsffe191c2011-06-29 13:09:25 -07001389 state = iport->sm.current_state_id;
Piotr Sawicki051266c2011-05-12 19:10:14 +00001390 switch (state) {
Edmund Nadolskie3013702011-06-02 00:10:43 +00001391 case SCI_PORT_SUB_OPERATIONAL:
Dan Williams89a73012011-06-30 19:14:33 -07001392 sci_port_deactivate_phy(iport, iphy, true);
Piotr Sawicki051266c2011-05-12 19:10:14 +00001393
1394 /* If there are no active phys left in the port, then
1395 * transition the port to the WAITING state until such time
1396 * as a phy goes link up
1397 */
Dan Williamsffe191c2011-06-29 13:09:25 -07001398 if (iport->active_phy_mask == 0)
1399 port_state_machine_change(iport,
Edmund Nadolskie3013702011-06-02 00:10:43 +00001400 SCI_PORT_SUB_WAITING);
Piotr Sawicki051266c2011-05-12 19:10:14 +00001401 return SCI_SUCCESS;
Edmund Nadolskie3013702011-06-02 00:10:43 +00001402 case SCI_PORT_RESETTING:
Piotr Sawicki051266c2011-05-12 19:10:14 +00001403 /* In the resetting state we don't notify the user regarding
1404 * link up and link down notifications. */
Dan Williams89a73012011-06-30 19:14:33 -07001405 sci_port_deactivate_phy(iport, iphy, false);
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001406 return SCI_SUCCESS;
1407 default:
Dan Williamsffe191c2011-06-29 13:09:25 -07001408 dev_warn(sciport_to_dev(iport),
Piotr Sawickibd6713b2011-05-12 19:10:03 +00001409 "%s: in wrong state: %d\n", __func__, state);
1410 return SCI_FAILURE_INVALID_STATE;
1411 }
1412}
1413
Dan Williams89a73012011-06-30 19:14:33 -07001414enum sci_status sci_port_start_io(struct isci_port *iport,
1415 struct isci_remote_device *idev,
1416 struct isci_request *ireq)
Dan Williams68138202011-05-12 07:16:06 -07001417{
Dan Williams89a73012011-06-30 19:14:33 -07001418 enum sci_port_states state;
Dan Williamse2f8db52011-05-10 02:28:46 -07001419
Dan Williamsffe191c2011-06-29 13:09:25 -07001420 state = iport->sm.current_state_id;
Dan Williams68138202011-05-12 07:16:06 -07001421 switch (state) {
Edmund Nadolskie3013702011-06-02 00:10:43 +00001422 case SCI_PORT_SUB_WAITING:
Dan Williams68138202011-05-12 07:16:06 -07001423 return SCI_FAILURE_INVALID_STATE;
Edmund Nadolskie3013702011-06-02 00:10:43 +00001424 case SCI_PORT_SUB_OPERATIONAL:
Dan Williamsffe191c2011-06-29 13:09:25 -07001425 iport->started_request_count++;
Dan Williams68138202011-05-12 07:16:06 -07001426 return SCI_SUCCESS;
1427 default:
Dan Williamsffe191c2011-06-29 13:09:25 -07001428 dev_warn(sciport_to_dev(iport),
Dan Williams68138202011-05-12 07:16:06 -07001429 "%s: in wrong state: %d\n", __func__, state);
1430 return SCI_FAILURE_INVALID_STATE;
1431 }
1432}
1433
Dan Williams89a73012011-06-30 19:14:33 -07001434enum sci_status sci_port_complete_io(struct isci_port *iport,
1435 struct isci_remote_device *idev,
1436 struct isci_request *ireq)
Dan Williams68138202011-05-12 07:16:06 -07001437{
Dan Williams89a73012011-06-30 19:14:33 -07001438 enum sci_port_states state;
Dan Williams68138202011-05-12 07:16:06 -07001439
Dan Williamsffe191c2011-06-29 13:09:25 -07001440 state = iport->sm.current_state_id;
Dan Williams68138202011-05-12 07:16:06 -07001441 switch (state) {
Edmund Nadolskie3013702011-06-02 00:10:43 +00001442 case SCI_PORT_STOPPED:
Dan Williamsffe191c2011-06-29 13:09:25 -07001443 dev_warn(sciport_to_dev(iport),
Dan Williams68138202011-05-12 07:16:06 -07001444 "%s: in wrong state: %d\n", __func__, state);
1445 return SCI_FAILURE_INVALID_STATE;
Edmund Nadolskie3013702011-06-02 00:10:43 +00001446 case SCI_PORT_STOPPING:
Dan Williams89a73012011-06-30 19:14:33 -07001447 sci_port_decrement_request_count(iport);
Dan Williams68138202011-05-12 07:16:06 -07001448
Dan Williamsffe191c2011-06-29 13:09:25 -07001449 if (iport->started_request_count == 0)
1450 port_state_machine_change(iport,
Edmund Nadolskie3013702011-06-02 00:10:43 +00001451 SCI_PORT_STOPPED);
Dan Williams68138202011-05-12 07:16:06 -07001452 break;
Edmund Nadolskie3013702011-06-02 00:10:43 +00001453 case SCI_PORT_READY:
1454 case SCI_PORT_RESETTING:
1455 case SCI_PORT_FAILED:
1456 case SCI_PORT_SUB_WAITING:
1457 case SCI_PORT_SUB_OPERATIONAL:
Dan Williams89a73012011-06-30 19:14:33 -07001458 sci_port_decrement_request_count(iport);
Dan Williams68138202011-05-12 07:16:06 -07001459 break;
Edmund Nadolskie3013702011-06-02 00:10:43 +00001460 case SCI_PORT_SUB_CONFIGURING:
Dan Williams89a73012011-06-30 19:14:33 -07001461 sci_port_decrement_request_count(iport);
Dan Williamsffe191c2011-06-29 13:09:25 -07001462 if (iport->started_request_count == 0) {
1463 port_state_machine_change(iport,
Edmund Nadolskie3013702011-06-02 00:10:43 +00001464 SCI_PORT_SUB_OPERATIONAL);
Dan Williams68138202011-05-12 07:16:06 -07001465 }
1466 break;
1467 }
1468 return SCI_SUCCESS;
1469}
Dan Williamse2f8db52011-05-10 02:28:46 -07001470
Dan Williams89a73012011-06-30 19:14:33 -07001471static void sci_port_enable_port_task_scheduler(struct isci_port *iport)
Dan Williamse2f8db52011-05-10 02:28:46 -07001472{
1473 u32 pts_control_value;
1474
Dan Williams89a73012011-06-30 19:14:33 -07001475 /* enable the port task scheduler in a suspended state */
Dan Williamsffe191c2011-06-29 13:09:25 -07001476 pts_control_value = readl(&iport->port_task_scheduler_registers->control);
Dan Williamse2f8db52011-05-10 02:28:46 -07001477 pts_control_value |= SCU_PTSxCR_GEN_BIT(ENABLE) | SCU_PTSxCR_GEN_BIT(SUSPEND);
Dan Williamsffe191c2011-06-29 13:09:25 -07001478 writel(pts_control_value, &iport->port_task_scheduler_registers->control);
Dan Williamse2f8db52011-05-10 02:28:46 -07001479}
1480
Dan Williams89a73012011-06-30 19:14:33 -07001481static void sci_port_disable_port_task_scheduler(struct isci_port *iport)
Dan Williamse2f8db52011-05-10 02:28:46 -07001482{
1483 u32 pts_control_value;
1484
Dan Williamsffe191c2011-06-29 13:09:25 -07001485 pts_control_value = readl(&iport->port_task_scheduler_registers->control);
Dan Williamse2f8db52011-05-10 02:28:46 -07001486 pts_control_value &=
1487 ~(SCU_PTSxCR_GEN_BIT(ENABLE) | SCU_PTSxCR_GEN_BIT(SUSPEND));
Dan Williamsffe191c2011-06-29 13:09:25 -07001488 writel(pts_control_value, &iport->port_task_scheduler_registers->control);
Dan Williamse2f8db52011-05-10 02:28:46 -07001489}
1490
Dan Williams89a73012011-06-30 19:14:33 -07001491static void sci_port_post_dummy_remote_node(struct isci_port *iport)
Dan Williamse2f8db52011-05-10 02:28:46 -07001492{
Dan Williamsd9dcb4b2011-06-30 17:38:32 -07001493 struct isci_host *ihost = iport->owning_controller;
Dan Williamsffe191c2011-06-29 13:09:25 -07001494 u8 phys_index = iport->physical_port_index;
Dan Williamse2f8db52011-05-10 02:28:46 -07001495 union scu_remote_node_context *rnc;
Dan Williamsffe191c2011-06-29 13:09:25 -07001496 u16 rni = iport->reserved_rni;
Dan Williamse2f8db52011-05-10 02:28:46 -07001497 u32 command;
1498
Dan Williamsd9dcb4b2011-06-30 17:38:32 -07001499 rnc = &ihost->remote_node_context_table[rni];
Dan Williamse2f8db52011-05-10 02:28:46 -07001500 rnc->ssp.is_valid = true;
1501
1502 command = SCU_CONTEXT_COMMAND_POST_RNC_32 |
1503 phys_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT | rni;
1504
Dan Williams89a73012011-06-30 19:14:33 -07001505 sci_controller_post_request(ihost, command);
Dan Williamse2f8db52011-05-10 02:28:46 -07001506
1507 /* ensure hardware has seen the post rnc command and give it
1508 * ample time to act before sending the suspend
1509 */
Dan Williamsd9dcb4b2011-06-30 17:38:32 -07001510 readl(&ihost->smu_registers->interrupt_status); /* flush */
Dan Williamse2f8db52011-05-10 02:28:46 -07001511 udelay(10);
1512
1513 command = SCU_CONTEXT_COMMAND_POST_RNC_SUSPEND_TX_RX |
1514 phys_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT | rni;
1515
Dan Williams89a73012011-06-30 19:14:33 -07001516 sci_controller_post_request(ihost, command);
Dan Williamse2f8db52011-05-10 02:28:46 -07001517}
1518
Dan Williams89a73012011-06-30 19:14:33 -07001519static void sci_port_stopped_state_enter(struct sci_base_state_machine *sm)
Dan Williamse2f8db52011-05-10 02:28:46 -07001520{
Dan Williamsffe191c2011-06-29 13:09:25 -07001521 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
Dan Williamse2f8db52011-05-10 02:28:46 -07001522
Dan Williamsffe191c2011-06-29 13:09:25 -07001523 if (iport->sm.previous_state_id == SCI_PORT_STOPPING) {
Dan Williamse2f8db52011-05-10 02:28:46 -07001524 /*
1525 * If we enter this state becasuse of a request to stop
1526 * the port then we want to disable the hardwares port
1527 * task scheduler. */
Dan Williams89a73012011-06-30 19:14:33 -07001528 sci_port_disable_port_task_scheduler(iport);
Dan Williamse2f8db52011-05-10 02:28:46 -07001529 }
1530}
1531
Dan Williams89a73012011-06-30 19:14:33 -07001532static void sci_port_stopped_state_exit(struct sci_base_state_machine *sm)
Dan Williamse2f8db52011-05-10 02:28:46 -07001533{
Dan Williamsffe191c2011-06-29 13:09:25 -07001534 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
Dan Williamse2f8db52011-05-10 02:28:46 -07001535
1536 /* Enable and suspend the port task scheduler */
Dan Williams89a73012011-06-30 19:14:33 -07001537 sci_port_enable_port_task_scheduler(iport);
Dan Williamse2f8db52011-05-10 02:28:46 -07001538}
1539
Dan Williams89a73012011-06-30 19:14:33 -07001540static void sci_port_ready_state_enter(struct sci_base_state_machine *sm)
Dan Williamse2f8db52011-05-10 02:28:46 -07001541{
Dan Williamsffe191c2011-06-29 13:09:25 -07001542 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
Dan Williamsd9dcb4b2011-06-30 17:38:32 -07001543 struct isci_host *ihost = iport->owning_controller;
Dan Williamse2f8db52011-05-10 02:28:46 -07001544 u32 prev_state;
1545
Dan Williamsffe191c2011-06-29 13:09:25 -07001546 prev_state = iport->sm.previous_state_id;
Edmund Nadolskie3013702011-06-02 00:10:43 +00001547 if (prev_state == SCI_PORT_RESETTING)
Dan Williamse2f8db52011-05-10 02:28:46 -07001548 isci_port_hard_reset_complete(iport, SCI_SUCCESS);
1549 else
1550 isci_port_not_ready(ihost, iport);
1551
1552 /* Post and suspend the dummy remote node context for this port. */
Dan Williams89a73012011-06-30 19:14:33 -07001553 sci_port_post_dummy_remote_node(iport);
Dan Williamse2f8db52011-05-10 02:28:46 -07001554
1555 /* Start the ready substate machine */
Dan Williamsffe191c2011-06-29 13:09:25 -07001556 port_state_machine_change(iport,
Edmund Nadolskie3013702011-06-02 00:10:43 +00001557 SCI_PORT_SUB_WAITING);
Dan Williamse2f8db52011-05-10 02:28:46 -07001558}
1559
Dan Williams89a73012011-06-30 19:14:33 -07001560static void sci_port_resetting_state_exit(struct sci_base_state_machine *sm)
Dan Williamse2f8db52011-05-10 02:28:46 -07001561{
Dan Williamsffe191c2011-06-29 13:09:25 -07001562 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
Dan Williamse2f8db52011-05-10 02:28:46 -07001563
Dan Williamsffe191c2011-06-29 13:09:25 -07001564 sci_del_timer(&iport->timer);
Dan Williamse2f8db52011-05-10 02:28:46 -07001565}
1566
Dan Williams89a73012011-06-30 19:14:33 -07001567static void sci_port_stopping_state_exit(struct sci_base_state_machine *sm)
Dan Williamse2f8db52011-05-10 02:28:46 -07001568{
Dan Williamsffe191c2011-06-29 13:09:25 -07001569 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
Dan Williamse2f8db52011-05-10 02:28:46 -07001570
Dan Williamsffe191c2011-06-29 13:09:25 -07001571 sci_del_timer(&iport->timer);
Dan Williamse2f8db52011-05-10 02:28:46 -07001572
Dan Williams89a73012011-06-30 19:14:33 -07001573 sci_port_destroy_dummy_resources(iport);
Dan Williamse2f8db52011-05-10 02:28:46 -07001574}
1575
Dan Williams89a73012011-06-30 19:14:33 -07001576static void sci_port_failed_state_enter(struct sci_base_state_machine *sm)
Dan Williamse2f8db52011-05-10 02:28:46 -07001577{
Dan Williamsffe191c2011-06-29 13:09:25 -07001578 struct isci_port *iport = container_of(sm, typeof(*iport), sm);
Dan Williamse2f8db52011-05-10 02:28:46 -07001579
Dan Williamse2f8db52011-05-10 02:28:46 -07001580 isci_port_hard_reset_complete(iport, SCI_FAILURE_TIMEOUT);
1581}
1582
1583/* --------------------------------------------------------------------------- */
1584
Dan Williams89a73012011-06-30 19:14:33 -07001585static const struct sci_base_state sci_port_state_table[] = {
Edmund Nadolskie3013702011-06-02 00:10:43 +00001586 [SCI_PORT_STOPPED] = {
Dan Williams89a73012011-06-30 19:14:33 -07001587 .enter_state = sci_port_stopped_state_enter,
1588 .exit_state = sci_port_stopped_state_exit
Dan Williamse2f8db52011-05-10 02:28:46 -07001589 },
Edmund Nadolskie3013702011-06-02 00:10:43 +00001590 [SCI_PORT_STOPPING] = {
Dan Williams89a73012011-06-30 19:14:33 -07001591 .exit_state = sci_port_stopping_state_exit
Dan Williamse2f8db52011-05-10 02:28:46 -07001592 },
Edmund Nadolskie3013702011-06-02 00:10:43 +00001593 [SCI_PORT_READY] = {
Dan Williams89a73012011-06-30 19:14:33 -07001594 .enter_state = sci_port_ready_state_enter,
Piotr Sawickie91f41e2011-05-11 23:52:21 +00001595 },
Edmund Nadolskie3013702011-06-02 00:10:43 +00001596 [SCI_PORT_SUB_WAITING] = {
Dan Williams89a73012011-06-30 19:14:33 -07001597 .enter_state = sci_port_ready_substate_waiting_enter,
Marcin Tomczak05b080f2012-01-04 01:33:41 -08001598 .exit_state = scic_sds_port_ready_substate_waiting_exit,
Piotr Sawickie91f41e2011-05-11 23:52:21 +00001599 },
Edmund Nadolskie3013702011-06-02 00:10:43 +00001600 [SCI_PORT_SUB_OPERATIONAL] = {
Dan Williams89a73012011-06-30 19:14:33 -07001601 .enter_state = sci_port_ready_substate_operational_enter,
1602 .exit_state = sci_port_ready_substate_operational_exit
Piotr Sawickie91f41e2011-05-11 23:52:21 +00001603 },
Edmund Nadolskie3013702011-06-02 00:10:43 +00001604 [SCI_PORT_SUB_CONFIGURING] = {
Marcin Tomczak05b080f2012-01-04 01:33:41 -08001605 .enter_state = sci_port_ready_substate_configuring_enter
Dan Williamse2f8db52011-05-10 02:28:46 -07001606 },
Edmund Nadolskie3013702011-06-02 00:10:43 +00001607 [SCI_PORT_RESETTING] = {
Dan Williams89a73012011-06-30 19:14:33 -07001608 .exit_state = sci_port_resetting_state_exit
Dan Williamse2f8db52011-05-10 02:28:46 -07001609 },
Edmund Nadolskie3013702011-06-02 00:10:43 +00001610 [SCI_PORT_FAILED] = {
Dan Williams89a73012011-06-30 19:14:33 -07001611 .enter_state = sci_port_failed_state_enter,
Dan Williamse2f8db52011-05-10 02:28:46 -07001612 }
1613};
1614
Dan Williams89a73012011-06-30 19:14:33 -07001615void sci_port_construct(struct isci_port *iport, u8 index,
Dan Williamsd9dcb4b2011-06-30 17:38:32 -07001616 struct isci_host *ihost)
Dan Williamse2f8db52011-05-10 02:28:46 -07001617{
Dan Williams89a73012011-06-30 19:14:33 -07001618 sci_init_sm(&iport->sm, sci_port_state_table, SCI_PORT_STOPPED);
Dan Williamse2f8db52011-05-10 02:28:46 -07001619
Dan Williamsffe191c2011-06-29 13:09:25 -07001620 iport->logical_port_index = SCIC_SDS_DUMMY_PORT;
1621 iport->physical_port_index = index;
1622 iport->active_phy_mask = 0;
Marcin Tomczak05b080f2012-01-04 01:33:41 -08001623 iport->enabled_phy_mask = 0;
Jeff Skirvin8e35a132011-10-27 15:05:32 -07001624 iport->last_active_phy = 0;
1625 iport->ready_exit = false;
Dan Williamse2f8db52011-05-10 02:28:46 -07001626
Dan Williamsd9dcb4b2011-06-30 17:38:32 -07001627 iport->owning_controller = ihost;
Dan Williamse2f8db52011-05-10 02:28:46 -07001628
Dan Williamsffe191c2011-06-29 13:09:25 -07001629 iport->started_request_count = 0;
1630 iport->assigned_device_count = 0;
Dan Williamse2f8db52011-05-10 02:28:46 -07001631
Dan Williamsffe191c2011-06-29 13:09:25 -07001632 iport->reserved_rni = SCU_DUMMY_INDEX;
1633 iport->reserved_tag = SCI_CONTROLLER_INVALID_IO_TAG;
Dan Williamse2f8db52011-05-10 02:28:46 -07001634
Dan Williamsffe191c2011-06-29 13:09:25 -07001635 sci_init_timer(&iport->timer, port_timeout);
Edmund Nadolski5553ba22011-05-19 11:59:10 +00001636
Dan Williamsffe191c2011-06-29 13:09:25 -07001637 iport->port_task_scheduler_registers = NULL;
Dan Williamse2f8db52011-05-10 02:28:46 -07001638
1639 for (index = 0; index < SCI_MAX_PHYS; index++)
Dan Williamsffe191c2011-06-29 13:09:25 -07001640 iport->phy_table[index] = NULL;
Dan Williamse2f8db52011-05-10 02:28:46 -07001641}
1642
1643void isci_port_init(struct isci_port *iport, struct isci_host *ihost, int index)
1644{
1645 INIT_LIST_HEAD(&iport->remote_dev_list);
1646 INIT_LIST_HEAD(&iport->domain_dev_list);
1647 spin_lock_init(&iport->state_lock);
1648 init_completion(&iport->start_complete);
1649 iport->isci_host = ihost;
1650 isci_port_change_state(iport, isci_freed);
1651}
1652
1653/**
1654 * isci_port_get_state() - This function gets the status of the port object.
1655 * @isci_port: This parameter points to the isci_port object
1656 *
1657 * status of the object as a isci_status enum.
1658 */
1659enum isci_status isci_port_get_state(
1660 struct isci_port *isci_port)
1661{
1662 return isci_port->status;
1663}
1664
Dan Williams89a73012011-06-30 19:14:33 -07001665void sci_port_broadcast_change_received(struct isci_port *iport, struct isci_phy *iphy)
Dan Williamse2f8db52011-05-10 02:28:46 -07001666{
Dan Williamsd9dcb4b2011-06-30 17:38:32 -07001667 struct isci_host *ihost = iport->owning_controller;
Dan Williamse2f8db52011-05-10 02:28:46 -07001668
1669 /* notify the user. */
Dan Williamsffe191c2011-06-29 13:09:25 -07001670 isci_port_bc_change_received(ihost, iport, iphy);
Dan Williamse2f8db52011-05-10 02:28:46 -07001671}
1672
Dan Williams4393aa42011-03-31 13:10:44 -07001673int isci_port_perform_hard_reset(struct isci_host *ihost, struct isci_port *iport,
1674 struct isci_phy *iphy)
Dan Williams6f231dd2011-07-02 22:56:22 -07001675{
Dan Williams4393aa42011-03-31 13:10:44 -07001676 unsigned long flags;
Dan Williams6f231dd2011-07-02 22:56:22 -07001677 enum sci_status status;
Jeff Skirvin8e35a132011-10-27 15:05:32 -07001678 int ret = TMF_RESP_FUNC_COMPLETE;
Dan Williams6f231dd2011-07-02 22:56:22 -07001679
Dan Williams4393aa42011-03-31 13:10:44 -07001680 dev_dbg(&ihost->pdev->dev, "%s: iport = %p\n",
1681 __func__, iport);
Dan Williams6f231dd2011-07-02 22:56:22 -07001682
Dan Williams4393aa42011-03-31 13:10:44 -07001683 init_completion(&iport->hard_reset_complete);
Dan Williams6f231dd2011-07-02 22:56:22 -07001684
Dan Williams4393aa42011-03-31 13:10:44 -07001685 spin_lock_irqsave(&ihost->scic_lock, flags);
Dan Williams6f231dd2011-07-02 22:56:22 -07001686
1687 #define ISCI_PORT_RESET_TIMEOUT SCIC_SDS_SIGNATURE_FIS_TIMEOUT
Dan Williams89a73012011-06-30 19:14:33 -07001688 status = sci_port_hard_reset(iport, ISCI_PORT_RESET_TIMEOUT);
Dan Williams6f231dd2011-07-02 22:56:22 -07001689
Dan Williams4393aa42011-03-31 13:10:44 -07001690 spin_unlock_irqrestore(&ihost->scic_lock, flags);
Dan Williams6f231dd2011-07-02 22:56:22 -07001691
1692 if (status == SCI_SUCCESS) {
Dan Williams4393aa42011-03-31 13:10:44 -07001693 wait_for_completion(&iport->hard_reset_complete);
Dan Williams6f231dd2011-07-02 22:56:22 -07001694
Dan Williams4393aa42011-03-31 13:10:44 -07001695 dev_dbg(&ihost->pdev->dev,
1696 "%s: iport = %p; hard reset completion\n",
1697 __func__, iport);
Dan Williams6f231dd2011-07-02 22:56:22 -07001698
Jeff Skirvin8e35a132011-10-27 15:05:32 -07001699 if (iport->hard_reset_status != SCI_SUCCESS) {
Dan Williams6f231dd2011-07-02 22:56:22 -07001700 ret = TMF_RESP_FUNC_FAILED;
Jeff Skirvin8e35a132011-10-27 15:05:32 -07001701
1702 dev_err(&ihost->pdev->dev,
1703 "%s: iport = %p; hard reset failed (0x%x)\n",
1704 __func__, iport, iport->hard_reset_status);
1705 }
Dan Williams6f231dd2011-07-02 22:56:22 -07001706 } else {
1707 ret = TMF_RESP_FUNC_FAILED;
1708
Dan Williams4393aa42011-03-31 13:10:44 -07001709 dev_err(&ihost->pdev->dev,
Dan Williams89a73012011-06-30 19:14:33 -07001710 "%s: iport = %p; sci_port_hard_reset call"
Dan Williams6f231dd2011-07-02 22:56:22 -07001711 " failed 0x%x\n",
Dan Williams4393aa42011-03-31 13:10:44 -07001712 __func__, iport, status);
Dan Williams6f231dd2011-07-02 22:56:22 -07001713
1714 }
1715
1716 /* If the hard reset for the port has failed, consider this
1717 * the same as link failures on all phys in the port.
1718 */
1719 if (ret != TMF_RESP_FUNC_COMPLETE) {
Jeff Skirvinfd0527a2011-06-20 14:09:26 -07001720
Dan Williams4393aa42011-03-31 13:10:44 -07001721 dev_err(&ihost->pdev->dev,
1722 "%s: iport = %p; hard reset failed "
Jeff Skirvinfd0527a2011-06-20 14:09:26 -07001723 "(0x%x) - driving explicit link fail for all phys\n",
1724 __func__, iport, iport->hard_reset_status);
Dan Williams6f231dd2011-07-02 22:56:22 -07001725 }
Dan Williams6f231dd2011-07-02 22:56:22 -07001726 return ret;
1727}
Dave Jiang09d7da12011-03-26 16:11:51 -07001728
Dan Williamse2f8db52011-05-10 02:28:46 -07001729/**
1730 * isci_port_deformed() - This function is called by libsas when a port becomes
1731 * inactive.
1732 * @phy: This parameter specifies the libsas phy with the inactive port.
1733 *
1734 */
1735void isci_port_deformed(struct asd_sas_phy *phy)
Dave Jiang09d7da12011-03-26 16:11:51 -07001736{
Dan Williamse2f8db52011-05-10 02:28:46 -07001737 pr_debug("%s: sas_phy = %p\n", __func__, phy);
1738}
1739
1740/**
1741 * isci_port_formed() - This function is called by libsas when a port becomes
1742 * active.
1743 * @phy: This parameter specifies the libsas phy with the active port.
1744 *
1745 */
1746void isci_port_formed(struct asd_sas_phy *phy)
1747{
1748 pr_debug("%s: sas_phy = %p, sas_port = %p\n", __func__, phy, phy->port);
Dave Jiang09d7da12011-03-26 16:11:51 -07001749}