1 /*
2 * IBM eServer eHCA Infiniband device driver for Linux on POWER
3 *
4 * Struct definition for eHCA internal structures
5 *
6 * Authors: Heiko J Schick <schickhj@de.ibm.com>
7 * Christoph Raisch <raisch@de.ibm.com>
8 * Joachim Fenkes <fenkes@de.ibm.com>
9 *
10 * Copyright (c) 2005 IBM Corporation
11 *
12 * All rights reserved.
13 *
14 * This source code is distributed under a dual license of GPL v2.0 and OpenIB
15 * BSD.
16 *
17 * OpenIB BSD License
18 *
19 * Redistribution and use in source and binary forms, with or without
20 * modification, are permitted provided that the following conditions are met:
21 *
22 * Redistributions of source code must retain the above copyright notice, this
23 * list of conditions and the following disclaimer.
24 *
25 * Redistributions in binary form must reproduce the above copyright notice,
26 * this list of conditions and the following disclaimer in the documentation
27 * and/or other materials
28 * provided with the distribution.
29 *
30 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
31 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
32 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
33 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
34 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
35 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
36 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
37 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
38 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
39 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
40 * POSSIBILITY OF SUCH DAMAGE.
41 */
42
43 #ifndef __EHCA_CLASSES_H__
44 #define __EHCA_CLASSES_H__
45
46 struct ehca_module;
47 struct ehca_qp;
48 struct ehca_cq;
49 struct ehca_eq;
50 struct ehca_mr;
51 struct ehca_mw;
52 struct ehca_pd;
53 struct ehca_av;
54
55 #include <linux/wait.h>
56 #include <linux/mutex.h>
57
58 #include <rdma/ib_verbs.h>
59 #include <rdma/ib_user_verbs.h>
60
61 #ifdef CONFIG_PPC64
62 #include "ehca_classes_pSeries.h"
63 #endif
64 #include "ipz_pt_fn.h"
65 #include "ehca_qes.h"
66 #include "ehca_irq.h"
67
68 #define EHCA_EQE_CACHE_SIZE 20
69
70 struct ehca_eqe_cache_entry {
71 struct ehca_eqe *eqe;
72 struct ehca_cq *cq;
73 };
74
75 struct ehca_eq {
76 u32 length;
77 struct ipz_queue ipz_queue;
78 struct ipz_eq_handle ipz_eq_handle;
79 struct work_struct work;
80 struct h_galpas galpas;
81 int is_initialized;
82 struct ehca_pfeq pf;
83 spinlock_t spinlock;
84 struct tasklet_struct interrupt_task;
85 u32 ist;
86 spinlock_t irq_spinlock;
87 struct ehca_eqe_cache_entry eqe_cache[EHCA_EQE_CACHE_SIZE];
88 };
89
90 struct ehca_sma_attr {
91 u16 lid, lmc, sm_sl, sm_lid;
92 u16 pkey_tbl_len, pkeys[16];
93 };
94
95 struct ehca_sport {
96 struct ib_cq *ibcq_aqp1;
97 struct ib_qp *ibqp_sqp[2];
98 /* lock to serialze modify_qp() calls for sqp in normal
99 * and irq path (when event PORT_ACTIVE is received first time)
100 */
101 spinlock_t mod_sqp_lock;
102 enum ib_port_state port_state;
103 struct ehca_sma_attr saved_attr;
104 u32 pma_qp_nr;
105 };
106
107 #define HCA_CAP_MR_PGSIZE_4K 0x80000000
108 #define HCA_CAP_MR_PGSIZE_64K 0x40000000
109 #define HCA_CAP_MR_PGSIZE_1M 0x20000000
110 #define HCA_CAP_MR_PGSIZE_16M 0x10000000
111
112 struct ehca_shca {
113 struct ib_device ib_device;
114 struct of_device *ofdev;
115 u8 num_ports;
116 int hw_level;
117 struct list_head shca_list;
118 struct ipz_adapter_handle ipz_hca_handle;
119 struct ehca_sport sport[2];
120 struct ehca_eq eq;
121 struct ehca_eq neq;
122 struct ehca_mr *maxmr;
123 struct ehca_pd *pd;
124 struct h_galpas galpas;
125 struct mutex modify_mutex;
126 u64 hca_cap;
127 /* MR pgsize: bit 0-3 means 4K, 64K, 1M, 16M respectively */
128 u32 hca_cap_mr_pgsize;
129 int max_mtu;
130 };
131
132 struct ehca_pd {
133 struct ib_pd ib_pd;
134 struct ipz_pd fw_pd;
135 u32 ownpid;
136 /* small queue mgmt */
137 struct mutex lock;
138 struct list_head free[2];
139 struct list_head full[2];
140 };
141
142 enum ehca_ext_qp_type {
143 EQPT_NORMAL = 0,
144 EQPT_LLQP = 1,
145 EQPT_SRQBASE = 2,
146 EQPT_SRQ = 3,
147 };
148
149 /* struct to cache modify_qp()'s parms for GSI/SMI qp */
150 struct ehca_mod_qp_parm {
151 int mask;
152 struct ib_qp_attr attr;
153 };
154
155 #define EHCA_MOD_QP_PARM_MAX 4
156
157 struct ehca_qp {
158 union {
159 struct ib_qp ib_qp;
160 struct ib_srq ib_srq;
161 };
162 u32 qp_type;
163 enum ehca_ext_qp_type ext_type;
164 struct ipz_queue ipz_squeue;
165 struct ipz_queue ipz_rqueue;
166 struct h_galpas galpas;
167 u32 qkey;
168 u32 real_qp_num;
169 u32 token;
170 spinlock_t spinlock_s;
171 spinlock_t spinlock_r;
172 u32 sq_max_inline_data_size;
173 struct ipz_qp_handle ipz_qp_handle;
174 struct ehca_pfqp pf;
175 struct ib_qp_init_attr init_attr;
176 struct ehca_cq *send_cq;
177 struct ehca_cq *recv_cq;
178 unsigned int sqerr_purgeflag;
179 struct hlist_node list_entries;
180 /* array to cache modify_qp()'s parms for GSI/SMI qp */
181 struct ehca_mod_qp_parm *mod_qp_parm;
182 int mod_qp_parm_idx;
183 /* mmap counter for resources mapped into user space */
184 u32 mm_count_squeue;
185 u32 mm_count_rqueue;
186 u32 mm_count_galpa;
187 /* unsolicited ack circumvention */
188 int unsol_ack_circ;
189 int mtu_shift;
190 u32 message_count;
191 u32 packet_count;
192 };
193
194 #define IS_SRQ(qp) (qp->ext_type == EQPT_SRQ)
195 #define HAS_SQ(qp) (qp->ext_type != EQPT_SRQ)
196 #define HAS_RQ(qp) (qp->ext_type != EQPT_SRQBASE)
197
198 /* must be power of 2 */
199 #define QP_HASHTAB_LEN 8
200
201 struct ehca_cq {
202 struct ib_cq ib_cq;
203 struct ipz_queue ipz_queue;
204 struct h_galpas galpas;
205 spinlock_t spinlock;
206 u32 cq_number;
207 u32 token;
208 u32 nr_of_entries;
209 struct ipz_cq_handle ipz_cq_handle;
210 struct ehca_pfcq pf;
211 spinlock_t cb_lock;
212 struct hlist_head qp_hashtab[QP_HASHTAB_LEN];
213 struct list_head entry;
214 u32 nr_callbacks; /* #events assigned to cpu by scaling code */
215 atomic_t nr_events; /* #events seen */
216 wait_queue_head_t wait_completion;
217 spinlock_t task_lock;
218 u32 ownpid;
219 /* mmap counter for resources mapped into user space */
220 u32 mm_count_queue;
221 u32 mm_count_galpa;
222 };
223
224 enum ehca_mr_flag {
225 EHCA_MR_FLAG_FMR = 0x80000000, /* FMR, created with ehca_alloc_fmr */
226 EHCA_MR_FLAG_MAXMR = 0x40000000, /* max-MR */
227 };
228
229 struct ehca_mr {
230 union {
231 struct ib_mr ib_mr; /* must always be first in ehca_mr */
232 struct ib_fmr ib_fmr; /* must always be first in ehca_mr */
233 } ib;
234 struct ib_umem *umem;
235 spinlock_t mrlock;
236
237 enum ehca_mr_flag flags;
238 u32 num_kpages; /* number of kernel pages */
239 u32 num_hwpages; /* number of hw pages to form MR */
240 u64 hwpage_size; /* hw page size used for this MR */
241 int acl; /* ACL (stored here for usage in reregister) */
242 u64 *start; /* virtual start address (stored here for */
243 /* usage in reregister) */
244 u64 size; /* size (stored here for usage in reregister) */
245 u32 fmr_page_size; /* page size for FMR */
246 u32 fmr_max_pages; /* max pages for FMR */
247 u32 fmr_max_maps; /* max outstanding maps for FMR */
248 u32 fmr_map_cnt; /* map counter for FMR */
249 /* fw specific data */
250 struct ipz_mrmw_handle ipz_mr_handle; /* MR handle for h-calls */
251 struct h_galpas galpas;
252 };
253
254 struct ehca_mw {
255 struct ib_mw ib_mw; /* gen2 mw, must always be first in ehca_mw */
256 spinlock_t mwlock;
257
258 u8 never_bound; /* indication MW was never bound */
259 struct ipz_mrmw_handle ipz_mw_handle; /* MW handle for h-calls */
260 struct h_galpas galpas;
261 };
262
263 enum ehca_mr_pgi_type {
264 EHCA_MR_PGI_PHYS = 1, /* type of ehca_reg_phys_mr,
265 * ehca_rereg_phys_mr,
266 * ehca_reg_internal_maxmr */
267 EHCA_MR_PGI_USER = 2, /* type of ehca_reg_user_mr */
268 EHCA_MR_PGI_FMR = 3 /* type of ehca_map_phys_fmr */
269 };
270
271 struct ehca_mr_pginfo {
272 enum ehca_mr_pgi_type type;
273 u64 num_kpages;
274 u64 kpage_cnt;
275 u64 hwpage_size; /* hw page size used for this MR */
276 u64 num_hwpages; /* number of hw pages */
277 u64 hwpage_cnt; /* counter for hw pages */
278 u64 next_hwpage; /* next hw page in buffer/chunk/listelem */
279
280 union {
281 struct { /* type EHCA_MR_PGI_PHYS section */
282 int num_phys_buf;
283 struct ib_phys_buf *phys_buf_array;
284 u64 next_buf;
285 } phy;
286 struct { /* type EHCA_MR_PGI_USER section */
287 struct ib_umem *region;
288 struct ib_umem_chunk *next_chunk;
289 u64 next_nmap;
290 } usr;
291 struct { /* type EHCA_MR_PGI_FMR section */
292 u64 fmr_pgsize;
293 u64 *page_list;
294 u64 next_listelem;
295 } fmr;
296 } u;
297 };
298
299 /* output parameters for MR/FMR hipz calls */
300 struct ehca_mr_hipzout_parms {
301 struct ipz_mrmw_handle handle;
302 u32 lkey;
303 u32 rkey;
304 u64 len;
305 u64 vaddr;
306 u32 acl;
307 };
308
309 /* output parameters for MW hipz calls */
310 struct ehca_mw_hipzout_parms {
311 struct ipz_mrmw_handle handle;
312 u32 rkey;
313 };
314
315 struct ehca_av {
316 struct ib_ah ib_ah;
317 struct ehca_ud_av av;
318 };
319
320 struct ehca_ucontext {
321 struct ib_ucontext ib_ucontext;
322 };
323
324 int ehca_init_pd_cache(void);
325 void ehca_cleanup_pd_cache(void);
326 int ehca_init_cq_cache(void);
327 void ehca_cleanup_cq_cache(void);
328 int ehca_init_qp_cache(void);
329 void ehca_cleanup_qp_cache(void);
330 int ehca_init_av_cache(void);
331 void ehca_cleanup_av_cache(void);
332 int ehca_init_mrmw_cache(void);
333 void ehca_cleanup_mrmw_cache(void);
334 int ehca_init_small_qp_cache(void);
335 void ehca_cleanup_small_qp_cache(void);
336
337 extern rwlock_t ehca_qp_idr_lock;
338 extern rwlock_t ehca_cq_idr_lock;
339 extern struct idr ehca_qp_idr;
340 extern struct idr ehca_cq_idr;
341
342 extern int ehca_static_rate;
343 extern int ehca_port_act_time;
344 extern int ehca_use_hp_mr;
345 extern int ehca_scaling_code;
346 extern int ehca_lock_hcalls;
347 extern int ehca_nr_ports;
348
349 struct ipzu_queue_resp {
350 u32 qe_size; /* queue entry size */
351 u32 act_nr_of_sg;
352 u32 queue_length; /* queue length allocated in bytes */
353 u32 pagesize;
354 u32 toggle_state;
355 u32 offset; /* save offset within a page for small_qp */
356 };
357
358 struct ehca_create_cq_resp {
359 u32 cq_number;
360 u32 token;
361 struct ipzu_queue_resp ipz_queue;
362 u32 fw_handle_ofs;
363 u32 dummy;
364 };
365
366 struct ehca_create_qp_resp {
367 u32 qp_num;
368 u32 token;
369 u32 qp_type;
370 u32 ext_type;
371 u32 qkey;
372 /* qp_num assigned by ehca: sqp0/1 may have got different numbers */
373 u32 real_qp_num;
374 u32 fw_handle_ofs;
375 u32 dummy;
376 struct ipzu_queue_resp ipz_squeue;
377 struct ipzu_queue_resp ipz_rqueue;
378 };
379
380 struct ehca_alloc_cq_parms {
381 u32 nr_cqe;
382 u32 act_nr_of_entries;
383 u32 act_pages;
384 struct ipz_eq_handle eq_handle;
385 };
386
387 enum ehca_service_type {
388 ST_RC = 0,
389 ST_UC = 1,
390 ST_RD = 2,
391 ST_UD = 3,
392 };
393
394 enum ehca_ll_comp_flags {
395 LLQP_SEND_COMP = 0x20,
396 LLQP_RECV_COMP = 0x40,
397 LLQP_COMP_MASK = 0x60,
398 };
399
400 struct ehca_alloc_queue_parms {
401 /* input parameters */
402 int max_wr;
403 int max_sge;
404 int page_size;
405 int is_small;
406
407 /* output parameters */
408 u16 act_nr_wqes;
409 u8 act_nr_sges;
410 u32 queue_size; /* bytes for small queues, pages otherwise */
411 };
412
413 struct ehca_alloc_qp_parms {
414 struct ehca_alloc_queue_parms squeue;
415 struct ehca_alloc_queue_parms rqueue;
416
417 /* input parameters */
418 enum ehca_service_type servicetype;
419 int qp_storage;
420 int sigtype;
421 enum ehca_ext_qp_type ext_type;
422 enum ehca_ll_comp_flags ll_comp_flags;
423 int ud_av_l_key_ctl;
424
425 u32 token;
426 struct ipz_eq_handle eq_handle;
427 struct ipz_pd pd;
428 struct ipz_cq_handle send_cq_handle, recv_cq_handle;
429
430 u32 srq_qpn, srq_token, srq_limit;
431
432 /* output parameters */
433 u32 real_qp_num;
434 struct ipz_qp_handle qp_handle;
435 struct h_galpas galpas;
436 };
437
438 int ehca_cq_assign_qp(struct ehca_cq *cq, struct ehca_qp *qp);
439 int ehca_cq_unassign_qp(struct ehca_cq *cq, unsigned int qp_num);
440 struct ehca_qp *ehca_cq_get_qp(struct ehca_cq *cq, int qp_num);
441
442 #endif
443
|
This page was automatically generated by the
LXR engine.
|