1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46#include "ehca_iverbs.h"
47#include "ehca_classes.h"
48#include "ehca_irq.h"
49#include "hcp_if.h"
50
51static struct kmem_cache *cq_cache;
52
53int ehca_cq_assign_qp(struct ehca_cq *cq, struct ehca_qp *qp)
54{
55 unsigned int qp_num = qp->real_qp_num;
56 unsigned int key = qp_num & (QP_HASHTAB_LEN-1);
57 unsigned long flags;
58
59 spin_lock_irqsave(&cq->spinlock, flags);
60 hlist_add_head(&qp->list_entries, &cq->qp_hashtab[key]);
61 spin_unlock_irqrestore(&cq->spinlock, flags);
62
63 ehca_dbg(cq->ib_cq.device, "cq_num=%x real_qp_num=%x",
64 cq->cq_number, qp_num);
65
66 return 0;
67}
68
69int ehca_cq_unassign_qp(struct ehca_cq *cq, unsigned int real_qp_num)
70{
71 int ret = -EINVAL;
72 unsigned int key = real_qp_num & (QP_HASHTAB_LEN-1);
73 struct hlist_node *iter;
74 struct ehca_qp *qp;
75 unsigned long flags;
76
77 spin_lock_irqsave(&cq->spinlock, flags);
78 hlist_for_each(iter, &cq->qp_hashtab[key]) {
79 qp = hlist_entry(iter, struct ehca_qp, list_entries);
80 if (qp->real_qp_num == real_qp_num) {
81 hlist_del(iter);
82 ehca_dbg(cq->ib_cq.device,
83 "removed qp from cq .cq_num=%x real_qp_num=%x",
84 cq->cq_number, real_qp_num);
85 ret = 0;
86 break;
87 }
88 }
89 spin_unlock_irqrestore(&cq->spinlock, flags);
90 if (ret)
91 ehca_err(cq->ib_cq.device,
92 "qp not found cq_num=%x real_qp_num=%x",
93 cq->cq_number, real_qp_num);
94
95 return ret;
96}
97
98struct ehca_qp *ehca_cq_get_qp(struct ehca_cq *cq, int real_qp_num)
99{
100 struct ehca_qp *ret = NULL;
101 unsigned int key = real_qp_num & (QP_HASHTAB_LEN-1);
102 struct hlist_node *iter;
103 struct ehca_qp *qp;
104 hlist_for_each(iter, &cq->qp_hashtab[key]) {
105 qp = hlist_entry(iter, struct ehca_qp, list_entries);
106 if (qp->real_qp_num == real_qp_num) {
107 ret = qp;
108 break;
109 }
110 }
111 return ret;
112}
113
114struct ib_cq *ehca_create_cq(struct ib_device *device, int cqe, int comp_vector,
115 struct ib_ucontext *context,
116 struct ib_udata *udata)
117{
118 static const u32 additional_cqe = 20;
119 struct ib_cq *cq;
120 struct ehca_cq *my_cq;
121 struct ehca_shca *shca =
122 container_of(device, struct ehca_shca, ib_device);
123 struct ipz_adapter_handle adapter_handle;
124 struct ehca_alloc_cq_parms param;
125 struct h_galpa gal;
126 void *vpage;
127 u32 counter;
128 u64 rpage, cqx_fec, h_ret;
129 int ipz_rc, ret, i;
130 unsigned long flags;
131
132 if (cqe >= 0xFFFFFFFF - 64 - additional_cqe)
133 return ERR_PTR(-EINVAL);
134
135 if (!atomic_add_unless(&shca->num_cqs, 1, shca->max_num_cqs)) {
136 ehca_err(device, "Unable to create CQ, max number of %i "
137 "CQs reached.", shca->max_num_cqs);
138 ehca_err(device, "To increase the maximum number of CQs "
139 "use the number_of_cqs module parameter.\n");
140 return ERR_PTR(-ENOSPC);
141 }
142
143 my_cq = kmem_cache_zalloc(cq_cache, GFP_KERNEL);
144 if (!my_cq) {
145 ehca_err(device, "Out of memory for ehca_cq struct device=%p",
146 device);
147 atomic_dec(&shca->num_cqs);
148 return ERR_PTR(-ENOMEM);
149 }
150
151 memset(¶m, 0, sizeof(struct ehca_alloc_cq_parms));
152
153 spin_lock_init(&my_cq->spinlock);
154 spin_lock_init(&my_cq->cb_lock);
155 spin_lock_init(&my_cq->task_lock);
156 atomic_set(&my_cq->nr_events, 0);
157 init_waitqueue_head(&my_cq->wait_completion);
158
159 cq = &my_cq->ib_cq;
160
161 adapter_handle = shca->ipz_hca_handle;
162 param.eq_handle = shca->eq.ipz_eq_handle;
163
164 do {
165 if (!idr_pre_get(&ehca_cq_idr, GFP_KERNEL)) {
166 cq = ERR_PTR(-ENOMEM);
167 ehca_err(device, "Can't reserve idr nr. device=%p",
168 device);
169 goto create_cq_exit1;
170 }
171
172 write_lock_irqsave(&ehca_cq_idr_lock, flags);
173 ret = idr_get_new(&ehca_cq_idr, my_cq, &my_cq->token);
174 write_unlock_irqrestore(&ehca_cq_idr_lock, flags);
175 } while (ret == -EAGAIN);
176
177 if (ret) {
178 cq = ERR_PTR(-ENOMEM);
179 ehca_err(device, "Can't allocate new idr entry. device=%p",
180 device);
181 goto create_cq_exit1;
182 }
183
184 if (my_cq->token > 0x1FFFFFF) {
185 cq = ERR_PTR(-ENOMEM);
186 ehca_err(device, "Invalid number of cq. device=%p", device);
187 goto create_cq_exit2;
188 }
189
190
191
192
193
194 param.nr_cqe = cqe + additional_cqe;
195 h_ret = hipz_h_alloc_resource_cq(adapter_handle, my_cq, ¶m);
196
197 if (h_ret != H_SUCCESS) {
198 ehca_err(device, "hipz_h_alloc_resource_cq() failed "
199 "h_ret=%lli device=%p", h_ret, device);
200 cq = ERR_PTR(ehca2ib_return_code(h_ret));
201 goto create_cq_exit2;
202 }
203
204 ipz_rc = ipz_queue_ctor(NULL, &my_cq->ipz_queue, param.act_pages,
205 EHCA_PAGESIZE, sizeof(struct ehca_cqe), 0, 0);
206 if (!ipz_rc) {
207 ehca_err(device, "ipz_queue_ctor() failed ipz_rc=%i device=%p",
208 ipz_rc, device);
209 cq = ERR_PTR(-EINVAL);
210 goto create_cq_exit3;
211 }
212
213 for (counter = 0; counter < param.act_pages; counter++) {
214 vpage = ipz_qpageit_get_inc(&my_cq->ipz_queue);
215 if (!vpage) {
216 ehca_err(device, "ipz_qpageit_get_inc() "
217 "returns NULL device=%p", device);
218 cq = ERR_PTR(-EAGAIN);
219 goto create_cq_exit4;
220 }
221 rpage = virt_to_abs(vpage);
222
223 h_ret = hipz_h_register_rpage_cq(adapter_handle,
224 my_cq->ipz_cq_handle,
225 &my_cq->pf,
226 0,
227 0,
228 rpage,
229 1,
230 my_cq->galpas.
231 kernel);
232
233 if (h_ret < H_SUCCESS) {
234 ehca_err(device, "hipz_h_register_rpage_cq() failed "
235 "ehca_cq=%p cq_num=%x h_ret=%lli counter=%i "
236 "act_pages=%i", my_cq, my_cq->cq_number,
237 h_ret, counter, param.act_pages);
238 cq = ERR_PTR(-EINVAL);
239 goto create_cq_exit4;
240 }
241
242 if (counter == (param.act_pages - 1)) {
243 vpage = ipz_qpageit_get_inc(&my_cq->ipz_queue);
244 if ((h_ret != H_SUCCESS) || vpage) {
245 ehca_err(device, "Registration of pages not "
246 "complete ehca_cq=%p cq_num=%x "
247 "h_ret=%lli", my_cq, my_cq->cq_number,
248 h_ret);
249 cq = ERR_PTR(-EAGAIN);
250 goto create_cq_exit4;
251 }
252 } else {
253 if (h_ret != H_PAGE_REGISTERED) {
254 ehca_err(device, "Registration of page failed "
255 "ehca_cq=%p cq_num=%x h_ret=%lli "
256 "counter=%i act_pages=%i",
257 my_cq, my_cq->cq_number,
258 h_ret, counter, param.act_pages);
259 cq = ERR_PTR(-ENOMEM);
260 goto create_cq_exit4;
261 }
262 }
263 }
264
265 ipz_qeit_reset(&my_cq->ipz_queue);
266
267 gal = my_cq->galpas.kernel;
268 cqx_fec = hipz_galpa_load(gal, CQTEMM_OFFSET(cqx_fec));
269 ehca_dbg(device, "ehca_cq=%p cq_num=%x CQX_FEC=%llx",
270 my_cq, my_cq->cq_number, cqx_fec);
271
272 my_cq->ib_cq.cqe = my_cq->nr_of_entries =
273 param.act_nr_of_entries - additional_cqe;
274 my_cq->cq_number = (my_cq->ipz_cq_handle.handle) & 0xffff;
275
276 for (i = 0; i < QP_HASHTAB_LEN; i++)
277 INIT_HLIST_HEAD(&my_cq->qp_hashtab[i]);
278
279 INIT_LIST_HEAD(&my_cq->sqp_err_list);
280 INIT_LIST_HEAD(&my_cq->rqp_err_list);
281
282 if (context) {
283 struct ipz_queue *ipz_queue = &my_cq->ipz_queue;
284 struct ehca_create_cq_resp resp;
285 memset(&resp, 0, sizeof(resp));
286 resp.cq_number = my_cq->cq_number;
287 resp.token = my_cq->token;
288 resp.ipz_queue.qe_size = ipz_queue->qe_size;
289 resp.ipz_queue.act_nr_of_sg = ipz_queue->act_nr_of_sg;
290 resp.ipz_queue.queue_length = ipz_queue->queue_length;
291 resp.ipz_queue.pagesize = ipz_queue->pagesize;
292 resp.ipz_queue.toggle_state = ipz_queue->toggle_state;
293 resp.fw_handle_ofs = (u32)
294 (my_cq->galpas.user.fw_handle & (PAGE_SIZE - 1));
295 if (ib_copy_to_udata(udata, &resp, sizeof(resp))) {
296 ehca_err(device, "Copy to udata failed.");
297 goto create_cq_exit4;
298 }
299 }
300
301 return cq;
302
303create_cq_exit4:
304 ipz_queue_dtor(NULL, &my_cq->ipz_queue);
305
306create_cq_exit3:
307 h_ret = hipz_h_destroy_cq(adapter_handle, my_cq, 1);
308 if (h_ret != H_SUCCESS)
309 ehca_err(device, "hipz_h_destroy_cq() failed ehca_cq=%p "
310 "cq_num=%x h_ret=%lli", my_cq, my_cq->cq_number, h_ret);
311
312create_cq_exit2:
313 write_lock_irqsave(&ehca_cq_idr_lock, flags);
314 idr_remove(&ehca_cq_idr, my_cq->token);
315 write_unlock_irqrestore(&ehca_cq_idr_lock, flags);
316
317create_cq_exit1:
318 kmem_cache_free(cq_cache, my_cq);
319
320 atomic_dec(&shca->num_cqs);
321 return cq;
322}
323
324int ehca_destroy_cq(struct ib_cq *cq)
325{
326 u64 h_ret;
327 struct ehca_cq *my_cq = container_of(cq, struct ehca_cq, ib_cq);
328 int cq_num = my_cq->cq_number;
329 struct ib_device *device = cq->device;
330 struct ehca_shca *shca = container_of(device, struct ehca_shca,
331 ib_device);
332 struct ipz_adapter_handle adapter_handle = shca->ipz_hca_handle;
333 unsigned long flags;
334
335 if (cq->uobject) {
336 if (my_cq->mm_count_galpa || my_cq->mm_count_queue) {
337 ehca_err(device, "Resources still referenced in "
338 "user space cq_num=%x", my_cq->cq_number);
339 return -EINVAL;
340 }
341 }
342
343
344
345
346
347 write_lock_irqsave(&ehca_cq_idr_lock, flags);
348 idr_remove(&ehca_cq_idr, my_cq->token);
349 write_unlock_irqrestore(&ehca_cq_idr_lock, flags);
350
351
352 wait_event(my_cq->wait_completion, !atomic_read(&my_cq->nr_events));
353
354
355 h_ret = hipz_h_destroy_cq(adapter_handle, my_cq, 0);
356 if (h_ret == H_R_STATE) {
357
358 ehca_dbg(device, "ehca_cq=%p cq_num=%x resource=%llx in err "
359 "state. Try to delete it forcibly.",
360 my_cq, cq_num, my_cq->ipz_cq_handle.handle);
361 ehca_error_data(shca, my_cq, my_cq->ipz_cq_handle.handle);
362 h_ret = hipz_h_destroy_cq(adapter_handle, my_cq, 1);
363 if (h_ret == H_SUCCESS)
364 ehca_dbg(device, "cq_num=%x deleted successfully.",
365 cq_num);
366 }
367 if (h_ret != H_SUCCESS) {
368 ehca_err(device, "hipz_h_destroy_cq() failed h_ret=%lli "
369 "ehca_cq=%p cq_num=%x", h_ret, my_cq, cq_num);
370 return ehca2ib_return_code(h_ret);
371 }
372 ipz_queue_dtor(NULL, &my_cq->ipz_queue);
373 kmem_cache_free(cq_cache, my_cq);
374
375 atomic_dec(&shca->num_cqs);
376 return 0;
377}
378
379int ehca_resize_cq(struct ib_cq *cq, int cqe, struct ib_udata *udata)
380{
381
382 ehca_err(cq->device, "not implemented yet");
383
384 return -EFAULT;
385}
386
387int ehca_init_cq_cache(void)
388{
389 cq_cache = kmem_cache_create("ehca_cache_cq",
390 sizeof(struct ehca_cq), 0,
391 SLAB_HWCACHE_ALIGN,
392 NULL);
393 if (!cq_cache)
394 return -ENOMEM;
395 return 0;
396}
397
398void ehca_cleanup_cq_cache(void)
399{
400 if (cq_cache)
401 kmem_cache_destroy(cq_cache);
402}
403
