libibmad: updated based on merge feedback
[mirror/winof/.git] / ulp / libibmad / src / gs.c
1 /*
2  * Copyright (c) 2004-2007 Voltaire Inc.  All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  *
32  */
33
34 #if HAVE_CONFIG_H
35 #  include <config.h>
36 #endif /* HAVE_CONFIG_H */
37
38 #include <infiniband/umad.h>
39 #include "mad.h"
40
41 #undef DEBUG
42 #define DEBUG   if (ibdebug)    IBWARN
43
44 static uint8_t *
45 pma_query_via(void *rcvbuf, ib_portid_t *dest, int port,
46               unsigned timeout, unsigned id, const void *srcport)
47 {
48         ib_rpc_t rpc = {0};
49         int lid = dest->lid;
50
51         DEBUG("lid %d port %d", lid, port);
52
53         if (lid == -1) {
54                 IBWARN("only lid routed is supported");
55                 return 0;
56         }
57
58         rpc.mgtclass = IB_PERFORMANCE_CLASS;
59         rpc.method = IB_MAD_METHOD_GET;
60         rpc.attr.id = id;
61
62         /* Same for attribute IDs */
63         mad_set_field(rcvbuf, 0, IB_PC_PORT_SELECT_F, port);
64         rpc.attr.mod = 0;
65         rpc.timeout = timeout;
66         rpc.datasz = IB_PC_DATA_SZ;
67         rpc.dataoffs = IB_PC_DATA_OFFS;
68
69         dest->qp = 1;
70         if (!dest->qkey)
71                 dest->qkey = IB_DEFAULT_QP1_QKEY;
72
73         if (srcport) {
74                 return mad_rpc(srcport, &rpc, dest, rcvbuf, rcvbuf);
75         } else {
76                 return madrpc(&rpc, dest, rcvbuf, rcvbuf);
77         }
78 }
79
80 uint8_t *
81 pma_query(void *rcvbuf, ib_portid_t *dest, int port, unsigned timeout, unsigned id)
82 {
83         return pma_query_via(rcvbuf, dest, port, timeout, id, NULL);
84 }
85
86 uint8_t *
87 perf_classportinfo_query_via(void *rcvbuf, ib_portid_t *dest, int port,
88                              unsigned timeout, const void *srcport)
89 {
90         return pma_query_via(rcvbuf, dest, port, timeout, CLASS_PORT_INFO,
91                              srcport);
92 }
93
94 uint8_t *
95 perf_classportinfo_query(void *rcvbuf, ib_portid_t *dest, int port, unsigned timeout)
96 {
97         return pma_query(rcvbuf, dest, port, timeout, CLASS_PORT_INFO);
98 }
99
100 uint8_t *
101 port_performance_query_via(void *rcvbuf, ib_portid_t *dest, int port,
102                            unsigned timeout, const void *srcport)
103 {
104         return pma_query_via(rcvbuf, dest, port, timeout,
105                              IB_GSI_PORT_COUNTERS, srcport);
106 }
107
108 uint8_t *
109 port_performance_query(void *rcvbuf, ib_portid_t *dest, int port, unsigned timeout)
110 {
111         return pma_query(rcvbuf, dest, port, timeout, IB_GSI_PORT_COUNTERS);
112 }
113
114 static uint8_t *
115 performance_reset_via(void *rcvbuf, ib_portid_t *dest, int port, unsigned mask,
116                       unsigned timeout, unsigned id, const void *srcport)
117 {
118         ib_rpc_t rpc = {0};
119         int lid = dest->lid;
120
121         DEBUG("lid %d port %d mask 0x%x", lid, port, mask);
122
123         if (lid == -1) {
124                 IBWARN("only lid routed is supported");
125                 return 0;
126         }
127
128         if (!mask)
129                 mask = ~0;
130
131         rpc.mgtclass = IB_PERFORMANCE_CLASS;
132         rpc.method = IB_MAD_METHOD_SET;
133         rpc.attr.id = id;
134
135         memset(rcvbuf, 0, IB_MAD_SIZE);
136
137         /* Same for attribute IDs */
138         mad_set_field(rcvbuf, 0, IB_PC_PORT_SELECT_F, port);
139         mad_set_field(rcvbuf, 0, IB_PC_COUNTER_SELECT_F, mask);
140         rpc.attr.mod = 0;
141         rpc.timeout = timeout;
142         rpc.datasz = IB_PC_DATA_SZ;
143         rpc.dataoffs = IB_PC_DATA_OFFS;
144         dest->qp = 1;
145         if (!dest->qkey)
146                 dest->qkey = IB_DEFAULT_QP1_QKEY;
147
148         if (srcport) {
149                 return mad_rpc(srcport, &rpc, dest, rcvbuf, rcvbuf);
150         } else {
151                 return madrpc(&rpc, dest, rcvbuf, rcvbuf);
152         }
153 }
154
155 static uint8_t *
156 performance_reset(void *rcvbuf, ib_portid_t *dest, int port, unsigned mask,
157                   unsigned timeout, unsigned id)
158 {
159         return performance_reset_via(rcvbuf, dest, port, mask, timeout,
160                                      id, NULL);
161 }
162
163 uint8_t *
164 port_performance_reset_via(void *rcvbuf, ib_portid_t *dest, int port,
165                            unsigned mask, unsigned timeout, const void *srcport)
166 {
167         return performance_reset_via(rcvbuf, dest, port, mask, timeout,
168                                      IB_GSI_PORT_COUNTERS, srcport);
169 }
170
171 uint8_t *
172 port_performance_reset(void *rcvbuf, ib_portid_t *dest, int port, unsigned mask,
173                        unsigned timeout)
174 {
175         return performance_reset(rcvbuf, dest, port, mask, timeout, IB_GSI_PORT_COUNTERS);
176 }
177
178 uint8_t *
179 port_performance_ext_query_via(void *rcvbuf, ib_portid_t *dest, int port,
180                                unsigned timeout, const void *srcport)
181 {
182         return pma_query_via(rcvbuf, dest, port, timeout,
183                              IB_GSI_PORT_COUNTERS_EXT, srcport);
184 }
185
186 uint8_t *
187 port_performance_ext_query(void *rcvbuf, ib_portid_t *dest, int port, unsigned timeout)
188 {
189         return pma_query(rcvbuf, dest, port, timeout, IB_GSI_PORT_COUNTERS_EXT);
190 }
191
192 uint8_t *
193 port_performance_ext_reset_via(void *rcvbuf, ib_portid_t *dest, int port,
194                                unsigned mask, unsigned timeout,
195                                const void *srcport)
196 {
197         return performance_reset_via(rcvbuf, dest, port, mask, timeout,
198                                      IB_GSI_PORT_COUNTERS_EXT, srcport);
199 }
200
201 uint8_t *
202 port_performance_ext_reset(void *rcvbuf, ib_portid_t *dest, int port, unsigned mask,
203                            unsigned timeout)
204 {
205         return performance_reset(rcvbuf, dest, port, mask, timeout, IB_GSI_PORT_COUNTERS_EXT);
206 }
207
208 uint8_t *
209 port_samples_control_query_via(void *rcvbuf, ib_portid_t *dest, int port,
210                                unsigned timeout, const void *srcport)
211 {
212         return pma_query_via(rcvbuf, dest, port, timeout,
213                              IB_GSI_PORT_SAMPLES_CONTROL, srcport);
214 }
215
216 uint8_t *
217 port_samples_control_query(void *rcvbuf, ib_portid_t *dest, int port, unsigned timeout)
218 {
219         return pma_query(rcvbuf, dest, port, timeout, IB_GSI_PORT_SAMPLES_CONTROL);
220 }
221
222 uint8_t *
223 port_samples_result_query_via(void *rcvbuf, ib_portid_t *dest, int port,
224                               unsigned timeout, const void *srcport)
225 {
226         return pma_query_via(rcvbuf, dest, port, timeout,
227                              IB_GSI_PORT_SAMPLES_RESULT, srcport);
228 }
229
230 uint8_t *
231 port_samples_result_query(void *rcvbuf, ib_portid_t *dest, int port,  unsigned timeout)
232 {
233         return pma_query(rcvbuf, dest, port, timeout, IB_GSI_PORT_SAMPLES_RESULT);
234 }