isci: remove SCI_INVALID_HANDLE
[linux-3.10.git] / drivers / scsi / isci / core / scic_sds_port_configuration_agent.c
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 /**
57  * This file contains the implementation for the public and protected methods
58  *    for the port configuration agent.
59  *
60  *
61  */
62
63 #include "sci_environment.h"
64 #include "scic_controller.h"
65 #include "scic_sds_controller.h"
66 #include "scic_sds_port_configuration_agent.h"
67
68 #define SCIC_SDS_MPC_RECONFIGURATION_TIMEOUT    (10)
69 #define SCIC_SDS_APC_RECONFIGURATION_TIMEOUT    (10)
70 #define SCIC_SDS_APC_WAIT_LINK_UP_NOTIFICATION  (100)
71
72 enum SCIC_SDS_APC_ACTIVITY {
73         SCIC_SDS_APC_SKIP_PHY,
74         SCIC_SDS_APC_ADD_PHY,
75         SCIC_SDS_APC_START_TIMER,
76
77         SCIC_SDS_APC_ACTIVITY_MAX
78 };
79
80 /*
81  * ******************************************************************************
82  * General port configuration agent routines
83  * ****************************************************************************** */
84
85 /**
86  *
87  * @address_one: A SAS Address to be compared.
88  * @address_two: A SAS Address to be compared.
89  *
90  * Compare the two SAS Address and if SAS Address One is greater than SAS
91  * Address Two then return > 0 else if SAS Address One is less than SAS Address
92  * Two return < 0 Otherwise they are the same return 0 A signed value of x > 0
93  * > y where x is returned for Address One > Address Two y is returned for
94  * Address One < Address Two 0 is returned ofr Address One = Address Two
95  */
96 static s32 sci_sas_address_compare(
97         struct sci_sas_address address_one,
98         struct sci_sas_address address_two)
99 {
100         if (address_one.high > address_two.high) {
101                 return 1;
102         } else if (address_one.high < address_two.high) {
103                 return -1;
104         } else if (address_one.low > address_two.low) {
105                 return 1;
106         } else if (address_one.low < address_two.low) {
107                 return -1;
108         }
109
110         /* The two SAS Address must be identical */
111         return 0;
112 }
113
114 /**
115  *
116  * @controller: The controller object used for the port search.
117  * @phy: The phy object to match.
118  *
119  * This routine will find a matching port for the phy.  This means that the
120  * port and phy both have the same broadcast sas address and same received sas
121  * address. The port address or the NULL if there is no matching
122  * port. port address if the port can be found to match the phy.
123  * NULL if there is no matching port for the phy.
124  */
125 static struct scic_sds_port *scic_sds_port_configuration_agent_find_port(
126         struct scic_sds_controller *controller,
127         struct scic_sds_phy *phy)
128 {
129         u8 port_index;
130         struct scic_sds_port *port_handle;
131         struct sci_sas_address port_sas_address;
132         struct sci_sas_address port_attached_device_address;
133         struct sci_sas_address phy_sas_address;
134         struct sci_sas_address phy_attached_device_address;
135
136         /*
137          * Since this phy can be a member of a wide port check to see if one or
138          * more phys match the sent and received SAS address as this phy in which
139          * case it should participate in the same port. */
140         scic_sds_phy_get_sas_address(phy, &phy_sas_address);
141         scic_sds_phy_get_attached_sas_address(phy, &phy_attached_device_address);
142
143         for (port_index = 0; port_index < SCI_MAX_PORTS; port_index++) {
144                 if (scic_controller_get_port_handle(controller, port_index, &port_handle) == SCI_SUCCESS) {
145                         struct scic_sds_port *port = (struct scic_sds_port *)port_handle;
146
147                         scic_sds_port_get_sas_address(port, &port_sas_address);
148                         scic_sds_port_get_attached_sas_address(port, &port_attached_device_address);
149
150                         if (
151                                 (sci_sas_address_compare(port_sas_address, phy_sas_address) == 0)
152                                 && (sci_sas_address_compare(port_attached_device_address, phy_attached_device_address) == 0)
153                                 ) {
154                                 return port;
155                         }
156                 }
157         }
158
159         return NULL;
160 }
161
162 /**
163  *
164  * @controller: This is the controller object that contains the port agent
165  * @port_agent: This is the port configruation agent for the controller.
166  *
167  * This routine will validate the port configuration is correct for the SCU
168  * hardware.  The SCU hardware allows for port configurations as follows. LP0
169  * -> (PE0), (PE0, PE1), (PE0, PE1, PE2, PE3) LP1 -> (PE1) LP2 -> (PE2), (PE2,
170  * PE3) LP3 -> (PE3) enum sci_status SCI_SUCCESS the port configuration is valid for
171  * this port configuration agent. SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION
172  * the port configuration is not valid for this port configuration agent.
173  */
174 static enum sci_status scic_sds_port_configuration_agent_validate_ports(
175         struct scic_sds_controller *controller,
176         struct scic_sds_port_configuration_agent *port_agent)
177 {
178         struct sci_sas_address first_address;
179         struct sci_sas_address second_address;
180
181         /*
182          * Sanity check the max ranges for all the phys the max index
183          * is always equal to the port range index */
184         if (
185                 (port_agent->phy_valid_port_range[0].max_index != 0)
186                 || (port_agent->phy_valid_port_range[1].max_index != 1)
187                 || (port_agent->phy_valid_port_range[2].max_index != 2)
188                 || (port_agent->phy_valid_port_range[3].max_index != 3)
189                 ) {
190                 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
191         }
192
193         /*
194          * This is a request to configure a single x4 port or at least attempt
195          * to make all the phys into a single port */
196         if (
197                 (port_agent->phy_valid_port_range[0].min_index == 0)
198                 && (port_agent->phy_valid_port_range[1].min_index == 0)
199                 && (port_agent->phy_valid_port_range[2].min_index == 0)
200                 && (port_agent->phy_valid_port_range[3].min_index == 0)
201                 ) {
202                 return SCI_SUCCESS;
203         }
204
205         /*
206          * This is a degenerate case where phy 1 and phy 2 are assigned
207          * to the same port this is explicitly disallowed by the hardware
208          * unless they are part of the same x4 port and this condition was
209          * already checked above. */
210         if (port_agent->phy_valid_port_range[2].min_index == 1) {
211                 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
212         }
213
214         /*
215          * PE0 and PE3 can never have the same SAS Address unless they
216          * are part of the same x4 wide port and we have already checked
217          * for this condition. */
218         scic_sds_phy_get_sas_address(&controller->phy_table[0], &first_address);
219         scic_sds_phy_get_sas_address(&controller->phy_table[3], &second_address);
220
221         if (sci_sas_address_compare(first_address, second_address) == 0) {
222                 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
223         }
224
225         /*
226          * PE0 and PE1 are configured into a 2x1 ports make sure that the
227          * SAS Address for PE0 and PE2 are different since they can not be
228          * part of the same port. */
229         if (
230                 (port_agent->phy_valid_port_range[0].min_index == 0)
231                 && (port_agent->phy_valid_port_range[1].min_index == 1)
232                 ) {
233                 scic_sds_phy_get_sas_address(&controller->phy_table[0], &first_address);
234                 scic_sds_phy_get_sas_address(&controller->phy_table[2], &second_address);
235
236                 if (sci_sas_address_compare(first_address, second_address) == 0) {
237                         return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
238                 }
239         }
240
241         /*
242          * PE2 and PE3 are configured into a 2x1 ports make sure that the
243          * SAS Address for PE1 and PE3 are different since they can not be
244          * part of the same port. */
245         if (
246                 (port_agent->phy_valid_port_range[2].min_index == 2)
247                 && (port_agent->phy_valid_port_range[3].min_index == 3)
248                 ) {
249                 scic_sds_phy_get_sas_address(&controller->phy_table[1], &first_address);
250                 scic_sds_phy_get_sas_address(&controller->phy_table[3], &second_address);
251
252                 if (sci_sas_address_compare(first_address, second_address) == 0) {
253                         return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
254                 }
255         }
256
257         return SCI_SUCCESS;
258 }
259
260 /*
261  * ******************************************************************************
262  * Manual port configuration agent routines
263  * ****************************************************************************** */
264
265 /**
266  *
267  *
268  * This routine will verify that all of the phys in the same port are using the
269  * same SAS address.
270  */
271 static enum sci_status scic_sds_mpc_agent_validate_phy_configuration(
272         struct scic_sds_controller *controller,
273         struct scic_sds_port_configuration_agent *port_agent)
274 {
275         u32 phy_mask;
276         u32 assigned_phy_mask;
277         struct sci_sas_address sas_address;
278         struct sci_sas_address phy_assigned_address;
279         u8 port_index;
280         u8 phy_index;
281
282         assigned_phy_mask = 0;
283         sas_address.high = 0;
284         sas_address.low = 0;
285
286         for (port_index = 0; port_index < SCI_MAX_PORTS; port_index++) {
287                 phy_mask = controller->oem_parameters.sds1.ports[port_index].phy_mask;
288
289                 if (phy_mask != 0) {
290                         /*
291                          * Make sure that one or more of the phys were not already assinged to
292                          * a different port. */
293                         if ((phy_mask & ~assigned_phy_mask) == 0) {
294                                 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
295                         }
296
297                         /* Find the starting phy index for this round through the loop */
298                         for (phy_index = 0; phy_index < SCI_MAX_PHYS; phy_index++) {
299                                 if ((1 << phy_index) & phy_mask) {
300                                         scic_sds_phy_get_sas_address(
301                                                 &controller->phy_table[phy_index], &sas_address
302                                                 );
303
304                                         /*
305                                          * The phy_index can be used as the starting point for the
306                                          * port range since the hardware starts all logical ports
307                                          * the same as the PE index. */
308                                         port_agent->phy_valid_port_range[phy_index].min_index = port_index;
309                                         port_agent->phy_valid_port_range[phy_index].max_index = phy_index;
310
311                                         if (phy_index != port_index) {
312                                                 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
313                                         }
314
315                                         break;
316                                 }
317                         }
318
319                         /*
320                          * See how many additional phys are being added to this logical port.
321                          * Note: We have not moved the current phy_index so we will actually
322                          *       compare the startting phy with itself.
323                          *       This is expected and required to add the phy to the port. */
324                         while (phy_index < SCI_MAX_PHYS) {
325                                 if ((1 << phy_index) & phy_mask) {
326                                         scic_sds_phy_get_sas_address(
327                                                 &controller->phy_table[phy_index], &phy_assigned_address
328                                                 );
329
330                                         if (sci_sas_address_compare(sas_address, phy_assigned_address) != 0) {
331                                                 /*
332                                                  * The phy mask specified that this phy is part of the same port
333                                                  * as the starting phy and it is not so fail this configuration */
334                                                 return SCI_FAILURE_UNSUPPORTED_PORT_CONFIGURATION;
335                                         }
336
337                                         port_agent->phy_valid_port_range[phy_index].min_index = port_index;
338                                         port_agent->phy_valid_port_range[phy_index].max_index = phy_index;
339
340                                         scic_sds_port_add_phy(
341                                                 &controller->port_table[port_index],
342                                                 &controller->phy_table[phy_index]
343                                                 );
344
345                                         assigned_phy_mask |= (1 << phy_index);
346                                 }
347
348                                 phy_index++;
349                         }
350                 }
351         }
352
353         return scic_sds_port_configuration_agent_validate_ports(controller, port_agent);
354 }
355
356 /**
357  *
358  *
359  * This timer routine is used to allow the SCI User to rediscover or change
360  * device objects before a new series of link up notifications because a link
361  * down has allowed a better port configuration.
362  */
363 static void scic_sds_mpc_agent_timeout_handler(
364         void *object)
365 {
366         u8 index;
367         struct scic_sds_controller *controller = (struct scic_sds_controller *)object;
368         struct scic_sds_port_configuration_agent *port_agent = &controller->port_agent;
369         u16 configure_phy_mask;
370
371         port_agent->timer_pending = false;
372
373         /* Find the mask of phys that are reported read but as yet unconfigured into a port */
374         configure_phy_mask = ~port_agent->phy_configured_mask & port_agent->phy_ready_mask;
375
376         for (index = 0; index < SCI_MAX_PHYS; index++) {
377                 if (configure_phy_mask & (1 << index)) {
378                         port_agent->link_up_handler(
379                                 controller,
380                                 port_agent,
381                                 scic_sds_phy_get_port(&controller->phy_table[index]),
382                                 &controller->phy_table[index]
383                                 );
384                 }
385         }
386 }
387
388 /**
389  *
390  * @controller: This is the controller object that receives the link up
391  *    notification.
392  * @port: This is the port object associated with the phy.  If the is no
393  *    associated port this is an NULL.
394  * @phy: This is the phy object which has gone ready.
395  *
396  * This method handles the manual port configuration link up notifications.
397  * Since all ports and phys are associate at initialization time we just turn
398  * around and notifiy the port object that there is a link up.  If this PHY is
399  * not associated with a port there is no action taken. Is it possible to get a
400  * link up notification from a phy that has no assocoated port?
401  */
402 static void scic_sds_mpc_agent_link_up(
403         struct scic_sds_controller *controller,
404         struct scic_sds_port_configuration_agent *port_agent,
405         struct scic_sds_port *port,
406         struct scic_sds_phy *phy)
407 {
408         /*
409          * If the port has an invalid handle then the phy was not assigned to
410          * a port.  This is because the phy was not given the same SAS Address
411          * as the other PHYs in the port. */
412         if (port != NULL) {
413                 port_agent->phy_ready_mask |= (1 << scic_sds_phy_get_index(phy));
414
415                 scic_sds_port_link_up(port, phy);
416
417                 if ((port->active_phy_mask & (1 << scic_sds_phy_get_index(phy))) != 0) {
418                         port_agent->phy_configured_mask |= (1 << scic_sds_phy_get_index(phy));
419                 }
420         }
421 }
422
423 /**
424  *
425  * @controller: This is the controller object that receives the link down
426  *    notification.
427  * @port: This is the port object associated with the phy.  If the is no
428  *    associated port this is an NULL.  The port is an invalid
429  *    handle only if the phy was never port of this port.  This happens when
430  *    the phy is not broadcasting the same SAS address as the other phys in the
431  *    assigned port.
432  * @phy: This is the phy object which has gone link down.
433  *
434  * This method handles the manual port configuration link down notifications.
435  * Since all ports and phys are associated at initialization time we just turn
436  * around and notifiy the port object of the link down event.  If this PHY is
437  * not associated with a port there is no action taken. Is it possible to get a
438  * link down notification from a phy that has no assocoated port?
439  */
440 static void scic_sds_mpc_agent_link_down(
441         struct scic_sds_controller *controller,
442         struct scic_sds_port_configuration_agent *port_agent,
443         struct scic_sds_port *port,
444         struct scic_sds_phy *phy)
445 {
446         if (port != NULL) {
447                 /*
448                  * If we can form a new port from the remainder of the phys then we want
449                  * to start the timer to allow the SCI User to cleanup old devices and
450                  * rediscover the port before rebuilding the port with the phys that
451                  * remain in the ready state. */
452                 port_agent->phy_ready_mask &= ~(1 << scic_sds_phy_get_index(phy));
453                 port_agent->phy_configured_mask &= ~(1 << scic_sds_phy_get_index(phy));
454
455                 /*
456                  * Check to see if there are more phys waiting to be configured into a port.
457                  * If there are allow the SCI User to tear down this port, if necessary, and
458                  * then reconstruc the port after the timeout. */
459                 if (
460                         (port_agent->phy_configured_mask == 0x0000)
461                         && (port_agent->phy_ready_mask != 0x0000)
462                         && !port_agent->timer_pending
463                         ) {
464                         port_agent->timer_pending = true;
465
466                         scic_cb_timer_start(
467                                 controller,
468                                 port_agent->timer,
469                                 SCIC_SDS_MPC_RECONFIGURATION_TIMEOUT
470                                 );
471                 }
472
473                 scic_sds_port_link_down(port, phy);
474         }
475 }
476
477 /*
478  * ******************************************************************************
479  * Automatic port configuration agent routines
480  * ****************************************************************************** */
481
482 /**
483  *
484  *
485  * This routine will verify that the phys are assigned a valid SAS address for
486  * automatic port configuration mode.
487  */
488 static enum sci_status scic_sds_apc_agent_validate_phy_configuration(
489         struct scic_sds_controller *controller,
490         struct scic_sds_port_configuration_agent *port_agent)
491 {
492         u8 phy_index;
493         u8 port_index;
494         struct sci_sas_address sas_address;
495         struct sci_sas_address phy_assigned_address;
496
497         phy_index = 0;
498
499         while (phy_index < SCI_MAX_PHYS) {
500                 port_index = phy_index;
501
502                 /* Get the assigned SAS Address for the first PHY on the controller. */
503                 scic_sds_phy_get_sas_address(
504                         &controller->phy_table[phy_index], &sas_address
505                         );
506
507                 while (++phy_index < SCI_MAX_PHYS) {
508                         scic_sds_phy_get_sas_address(
509                                 &controller->phy_table[phy_index], &phy_assigned_address
510                                 );
511
512                         /* Verify each of the SAS address are all the same for every PHY */
513                         if (sci_sas_address_compare(sas_address, phy_assigned_address) == 0) {
514                                 port_agent->phy_valid_port_range[phy_index].min_index = port_index;
515                                 port_agent->phy_valid_port_range[phy_index].max_index = phy_index;
516                         } else {
517                                 port_agent->phy_valid_port_range[phy_index].min_index = phy_index;
518                                 port_agent->phy_valid_port_range[phy_index].max_index = phy_index;
519                                 break;
520                         }
521                 }
522         }
523
524         return scic_sds_port_configuration_agent_validate_ports(controller, port_agent);
525 }
526
527 /**
528  *
529  * @controller: This is the controller that to which the port agent is assigned.
530  * @port_agent: This is the port agent that is requesting the timer start
531  *    operation.
532  * @phy: This is the phy that has caused the timer operation to be scheduled.
533  *
534  * This routine will restart the automatic port configuration timeout timer for
535  * the next time period.  This could be caused by either a link down event or a
536  * link up event where we can not yet tell to which port a phy belongs.
537  */
538 static void scic_sds_apc_agent_start_timer(
539         struct scic_sds_controller *controller,
540         struct scic_sds_port_configuration_agent *port_agent,
541         struct scic_sds_phy *phy,
542         u32 timeout)
543 {
544         if (port_agent->timer_pending) {
545                 scic_cb_timer_stop(controller, port_agent->timer);
546         }
547
548         port_agent->timer_pending = true;
549
550         scic_cb_timer_start(controller, port_agent->timer, timeout);
551 }
552
553 /**
554  *
555  * @controller: This is the controller object that receives the link up
556  *    notification.
557  * @phy: This is the phy object which has gone link up.
558  *
559  * This method handles the automatic port configuration for link up
560  * notifications.
561  */
562 static void scic_sds_apc_agent_configure_ports(
563         struct scic_sds_controller *controller,
564         struct scic_sds_port_configuration_agent *port_agent,
565         struct scic_sds_phy *phy,
566         bool start_timer)
567 {
568         u8 port_index;
569         enum sci_status status;
570         struct scic_sds_port *port;
571         struct scic_sds_port *port_handle;
572         enum SCIC_SDS_APC_ACTIVITY apc_activity = SCIC_SDS_APC_SKIP_PHY;
573
574         port = scic_sds_port_configuration_agent_find_port(controller, phy);
575
576         if (port != NULL) {
577                 if (scic_sds_port_is_valid_phy_assignment(port, phy->phy_index))
578                         apc_activity = SCIC_SDS_APC_ADD_PHY;
579                 else
580                         apc_activity = SCIC_SDS_APC_SKIP_PHY;
581         } else {
582                 /*
583                  * There is no matching Port for this PHY so lets search through the
584                  * Ports and see if we can add the PHY to its own port or maybe start
585                  * the timer and wait to see if a wider port can be made.
586                  *
587                  * Note the break when we reach the condition of the port id == phy id */
588                 for (
589                         port_index = port_agent->phy_valid_port_range[phy->phy_index].min_index;
590                         port_index <= port_agent->phy_valid_port_range[phy->phy_index].max_index;
591                         port_index++
592                         ) {
593                         scic_controller_get_port_handle(controller, port_index, &port_handle);
594
595                         port = (struct scic_sds_port *)port_handle;
596
597                         /* First we must make sure that this PHY can be added to this Port. */
598                         if (scic_sds_port_is_valid_phy_assignment(port, phy->phy_index)) {
599                                 /*
600                                  * Port contains a PHY with a greater PHY ID than the current
601                                  * PHY that has gone link up.  This phy can not be part of any
602                                  * port so skip it and move on. */
603                                 if (port->active_phy_mask > (1 << phy->phy_index)) {
604                                         apc_activity = SCIC_SDS_APC_SKIP_PHY;
605                                         break;
606                                 }
607
608                                 /*
609                                  * We have reached the end of our Port list and have not found
610                                  * any reason why we should not either add the PHY to the port
611                                  * or wait for more phys to become active. */
612                                 if (port->physical_port_index == phy->phy_index) {
613                                         /*
614                                          * The Port either has no active PHYs.
615                                          * Consider that if the port had any active PHYs we would have
616                                          * or active PHYs with
617                                          * a lower PHY Id than this PHY. */
618                                         if (apc_activity != SCIC_SDS_APC_START_TIMER) {
619                                                 apc_activity = SCIC_SDS_APC_ADD_PHY;
620                                         }
621
622                                         break;
623                                 }
624
625                                 /*
626                                  * The current Port has no active PHYs and this PHY could be part
627                                  * of this Port.  Since we dont know as yet setup to start the
628                                  * timer and see if there is a better configuration. */
629                                 if (port->active_phy_mask == 0) {
630                                         apc_activity = SCIC_SDS_APC_START_TIMER;
631                                 }
632                         } else if (port->active_phy_mask != 0) {
633                                 /*
634                                  * The Port has an active phy and the current Phy can not
635                                  * participate in this port so skip the PHY and see if
636                                  * there is a better configuration. */
637                                 apc_activity = SCIC_SDS_APC_SKIP_PHY;
638                         }
639                 }
640         }
641
642         /*
643          * Check to see if the start timer operations should instead map to an
644          * add phy operation.  This is caused because we have been waiting to
645          * add a phy to a port but could not becuase the automatic port
646          * configuration engine had a choice of possible ports for the phy.
647          * Since we have gone through a timeout we are going to restrict the
648          * choice to the smallest possible port. */
649         if (
650                 (start_timer == false)
651                 && (apc_activity == SCIC_SDS_APC_START_TIMER)
652                 ) {
653                 apc_activity = SCIC_SDS_APC_ADD_PHY;
654         }
655
656         switch (apc_activity) {
657         case SCIC_SDS_APC_ADD_PHY:
658                 status = scic_sds_port_add_phy(port, phy);
659
660                 if (status == SCI_SUCCESS) {
661                         port_agent->phy_configured_mask |= (1 << phy->phy_index);
662                 }
663                 break;
664
665         case SCIC_SDS_APC_START_TIMER:
666                 scic_sds_apc_agent_start_timer(
667                         controller, port_agent, phy, SCIC_SDS_APC_WAIT_LINK_UP_NOTIFICATION
668                         );
669                 break;
670
671         case SCIC_SDS_APC_SKIP_PHY:
672         default:
673                 /* do nothing the PHY can not be made part of a port at this time. */
674                 break;
675         }
676 }
677
678 /**
679  *
680  * @controller: This is the controller object that receives the link up
681  *    notification.
682  * @port: This is the port object associated with the phy.  If the is no
683  *    associated port this is an NULL.
684  * @phy: This is the phy object which has gone link up.
685  *
686  * This method handles the automatic port configuration for link up
687  * notifications. Is it possible to get a link down notification from a phy
688  * that has no assocoated port?
689  */
690 static void scic_sds_apc_agent_link_up(
691         struct scic_sds_controller *controller,
692         struct scic_sds_port_configuration_agent *port_agent,
693         struct scic_sds_port *port,
694         struct scic_sds_phy *phy)
695 {
696         BUG_ON(port != NULL);
697
698         port_agent->phy_ready_mask |= (1 << scic_sds_phy_get_index(phy));
699
700         scic_sds_apc_agent_configure_ports(controller, port_agent, phy, true);
701 }
702
703 /**
704  *
705  * @controller: This is the controller object that receives the link down
706  *    notification.
707  * @port: This is the port object associated with the phy.  If the is no
708  *    associated port this is an NULL.
709  * @phy: This is the phy object which has gone link down.
710  *
711  * This method handles the automatic port configuration link down
712  * notifications. not associated with a port there is no action taken. Is it
713  * possible to get a link down notification from a phy that has no assocoated
714  * port?
715  */
716 static void scic_sds_apc_agent_link_down(
717         struct scic_sds_controller *controller,
718         struct scic_sds_port_configuration_agent *port_agent,
719         struct scic_sds_port *port,
720         struct scic_sds_phy *phy)
721 {
722         port_agent->phy_ready_mask &= ~(1 << scic_sds_phy_get_index(phy));
723
724         if (port != NULL) {
725                 if (port_agent->phy_configured_mask & (1 << phy->phy_index)) {
726                         enum sci_status status;
727
728                         status = scic_sds_port_remove_phy(port, phy);
729
730                         if (status == SCI_SUCCESS) {
731                                 port_agent->phy_configured_mask &= ~(1 << phy->phy_index);
732                         }
733                 }
734         }
735 }
736
737 /**
738  *
739  *
740  * This routine will try to configure the phys into ports when the timer fires.
741  */
742 static void scic_sds_apc_agent_timeout_handler(
743         void *object)
744 {
745         u32 index;
746         struct scic_sds_port_configuration_agent *port_agent;
747         struct scic_sds_controller *controller = (struct scic_sds_controller *)object;
748         u16 configure_phy_mask;
749
750         port_agent = scic_sds_controller_get_port_configuration_agent(controller);
751
752         port_agent->timer_pending = false;
753
754         configure_phy_mask = ~port_agent->phy_configured_mask & port_agent->phy_ready_mask;
755
756         if (configure_phy_mask != 0x00) {
757                 for (index = 0; index < SCI_MAX_PHYS; index++) {
758                         if (configure_phy_mask & (1 << index)) {
759                                 scic_sds_apc_agent_configure_ports(
760                                         controller, port_agent, &controller->phy_table[index], false
761                                         );
762                         }
763                 }
764         }
765 }
766
767 /*
768  * ******************************************************************************
769  * Public port configuration agent routines
770  * ****************************************************************************** */
771
772 /**
773  *
774  *
775  * This method will construct the port configuration agent for operation. This
776  * call is universal for both manual port configuration and automatic port
777  * configuration modes.
778  */
779 void scic_sds_port_configuration_agent_construct(
780         struct scic_sds_port_configuration_agent *port_agent)
781 {
782         u32 index;
783
784         port_agent->phy_configured_mask = 0x00;
785         port_agent->phy_ready_mask = 0x00;
786
787         port_agent->link_up_handler = NULL;
788         port_agent->link_down_handler = NULL;
789
790         port_agent->timer_pending = false;
791         port_agent->timer = NULL;
792
793         for (index = 0; index < SCI_MAX_PORTS; index++) {
794                 port_agent->phy_valid_port_range[index].min_index = 0;
795                 port_agent->phy_valid_port_range[index].max_index = 0;
796         }
797 }
798
799 /**
800  *
801  * @controller: This is the controller object for which the port agent is being
802  *    initialized.
803  *
804  * This method will construct the port configuration agent for this controller.
805  */
806 enum sci_status scic_sds_port_configuration_agent_initialize(
807         struct scic_sds_controller *controller,
808         struct scic_sds_port_configuration_agent *port_agent)
809 {
810         enum sci_status status = SCI_SUCCESS;
811         enum SCIC_PORT_CONFIGURATION_MODE mode;
812
813         mode = scic_sds_controller_get_port_configuration_mode(controller);
814
815         if (mode == SCIC_PORT_MANUAL_CONFIGURATION_MODE) {
816                 status = scic_sds_mpc_agent_validate_phy_configuration(controller, port_agent);
817
818                 port_agent->link_up_handler = scic_sds_mpc_agent_link_up;
819                 port_agent->link_down_handler = scic_sds_mpc_agent_link_down;
820
821                 port_agent->timer = scic_cb_timer_create(
822                         controller,
823                         scic_sds_mpc_agent_timeout_handler,
824                         controller
825                         );
826         } else {
827                 status = scic_sds_apc_agent_validate_phy_configuration(controller, port_agent);
828
829                 port_agent->link_up_handler = scic_sds_apc_agent_link_up;
830                 port_agent->link_down_handler = scic_sds_apc_agent_link_down;
831
832                 port_agent->timer = scic_cb_timer_create(
833                         controller,
834                         scic_sds_apc_agent_timeout_handler,
835                         controller
836                         );
837         }
838
839         /* Make sure we have actually gotten a timer */
840         if ((status == SCI_SUCCESS) && (port_agent->timer == NULL)) {
841                 dev_err(scic_to_dev(controller),
842                         "%s: Controller 0x%p automatic port configuration "
843                         "agent could not get timer.\n",
844                         __func__,
845                         controller);
846
847                 status = SCI_FAILURE;
848         }
849
850         return status;
851 }