1 /*
2  * This file is provided under a dual BSD/GPLv2 license.  When using or
3  * redistributing this file, you may do so under either license.
4  *
5  * GPL LICENSE SUMMARY
6  *
7  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of version 2 of the GNU General Public License as
11  * published by the Free Software Foundation.
12  *
13  * This program is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
21  * The full GNU General Public License is included in this distribution
22  * in the file called LICENSE.GPL.
23  *
24  * BSD LICENSE
25  *
26  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
27  * All rights reserved.
28  *
29  * Redistribution and use in source and binary forms, with or without
30  * modification, are permitted provided that the following conditions
31  * are met:
32  *
33  *   * Redistributions of source code must retain the above copyright
34  *     notice, this list of conditions and the following disclaimer.
35  *   * Redistributions in binary form must reproduce the above copyright
36  *     notice, this list of conditions and the following disclaimer in
37  *     the documentation and/or other materials provided with the
38  *     distribution.
39  *   * Neither the name of Intel Corporation nor the names of its
40  *     contributors may be used to endorse or promote products derived
41  *     from this software without specific prior written permission.
42  *
43  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
44  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
45  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
46  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
47  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
48  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
49  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
50  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
51  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
52  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
53  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
54  */
55 
56 #include "host.h"
57 
58 #define SCIC_SDS_MPC_RECONFIGURATION_TIMEOUT    (10)
59 #define SCIC_SDS_APC_RECONFIGURATION_TIMEOUT    (10)
60 #define SCIC_SDS_APC_WAIT_LINK_UP_NOTIFICATION  (1000)
61 
62 enum SCIC_SDS_APC_ACTIVITY {
63 	SCIC_SDS_APC_SKIP_PHY,
64 	SCIC_SDS_APC_ADD_PHY,
65 	SCIC_SDS_APC_START_TIMER,
66 
67 	SCIC_SDS_APC_ACTIVITY_MAX
68 };
69 
70 /*
71  * ******************************************************************************
72  * General port configuration agent routines
73  * ****************************************************************************** */
74 
75 /**
76  * sci_sas_address_compare()
77  * @address_one: A SAS Address to be compared.
78  * @address_two: A SAS Address to be compared.
79  *
80  * Compare the two SAS Address and if SAS Address One is greater than SAS
81  * Address Two then return > 0 else if SAS Address One is less than SAS Address
82  * Two return < 0 Otherwise they are the same return 0 A signed value of x > 0
83  * > y where x is returned for Address One > Address Two y is returned for
84  * Address One < Address Two 0 is returned ofr Address One = Address Two
85  */
sci_sas_address_compare(struct sci_sas_address address_one,struct sci_sas_address address_two)86 static s32 sci_sas_address_compare(
87 	struct sci_sas_address address_one,
88 	struct sci_sas_address address_two)
89 {
90 	if (address_one.high > address_two.high) {
91 		return 1;
92 	} else if (address_one.high < address_two.high) {
93 		return -1;
94 	} else if (address_one.low > address_two.low) {
95 		return 1;
96 	} else if (address_one.low < address_two.low) {
97 		return -1;
98 	}
99 
100 	/* The two SAS Address must be identical */
101 	return 0;
102 }
103 
104 /**
105  * sci_port_configuration_agent_find_port()
106  * @ihost: The controller object used for the port search.
107  * @iphy: The phy object to match.
108  *
109  * This routine will find a matching port for the phy.  This means that the
110  * port and phy both have the same broadcast sas address and same received sas
111  * address. The port address or the NULL if there is no matching
112  * port. port address if the port can be found to match the phy.
113  * NULL if there is no matching port for the phy.
114  */
sci_port_configuration_agent_find_port(struct isci_host * ihost,struct isci_phy * iphy)115 static struct isci_port *sci_port_configuration_agent_find_port(
116 	struct isci_host *ihost,
117 	struct isci_phy *iphy)
118 {
119 	u8 i;
120 	struct sci_sas_address port_sas_address;
121 	struct sci_sas_address port_attached_device_address;
122 	struct sci_sas_address phy_sas_address;
123 	struct sci_sas_address phy_attached_device_address;
124 
125 	/*
126 	 * Since this phy can be a member of a wide port check to see if one or
127 	 * more phys match the sent and received SAS address as this phy in which
128 	 * case it should participate in the same port.
129 	 */
130 	sci_phy_get_sas_address(iphy, &phy_sas_address);
131 	sci_phy_get_attached_sas_address(iphy, &phy_attached_device_address);
132 
133 	for (i = 0; i < ihost->logical_port_entries; i++) {
134 		struct isci_port *iport = &ihost->ports[i];
135 
136 		sci_port_get_sas_address(iport, &port_sas_address);
137 		sci_port_get_attached_sas_address(iport, &port_attached_device_address);
138 
139 		if (sci_sas_address_compare(port_sas_address, phy_sas_address) == 0 &&
140 		    sci_sas_address_compare(port_attached_device_address, phy_attached_device_address) == 0)
141 			return iport;
142 	}
143 
144 	return NULL;
145 }
146 
147 /**
148  * sci_port_configuration_agent_validate_ports()
149  * @ihost: This is the controller object that contains the port agent
150  * @port_agent: This is the port configuration agent for the controller.
151  *
152  * This routine will validate the port configuration is correct for the SCU
153  * hardware.  The SCU hardware allows for port configurations as follows. LP0
154  * -> (PE0), (PE0, PE1), (PE0, PE1, PE2, PE3) LP1 -> (PE1) LP2 -> (PE2), (PE2,
155  * PE3) LP3 -> (PE3) enum sci_status SCI_SUCCESS the port configuration is valid for
156  * this port configuration agent. SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION
157  * the port configuration is not valid for this port configuration agent.
158  */
sci_port_configuration_agent_validate_ports(struct isci_host * ihost,struct sci_port_configuration_agent * port_agent)159 static enum sci_status sci_port_configuration_agent_validate_ports(
160 	struct isci_host *ihost,
161 	struct sci_port_configuration_agent *port_agent)
162 {
163 	struct sci_sas_address first_address;
164 	struct sci_sas_address second_address;
165 
166 	/*
167 	 * Sanity check the max ranges for all the phys the max index
168 	 * is always equal to the port range index */
169 	if (port_agent->phy_valid_port_range[0].max_index != 0 ||
170 	    port_agent->phy_valid_port_range[1].max_index != 1 ||
171 	    port_agent->phy_valid_port_range[2].max_index != 2 ||
172 	    port_agent->phy_valid_port_range[3].max_index != 3)
173 		return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
174 
175 	/*
176 	 * This is a request to configure a single x4 port or at least attempt
177 	 * to make all the phys into a single port */
178 	if (port_agent->phy_valid_port_range[0].min_index == 0 &&
179 	    port_agent->phy_valid_port_range[1].min_index == 0 &&
180 	    port_agent->phy_valid_port_range[2].min_index == 0 &&
181 	    port_agent->phy_valid_port_range[3].min_index == 0)
182 		return SCI_SUCCESS;
183 
184 	/*
185 	 * This is a degenerate case where phy 1 and phy 2 are assigned
186 	 * to the same port this is explicitly disallowed by the hardware
187 	 * unless they are part of the same x4 port and this condition was
188 	 * already checked above. */
189 	if (port_agent->phy_valid_port_range[2].min_index == 1) {
190 		return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
191 	}
192 
193 	/*
194 	 * PE0 and PE3 can never have the same SAS Address unless they
195 	 * are part of the same x4 wide port and we have already checked
196 	 * for this condition. */
197 	sci_phy_get_sas_address(&ihost->phys[0], &first_address);
198 	sci_phy_get_sas_address(&ihost->phys[3], &second_address);
199 
200 	if (sci_sas_address_compare(first_address, second_address) == 0) {
201 		return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
202 	}
203 
204 	/*
205 	 * PE0 and PE1 are configured into a 2x1 ports make sure that the
206 	 * SAS Address for PE0 and PE2 are different since they can not be
207 	 * part of the same port. */
208 	if (port_agent->phy_valid_port_range[0].min_index == 0 &&
209 	    port_agent->phy_valid_port_range[1].min_index == 1) {
210 		sci_phy_get_sas_address(&ihost->phys[0], &first_address);
211 		sci_phy_get_sas_address(&ihost->phys[2], &second_address);
212 
213 		if (sci_sas_address_compare(first_address, second_address) == 0) {
214 			return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
215 		}
216 	}
217 
218 	/*
219 	 * PE2 and PE3 are configured into a 2x1 ports make sure that the
220 	 * SAS Address for PE1 and PE3 are different since they can not be
221 	 * part of the same port. */
222 	if (port_agent->phy_valid_port_range[2].min_index == 2 &&
223 	    port_agent->phy_valid_port_range[3].min_index == 3) {
224 		sci_phy_get_sas_address(&ihost->phys[1], &first_address);
225 		sci_phy_get_sas_address(&ihost->phys[3], &second_address);
226 
227 		if (sci_sas_address_compare(first_address, second_address) == 0) {
228 			return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
229 		}
230 	}
231 
232 	return SCI_SUCCESS;
233 }
234 
235 /*
236  * ******************************************************************************
237  * Manual port configuration agent routines
238  * ****************************************************************************** */
239 
240 /* verify all of the phys in the same port are using the same SAS address */
241 static enum sci_status
sci_mpc_agent_validate_phy_configuration(struct isci_host * ihost,struct sci_port_configuration_agent * port_agent)242 sci_mpc_agent_validate_phy_configuration(struct isci_host *ihost,
243 					      struct sci_port_configuration_agent *port_agent)
244 {
245 	u32 phy_mask;
246 	u32 assigned_phy_mask;
247 	struct sci_sas_address sas_address;
248 	struct sci_sas_address phy_assigned_address;
249 	u8 port_index;
250 	u8 phy_index;
251 
252 	assigned_phy_mask = 0;
253 	sas_address.high = 0;
254 	sas_address.low = 0;
255 
256 	for (port_index = 0; port_index < SCI_MAX_PORTS; port_index++) {
257 		phy_mask = ihost->oem_parameters.ports[port_index].phy_mask;
258 
259 		if (!phy_mask)
260 			continue;
261 		/*
262 		 * Make sure that one or more of the phys were not already assinged to
263 		 * a different port. */
264 		if ((phy_mask & ~assigned_phy_mask) == 0) {
265 			return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
266 		}
267 
268 		/* Find the starting phy index for this round through the loop */
269 		for (phy_index = 0; phy_index < SCI_MAX_PHYS; phy_index++) {
270 			if ((phy_mask & (1 << phy_index)) == 0)
271 				continue;
272 			sci_phy_get_sas_address(&ihost->phys[phy_index],
273 						     &sas_address);
274 
275 			/*
276 			 * The phy_index can be used as the starting point for the
277 			 * port range since the hardware starts all logical ports
278 			 * the same as the PE index. */
279 			port_agent->phy_valid_port_range[phy_index].min_index = port_index;
280 			port_agent->phy_valid_port_range[phy_index].max_index = phy_index;
281 
282 			if (phy_index != port_index) {
283 				return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
284 			}
285 
286 			break;
287 		}
288 
289 		/*
290 		 * See how many additional phys are being added to this logical port.
291 		 * Note: We have not moved the current phy_index so we will actually
292 		 *       compare the startting phy with itself.
293 		 *       This is expected and required to add the phy to the port. */
294 		for (; phy_index < SCI_MAX_PHYS; phy_index++) {
295 			if ((phy_mask & (1 << phy_index)) == 0)
296 				continue;
297 			sci_phy_get_sas_address(&ihost->phys[phy_index],
298 						     &phy_assigned_address);
299 
300 			if (sci_sas_address_compare(sas_address, phy_assigned_address) != 0) {
301 				/*
302 				 * The phy mask specified that this phy is part of the same port
303 				 * as the starting phy and it is not so fail this configuration */
304 				return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
305 			}
306 
307 			port_agent->phy_valid_port_range[phy_index].min_index = port_index;
308 			port_agent->phy_valid_port_range[phy_index].max_index = phy_index;
309 
310 			sci_port_add_phy(&ihost->ports[port_index],
311 					      &ihost->phys[phy_index]);
312 
313 			assigned_phy_mask |= (1 << phy_index);
314 		}
315 
316 	}
317 
318 	return sci_port_configuration_agent_validate_ports(ihost, port_agent);
319 }
320 
mpc_agent_timeout(struct timer_list * t)321 static void mpc_agent_timeout(struct timer_list *t)
322 {
323 	u8 index;
324 	struct sci_timer *tmr = from_timer(tmr, t, timer);
325 	struct sci_port_configuration_agent *port_agent;
326 	struct isci_host *ihost;
327 	unsigned long flags;
328 	u16 configure_phy_mask;
329 
330 	port_agent = container_of(tmr, typeof(*port_agent), timer);
331 	ihost = container_of(port_agent, typeof(*ihost), port_agent);
332 
333 	spin_lock_irqsave(&ihost->scic_lock, flags);
334 
335 	if (tmr->cancel)
336 		goto done;
337 
338 	port_agent->timer_pending = false;
339 
340 	/* Find the mask of phys that are reported read but as yet unconfigured into a port */
341 	configure_phy_mask = ~port_agent->phy_configured_mask & port_agent->phy_ready_mask;
342 
343 	for (index = 0; index < SCI_MAX_PHYS; index++) {
344 		struct isci_phy *iphy = &ihost->phys[index];
345 
346 		if (configure_phy_mask & (1 << index)) {
347 			port_agent->link_up_handler(ihost, port_agent,
348 						    phy_get_non_dummy_port(iphy),
349 						    iphy);
350 		}
351 	}
352 
353 done:
354 	spin_unlock_irqrestore(&ihost->scic_lock, flags);
355 }
356 
sci_mpc_agent_link_up(struct isci_host * ihost,struct sci_port_configuration_agent * port_agent,struct isci_port * iport,struct isci_phy * iphy)357 static void sci_mpc_agent_link_up(struct isci_host *ihost,
358 				       struct sci_port_configuration_agent *port_agent,
359 				       struct isci_port *iport,
360 				       struct isci_phy *iphy)
361 {
362 	/* If the port is NULL then the phy was not assigned to a port.
363 	 * This is because the phy was not given the same SAS Address as
364 	 * the other PHYs in the port.
365 	 */
366 	if (!iport)
367 		return;
368 
369 	port_agent->phy_ready_mask |= (1 << iphy->phy_index);
370 	sci_port_link_up(iport, iphy);
371 	if ((iport->active_phy_mask & (1 << iphy->phy_index)))
372 		port_agent->phy_configured_mask |= (1 << iphy->phy_index);
373 }
374 
375 /**
376  * sci_mpc_agent_link_down()
377  * @ihost: This is the controller object that receives the link down
378  *    notification.
379  * @port_agent: This is the port configuration agent for the controller.
380  * @iport: This is the port object associated with the phy.  If the is no
381  *    associated port this is an NULL.  The port is an invalid
382  *    handle only if the phy was never port of this port.  This happens when
383  *    the phy is not broadcasting the same SAS address as the other phys in the
384  *    assigned port.
385  * @iphy: This is the phy object which has gone link down.
386  *
387  * This function handles the manual port configuration link down notifications.
388  * Since all ports and phys are associated at initialization time we just turn
389  * around and notifiy the port object of the link down event.  If this PHY is
390  * not associated with a port there is no action taken. Is it possible to get a
391  * link down notification from a phy that has no assocoated port?
392  */
sci_mpc_agent_link_down(struct isci_host * ihost,struct sci_port_configuration_agent * port_agent,struct isci_port * iport,struct isci_phy * iphy)393 static void sci_mpc_agent_link_down(
394 	struct isci_host *ihost,
395 	struct sci_port_configuration_agent *port_agent,
396 	struct isci_port *iport,
397 	struct isci_phy *iphy)
398 {
399 	if (iport != NULL) {
400 		/*
401 		 * If we can form a new port from the remainder of the phys
402 		 * then we want to start the timer to allow the SCI User to
403 		 * cleanup old devices and rediscover the port before
404 		 * rebuilding the port with the phys that remain in the ready
405 		 * state.
406 		 */
407 		port_agent->phy_ready_mask &= ~(1 << iphy->phy_index);
408 		port_agent->phy_configured_mask &= ~(1 << iphy->phy_index);
409 
410 		/*
411 		 * Check to see if there are more phys waiting to be
412 		 * configured into a port. If there are allow the SCI User
413 		 * to tear down this port, if necessary, and then reconstruct
414 		 * the port after the timeout.
415 		 */
416 		if ((port_agent->phy_configured_mask == 0x0000) &&
417 		    (port_agent->phy_ready_mask != 0x0000) &&
418 		    !port_agent->timer_pending) {
419 			port_agent->timer_pending = true;
420 
421 			sci_mod_timer(&port_agent->timer,
422 				      SCIC_SDS_MPC_RECONFIGURATION_TIMEOUT);
423 		}
424 
425 		sci_port_link_down(iport, iphy);
426 	}
427 }
428 
429 /* verify phys are assigned a valid SAS address for automatic port
430  * configuration mode.
431  */
432 static enum sci_status
sci_apc_agent_validate_phy_configuration(struct isci_host * ihost,struct sci_port_configuration_agent * port_agent)433 sci_apc_agent_validate_phy_configuration(struct isci_host *ihost,
434 					      struct sci_port_configuration_agent *port_agent)
435 {
436 	u8 phy_index;
437 	u8 port_index;
438 	struct sci_sas_address sas_address;
439 	struct sci_sas_address phy_assigned_address;
440 
441 	phy_index = 0;
442 
443 	while (phy_index < SCI_MAX_PHYS) {
444 		port_index = phy_index;
445 
446 		/* Get the assigned SAS Address for the first PHY on the controller. */
447 		sci_phy_get_sas_address(&ihost->phys[phy_index],
448 					    &sas_address);
449 
450 		while (++phy_index < SCI_MAX_PHYS) {
451 			sci_phy_get_sas_address(&ihost->phys[phy_index],
452 						     &phy_assigned_address);
453 
454 			/* Verify each of the SAS address are all the same for every PHY */
455 			if (sci_sas_address_compare(sas_address, phy_assigned_address) == 0) {
456 				port_agent->phy_valid_port_range[phy_index].min_index = port_index;
457 				port_agent->phy_valid_port_range[phy_index].max_index = phy_index;
458 			} else {
459 				port_agent->phy_valid_port_range[phy_index].min_index = phy_index;
460 				port_agent->phy_valid_port_range[phy_index].max_index = phy_index;
461 				break;
462 			}
463 		}
464 	}
465 
466 	return sci_port_configuration_agent_validate_ports(ihost, port_agent);
467 }
468 
469 /*
470  * This routine will restart the automatic port configuration timeout
471  * timer for the next time period. This could be caused by either a link
472  * down event or a link up event where we can not yet tell to which a phy
473  * belongs.
474  */
sci_apc_agent_start_timer(struct sci_port_configuration_agent * port_agent,u32 timeout)475 static void sci_apc_agent_start_timer(struct sci_port_configuration_agent *port_agent,
476 				      u32 timeout)
477 {
478 	port_agent->timer_pending = true;
479 	sci_mod_timer(&port_agent->timer, timeout);
480 }
481 
sci_apc_agent_configure_ports(struct isci_host * ihost,struct sci_port_configuration_agent * port_agent,struct isci_phy * iphy,bool start_timer)482 static void sci_apc_agent_configure_ports(struct isci_host *ihost,
483 					       struct sci_port_configuration_agent *port_agent,
484 					       struct isci_phy *iphy,
485 					       bool start_timer)
486 {
487 	u8 port_index;
488 	enum sci_status status;
489 	struct isci_port *iport;
490 	enum SCIC_SDS_APC_ACTIVITY apc_activity = SCIC_SDS_APC_SKIP_PHY;
491 
492 	iport = sci_port_configuration_agent_find_port(ihost, iphy);
493 
494 	if (iport) {
495 		if (sci_port_is_valid_phy_assignment(iport, iphy->phy_index))
496 			apc_activity = SCIC_SDS_APC_ADD_PHY;
497 		else
498 			apc_activity = SCIC_SDS_APC_SKIP_PHY;
499 	} else {
500 		/*
501 		 * There is no matching Port for this PHY so lets search through the
502 		 * Ports and see if we can add the PHY to its own port or maybe start
503 		 * the timer and wait to see if a wider port can be made.
504 		 *
505 		 * Note the break when we reach the condition of the port id == phy id */
506 		for (port_index = port_agent->phy_valid_port_range[iphy->phy_index].min_index;
507 		     port_index <= port_agent->phy_valid_port_range[iphy->phy_index].max_index;
508 		     port_index++) {
509 
510 			iport = &ihost->ports[port_index];
511 
512 			/* First we must make sure that this PHY can be added to this Port. */
513 			if (sci_port_is_valid_phy_assignment(iport, iphy->phy_index)) {
514 				/*
515 				 * Port contains a PHY with a greater PHY ID than the current
516 				 * PHY that has gone link up.  This phy can not be part of any
517 				 * port so skip it and move on. */
518 				if (iport->active_phy_mask > (1 << iphy->phy_index)) {
519 					apc_activity = SCIC_SDS_APC_SKIP_PHY;
520 					break;
521 				}
522 
523 				/*
524 				 * We have reached the end of our Port list and have not found
525 				 * any reason why we should not either add the PHY to the port
526 				 * or wait for more phys to become active. */
527 				if (iport->physical_port_index == iphy->phy_index) {
528 					/*
529 					 * The Port either has no active PHYs.
530 					 * Consider that if the port had any active PHYs we would have
531 					 * or active PHYs with
532 					 * a lower PHY Id than this PHY. */
533 					if (apc_activity != SCIC_SDS_APC_START_TIMER) {
534 						apc_activity = SCIC_SDS_APC_ADD_PHY;
535 					}
536 
537 					break;
538 				}
539 
540 				/*
541 				 * The current Port has no active PHYs and this PHY could be part
542 				 * of this Port.  Since we dont know as yet setup to start the
543 				 * timer and see if there is a better configuration. */
544 				if (iport->active_phy_mask == 0) {
545 					apc_activity = SCIC_SDS_APC_START_TIMER;
546 				}
547 			} else if (iport->active_phy_mask != 0) {
548 				/*
549 				 * The Port has an active phy and the current Phy can not
550 				 * participate in this port so skip the PHY and see if
551 				 * there is a better configuration. */
552 				apc_activity = SCIC_SDS_APC_SKIP_PHY;
553 			}
554 		}
555 	}
556 
557 	/*
558 	 * Check to see if the start timer operations should instead map to an
559 	 * add phy operation.  This is caused because we have been waiting to
560 	 * add a phy to a port but could not becuase the automatic port
561 	 * configuration engine had a choice of possible ports for the phy.
562 	 * Since we have gone through a timeout we are going to restrict the
563 	 * choice to the smallest possible port. */
564 	if (
565 		(start_timer == false)
566 		&& (apc_activity == SCIC_SDS_APC_START_TIMER)
567 		) {
568 		apc_activity = SCIC_SDS_APC_ADD_PHY;
569 	}
570 
571 	switch (apc_activity) {
572 	case SCIC_SDS_APC_ADD_PHY:
573 		status = sci_port_add_phy(iport, iphy);
574 
575 		if (status == SCI_SUCCESS) {
576 			port_agent->phy_configured_mask |= (1 << iphy->phy_index);
577 		}
578 		break;
579 
580 	case SCIC_SDS_APC_START_TIMER:
581 		sci_apc_agent_start_timer(port_agent,
582 					  SCIC_SDS_APC_WAIT_LINK_UP_NOTIFICATION);
583 		break;
584 
585 	case SCIC_SDS_APC_SKIP_PHY:
586 	default:
587 		/* do nothing the PHY can not be made part of a port at this time. */
588 		break;
589 	}
590 }
591 
592 /**
593  * sci_apc_agent_link_up - handle apc link up events
594  * @ihost: This is the controller object that receives the link up
595  *    notification.
596  * @port_agent: This is the port configuration agent for the controller.
597  * @iport: This is the port object associated with the phy.  If the is no
598  *    associated port this is an NULL.
599  * @iphy: This is the phy object which has gone link up.
600  *
601  * This method handles the automatic port configuration for link up
602  * notifications. Is it possible to get a link down notification from a phy
603  * that has no assocoated port?
604  */
sci_apc_agent_link_up(struct isci_host * ihost,struct sci_port_configuration_agent * port_agent,struct isci_port * iport,struct isci_phy * iphy)605 static void sci_apc_agent_link_up(struct isci_host *ihost,
606 				       struct sci_port_configuration_agent *port_agent,
607 				       struct isci_port *iport,
608 				       struct isci_phy *iphy)
609 {
610 	u8 phy_index  = iphy->phy_index;
611 
612 	if (!iport) {
613 		/* the phy is not the part of this port */
614 		port_agent->phy_ready_mask |= 1 << phy_index;
615 		sci_apc_agent_start_timer(port_agent,
616 					  SCIC_SDS_APC_WAIT_LINK_UP_NOTIFICATION);
617 	} else {
618 		/* the phy is already the part of the port */
619 		port_agent->phy_ready_mask |= 1 << phy_index;
620 		sci_port_link_up(iport, iphy);
621 	}
622 }
623 
624 /**
625  * sci_apc_agent_link_down()
626  * @ihost: This is the controller object that receives the link down
627  *    notification.
628  * @port_agent: This is the port configuration agent for the controller.
629  * @iport: This is the port object associated with the phy.  If the is no
630  *    associated port this is an NULL.
631  * @iphy: This is the phy object which has gone link down.
632  *
633  * This method handles the automatic port configuration link down
634  * notifications. not associated with a port there is no action taken. Is it
635  * possible to get a link down notification from a phy that has no assocoated
636  * port?
637  */
sci_apc_agent_link_down(struct isci_host * ihost,struct sci_port_configuration_agent * port_agent,struct isci_port * iport,struct isci_phy * iphy)638 static void sci_apc_agent_link_down(
639 	struct isci_host *ihost,
640 	struct sci_port_configuration_agent *port_agent,
641 	struct isci_port *iport,
642 	struct isci_phy *iphy)
643 {
644 	port_agent->phy_ready_mask &= ~(1 << iphy->phy_index);
645 
646 	if (!iport)
647 		return;
648 	if (port_agent->phy_configured_mask & (1 << iphy->phy_index)) {
649 		enum sci_status status;
650 
651 		status = sci_port_remove_phy(iport, iphy);
652 
653 		if (status == SCI_SUCCESS)
654 			port_agent->phy_configured_mask &= ~(1 << iphy->phy_index);
655 	}
656 }
657 
658 /* configure the phys into ports when the timer fires */
apc_agent_timeout(struct timer_list * t)659 static void apc_agent_timeout(struct timer_list *t)
660 {
661 	u32 index;
662 	struct sci_timer *tmr = from_timer(tmr, t, timer);
663 	struct sci_port_configuration_agent *port_agent;
664 	struct isci_host *ihost;
665 	unsigned long flags;
666 	u16 configure_phy_mask;
667 
668 	port_agent = container_of(tmr, typeof(*port_agent), timer);
669 	ihost = container_of(port_agent, typeof(*ihost), port_agent);
670 
671 	spin_lock_irqsave(&ihost->scic_lock, flags);
672 
673 	if (tmr->cancel)
674 		goto done;
675 
676 	port_agent->timer_pending = false;
677 
678 	configure_phy_mask = ~port_agent->phy_configured_mask & port_agent->phy_ready_mask;
679 
680 	if (!configure_phy_mask)
681 		goto done;
682 
683 	for (index = 0; index < SCI_MAX_PHYS; index++) {
684 		if ((configure_phy_mask & (1 << index)) == 0)
685 			continue;
686 
687 		sci_apc_agent_configure_ports(ihost, port_agent,
688 						   &ihost->phys[index], false);
689 	}
690 
691 	if (is_controller_start_complete(ihost))
692 		sci_controller_transition_to_ready(ihost, SCI_SUCCESS);
693 
694 done:
695 	spin_unlock_irqrestore(&ihost->scic_lock, flags);
696 }
697 
698 /*
699  * ******************************************************************************
700  * Public port configuration agent routines
701  * ****************************************************************************** */
702 
703 /*
704  * This method will construct the port configuration agent for operation. This
705  * call is universal for both manual port configuration and automatic port
706  * configuration modes.
707  */
sci_port_configuration_agent_construct(struct sci_port_configuration_agent * port_agent)708 void sci_port_configuration_agent_construct(
709 	struct sci_port_configuration_agent *port_agent)
710 {
711 	u32 index;
712 
713 	port_agent->phy_configured_mask = 0x00;
714 	port_agent->phy_ready_mask = 0x00;
715 
716 	port_agent->link_up_handler = NULL;
717 	port_agent->link_down_handler = NULL;
718 
719 	port_agent->timer_pending = false;
720 
721 	for (index = 0; index < SCI_MAX_PORTS; index++) {
722 		port_agent->phy_valid_port_range[index].min_index = 0;
723 		port_agent->phy_valid_port_range[index].max_index = 0;
724 	}
725 }
726 
is_port_config_apc(struct isci_host * ihost)727 bool is_port_config_apc(struct isci_host *ihost)
728 {
729 	return ihost->port_agent.link_up_handler == sci_apc_agent_link_up;
730 }
731 
sci_port_configuration_agent_initialize(struct isci_host * ihost,struct sci_port_configuration_agent * port_agent)732 enum sci_status sci_port_configuration_agent_initialize(
733 	struct isci_host *ihost,
734 	struct sci_port_configuration_agent *port_agent)
735 {
736 	enum sci_status status;
737 	enum sci_port_configuration_mode mode;
738 
739 	mode = ihost->oem_parameters.controller.mode_type;
740 
741 	if (mode == SCIC_PORT_MANUAL_CONFIGURATION_MODE) {
742 		status = sci_mpc_agent_validate_phy_configuration(
743 				ihost, port_agent);
744 
745 		port_agent->link_up_handler = sci_mpc_agent_link_up;
746 		port_agent->link_down_handler = sci_mpc_agent_link_down;
747 
748 		sci_init_timer(&port_agent->timer, mpc_agent_timeout);
749 	} else {
750 		status = sci_apc_agent_validate_phy_configuration(
751 				ihost, port_agent);
752 
753 		port_agent->link_up_handler = sci_apc_agent_link_up;
754 		port_agent->link_down_handler = sci_apc_agent_link_down;
755 
756 		sci_init_timer(&port_agent->timer, apc_agent_timeout);
757 	}
758 
759 	return status;
760 }
761