]>
git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - drivers/staging/rdma/ehca/ehca_av.c
2 * IBM eServer eHCA Infiniband device driver for Linux on POWER
4 * address vector functions
6 * Authors: Hoang-Nam Nguyen <hnguyen@de.ibm.com>
7 * Khadija Souissi <souissik@de.ibm.com>
8 * Reinhard Ernst <rernst@de.ibm.com>
9 * Christoph Raisch <raisch@de.ibm.com>
11 * Copyright (c) 2005 IBM Corporation
13 * All rights reserved.
15 * This source code is distributed under a dual license of GPL v2.0 and OpenIB
20 * Redistribution and use in source and binary forms, with or without
21 * modification, are permitted provided that the following conditions are met:
23 * Redistributions of source code must retain the above copyright notice, this
24 * list of conditions and the following disclaimer.
26 * Redistributions in binary form must reproduce the above copyright notice,
27 * this list of conditions and the following disclaimer in the documentation
28 * and/or other materials
29 * provided with the distribution.
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
32 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
33 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
34 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
35 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
36 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
37 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
38 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
39 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
40 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGE.
44 #include <linux/slab.h>
46 #include "ehca_tools.h"
47 #include "ehca_iverbs.h"
50 static struct kmem_cache
*av_cache
;
52 int ehca_calc_ipd(struct ehca_shca
*shca
, int port
,
53 enum ib_rate path_rate
, u32
*ipd
)
55 int path
= ib_rate_to_mult(path_rate
);
57 struct ib_port_attr pa
;
59 if (path_rate
== IB_RATE_PORT_CURRENT
) {
64 if (unlikely(path
< 0)) {
65 ehca_err(&shca
->ib_device
, "Invalid static rate! path_rate=%x",
70 ret
= ehca_query_port(&shca
->ib_device
, port
, &pa
);
71 if (unlikely(ret
< 0)) {
72 ehca_err(&shca
->ib_device
, "Failed to query port ret=%i", ret
);
76 link
= ib_width_enum_to_int(pa
.active_width
) * pa
.active_speed
;
79 /* no need to throttle if path faster than link */
82 /* IPD = round((link / path) - 1) */
83 *ipd
= ((link
+ (path
>> 1)) / path
) - 1;
88 struct ib_ah
*ehca_create_ah(struct ib_pd
*pd
, struct ib_ah_attr
*ah_attr
)
92 struct ehca_shca
*shca
= container_of(pd
->device
, struct ehca_shca
,
95 av
= kmem_cache_alloc(av_cache
, GFP_KERNEL
);
97 ehca_err(pd
->device
, "Out of memory pd=%p ah_attr=%p",
99 return ERR_PTR(-ENOMEM
);
102 av
->av
.sl
= ah_attr
->sl
;
103 av
->av
.dlid
= ah_attr
->dlid
;
104 av
->av
.slid_path_bits
= ah_attr
->src_path_bits
;
106 if (ehca_static_rate
< 0) {
109 if (ehca_calc_ipd(shca
, ah_attr
->port_num
,
110 ah_attr
->static_rate
, &ipd
)) {
112 goto create_ah_exit1
;
116 av
->av
.ipd
= ehca_static_rate
;
118 av
->av
.lnh
= ah_attr
->ah_flags
;
119 av
->av
.grh
.word_0
= EHCA_BMASK_SET(GRH_IPVERSION_MASK
, 6);
120 av
->av
.grh
.word_0
|= EHCA_BMASK_SET(GRH_TCLASS_MASK
,
121 ah_attr
->grh
.traffic_class
);
122 av
->av
.grh
.word_0
|= EHCA_BMASK_SET(GRH_FLOWLABEL_MASK
,
123 ah_attr
->grh
.flow_label
);
124 av
->av
.grh
.word_0
|= EHCA_BMASK_SET(GRH_HOPLIMIT_MASK
,
125 ah_attr
->grh
.hop_limit
);
126 av
->av
.grh
.word_0
|= EHCA_BMASK_SET(GRH_NEXTHEADER_MASK
, 0x1B);
127 /* set sgid in grh.word_1 */
128 if (ah_attr
->ah_flags
& IB_AH_GRH
) {
130 struct ib_port_attr port_attr
;
133 memset(&port_attr
, 0, sizeof(port_attr
));
134 rc
= ehca_query_port(pd
->device
, ah_attr
->port_num
,
136 if (rc
) { /* invalid port number */
138 ehca_err(pd
->device
, "Invalid port number "
139 "ehca_query_port() returned %x "
140 "pd=%p ah_attr=%p", rc
, pd
, ah_attr
);
141 goto create_ah_exit1
;
143 memset(&gid
, 0, sizeof(gid
));
144 rc
= ehca_query_gid(pd
->device
,
146 ah_attr
->grh
.sgid_index
, &gid
);
149 ehca_err(pd
->device
, "Failed to retrieve sgid "
150 "ehca_query_gid() returned %x "
151 "pd=%p ah_attr=%p", rc
, pd
, ah_attr
);
152 goto create_ah_exit1
;
154 memcpy(&av
->av
.grh
.word_1
, &gid
, sizeof(gid
));
156 av
->av
.pmtu
= shca
->max_mtu
;
158 /* dgid comes in grh.word_3 */
159 memcpy(&av
->av
.grh
.word_3
, &ah_attr
->grh
.dgid
,
160 sizeof(ah_attr
->grh
.dgid
));
165 kmem_cache_free(av_cache
, av
);
170 int ehca_modify_ah(struct ib_ah
*ah
, struct ib_ah_attr
*ah_attr
)
173 struct ehca_ud_av new_ehca_av
;
174 struct ehca_shca
*shca
= container_of(ah
->pd
->device
, struct ehca_shca
,
177 memset(&new_ehca_av
, 0, sizeof(new_ehca_av
));
178 new_ehca_av
.sl
= ah_attr
->sl
;
179 new_ehca_av
.dlid
= ah_attr
->dlid
;
180 new_ehca_av
.slid_path_bits
= ah_attr
->src_path_bits
;
181 new_ehca_av
.ipd
= ah_attr
->static_rate
;
182 new_ehca_av
.lnh
= EHCA_BMASK_SET(GRH_FLAG_MASK
,
183 (ah_attr
->ah_flags
& IB_AH_GRH
) > 0);
184 new_ehca_av
.grh
.word_0
= EHCA_BMASK_SET(GRH_TCLASS_MASK
,
185 ah_attr
->grh
.traffic_class
);
186 new_ehca_av
.grh
.word_0
|= EHCA_BMASK_SET(GRH_FLOWLABEL_MASK
,
187 ah_attr
->grh
.flow_label
);
188 new_ehca_av
.grh
.word_0
|= EHCA_BMASK_SET(GRH_HOPLIMIT_MASK
,
189 ah_attr
->grh
.hop_limit
);
190 new_ehca_av
.grh
.word_0
|= EHCA_BMASK_SET(GRH_NEXTHEADER_MASK
, 0x1b);
192 /* set sgid in grh.word_1 */
193 if (ah_attr
->ah_flags
& IB_AH_GRH
) {
195 struct ib_port_attr port_attr
;
198 memset(&port_attr
, 0, sizeof(port_attr
));
199 rc
= ehca_query_port(ah
->device
, ah_attr
->port_num
,
201 if (rc
) { /* invalid port number */
202 ehca_err(ah
->device
, "Invalid port number "
203 "ehca_query_port() returned %x "
204 "ah=%p ah_attr=%p port_num=%x",
205 rc
, ah
, ah_attr
, ah_attr
->port_num
);
208 memset(&gid
, 0, sizeof(gid
));
209 rc
= ehca_query_gid(ah
->device
,
211 ah_attr
->grh
.sgid_index
, &gid
);
213 ehca_err(ah
->device
, "Failed to retrieve sgid "
214 "ehca_query_gid() returned %x "
215 "ah=%p ah_attr=%p port_num=%x "
217 rc
, ah
, ah_attr
, ah_attr
->port_num
,
218 ah_attr
->grh
.sgid_index
);
221 memcpy(&new_ehca_av
.grh
.word_1
, &gid
, sizeof(gid
));
224 new_ehca_av
.pmtu
= shca
->max_mtu
;
226 memcpy(&new_ehca_av
.grh
.word_3
, &ah_attr
->grh
.dgid
,
227 sizeof(ah_attr
->grh
.dgid
));
229 av
= container_of(ah
, struct ehca_av
, ib_ah
);
230 av
->av
= new_ehca_av
;
235 int ehca_query_ah(struct ib_ah
*ah
, struct ib_ah_attr
*ah_attr
)
237 struct ehca_av
*av
= container_of(ah
, struct ehca_av
, ib_ah
);
239 memcpy(&ah_attr
->grh
.dgid
, &av
->av
.grh
.word_3
,
240 sizeof(ah_attr
->grh
.dgid
));
241 ah_attr
->sl
= av
->av
.sl
;
243 ah_attr
->dlid
= av
->av
.dlid
;
245 ah_attr
->src_path_bits
= av
->av
.slid_path_bits
;
246 ah_attr
->static_rate
= av
->av
.ipd
;
247 ah_attr
->ah_flags
= EHCA_BMASK_GET(GRH_FLAG_MASK
, av
->av
.lnh
);
248 ah_attr
->grh
.traffic_class
= EHCA_BMASK_GET(GRH_TCLASS_MASK
,
250 ah_attr
->grh
.hop_limit
= EHCA_BMASK_GET(GRH_HOPLIMIT_MASK
,
252 ah_attr
->grh
.flow_label
= EHCA_BMASK_GET(GRH_FLOWLABEL_MASK
,
258 int ehca_destroy_ah(struct ib_ah
*ah
)
260 kmem_cache_free(av_cache
, container_of(ah
, struct ehca_av
, ib_ah
));
265 int ehca_init_av_cache(void)
267 av_cache
= kmem_cache_create("ehca_cache_av",
268 sizeof(struct ehca_av
), 0,
276 void ehca_cleanup_av_cache(void)
278 kmem_cache_destroy(av_cache
);