Commit | Line | Data |
---|---|---|
0194621b DD |
1 | #ifndef DEF_RDMA_VT_H |
2 | #define DEF_RDMA_VT_H | |
3 | ||
4 | /* | |
5d18ee67 | 5 | * Copyright(c) 2016 - 2018 Intel Corporation. |
0194621b DD |
6 | * |
7 | * This file is provided under a dual BSD/GPLv2 license. When using or | |
8 | * redistributing this file, you may do so under either license. | |
9 | * | |
10 | * GPL LICENSE SUMMARY | |
11 | * | |
12 | * This program is free software; you can redistribute it and/or modify | |
13 | * it under the terms of version 2 of the GNU General Public License as | |
14 | * published by the Free Software Foundation. | |
15 | * | |
16 | * This program is distributed in the hope that it will be useful, but | |
17 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
19 | * General Public License for more details. | |
20 | * | |
21 | * BSD LICENSE | |
22 | * | |
23 | * Redistribution and use in source and binary forms, with or without | |
24 | * modification, are permitted provided that the following conditions | |
25 | * are met: | |
26 | * | |
27 | * - Redistributions of source code must retain the above copyright | |
28 | * notice, this list of conditions and the following disclaimer. | |
29 | * - Redistributions in binary form must reproduce the above copyright | |
30 | * notice, this list of conditions and the following disclaimer in | |
31 | * the documentation and/or other materials provided with the | |
32 | * distribution. | |
33 | * - Neither the name of Intel Corporation nor the names of its | |
34 | * contributors may be used to endorse or promote products derived | |
35 | * from this software without specific prior written permission. | |
36 | * | |
37 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
38 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
39 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
40 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
41 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
42 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
43 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
44 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
45 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
46 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
47 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
48 | * | |
49 | */ | |
50 | ||
51 | /* | |
52 | * Structure that low level drivers will populate in order to register with the | |
53 | * rdmavt layer. | |
54 | */ | |
55 | ||
f3d01bbc DD |
56 | #include <linux/spinlock.h> |
57 | #include <linux/list.h> | |
3b0b3fb3 | 58 | #include <linux/hash.h> |
b4e64397 | 59 | #include <rdma/ib_verbs.h> |
bf90aadd | 60 | #include <rdma/ib_mad.h> |
b4e64397 DD |
61 | #include <rdma/rdmavt_mr.h> |
62 | #include <rdma/rdmavt_qp.h> | |
f2f34211 | 63 | |
38ce2c6f DD |
64 | #define RVT_MAX_PKEY_VALUES 16 |
65 | ||
bf90aadd | 66 | #define RVT_MAX_TRAP_LEN 100 /* Limit pending trap list */ |
ec0d8b8a | 67 | #define RVT_MAX_TRAP_LISTS 5 /*((IB_NOTICE_TYPE_INFO & 0x0F) + 1)*/ |
bf90aadd MR |
68 | #define RVT_TRAP_TIMEOUT 4096 /* 4.096 usec */ |
69 | ||
70 | struct trap_list { | |
71 | u32 list_len; | |
72 | struct list_head list; | |
73 | }; | |
74 | ||
f3d01bbc DD |
75 | struct rvt_ibport { |
76 | struct rvt_qp __rcu *qp[2]; | |
77 | struct ib_mad_agent *send_agent; /* agent for SMI (traps) */ | |
78 | struct rb_root mcast_tree; | |
79 | spinlock_t lock; /* protect changes in this struct */ | |
80 | ||
81 | /* non-zero when timer is set */ | |
82 | unsigned long mkey_lease_timeout; | |
83 | unsigned long trap_timeout; | |
84 | __be64 gid_prefix; /* in network order */ | |
85 | __be64 mkey; | |
86 | u64 tid; | |
87 | u32 port_cap_flags; | |
cb49366f | 88 | u16 port_cap3_flags; |
f3d01bbc DD |
89 | u32 pma_sample_start; |
90 | u32 pma_sample_interval; | |
91 | __be16 pma_counter_select[5]; | |
92 | u16 pma_tag; | |
93 | u16 mkey_lease_period; | |
51e658f5 | 94 | u32 sm_lid; |
f3d01bbc DD |
95 | u8 sm_sl; |
96 | u8 mkeyprot; | |
97 | u8 subnet_timeout; | |
98 | u8 vl_high_limit; | |
99 | ||
100 | /* | |
101 | * Driver is expected to keep these up to date. These | |
102 | * counters are informational only and not required to be | |
103 | * completely accurate. | |
104 | */ | |
105 | u64 n_rc_resends; | |
106 | u64 n_seq_naks; | |
107 | u64 n_rdma_seq; | |
108 | u64 n_rnr_naks; | |
109 | u64 n_other_naks; | |
110 | u64 n_loop_pkts; | |
111 | u64 n_pkt_drops; | |
112 | u64 n_vl15_dropped; | |
113 | u64 n_rc_timeouts; | |
114 | u64 n_dmawait; | |
115 | u64 n_unaligned; | |
116 | u64 n_rc_dupreq; | |
117 | u64 n_rc_seqnak; | |
118 | u16 pkey_violations; | |
119 | u16 qkey_violations; | |
120 | u16 mkey_violations; | |
121 | ||
122 | /* Hot-path per CPU counters to avoid cacheline trading to update */ | |
123 | u64 z_rc_acks; | |
124 | u64 z_rc_qacks; | |
125 | u64 z_rc_delayed_comp; | |
126 | u64 __percpu *rc_acks; | |
127 | u64 __percpu *rc_qacks; | |
128 | u64 __percpu *rc_delayed_comp; | |
129 | ||
130 | void *priv; /* driver private data */ | |
131 | ||
38ce2c6f DD |
132 | /* |
133 | * The pkey table is allocated and maintained by the driver. Drivers | |
134 | * need to have access to this before registering with rdmav. However | |
135 | * rdmavt will need access to it so drivers need to proviee this during | |
136 | * the attach port API call. | |
137 | */ | |
138 | u16 *pkey_table; | |
139 | ||
3711baf2 | 140 | struct rvt_ah *sm_ah; |
bf90aadd MR |
141 | |
142 | /* | |
143 | * Keep a list of traps that have not been repressed. They will be | |
144 | * resent based on trap_timer. | |
145 | */ | |
146 | struct trap_list trap_lists[RVT_MAX_TRAP_LISTS]; | |
147 | struct timer_list trap_timer; | |
f3d01bbc DD |
148 | }; |
149 | ||
6f6387ae DD |
150 | #define RVT_CQN_MAX 16 /* maximum length of cq name */ |
151 | ||
019f118b BW |
152 | #define RVT_SGE_COPY_MEMCPY 0 |
153 | #define RVT_SGE_COPY_CACHELESS 1 | |
154 | #define RVT_SGE_COPY_ADAPTIVE 2 | |
155 | ||
8afd32eb DD |
156 | /* |
157 | * Things that are driver specific, module parameters in hfi1 and qib | |
158 | */ | |
159 | struct rvt_driver_params { | |
b1070a7a DD |
160 | struct ib_device_attr props; |
161 | ||
b1070a7a DD |
162 | /* |
163 | * Anything driver specific that is not covered by props | |
164 | * For instance special module parameters. Goes here. | |
165 | */ | |
7b1e2099 | 166 | unsigned int lkey_table_size; |
0acb0cc7 | 167 | unsigned int qp_table_size; |
019f118b BW |
168 | unsigned int sge_copy_mode; |
169 | unsigned int wss_threshold; | |
170 | unsigned int wss_clean_period; | |
0acb0cc7 DD |
171 | int qpn_start; |
172 | int qpn_inc; | |
173 | int qpn_res_start; | |
174 | int qpn_res_end; | |
f3d01bbc | 175 | int nports; |
38ce2c6f | 176 | int npkeys; |
6f6387ae | 177 | int node; |
3b0b3fb3 DD |
178 | int psn_mask; |
179 | int psn_shift; | |
180 | int psn_modify_mask; | |
61a650c1 HC |
181 | u32 core_cap_flags; |
182 | u32 max_mad_size; | |
4c0b6533 MM |
183 | u8 qos_shift; |
184 | u8 max_rdma_atomic; | |
ddf922c3 | 185 | u8 extra_rdma_atomic; |
856cc4c2 | 186 | u8 reserved_operations; |
8afd32eb DD |
187 | }; |
188 | ||
b036db83 DD |
189 | /* Protection domain */ |
190 | struct rvt_pd { | |
191 | struct ib_pd ibpd; | |
0128fcea | 192 | bool user; |
b036db83 DD |
193 | }; |
194 | ||
195 | /* Address handle */ | |
196 | struct rvt_ah { | |
197 | struct ib_ah ibah; | |
90898850 | 198 | struct rdma_ah_attr attr; |
b036db83 DD |
199 | atomic_t refcount; |
200 | u8 vl; | |
201 | u8 log_pmtu; | |
202 | }; | |
203 | ||
019f118b BW |
204 | /* memory working set size */ |
205 | struct rvt_wss { | |
206 | unsigned long *entries; | |
207 | atomic_t total_count; | |
208 | atomic_t clean_counter; | |
209 | atomic_t clean_entry; | |
210 | ||
211 | int threshold; | |
212 | int num_entries; | |
213 | long pages_mask; | |
214 | unsigned int clean_period; | |
215 | }; | |
216 | ||
b534875d | 217 | struct rvt_dev_info; |
46a80d62 | 218 | struct rvt_swqe; |
aec57787 DD |
219 | struct rvt_driver_provided { |
220 | /* | |
1348d706 DD |
221 | * Which functions are required depends on which verbs rdmavt is |
222 | * providing and which verbs the driver is overriding. See | |
223 | * check_support() for details. | |
aec57787 | 224 | */ |
b036db83 | 225 | |
be5d740b MM |
226 | /* hot path calldowns in a single cacheline */ |
227 | ||
228 | /* | |
229 | * Give the driver a notice that there is send work to do. It is up to | |
230 | * the driver to generally push the packets out, this just queues the | |
231 | * work with the driver. There are two variants here. The no_lock | |
232 | * version requires the s_lock not to be held. The other assumes the | |
233 | * s_lock is held. | |
234 | */ | |
5da0fc9d DD |
235 | bool (*schedule_send)(struct rvt_qp *qp); |
236 | bool (*schedule_send_no_lock)(struct rvt_qp *qp); | |
be5d740b | 237 | |
0b79b277 | 238 | /* |
d205a06a KW |
239 | * Driver specific work request setup and checking. |
240 | * This function is allowed to perform any setup, checks, or | |
241 | * adjustments required to the SWQE in order to be usable by | |
242 | * underlying protocols. This includes private data structure | |
243 | * allocations. | |
0b79b277 | 244 | */ |
d205a06a KW |
245 | int (*setup_wqe)(struct rvt_qp *qp, struct rvt_swqe *wqe, |
246 | bool *call_send); | |
be5d740b MM |
247 | |
248 | /* | |
249 | * Sometimes rdmavt needs to kick the driver's send progress. That is | |
250 | * done by this call back. | |
251 | */ | |
252 | void (*do_send)(struct rvt_qp *qp); | |
253 | ||
1348d706 DD |
254 | /* |
255 | * Returns a pointer to the undelying hardware's PCI device. This is | |
256 | * used to display information as to what hardware is being referenced | |
257 | * in an output message | |
258 | */ | |
b534875d | 259 | struct pci_dev * (*get_pci_dev)(struct rvt_dev_info *rdi); |
1348d706 DD |
260 | |
261 | /* | |
262 | * Allocate a private queue pair data structure for driver specific | |
c755f4af MM |
263 | * information which is opaque to rdmavt. Errors are returned via |
264 | * ERR_PTR(err). The driver is free to return NULL or a valid | |
265 | * pointer. | |
1348d706 | 266 | */ |
0f4d027c | 267 | void * (*qp_priv_alloc)(struct rvt_dev_info *rdi, struct rvt_qp *qp); |
1348d706 | 268 | |
5190f052 MM |
269 | /* |
270 | * Init a struture allocated with qp_priv_alloc(). This should be | |
271 | * called after all qp fields have been initialized in rdmavt. | |
272 | */ | |
273 | int (*qp_priv_init)(struct rvt_dev_info *rdi, struct rvt_qp *qp, | |
274 | struct ib_qp_init_attr *init_attr); | |
275 | ||
1348d706 DD |
276 | /* |
277 | * Free the driver's private qp structure. | |
278 | */ | |
515667f8 | 279 | void (*qp_priv_free)(struct rvt_dev_info *rdi, struct rvt_qp *qp); |
1348d706 DD |
280 | |
281 | /* | |
282 | * Inform the driver the particular qp in quesiton has been reset so | |
283 | * that it can clean up anything it needs to. | |
284 | */ | |
515667f8 | 285 | void (*notify_qp_reset)(struct rvt_qp *qp); |
1348d706 | 286 | |
1348d706 DD |
287 | /* |
288 | * Get a path mtu from the driver based on qp attributes. | |
289 | */ | |
3b0b3fb3 DD |
290 | int (*get_pmtu_from_attr)(struct rvt_dev_info *rdi, struct rvt_qp *qp, |
291 | struct ib_qp_attr *attr); | |
1348d706 DD |
292 | |
293 | /* | |
294 | * Notify driver that it needs to flush any outstanding IO requests that | |
295 | * are waiting on a qp. | |
296 | */ | |
3b0b3fb3 | 297 | void (*flush_qp_waiters)(struct rvt_qp *qp); |
1348d706 DD |
298 | |
299 | /* | |
300 | * Notify driver to stop its queue of sending packets. Nothing else | |
301 | * should be posted to the queue pair after this has been called. | |
302 | */ | |
3b0b3fb3 | 303 | void (*stop_send_queue)(struct rvt_qp *qp); |
1348d706 DD |
304 | |
305 | /* | |
306 | * Have the drivr drain any in progress operations | |
307 | */ | |
3b0b3fb3 | 308 | void (*quiesce_qp)(struct rvt_qp *qp); |
1348d706 DD |
309 | |
310 | /* | |
311 | * Inform the driver a qp has went to error state. | |
312 | */ | |
3b0b3fb3 | 313 | void (*notify_error_qp)(struct rvt_qp *qp); |
1348d706 DD |
314 | |
315 | /* | |
316 | * Get an MTU for a qp. | |
317 | */ | |
3b0b3fb3 DD |
318 | u32 (*mtu_from_qp)(struct rvt_dev_info *rdi, struct rvt_qp *qp, |
319 | u32 pmtu); | |
1348d706 DD |
320 | /* |
321 | * Convert an mtu to a path mtu | |
322 | */ | |
3b0b3fb3 | 323 | int (*mtu_to_path_mtu)(u32 mtu); |
1348d706 DD |
324 | |
325 | /* | |
326 | * Get the guid of a port in big endian byte order | |
327 | */ | |
1f024992 DD |
328 | int (*get_guid_be)(struct rvt_dev_info *rdi, struct rvt_ibport *rvp, |
329 | int guid_index, __be64 *guid); | |
1348d706 DD |
330 | |
331 | /* | |
332 | * Query driver for the state of the port. | |
333 | */ | |
61a650c1 HC |
334 | int (*query_port_state)(struct rvt_dev_info *rdi, u8 port_num, |
335 | struct ib_port_attr *props); | |
1348d706 DD |
336 | |
337 | /* | |
338 | * Tell driver to shutdown a port | |
339 | */ | |
61a650c1 | 340 | int (*shut_down_port)(struct rvt_dev_info *rdi, u8 port_num); |
1348d706 DD |
341 | |
342 | /* Tell driver to send a trap for changed port capabilities */ | |
61a650c1 | 343 | void (*cap_mask_chg)(struct rvt_dev_info *rdi, u8 port_num); |
aec57787 | 344 | |
1348d706 DD |
345 | /* |
346 | * The following functions can be safely ignored completely. Any use of | |
347 | * these is checked for NULL before blindly calling. Rdmavt should also | |
348 | * be functional if drivers omit these. | |
349 | */ | |
350 | ||
351 | /* Called to inform the driver that all qps should now be freed. */ | |
352 | unsigned (*free_all_qps)(struct rvt_dev_info *rdi); | |
353 | ||
354 | /* Driver specific AH validation */ | |
90898850 | 355 | int (*check_ah)(struct ib_device *, struct rdma_ah_attr *); |
1348d706 DD |
356 | |
357 | /* Inform the driver a new AH has been created */ | |
90898850 | 358 | void (*notify_new_ah)(struct ib_device *, struct rdma_ah_attr *, |
b036db83 | 359 | struct rvt_ah *); |
1348d706 DD |
360 | |
361 | /* Let the driver pick the next queue pair number*/ | |
515667f8 | 362 | int (*alloc_qpn)(struct rvt_dev_info *rdi, struct rvt_qpn_table *qpt, |
0f4d027c | 363 | enum ib_qp_type type, u8 port_num); |
1348d706 DD |
364 | |
365 | /* Determine if its safe or allowed to modify the qp */ | |
e85ec33d IW |
366 | int (*check_modify_qp)(struct rvt_qp *qp, struct ib_qp_attr *attr, |
367 | int attr_mask, struct ib_udata *udata); | |
1348d706 DD |
368 | |
369 | /* Driver specific QP modification/notification-of */ | |
e85ec33d IW |
370 | void (*modify_qp)(struct rvt_qp *qp, struct ib_qp_attr *attr, |
371 | int attr_mask, struct ib_udata *udata); | |
3711baf2 | 372 | |
1348d706 | 373 | /* Notify driver a mad agent has been created */ |
3711baf2 | 374 | void (*notify_create_mad_agent)(struct rvt_dev_info *rdi, int port_idx); |
1348d706 DD |
375 | |
376 | /* Notify driver a mad agent has been removed */ | |
3711baf2 | 377 | void (*notify_free_mad_agent)(struct rvt_dev_info *rdi, int port_idx); |
1348d706 | 378 | |
11a10d4b VSD |
379 | /* Notify driver to restart rc */ |
380 | void (*notify_restart_rc)(struct rvt_qp *qp, u32 psn, int wait); | |
5d18ee67 SS |
381 | |
382 | /* Get and return CPU to pin CQ processing thread */ | |
383 | int (*comp_vect_cpu_lookup)(struct rvt_dev_info *rdi, int comp_vect); | |
119a8e70 KH |
384 | }; |
385 | ||
0194621b | 386 | struct rvt_dev_info { |
7b1e2099 DD |
387 | struct ib_device ibdev; /* Keep this first. Nothing above here */ |
388 | ||
b1070a7a DD |
389 | /* |
390 | * Prior to calling for registration the driver will be responsible for | |
391 | * allocating space for this structure. | |
392 | * | |
393 | * The driver will also be responsible for filling in certain members of | |
feaeb6e2 HC |
394 | * dparms.props. The driver needs to fill in dparms exactly as it would |
395 | * want values reported to a ULP. This will be returned to the caller | |
396 | * in rdmavt's device. The driver should also therefore refrain from | |
397 | * modifying this directly after registration with rdmavt. | |
b1070a7a | 398 | */ |
8afd32eb | 399 | |
b1070a7a | 400 | /* Driver specific properties */ |
8afd32eb | 401 | struct rvt_driver_params dparms; |
b1070a7a | 402 | |
afcf8f76 MM |
403 | /* post send table */ |
404 | const struct rvt_operation_params *post_parms; | |
405 | ||
116aa033 VSD |
406 | /* opcode translation table */ |
407 | const enum ib_wc_opcode *wc_opcode; | |
408 | ||
aec57787 DD |
409 | /* Driver specific helper functions */ |
410 | struct rvt_driver_provided driver_f; | |
0194621b | 411 | |
be5d740b MM |
412 | struct rvt_mregion __rcu *dma_mr; |
413 | struct rvt_lkey_table lkey_table; | |
414 | ||
8afd32eb DD |
415 | /* Internal use */ |
416 | int n_pds_allocated; | |
417 | spinlock_t n_pds_lock; /* Protect pd allocated count */ | |
0b8a8aae | 418 | |
119a8e70 KH |
419 | int n_ahs_allocated; |
420 | spinlock_t n_ahs_lock; /* Protect ah allocated count */ | |
421 | ||
b8f881b9 JJ |
422 | u32 n_srqs_allocated; |
423 | spinlock_t n_srqs_lock; /* Protect srqs allocated count */ | |
424 | ||
0b8a8aae | 425 | int flags; |
f3d01bbc | 426 | struct rvt_ibport **ports; |
0acb0cc7 | 427 | |
515667f8 | 428 | /* QP */ |
0acb0cc7 | 429 | struct rvt_qp_ibdev *qp_dev; |
515667f8 | 430 | u32 n_qps_allocated; /* number of QPs allocated for device */ |
bfee5e32 VM |
431 | u32 n_rc_qps; /* number of RC QPs allocated for device */ |
432 | u32 busy_jiffies; /* timeout scaling based on RC QP count */ | |
433 | spinlock_t n_qps_lock; /* protect qps, rc qps and busy jiffy counts */ | |
822514d7 DD |
434 | |
435 | /* memory maps */ | |
436 | struct list_head pending_mmaps; | |
437 | spinlock_t mmap_offset_lock; /* protect mmap_offset */ | |
438 | u32 mmap_offset; | |
439 | spinlock_t pending_lock; /* protect pending mmap list */ | |
6f6387ae DD |
440 | |
441 | /* CQ */ | |
6f6387ae DD |
442 | u32 n_cqs_allocated; /* number of CQs allocated for device */ |
443 | spinlock_t n_cqs_lock; /* protect count of in use cqs */ | |
4e74080b DD |
444 | |
445 | /* Multicast */ | |
446 | u32 n_mcast_grps_allocated; /* number of mcast groups allocated */ | |
447 | spinlock_t n_mcast_grps_lock; | |
448 | ||
019f118b BW |
449 | /* Memory Working Set Size */ |
450 | struct rvt_wss *wss; | |
0194621b DD |
451 | }; |
452 | ||
5084c8ff MR |
453 | /** |
454 | * rvt_set_ibdev_name - Craft an IB device name from client info | |
455 | * @rdi: pointer to the client rvt_dev_info structure | |
456 | * @name: client specific name | |
457 | * @unit: client specific unit number. | |
458 | */ | |
459 | static inline void rvt_set_ibdev_name(struct rvt_dev_info *rdi, | |
460 | const char *fmt, const char *name, | |
461 | const int unit) | |
462 | { | |
e349f858 JG |
463 | /* |
464 | * FIXME: rvt and its users want to touch the ibdev before | |
465 | * registration and have things like the name work. We don't have the | |
466 | * infrastructure in the core to support this directly today, hack it | |
467 | * to work by setting the name manually here. | |
468 | */ | |
469 | dev_set_name(&rdi->ibdev.dev, fmt, name, unit); | |
470 | strlcpy(rdi->ibdev.name, dev_name(&rdi->ibdev.dev), IB_DEVICE_NAME_MAX); | |
5084c8ff MR |
471 | } |
472 | ||
06f2597f MR |
473 | /** |
474 | * rvt_get_ibdev_name - return the IB name | |
475 | * @rdi: rdmavt device | |
476 | * | |
477 | * Return the registered name of the device. | |
478 | */ | |
479 | static inline const char *rvt_get_ibdev_name(const struct rvt_dev_info *rdi) | |
480 | { | |
6c854111 | 481 | return dev_name(&rdi->ibdev.dev); |
06f2597f MR |
482 | } |
483 | ||
8afd32eb DD |
484 | static inline struct rvt_pd *ibpd_to_rvtpd(struct ib_pd *ibpd) |
485 | { | |
486 | return container_of(ibpd, struct rvt_pd, ibpd); | |
487 | } | |
488 | ||
119a8e70 KH |
489 | static inline struct rvt_ah *ibah_to_rvtah(struct ib_ah *ibah) |
490 | { | |
491 | return container_of(ibah, struct rvt_ah, ibah); | |
492 | } | |
493 | ||
8afd32eb DD |
494 | static inline struct rvt_dev_info *ib_to_rvt(struct ib_device *ibdev) |
495 | { | |
496 | return container_of(ibdev, struct rvt_dev_info, ibdev); | |
497 | } | |
498 | ||
70a1a351 DD |
499 | static inline struct rvt_srq *ibsrq_to_rvtsrq(struct ib_srq *ibsrq) |
500 | { | |
501 | return container_of(ibsrq, struct rvt_srq, ibsrq); | |
502 | } | |
503 | ||
bfbac097 DD |
504 | static inline struct rvt_qp *ibqp_to_rvtqp(struct ib_qp *ibqp) |
505 | { | |
506 | return container_of(ibqp, struct rvt_qp, ibqp); | |
507 | } | |
508 | ||
38ce2c6f DD |
509 | static inline unsigned rvt_get_npkeys(struct rvt_dev_info *rdi) |
510 | { | |
511 | /* | |
512 | * All ports have same number of pkeys. | |
513 | */ | |
514 | return rdi->dparms.npkeys; | |
515 | } | |
516 | ||
8b103e9c MM |
517 | /* |
518 | * Return the max atomic suitable for determining | |
519 | * the size of the ack ring buffer in a QP. | |
520 | */ | |
521 | static inline unsigned int rvt_max_atomic(struct rvt_dev_info *rdi) | |
522 | { | |
ddf922c3 KW |
523 | return rdi->dparms.max_rdma_atomic + |
524 | rdi->dparms.extra_rdma_atomic + 1; | |
525 | } | |
526 | ||
527 | static inline unsigned int rvt_size_atomic(struct rvt_dev_info *rdi) | |
528 | { | |
529 | return rdi->dparms.max_rdma_atomic + | |
530 | rdi->dparms.extra_rdma_atomic; | |
8b103e9c MM |
531 | } |
532 | ||
38ce2c6f DD |
533 | /* |
534 | * Return the indexed PKEY from the port PKEY table. | |
535 | */ | |
536 | static inline u16 rvt_get_pkey(struct rvt_dev_info *rdi, | |
537 | int port_index, | |
538 | unsigned index) | |
539 | { | |
540 | if (index >= rvt_get_npkeys(rdi)) | |
541 | return 0; | |
542 | else | |
543 | return rdi->ports[port_index]->pkey_table[index]; | |
544 | } | |
545 | ||
3b0b3fb3 DD |
546 | /** |
547 | * rvt_lookup_qpn - return the QP with the given QPN | |
548 | * @ibp: the ibport | |
549 | * @qpn: the QP number to look up | |
550 | * | |
551 | * The caller must hold the rcu_read_lock(), and keep the lock until | |
552 | * the returned qp is no longer in use. | |
553 | */ | |
554 | /* TODO: Remove this and put in rdmavt/qp.h when no longer needed by drivers */ | |
555 | static inline struct rvt_qp *rvt_lookup_qpn(struct rvt_dev_info *rdi, | |
556 | struct rvt_ibport *rvp, | |
557 | u32 qpn) __must_hold(RCU) | |
558 | { | |
559 | struct rvt_qp *qp = NULL; | |
560 | ||
561 | if (unlikely(qpn <= 1)) { | |
562 | qp = rcu_dereference(rvp->qp[qpn]); | |
563 | } else { | |
564 | u32 n = hash_32(qpn, rdi->qp_dev->qp_table_bits); | |
565 | ||
566 | for (qp = rcu_dereference(rdi->qp_dev->qp_table[n]); qp; | |
567 | qp = rcu_dereference(qp->next)) | |
568 | if (qp->ibqp.qp_num == qpn) | |
569 | break; | |
570 | } | |
571 | return qp; | |
572 | } | |
573 | ||
11a10d4b VSD |
574 | /** |
575 | * rvt_mod_retry_timer - mod a retry timer | |
576 | * @qp - the QP | |
039cd3da | 577 | * @shift - timeout shift to wait for multiple packets |
11a10d4b VSD |
578 | * Modify a potentially already running retry timer |
579 | */ | |
039cd3da | 580 | static inline void rvt_mod_retry_timer_ext(struct rvt_qp *qp, u8 shift) |
11a10d4b VSD |
581 | { |
582 | struct ib_qp *ibqp = &qp->ibqp; | |
583 | struct rvt_dev_info *rdi = ib_to_rvt(ibqp->device); | |
584 | ||
585 | lockdep_assert_held(&qp->s_lock); | |
586 | qp->s_flags |= RVT_S_TIMER; | |
587 | /* 4.096 usec. * (1 << qp->timeout) */ | |
039cd3da KW |
588 | mod_timer(&qp->s_timer, jiffies + rdi->busy_jiffies + |
589 | (qp->timeout_jiffies << shift)); | |
590 | } | |
591 | ||
592 | static inline void rvt_mod_retry_timer(struct rvt_qp *qp) | |
593 | { | |
594 | return rvt_mod_retry_timer_ext(qp, 0); | |
11a10d4b VSD |
595 | } |
596 | ||
ff6acd69 | 597 | struct rvt_dev_info *rvt_alloc_device(size_t size, int nports); |
ea0e4ce3 | 598 | void rvt_dealloc_device(struct rvt_dev_info *rdi); |
0ede73bc | 599 | int rvt_register_device(struct rvt_dev_info *rvd, u32 driver_id); |
0194621b | 600 | void rvt_unregister_device(struct rvt_dev_info *rvd); |
90898850 | 601 | int rvt_check_ah(struct ib_device *ibdev, struct rdma_ah_attr *ah_attr); |
38ce2c6f | 602 | int rvt_init_port(struct rvt_dev_info *rdi, struct rvt_ibport *port, |
f1badc71 | 603 | int port_index, u16 *pkey_table); |
e8f8b098 JX |
604 | int rvt_fast_reg_mr(struct rvt_qp *qp, struct ib_mr *ibmr, u32 key, |
605 | int access); | |
606 | int rvt_invalidate_rkey(struct rvt_qp *qp, u32 rkey); | |
7b1e2099 DD |
607 | int rvt_rkey_ok(struct rvt_qp *qp, struct rvt_sge *sge, |
608 | u32 len, u64 vaddr, u32 rkey, int acc); | |
609 | int rvt_lkey_ok(struct rvt_lkey_table *rkt, struct rvt_pd *pd, | |
14fe13fc MM |
610 | struct rvt_sge *isge, struct rvt_sge *last_sge, |
611 | struct ib_sge *sge, int acc); | |
aad9ff97 MR |
612 | struct rvt_mcast *rvt_mcast_find(struct rvt_ibport *ibp, union ib_gid *mgid, |
613 | u16 lid); | |
822514d7 | 614 | |
0194621b | 615 | #endif /* DEF_RDMA_VT_H */ |