35852e794e26533aa61c8c8fe3900c3b5d372eee
[linux-2.6.git] / drivers / infiniband / core / smi.c
1 /*
2  * Copyright (c) 2004, 2005 Mellanox Technologies Ltd.  All rights reserved.
3  * Copyright (c) 2004, 2005 Infinicon Corporation.  All rights reserved.
4  * Copyright (c) 2004, 2005 Intel Corporation.  All rights reserved.
5  * Copyright (c) 2004, 2005 Topspin Corporation.  All rights reserved.
6  * Copyright (c) 2004, 2005 Voltaire Corporation.  All rights reserved.
7  * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
8  *
9  * This software is available to you under a choice of one of two
10  * licenses.  You may choose to be licensed under the terms of the GNU
11  * General Public License (GPL) Version 2, available from the file
12  * COPYING in the main directory of this source tree, or the
13  * OpenIB.org BSD license below:
14  *
15  *     Redistribution and use in source and binary forms, with or
16  *     without modification, are permitted provided that the following
17  *     conditions are met:
18  *
19  *      - Redistributions of source code must retain the above
20  *        copyright notice, this list of conditions and the following
21  *        disclaimer.
22  *
23  *      - Redistributions in binary form must reproduce the above
24  *        copyright notice, this list of conditions and the following
25  *        disclaimer in the documentation and/or other materials
26  *        provided with the distribution.
27  *
28  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
29  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
30  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
31  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
32  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
33  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
34  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
35  * SOFTWARE.
36  *
37  * $Id: smi.c 1389 2004-12-27 22:56:47Z roland $
38  */
39
40 #include <rdma/ib_smi.h>
41 #include "smi.h"
42
43 /*
44  * Fixup a directed route SMP for sending
45  * Return 0 if the SMP should be discarded
46  */
47 int smi_handle_dr_smp_send(struct ib_smp *smp,
48                            u8 node_type,
49                            int port_num)
50 {
51         u8 hop_ptr, hop_cnt;
52
53         hop_ptr = smp->hop_ptr;
54         hop_cnt = smp->hop_cnt;
55
56         /* See section 14.2.2.2, Vol 1 IB spec */
57         if (!ib_get_smp_direction(smp)) {
58                 /* C14-9:1 */
59                 if (hop_cnt && hop_ptr == 0) {
60                         smp->hop_ptr++;
61                         return (smp->initial_path[smp->hop_ptr] ==
62                                 port_num);
63                 }
64
65                 /* C14-9:2 */
66                 if (hop_ptr && hop_ptr < hop_cnt) {
67                         if (node_type != IB_NODE_SWITCH)
68                                 return 0;
69
70                         /* smp->return_path set when received */
71                         smp->hop_ptr++;
72                         return (smp->initial_path[smp->hop_ptr] ==
73                                 port_num);
74                 }
75
76                 /* C14-9:3 -- We're at the end of the DR segment of path */
77                 if (hop_ptr == hop_cnt) {
78                         /* smp->return_path set when received */
79                         smp->hop_ptr++;
80                         return (node_type == IB_NODE_SWITCH ||
81                                 smp->dr_dlid == IB_LID_PERMISSIVE);
82                 }
83
84                 /* C14-9:4 -- hop_ptr = hop_cnt + 1 -> give to SMA/SM */
85                 /* C14-9:5 -- Fail unreasonable hop pointer */
86                 return (hop_ptr == hop_cnt + 1);
87
88         } else {
89                 /* C14-13:1 */
90                 if (hop_cnt && hop_ptr == hop_cnt + 1) {
91                         smp->hop_ptr--;
92                         return (smp->return_path[smp->hop_ptr] ==
93                                 port_num);
94                 }
95
96                 /* C14-13:2 */
97                 if (2 <= hop_ptr && hop_ptr <= hop_cnt) {
98                         if (node_type != IB_NODE_SWITCH)
99                                 return 0;
100
101                         smp->hop_ptr--;
102                         return (smp->return_path[smp->hop_ptr] ==
103                                 port_num);
104                 }
105
106                 /* C14-13:3 -- at the end of the DR segment of path */
107                 if (hop_ptr == 1) {
108                         smp->hop_ptr--;
109                         /* C14-13:3 -- SMPs destined for SM shouldn't be here */
110                         return (node_type == IB_NODE_SWITCH ||
111                                 smp->dr_slid == IB_LID_PERMISSIVE);
112                 }
113
114                 /* C14-13:4 -- hop_ptr = 0 -> should have gone to SM */
115                 if (hop_ptr == 0)
116                         return 1;
117
118                 /* C14-13:5 -- Check for unreasonable hop pointer */
119                 return 0;
120         }
121 }
122
123 /*
124  * Adjust information for a received SMP
125  * Return 0 if the SMP should be dropped
126  */
127 int smi_handle_dr_smp_recv(struct ib_smp *smp,
128                            u8 node_type,
129                            int port_num,
130                            int phys_port_cnt)
131 {
132         u8 hop_ptr, hop_cnt;
133
134         hop_ptr = smp->hop_ptr;
135         hop_cnt = smp->hop_cnt;
136
137         /* See section 14.2.2.2, Vol 1 IB spec */
138         if (!ib_get_smp_direction(smp)) {
139                 /* C14-9:1 -- sender should have incremented hop_ptr */
140                 if (hop_cnt && hop_ptr == 0)
141                         return 0;
142
143                 /* C14-9:2 -- intermediate hop */
144                 if (hop_ptr && hop_ptr < hop_cnt) {
145                         if (node_type != IB_NODE_SWITCH)
146                                 return 0;
147
148                         smp->return_path[hop_ptr] = port_num;
149                         /* smp->hop_ptr updated when sending */
150                         return (smp->initial_path[hop_ptr+1] <= phys_port_cnt);
151                 }
152
153                 /* C14-9:3 -- We're at the end of the DR segment of path */
154                 if (hop_ptr == hop_cnt) {
155                         if (hop_cnt)
156                                 smp->return_path[hop_ptr] = port_num;
157                         /* smp->hop_ptr updated when sending */
158
159                         return (node_type == IB_NODE_SWITCH ||
160                                 smp->dr_dlid == IB_LID_PERMISSIVE);
161                 }
162
163                 /* C14-9:4 -- hop_ptr = hop_cnt + 1 -> give to SMA/SM */
164                 /* C14-9:5 -- fail unreasonable hop pointer */
165                 return (hop_ptr == hop_cnt + 1);
166
167         } else {
168
169                 /* C14-13:1 */
170                 if (hop_cnt && hop_ptr == hop_cnt + 1) {
171                         smp->hop_ptr--;
172                         return (smp->return_path[smp->hop_ptr] ==
173                                 port_num);
174                 }
175
176                 /* C14-13:2 */
177                 if (2 <= hop_ptr && hop_ptr <= hop_cnt) {
178                         if (node_type != IB_NODE_SWITCH)
179                                 return 0;
180
181                         /* smp->hop_ptr updated when sending */
182                         return (smp->return_path[hop_ptr-1] <= phys_port_cnt);
183                 }
184
185                 /* C14-13:3 -- We're at the end of the DR segment of path */
186                 if (hop_ptr == 1) {
187                         if (smp->dr_slid == IB_LID_PERMISSIVE) {
188                                 /* giving SMP to SM - update hop_ptr */
189                                 smp->hop_ptr--;
190                                 return 1;
191                         }
192                         /* smp->hop_ptr updated when sending */
193                         return (node_type == IB_NODE_SWITCH);
194                 }
195
196                 /* C14-13:4 -- hop_ptr = 0 -> give to SM */
197                 /* C14-13:5 -- Check for unreasonable hop pointer */
198                 return (hop_ptr == 0);
199         }
200 }
201
202 /*
203  * Return 1 if the received DR SMP should be forwarded to the send queue
204  * Return 0 if the SMP should be completed up the stack
205  */
206 int smi_check_forward_dr_smp(struct ib_smp *smp)
207 {
208         u8 hop_ptr, hop_cnt;
209
210         hop_ptr = smp->hop_ptr;
211         hop_cnt = smp->hop_cnt;
212
213         if (!ib_get_smp_direction(smp)) {
214                 /* C14-9:2 -- intermediate hop */
215                 if (hop_ptr && hop_ptr < hop_cnt)
216                         return 1;
217
218                 /* C14-9:3 -- at the end of the DR segment of path */
219                 if (hop_ptr == hop_cnt)
220                         return (smp->dr_dlid == IB_LID_PERMISSIVE);
221
222                 /* C14-9:4 -- hop_ptr = hop_cnt + 1 -> give to SMA/SM */
223                 if (hop_ptr == hop_cnt + 1)
224                         return 1;
225         } else {
226                 /* C14-13:2 */
227                 if (2 <= hop_ptr && hop_ptr <= hop_cnt)
228                         return 1;
229
230                 /* C14-13:3 -- at the end of the DR segment of path */
231                 if (hop_ptr == 1)
232                         return (smp->dr_slid != IB_LID_PERMISSIVE);
233         }
234         return 0;
235 }