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#include <linux/module.h>
35#include <linux/moduleparam.h>
36#include <linux/random.h>
37#include <linux/highmem.h>
38#include <asm/byteorder.h>
39
40#include <rdma/ib_verbs.h>
41#include <rdma/iw_cm.h>
42#include <rdma/ib_user_verbs.h>
43
44#include "nes.h"
45
46#include <rdma/ib_umem.h>
47
48atomic_t mod_qp_timouts;
49atomic_t qps_created;
50atomic_t sw_qps_destroyed;
51
52static void nes_unregister_ofa_device(struct nes_ib_device *nesibdev);
53
54
55
56
57static struct ib_mw *nes_alloc_mw(struct ib_pd *ibpd) {
58 struct nes_pd *nespd = to_nespd(ibpd);
59 struct nes_vnic *nesvnic = to_nesvnic(ibpd->device);
60 struct nes_device *nesdev = nesvnic->nesdev;
61 struct nes_adapter *nesadapter = nesdev->nesadapter;
62 struct nes_cqp_request *cqp_request;
63 struct nes_mr *nesmr;
64 struct ib_mw *ibmw;
65 struct nes_hw_cqp_wqe *cqp_wqe;
66 int ret;
67 u32 stag;
68 u32 stag_index = 0;
69 u32 next_stag_index = 0;
70 u32 driver_key = 0;
71 u8 stag_key = 0;
72
73 get_random_bytes(&next_stag_index, sizeof(next_stag_index));
74 stag_key = (u8)next_stag_index;
75
76 driver_key = 0;
77
78 next_stag_index >>= 8;
79 next_stag_index %= nesadapter->max_mr;
80
81 ret = nes_alloc_resource(nesadapter, nesadapter->allocated_mrs,
82 nesadapter->max_mr, &stag_index, &next_stag_index);
83 if (ret) {
84 return ERR_PTR(ret);
85 }
86
87 nesmr = kzalloc(sizeof(*nesmr), GFP_KERNEL);
88 if (!nesmr) {
89 nes_free_resource(nesadapter, nesadapter->allocated_mrs, stag_index);
90 return ERR_PTR(-ENOMEM);
91 }
92
93 stag = stag_index << 8;
94 stag |= driver_key;
95 stag += (u32)stag_key;
96
97 nes_debug(NES_DBG_MR, "Registering STag 0x%08X, index = 0x%08X\n",
98 stag, stag_index);
99
100
101 cqp_request = nes_get_cqp_request(nesdev);
102 if (cqp_request == NULL) {
103 kfree(nesmr);
104 nes_free_resource(nesadapter, nesadapter->allocated_mrs, stag_index);
105 return ERR_PTR(-ENOMEM);
106 }
107
108 cqp_request->waiting = 1;
109 cqp_wqe = &cqp_request->cqp_wqe;
110
111 cqp_wqe->wqe_words[NES_CQP_WQE_OPCODE_IDX] =
112 cpu_to_le32( NES_CQP_ALLOCATE_STAG | NES_CQP_STAG_RIGHTS_REMOTE_READ |
113 NES_CQP_STAG_RIGHTS_REMOTE_WRITE | NES_CQP_STAG_VA_TO |
114 NES_CQP_STAG_REM_ACC_EN);
115
116 nes_fill_init_cqp_wqe(cqp_wqe, nesdev);
117 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_STAG_WQE_LEN_HIGH_PD_IDX, (nespd->pd_id & 0x00007fff));
118 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_STAG_WQE_STAG_IDX, stag);
119
120 atomic_set(&cqp_request->refcount, 2);
121 nes_post_cqp_request(nesdev, cqp_request);
122
123
124 ret = wait_event_timeout(cqp_request->waitq, (cqp_request->request_done != 0),
125 NES_EVENT_TIMEOUT);
126 nes_debug(NES_DBG_MR, "Register STag 0x%08X completed, wait_event_timeout ret = %u,"
127 " CQP Major:Minor codes = 0x%04X:0x%04X.\n",
128 stag, ret, cqp_request->major_code, cqp_request->minor_code);
129 if ((!ret) || (cqp_request->major_code)) {
130 nes_put_cqp_request(nesdev, cqp_request);
131 kfree(nesmr);
132 nes_free_resource(nesadapter, nesadapter->allocated_mrs, stag_index);
133 if (!ret) {
134 return ERR_PTR(-ETIME);
135 } else {
136 return ERR_PTR(-ENOMEM);
137 }
138 }
139 nes_put_cqp_request(nesdev, cqp_request);
140
141 nesmr->ibmw.rkey = stag;
142 nesmr->mode = IWNES_MEMREG_TYPE_MW;
143 ibmw = &nesmr->ibmw;
144 nesmr->pbl_4k = 0;
145 nesmr->pbls_used = 0;
146
147 return ibmw;
148}
149
150
151
152
153
154static int nes_dealloc_mw(struct ib_mw *ibmw)
155{
156 struct nes_mr *nesmr = to_nesmw(ibmw);
157 struct nes_vnic *nesvnic = to_nesvnic(ibmw->device);
158 struct nes_device *nesdev = nesvnic->nesdev;
159 struct nes_adapter *nesadapter = nesdev->nesadapter;
160 struct nes_hw_cqp_wqe *cqp_wqe;
161 struct nes_cqp_request *cqp_request;
162 int err = 0;
163 int ret;
164
165
166 cqp_request = nes_get_cqp_request(nesdev);
167 if (cqp_request == NULL) {
168 nes_debug(NES_DBG_MR, "Failed to get a cqp_request.\n");
169 return -ENOMEM;
170 }
171 cqp_request->waiting = 1;
172 cqp_wqe = &cqp_request->cqp_wqe;
173 nes_fill_init_cqp_wqe(cqp_wqe, nesdev);
174 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_OPCODE_IDX, NES_CQP_DEALLOCATE_STAG);
175 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_STAG_WQE_STAG_IDX, ibmw->rkey);
176
177 atomic_set(&cqp_request->refcount, 2);
178 nes_post_cqp_request(nesdev, cqp_request);
179
180
181 nes_debug(NES_DBG_MR, "Waiting for deallocate STag 0x%08X to complete.\n",
182 ibmw->rkey);
183 ret = wait_event_timeout(cqp_request->waitq, (0 != cqp_request->request_done),
184 NES_EVENT_TIMEOUT);
185 nes_debug(NES_DBG_MR, "Deallocate STag completed, wait_event_timeout ret = %u,"
186 " CQP Major:Minor codes = 0x%04X:0x%04X.\n",
187 ret, cqp_request->major_code, cqp_request->minor_code);
188 if (!ret)
189 err = -ETIME;
190 else if (cqp_request->major_code)
191 err = -EIO;
192
193 nes_put_cqp_request(nesdev, cqp_request);
194
195 nes_free_resource(nesadapter, nesadapter->allocated_mrs,
196 (ibmw->rkey & 0x0fffff00) >> 8);
197 kfree(nesmr);
198
199 return err;
200}
201
202
203
204
205
206static int nes_bind_mw(struct ib_qp *ibqp, struct ib_mw *ibmw,
207 struct ib_mw_bind *ibmw_bind)
208{
209 u64 u64temp;
210 struct nes_vnic *nesvnic = to_nesvnic(ibqp->device);
211 struct nes_device *nesdev = nesvnic->nesdev;
212
213 struct nes_qp *nesqp = to_nesqp(ibqp);
214 struct nes_hw_qp_wqe *wqe;
215 unsigned long flags = 0;
216 u32 head;
217 u32 wqe_misc = 0;
218 u32 qsize;
219
220 if (nesqp->ibqp_state > IB_QPS_RTS)
221 return -EINVAL;
222
223 spin_lock_irqsave(&nesqp->lock, flags);
224
225 head = nesqp->hwqp.sq_head;
226 qsize = nesqp->hwqp.sq_tail;
227
228
229 if (((head + (2 * qsize) - nesqp->hwqp.sq_tail) % qsize) == (qsize - 1)) {
230 spin_unlock_irqrestore(&nesqp->lock, flags);
231 return -EINVAL;
232 }
233
234 wqe = &nesqp->hwqp.sq_vbase[head];
235
236 nes_fill_init_qp_wqe(wqe, nesqp, head);
237 u64temp = ibmw_bind->wr_id;
238 set_wqe_64bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_COMP_SCRATCH_LOW_IDX, u64temp);
239 wqe_misc = NES_IWARP_SQ_OP_BIND;
240
241 wqe_misc |= NES_IWARP_SQ_WQE_LOCAL_FENCE;
242
243 if (ibmw_bind->send_flags & IB_SEND_SIGNALED)
244 wqe_misc |= NES_IWARP_SQ_WQE_SIGNALED_COMPL;
245
246 if (ibmw_bind->mw_access_flags & IB_ACCESS_REMOTE_WRITE) {
247 wqe_misc |= NES_CQP_STAG_RIGHTS_REMOTE_WRITE;
248 }
249 if (ibmw_bind->mw_access_flags & IB_ACCESS_REMOTE_READ) {
250 wqe_misc |= NES_CQP_STAG_RIGHTS_REMOTE_READ;
251 }
252
253 set_wqe_32bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_MISC_IDX, wqe_misc);
254 set_wqe_32bit_value(wqe->wqe_words, NES_IWARP_SQ_BIND_WQE_MR_IDX, ibmw_bind->mr->lkey);
255 set_wqe_32bit_value(wqe->wqe_words, NES_IWARP_SQ_BIND_WQE_MW_IDX, ibmw->rkey);
256 set_wqe_32bit_value(wqe->wqe_words, NES_IWARP_SQ_BIND_WQE_LENGTH_LOW_IDX,
257 ibmw_bind->length);
258 wqe->wqe_words[NES_IWARP_SQ_BIND_WQE_LENGTH_HIGH_IDX] = 0;
259 u64temp = (u64)ibmw_bind->addr;
260 set_wqe_64bit_value(wqe->wqe_words, NES_IWARP_SQ_BIND_WQE_VA_FBO_LOW_IDX, u64temp);
261
262 head++;
263 if (head >= qsize)
264 head = 0;
265
266 nesqp->hwqp.sq_head = head;
267 barrier();
268
269 nes_write32(nesdev->regs+NES_WQE_ALLOC,
270 (1 << 24) | 0x00800000 | nesqp->hwqp.qp_id);
271
272 spin_unlock_irqrestore(&nesqp->lock, flags);
273
274 return 0;
275}
276
277
278
279
280
281static struct ib_fmr *nes_alloc_fmr(struct ib_pd *ibpd,
282 int ibmr_access_flags,
283 struct ib_fmr_attr *ibfmr_attr)
284{
285 unsigned long flags;
286 struct nes_pd *nespd = to_nespd(ibpd);
287 struct nes_vnic *nesvnic = to_nesvnic(ibpd->device);
288 struct nes_device *nesdev = nesvnic->nesdev;
289 struct nes_adapter *nesadapter = nesdev->nesadapter;
290 struct nes_fmr *nesfmr;
291 struct nes_cqp_request *cqp_request;
292 struct nes_hw_cqp_wqe *cqp_wqe;
293 int ret;
294 u32 stag;
295 u32 stag_index = 0;
296 u32 next_stag_index = 0;
297 u32 driver_key = 0;
298 u32 opcode = 0;
299 u8 stag_key = 0;
300 int i=0;
301 struct nes_vpbl vpbl;
302
303 get_random_bytes(&next_stag_index, sizeof(next_stag_index));
304 stag_key = (u8)next_stag_index;
305
306 driver_key = 0;
307
308 next_stag_index >>= 8;
309 next_stag_index %= nesadapter->max_mr;
310
311 ret = nes_alloc_resource(nesadapter, nesadapter->allocated_mrs,
312 nesadapter->max_mr, &stag_index, &next_stag_index);
313 if (ret) {
314 goto failed_resource_alloc;
315 }
316
317 nesfmr = kzalloc(sizeof(*nesfmr), GFP_KERNEL);
318 if (!nesfmr) {
319 ret = -ENOMEM;
320 goto failed_fmr_alloc;
321 }
322
323 nesfmr->nesmr.mode = IWNES_MEMREG_TYPE_FMR;
324 if (ibfmr_attr->max_pages == 1) {
325
326 nesfmr->nesmr.pbl_4k = 0;
327 nesfmr->nesmr.pbls_used = 0;
328 } else if (ibfmr_attr->max_pages <= 32) {
329
330 nesfmr->nesmr.pbl_4k = 0;
331 nesfmr->nesmr.pbls_used = 1;
332 } else if (ibfmr_attr->max_pages <= 512) {
333
334 nesfmr->nesmr.pbl_4k = 1;
335 nesfmr->nesmr.pbls_used = 1;
336 } else {
337
338
339 nesfmr->nesmr.pbl_4k = 1;
340 nesfmr->nesmr.pbls_used = 1 + (ibfmr_attr->max_pages >> 9) +
341 ((ibfmr_attr->max_pages & 511) ? 1 : 0);
342 }
343
344 spin_lock_irqsave(&nesadapter->pbl_lock, flags);
345
346
347 if (nesfmr->nesmr.pbls_used != 0) {
348 if (nesfmr->nesmr.pbl_4k) {
349 if (nesfmr->nesmr.pbls_used > nesadapter->free_4kpbl) {
350 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
351 ret = -ENOMEM;
352 goto failed_vpbl_avail;
353 } else {
354 nesadapter->free_4kpbl -= nesfmr->nesmr.pbls_used;
355 }
356 } else {
357 if (nesfmr->nesmr.pbls_used > nesadapter->free_256pbl) {
358 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
359 ret = -ENOMEM;
360 goto failed_vpbl_avail;
361 } else {
362 nesadapter->free_256pbl -= nesfmr->nesmr.pbls_used;
363 }
364 }
365 }
366
367
368 if (nesfmr->nesmr.pbls_used == 0) {
369 nesfmr->root_vpbl.pbl_vbase = NULL;
370 nes_debug(NES_DBG_MR, "zero level pbl \n");
371 } else if (nesfmr->nesmr.pbls_used == 1) {
372
373 nesfmr->root_vpbl.pbl_vbase = pci_alloc_consistent(nesdev->pcidev, 4096,
374 &nesfmr->root_vpbl.pbl_pbase);
375 if (!nesfmr->root_vpbl.pbl_vbase) {
376 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
377 ret = -ENOMEM;
378 goto failed_vpbl_alloc;
379 }
380 nesfmr->leaf_pbl_cnt = 0;
381 nes_debug(NES_DBG_MR, "one level pbl, root_vpbl.pbl_vbase=%p \n",
382 nesfmr->root_vpbl.pbl_vbase);
383 }
384
385 else {
386 nesfmr->root_vpbl.pbl_vbase = pci_alloc_consistent(nesdev->pcidev, 8192,
387 &nesfmr->root_vpbl.pbl_pbase);
388 if (!nesfmr->root_vpbl.pbl_vbase) {
389 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
390 ret = -ENOMEM;
391 goto failed_vpbl_alloc;
392 }
393
394 nesfmr->leaf_pbl_cnt = nesfmr->nesmr.pbls_used-1;
395 nesfmr->root_vpbl.leaf_vpbl = kzalloc(sizeof(*nesfmr->root_vpbl.leaf_vpbl)*1024, GFP_ATOMIC);
396 if (!nesfmr->root_vpbl.leaf_vpbl) {
397 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
398 ret = -ENOMEM;
399 goto failed_leaf_vpbl_alloc;
400 }
401
402 nes_debug(NES_DBG_MR, "two level pbl, root_vpbl.pbl_vbase=%p"
403 " leaf_pbl_cnt=%d root_vpbl.leaf_vpbl=%p\n",
404 nesfmr->root_vpbl.pbl_vbase, nesfmr->leaf_pbl_cnt, nesfmr->root_vpbl.leaf_vpbl);
405
406 for (i=0; i<nesfmr->leaf_pbl_cnt; i++)
407 nesfmr->root_vpbl.leaf_vpbl[i].pbl_vbase = NULL;
408
409 for (i=0; i<nesfmr->leaf_pbl_cnt; i++) {
410 vpbl.pbl_vbase = pci_alloc_consistent(nesdev->pcidev, 4096,
411 &vpbl.pbl_pbase);
412
413 if (!vpbl.pbl_vbase) {
414 ret = -ENOMEM;
415 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
416 goto failed_leaf_vpbl_pages_alloc;
417 }
418
419 nesfmr->root_vpbl.pbl_vbase[i].pa_low = cpu_to_le32((u32)vpbl.pbl_pbase);
420 nesfmr->root_vpbl.pbl_vbase[i].pa_high = cpu_to_le32((u32)((((u64)vpbl.pbl_pbase)>>32)));
421 nesfmr->root_vpbl.leaf_vpbl[i] = vpbl;
422
423 nes_debug(NES_DBG_MR, "pbase_low=0x%x, pbase_high=0x%x, vpbl=%p\n",
424 nesfmr->root_vpbl.pbl_vbase[i].pa_low,
425 nesfmr->root_vpbl.pbl_vbase[i].pa_high,
426 &nesfmr->root_vpbl.leaf_vpbl[i]);
427 }
428 }
429 nesfmr->ib_qp = NULL;
430 nesfmr->access_rights =0;
431
432 stag = stag_index << 8;
433 stag |= driver_key;
434 stag += (u32)stag_key;
435
436 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
437 cqp_request = nes_get_cqp_request(nesdev);
438 if (cqp_request == NULL) {
439 nes_debug(NES_DBG_MR, "Failed to get a cqp_request.\n");
440 ret = -ENOMEM;
441 goto failed_leaf_vpbl_pages_alloc;
442 }
443 cqp_request->waiting = 1;
444 cqp_wqe = &cqp_request->cqp_wqe;
445
446 nes_debug(NES_DBG_MR, "Registering STag 0x%08X, index = 0x%08X\n",
447 stag, stag_index);
448
449 opcode = NES_CQP_ALLOCATE_STAG | NES_CQP_STAG_VA_TO | NES_CQP_STAG_MR;
450
451 if (nesfmr->nesmr.pbl_4k == 1)
452 opcode |= NES_CQP_STAG_PBL_BLK_SIZE;
453
454 if (ibmr_access_flags & IB_ACCESS_REMOTE_WRITE) {
455 opcode |= NES_CQP_STAG_RIGHTS_REMOTE_WRITE |
456 NES_CQP_STAG_RIGHTS_LOCAL_WRITE | NES_CQP_STAG_REM_ACC_EN;
457 nesfmr->access_rights |=
458 NES_CQP_STAG_RIGHTS_REMOTE_WRITE | NES_CQP_STAG_RIGHTS_LOCAL_WRITE |
459 NES_CQP_STAG_REM_ACC_EN;
460 }
461
462 if (ibmr_access_flags & IB_ACCESS_REMOTE_READ) {
463 opcode |= NES_CQP_STAG_RIGHTS_REMOTE_READ |
464 NES_CQP_STAG_RIGHTS_LOCAL_READ | NES_CQP_STAG_REM_ACC_EN;
465 nesfmr->access_rights |=
466 NES_CQP_STAG_RIGHTS_REMOTE_READ | NES_CQP_STAG_RIGHTS_LOCAL_READ |
467 NES_CQP_STAG_REM_ACC_EN;
468 }
469
470 nes_fill_init_cqp_wqe(cqp_wqe, nesdev);
471 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_OPCODE_IDX, opcode);
472 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_STAG_WQE_LEN_HIGH_PD_IDX, (nespd->pd_id & 0x00007fff));
473 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_STAG_WQE_STAG_IDX, stag);
474
475 cqp_wqe->wqe_words[NES_CQP_STAG_WQE_PBL_BLK_COUNT_IDX] =
476 cpu_to_le32((nesfmr->nesmr.pbls_used>1) ?
477 (nesfmr->nesmr.pbls_used-1) : nesfmr->nesmr.pbls_used);
478
479 atomic_set(&cqp_request->refcount, 2);
480 nes_post_cqp_request(nesdev, cqp_request);
481
482
483 ret = wait_event_timeout(cqp_request->waitq, (cqp_request->request_done != 0),
484 NES_EVENT_TIMEOUT);
485 nes_debug(NES_DBG_MR, "Register STag 0x%08X completed, wait_event_timeout ret = %u,"
486 " CQP Major:Minor codes = 0x%04X:0x%04X.\n",
487 stag, ret, cqp_request->major_code, cqp_request->minor_code);
488
489 if ((!ret) || (cqp_request->major_code)) {
490 nes_put_cqp_request(nesdev, cqp_request);
491 ret = (!ret) ? -ETIME : -EIO;
492 goto failed_leaf_vpbl_pages_alloc;
493 }
494 nes_put_cqp_request(nesdev, cqp_request);
495 nesfmr->nesmr.ibfmr.lkey = stag;
496 nesfmr->nesmr.ibfmr.rkey = stag;
497 nesfmr->attr = *ibfmr_attr;
498
499 return &nesfmr->nesmr.ibfmr;
500
501 failed_leaf_vpbl_pages_alloc:
502
503 for (i=0; i<nesfmr->leaf_pbl_cnt; i++) {
504 if (nesfmr->root_vpbl.leaf_vpbl[i].pbl_vbase) {
505 pci_free_consistent(nesdev->pcidev, 4096, nesfmr->root_vpbl.leaf_vpbl[i].pbl_vbase,
506 nesfmr->root_vpbl.leaf_vpbl[i].pbl_pbase);
507 }
508 }
509 if (nesfmr->root_vpbl.leaf_vpbl)
510 kfree(nesfmr->root_vpbl.leaf_vpbl);
511
512 failed_leaf_vpbl_alloc:
513 if (nesfmr->leaf_pbl_cnt == 0) {
514 if (nesfmr->root_vpbl.pbl_vbase)
515 pci_free_consistent(nesdev->pcidev, 4096, nesfmr->root_vpbl.pbl_vbase,
516 nesfmr->root_vpbl.pbl_pbase);
517 } else
518 pci_free_consistent(nesdev->pcidev, 8192, nesfmr->root_vpbl.pbl_vbase,
519 nesfmr->root_vpbl.pbl_pbase);
520
521 failed_vpbl_alloc:
522 if (nesfmr->nesmr.pbls_used != 0) {
523 spin_lock_irqsave(&nesadapter->pbl_lock, flags);
524 if (nesfmr->nesmr.pbl_4k)
525 nesadapter->free_4kpbl += nesfmr->nesmr.pbls_used;
526 else
527 nesadapter->free_256pbl += nesfmr->nesmr.pbls_used;
528 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
529 }
530
531failed_vpbl_avail:
532 kfree(nesfmr);
533
534 failed_fmr_alloc:
535 nes_free_resource(nesadapter, nesadapter->allocated_mrs, stag_index);
536
537 failed_resource_alloc:
538 return ERR_PTR(ret);
539}
540
541
542
543
544
545static int nes_dealloc_fmr(struct ib_fmr *ibfmr)
546{
547 unsigned long flags;
548 struct nes_mr *nesmr = to_nesmr_from_ibfmr(ibfmr);
549 struct nes_fmr *nesfmr = to_nesfmr(nesmr);
550 struct nes_vnic *nesvnic = to_nesvnic(ibfmr->device);
551 struct nes_device *nesdev = nesvnic->nesdev;
552 struct nes_adapter *nesadapter = nesdev->nesadapter;
553 int i = 0;
554
555
556 if (nesfmr->leaf_pbl_cnt == 0) {
557
558 if (nesfmr->root_vpbl.pbl_vbase)
559 pci_free_consistent(nesdev->pcidev, 4096, nesfmr->root_vpbl.pbl_vbase,
560 nesfmr->root_vpbl.pbl_pbase);
561 } else {
562 for (i = 0; i < nesfmr->leaf_pbl_cnt; i++) {
563 pci_free_consistent(nesdev->pcidev, 4096, nesfmr->root_vpbl.leaf_vpbl[i].pbl_vbase,
564 nesfmr->root_vpbl.leaf_vpbl[i].pbl_pbase);
565 }
566 kfree(nesfmr->root_vpbl.leaf_vpbl);
567 pci_free_consistent(nesdev->pcidev, 8192, nesfmr->root_vpbl.pbl_vbase,
568 nesfmr->root_vpbl.pbl_pbase);
569 }
570 nesmr->ibmw.device = ibfmr->device;
571 nesmr->ibmw.pd = ibfmr->pd;
572 nesmr->ibmw.rkey = ibfmr->rkey;
573 nesmr->ibmw.uobject = NULL;
574
575 if (nesfmr->nesmr.pbls_used != 0) {
576 spin_lock_irqsave(&nesadapter->pbl_lock, flags);
577 if (nesfmr->nesmr.pbl_4k) {
578 nesadapter->free_4kpbl += nesfmr->nesmr.pbls_used;
579 WARN_ON(nesadapter->free_4kpbl > nesadapter->max_4kpbl);
580 } else {
581 nesadapter->free_256pbl += nesfmr->nesmr.pbls_used;
582 WARN_ON(nesadapter->free_256pbl > nesadapter->max_256pbl);
583 }
584 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
585 }
586
587 return nes_dealloc_mw(&nesmr->ibmw);
588}
589
590
591
592
593
594static int nes_map_phys_fmr(struct ib_fmr *ibfmr, u64 *page_list,
595 int list_len, u64 iova)
596{
597 return 0;
598}
599
600
601
602
603
604static int nes_unmap_fmr(struct list_head *ibfmr_list)
605{
606 return 0;
607}
608
609
610
611
612
613
614static int nes_query_device(struct ib_device *ibdev, struct ib_device_attr *props)
615{
616 struct nes_vnic *nesvnic = to_nesvnic(ibdev);
617 struct nes_device *nesdev = nesvnic->nesdev;
618 struct nes_ib_device *nesibdev = nesvnic->nesibdev;
619
620 memset(props, 0, sizeof(*props));
621 memcpy(&props->sys_image_guid, nesvnic->netdev->dev_addr, 6);
622
623 props->fw_ver = nesdev->nesadapter->fw_ver;
624 props->device_cap_flags = nesdev->nesadapter->device_cap_flags;
625 props->vendor_id = nesdev->nesadapter->vendor_id;
626 props->vendor_part_id = nesdev->nesadapter->vendor_part_id;
627 props->hw_ver = nesdev->nesadapter->hw_rev;
628 props->max_mr_size = 0x80000000;
629 props->max_qp = nesibdev->max_qp;
630 props->max_qp_wr = nesdev->nesadapter->max_qp_wr - 2;
631 props->max_sge = nesdev->nesadapter->max_sge;
632 props->max_cq = nesibdev->max_cq;
633 props->max_cqe = nesdev->nesadapter->max_cqe - 1;
634 props->max_mr = nesibdev->max_mr;
635 props->max_mw = nesibdev->max_mr;
636 props->max_pd = nesibdev->max_pd;
637 props->max_sge_rd = 1;
638 switch (nesdev->nesadapter->max_irrq_wr) {
639 case 0:
640 props->max_qp_rd_atom = 1;
641 break;
642 case 1:
643 props->max_qp_rd_atom = 4;
644 break;
645 case 2:
646 props->max_qp_rd_atom = 16;
647 break;
648 case 3:
649 props->max_qp_rd_atom = 32;
650 break;
651 default:
652 props->max_qp_rd_atom = 0;
653 }
654 props->max_qp_init_rd_atom = props->max_qp_wr;
655 props->atomic_cap = IB_ATOMIC_NONE;
656 props->max_map_per_fmr = 1;
657
658 return 0;
659}
660
661
662
663
664
665static int nes_query_port(struct ib_device *ibdev, u8 port, struct ib_port_attr *props)
666{
667 memset(props, 0, sizeof(*props));
668
669 props->max_mtu = IB_MTU_2048;
670 props->active_mtu = IB_MTU_2048;
671 props->lid = 1;
672 props->lmc = 0;
673 props->sm_lid = 0;
674 props->sm_sl = 0;
675 props->state = IB_PORT_ACTIVE;
676 props->phys_state = 0;
677 props->port_cap_flags = IB_PORT_CM_SUP | IB_PORT_REINIT_SUP |
678 IB_PORT_VENDOR_CLASS_SUP | IB_PORT_BOOT_MGMT_SUP;
679 props->gid_tbl_len = 1;
680 props->pkey_tbl_len = 1;
681 props->qkey_viol_cntr = 0;
682 props->active_width = IB_WIDTH_4X;
683 props->active_speed = 1;
684 props->max_msg_sz = 0x80000000;
685
686 return 0;
687}
688
689
690
691
692
693static int nes_modify_port(struct ib_device *ibdev, u8 port,
694 int port_modify_mask, struct ib_port_modify *props)
695{
696 return 0;
697}
698
699
700
701
702
703static int nes_query_pkey(struct ib_device *ibdev, u8 port, u16 index, u16 *pkey)
704{
705 *pkey = 0;
706 return 0;
707}
708
709
710
711
712
713static int nes_query_gid(struct ib_device *ibdev, u8 port,
714 int index, union ib_gid *gid)
715{
716 struct nes_vnic *nesvnic = to_nesvnic(ibdev);
717
718 memset(&(gid->raw[0]), 0, sizeof(gid->raw));
719 memcpy(&(gid->raw[0]), nesvnic->netdev->dev_addr, 6);
720
721 return 0;
722}
723
724
725
726
727
728
729static struct ib_ucontext *nes_alloc_ucontext(struct ib_device *ibdev,
730 struct ib_udata *udata)
731{
732 struct nes_vnic *nesvnic = to_nesvnic(ibdev);
733 struct nes_device *nesdev = nesvnic->nesdev;
734 struct nes_adapter *nesadapter = nesdev->nesadapter;
735 struct nes_alloc_ucontext_req req;
736 struct nes_alloc_ucontext_resp uresp;
737 struct nes_ucontext *nes_ucontext;
738 struct nes_ib_device *nesibdev = nesvnic->nesibdev;
739
740
741 if (ib_copy_from_udata(&req, udata, sizeof(struct nes_alloc_ucontext_req))) {
742 printk(KERN_ERR PFX "Invalid structure size on allocate user context.\n");
743 return ERR_PTR(-EINVAL);
744 }
745
746 if (req.userspace_ver != NES_ABI_USERSPACE_VER) {
747 printk(KERN_ERR PFX "Invalid userspace driver version detected. Detected version %d, should be %d\n",
748 req.userspace_ver, NES_ABI_USERSPACE_VER);
749 return ERR_PTR(-EINVAL);
750 }
751
752
753 memset(&uresp, 0, sizeof uresp);
754
755 uresp.max_qps = nesibdev->max_qp;
756 uresp.max_pds = nesibdev->max_pd;
757 uresp.wq_size = nesdev->nesadapter->max_qp_wr * 2;
758 uresp.virtwq = nesadapter->virtwq;
759 uresp.kernel_ver = NES_ABI_KERNEL_VER;
760
761 nes_ucontext = kzalloc(sizeof *nes_ucontext, GFP_KERNEL);
762 if (!nes_ucontext)
763 return ERR_PTR(-ENOMEM);
764
765 nes_ucontext->nesdev = nesdev;
766 nes_ucontext->mmap_wq_offset = uresp.max_pds;
767 nes_ucontext->mmap_cq_offset = nes_ucontext->mmap_wq_offset +
768 ((sizeof(struct nes_hw_qp_wqe) * uresp.max_qps * 2) + PAGE_SIZE-1) /
769 PAGE_SIZE;
770
771
772 if (ib_copy_to_udata(udata, &uresp, sizeof uresp)) {
773 kfree(nes_ucontext);
774 return ERR_PTR(-EFAULT);
775 }
776
777 INIT_LIST_HEAD(&nes_ucontext->cq_reg_mem_list);
778 INIT_LIST_HEAD(&nes_ucontext->qp_reg_mem_list);
779 atomic_set(&nes_ucontext->usecnt, 1);
780 return &nes_ucontext->ibucontext;
781}
782
783
784
785
786
787static int nes_dealloc_ucontext(struct ib_ucontext *context)
788{
789
790
791 struct nes_ucontext *nes_ucontext = to_nesucontext(context);
792
793 if (!atomic_dec_and_test(&nes_ucontext->usecnt))
794 return 0;
795 kfree(nes_ucontext);
796 return 0;
797}
798
799
800
801
802
803static int nes_mmap(struct ib_ucontext *context, struct vm_area_struct *vma)
804{
805 unsigned long index;
806 struct nes_vnic *nesvnic = to_nesvnic(context->device);
807 struct nes_device *nesdev = nesvnic->nesdev;
808
809 struct nes_ucontext *nes_ucontext;
810 struct nes_qp *nesqp;
811
812 nes_ucontext = to_nesucontext(context);
813
814
815 if (vma->vm_pgoff >= nes_ucontext->mmap_wq_offset) {
816 index = (vma->vm_pgoff - nes_ucontext->mmap_wq_offset) * PAGE_SIZE;
817 index /= ((sizeof(struct nes_hw_qp_wqe) * nesdev->nesadapter->max_qp_wr * 2) +
818 PAGE_SIZE-1) & (~(PAGE_SIZE-1));
819 if (!test_bit(index, nes_ucontext->allocated_wqs)) {
820 nes_debug(NES_DBG_MMAP, "wq %lu not allocated\n", index);
821 return -EFAULT;
822 }
823 nesqp = nes_ucontext->mmap_nesqp[index];
824 if (nesqp == NULL) {
825 nes_debug(NES_DBG_MMAP, "wq %lu has a NULL QP base.\n", index);
826 return -EFAULT;
827 }
828 if (remap_pfn_range(vma, vma->vm_start,
829 virt_to_phys(nesqp->hwqp.sq_vbase) >> PAGE_SHIFT,
830 vma->vm_end - vma->vm_start,
831 vma->vm_page_prot)) {
832 nes_debug(NES_DBG_MMAP, "remap_pfn_range failed.\n");
833 return -EAGAIN;
834 }
835 vma->vm_private_data = nesqp;
836 return 0;
837 } else {
838 index = vma->vm_pgoff;
839 if (!test_bit(index, nes_ucontext->allocated_doorbells))
840 return -EFAULT;
841
842 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
843 if (io_remap_pfn_range(vma, vma->vm_start,
844 (nesdev->doorbell_start +
845 ((nes_ucontext->mmap_db_index[index] - nesdev->base_doorbell_index) * 4096))
846 >> PAGE_SHIFT, PAGE_SIZE, vma->vm_page_prot))
847 return -EAGAIN;
848 vma->vm_private_data = nes_ucontext;
849 return 0;
850 }
851
852 return -ENOSYS;
853}
854
855
856
857
858
859static struct ib_pd *nes_alloc_pd(struct ib_device *ibdev,
860 struct ib_ucontext *context, struct ib_udata *udata)
861{
862 struct nes_pd *nespd;
863 struct nes_vnic *nesvnic = to_nesvnic(ibdev);
864 struct nes_device *nesdev = nesvnic->nesdev;
865 struct nes_adapter *nesadapter = nesdev->nesadapter;
866 struct nes_ucontext *nesucontext;
867 struct nes_alloc_pd_resp uresp;
868 u32 pd_num = 0;
869 int err;
870
871 nes_debug(NES_DBG_PD, "nesvnic=%p, netdev=%p %s, ibdev=%p, context=%p, netdev refcnt=%u\n",
872 nesvnic, nesdev->netdev[0], nesdev->netdev[0]->name, ibdev, context,
873 atomic_read(&nesvnic->netdev->refcnt));
874
875 err = nes_alloc_resource(nesadapter, nesadapter->allocated_pds,
876 nesadapter->max_pd, &pd_num, &nesadapter->next_pd);
877 if (err) {
878 return ERR_PTR(err);
879 }
880
881 nespd = kzalloc(sizeof (struct nes_pd), GFP_KERNEL);
882 if (!nespd) {
883 nes_free_resource(nesadapter, nesadapter->allocated_pds, pd_num);
884 return ERR_PTR(-ENOMEM);
885 }
886
887 nes_debug(NES_DBG_PD, "Allocating PD (%p) for ib device %s\n",
888 nespd, nesvnic->nesibdev->ibdev.name);
889
890 nespd->pd_id = (pd_num << (PAGE_SHIFT-12)) + nesadapter->base_pd;
891
892 if (context) {
893 nesucontext = to_nesucontext(context);
894 nespd->mmap_db_index = find_next_zero_bit(nesucontext->allocated_doorbells,
895 NES_MAX_USER_DB_REGIONS, nesucontext->first_free_db);
896 nes_debug(NES_DBG_PD, "find_first_zero_biton doorbells returned %u, mapping pd_id %u.\n",
897 nespd->mmap_db_index, nespd->pd_id);
898 if (nespd->mmap_db_index >= NES_MAX_USER_DB_REGIONS) {
899 nes_debug(NES_DBG_PD, "mmap_db_index > MAX\n");
900 nes_free_resource(nesadapter, nesadapter->allocated_pds, pd_num);
901 kfree(nespd);
902 return ERR_PTR(-ENOMEM);
903 }
904
905 uresp.pd_id = nespd->pd_id;
906 uresp.mmap_db_index = nespd->mmap_db_index;
907 if (ib_copy_to_udata(udata, &uresp, sizeof (struct nes_alloc_pd_resp))) {
908 nes_free_resource(nesadapter, nesadapter->allocated_pds, pd_num);
909 kfree(nespd);
910 return ERR_PTR(-EFAULT);
911 }
912
913 set_bit(nespd->mmap_db_index, nesucontext->allocated_doorbells);
914 nesucontext->mmap_db_index[nespd->mmap_db_index] = nespd->pd_id;
915 nesucontext->first_free_db = nespd->mmap_db_index + 1;
916 }
917
918 nes_debug(NES_DBG_PD, "PD%u structure located @%p.\n", nespd->pd_id, nespd);
919 return &nespd->ibpd;
920}
921
922
923
924
925
926static int nes_dealloc_pd(struct ib_pd *ibpd)
927{
928 struct nes_ucontext *nesucontext;
929 struct nes_pd *nespd = to_nespd(ibpd);
930 struct nes_vnic *nesvnic = to_nesvnic(ibpd->device);
931 struct nes_device *nesdev = nesvnic->nesdev;
932 struct nes_adapter *nesadapter = nesdev->nesadapter;
933
934 if ((ibpd->uobject) && (ibpd->uobject->context)) {
935 nesucontext = to_nesucontext(ibpd->uobject->context);
936 nes_debug(NES_DBG_PD, "Clearing bit %u from allocated doorbells\n",
937 nespd->mmap_db_index);
938 clear_bit(nespd->mmap_db_index, nesucontext->allocated_doorbells);
939 nesucontext->mmap_db_index[nespd->mmap_db_index] = 0;
940 if (nesucontext->first_free_db > nespd->mmap_db_index) {
941 nesucontext->first_free_db = nespd->mmap_db_index;
942 }
943 }
944
945 nes_debug(NES_DBG_PD, "Deallocating PD%u structure located @%p.\n",
946 nespd->pd_id, nespd);
947 nes_free_resource(nesadapter, nesadapter->allocated_pds,
948 (nespd->pd_id-nesadapter->base_pd)>>(PAGE_SHIFT-12));
949 kfree(nespd);
950
951 return 0;
952}
953
954
955
956
957
958static struct ib_ah *nes_create_ah(struct ib_pd *pd, struct ib_ah_attr *ah_attr)
959{
960 return ERR_PTR(-ENOSYS);
961}
962
963
964
965
966
967static int nes_destroy_ah(struct ib_ah *ah)
968{
969 return -ENOSYS;
970}
971
972
973
974
975
976static inline u8 nes_get_encoded_size(int *size)
977{
978 u8 encoded_size = 0;
979 if (*size <= 32) {
980 *size = 32;
981 encoded_size = 1;
982 } else if (*size <= 128) {
983 *size = 128;
984 encoded_size = 2;
985 } else if (*size <= 512) {
986 *size = 512;
987 encoded_size = 3;
988 }
989 return (encoded_size);
990}
991
992
993
994
995
996
997static int nes_setup_virt_qp(struct nes_qp *nesqp, struct nes_pbl *nespbl,
998 struct nes_vnic *nesvnic, int sq_size, int rq_size)
999{
1000 unsigned long flags;
1001 void *mem;
1002 __le64 *pbl = NULL;
1003 __le64 *tpbl;
1004 __le64 *pblbuffer;
1005 struct nes_device *nesdev = nesvnic->nesdev;
1006 struct nes_adapter *nesadapter = nesdev->nesadapter;
1007 u32 pbl_entries;
1008 u8 rq_pbl_entries;
1009 u8 sq_pbl_entries;
1010
1011 pbl_entries = nespbl->pbl_size >> 3;
1012 nes_debug(NES_DBG_QP, "Userspace PBL, pbl_size=%u, pbl_entries = %d pbl_vbase=%p, pbl_pbase=%lx\n",
1013 nespbl->pbl_size, pbl_entries,
1014 (void *)nespbl->pbl_vbase,
1015 (unsigned long) nespbl->pbl_pbase);
1016 pbl = (__le64 *) nespbl->pbl_vbase;
1017
1018
1019 rq_pbl_entries = (rq_size * sizeof(struct nes_hw_qp_wqe)) >> 12;
1020 sq_pbl_entries = (sq_size * sizeof(struct nes_hw_qp_wqe)) >> 12;
1021 nesqp->hwqp.sq_pbase = (le32_to_cpu(((__le32 *)pbl)[0])) | ((u64)((le32_to_cpu(((__le32 *)pbl)[1]))) << 32);
1022 if (!nespbl->page) {
1023 nes_debug(NES_DBG_QP, "QP nespbl->page is NULL \n");
1024 kfree(nespbl);
1025 return -ENOMEM;
1026 }
1027
1028 nesqp->hwqp.sq_vbase = kmap(nespbl->page);
1029 nesqp->page = nespbl->page;
1030 if (!nesqp->hwqp.sq_vbase) {
1031 nes_debug(NES_DBG_QP, "QP sq_vbase kmap failed\n");
1032 kfree(nespbl);
1033 return -ENOMEM;
1034 }
1035
1036
1037
1038 pbl += sq_pbl_entries;
1039 nesqp->hwqp.rq_pbase = (le32_to_cpu(((__le32 *)pbl)[0])) | ((u64)((le32_to_cpu(((__le32 *)pbl)[1]))) << 32);
1040
1041
1042
1043 nes_debug(NES_DBG_QP, "QP sq_vbase= %p sq_pbase=%lx rq_vbase=%p rq_pbase=%lx\n",
1044 nesqp->hwqp.sq_vbase, (unsigned long) nesqp->hwqp.sq_pbase,
1045 nesqp->hwqp.rq_vbase, (unsigned long) nesqp->hwqp.rq_pbase);
1046 spin_lock_irqsave(&nesadapter->pbl_lock, flags);
1047 if (!nesadapter->free_256pbl) {
1048 pci_free_consistent(nesdev->pcidev, nespbl->pbl_size, nespbl->pbl_vbase,
1049 nespbl->pbl_pbase);
1050 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1051 kunmap(nesqp->page);
1052 kfree(nespbl);
1053 return -ENOMEM;
1054 }
1055 nesadapter->free_256pbl--;
1056 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1057
1058 nesqp->pbl_vbase = pci_alloc_consistent(nesdev->pcidev, 256, &nesqp->pbl_pbase);
1059 pblbuffer = nesqp->pbl_vbase;
1060 if (!nesqp->pbl_vbase) {
1061
1062 pci_free_consistent(nesdev->pcidev, nespbl->pbl_size, nespbl->pbl_vbase,
1063 nespbl->pbl_pbase);
1064 kfree(nespbl);
1065 spin_lock_irqsave(&nesadapter->pbl_lock, flags);
1066 nesadapter->free_256pbl++;
1067 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1068 kunmap(nesqp->page);
1069 return -ENOMEM;
1070 }
1071 memset(nesqp->pbl_vbase, 0, 256);
1072
1073 tpbl = pblbuffer + 16;
1074 pbl = (__le64 *)nespbl->pbl_vbase;
1075 while (sq_pbl_entries--)
1076 *tpbl++ = *pbl++;
1077 tpbl = pblbuffer;
1078 while (rq_pbl_entries--)
1079 *tpbl++ = *pbl++;
1080
1081
1082 pci_free_consistent(nesdev->pcidev, nespbl->pbl_size, nespbl->pbl_vbase,
1083 nespbl->pbl_pbase);
1084 kfree(nespbl);
1085
1086 nesqp->qp_mem_size =
1087 max((u32)sizeof(struct nes_qp_context), ((u32)256)) + 256;
1088
1089 nesqp->qp_mem_size += PAGE_SIZE - 1;
1090 nesqp->qp_mem_size &= ~(PAGE_SIZE - 1);
1091
1092 mem = pci_alloc_consistent(nesdev->pcidev, nesqp->qp_mem_size,
1093 &nesqp->hwqp.q2_pbase);
1094
1095 if (!mem) {
1096 pci_free_consistent(nesdev->pcidev, 256, nesqp->pbl_vbase, nesqp->pbl_pbase);
1097 nesqp->pbl_vbase = NULL;
1098 spin_lock_irqsave(&nesadapter->pbl_lock, flags);
1099 nesadapter->free_256pbl++;
1100 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1101 kunmap(nesqp->page);
1102 return -ENOMEM;
1103 }
1104 nesqp->hwqp.q2_vbase = mem;
1105 mem += 256;
1106 memset(nesqp->hwqp.q2_vbase, 0, 256);
1107 nesqp->nesqp_context = mem;
1108 memset(nesqp->nesqp_context, 0, sizeof(*nesqp->nesqp_context));
1109 nesqp->nesqp_context_pbase = nesqp->hwqp.q2_pbase + 256;
1110
1111 return 0;
1112}
1113
1114
1115
1116
1117
1118static int nes_setup_mmap_qp(struct nes_qp *nesqp, struct nes_vnic *nesvnic,
1119 int sq_size, int rq_size)
1120{
1121 void *mem;
1122 struct nes_device *nesdev = nesvnic->nesdev;
1123
1124 nesqp->qp_mem_size = (sizeof(struct nes_hw_qp_wqe) * sq_size) +
1125 (sizeof(struct nes_hw_qp_wqe) * rq_size) +
1126 max((u32)sizeof(struct nes_qp_context), ((u32)256)) +
1127 256;
1128
1129 nesqp->qp_mem_size += PAGE_SIZE - 1;
1130 nesqp->qp_mem_size &= ~(PAGE_SIZE - 1);
1131
1132 mem = pci_alloc_consistent(nesdev->pcidev, nesqp->qp_mem_size,
1133 &nesqp->hwqp.sq_pbase);
1134 if (!mem)
1135 return -ENOMEM;
1136 nes_debug(NES_DBG_QP, "PCI consistent memory for "
1137 "host descriptor rings located @ %p (pa = 0x%08lX.) size = %u.\n",
1138 mem, (unsigned long)nesqp->hwqp.sq_pbase, nesqp->qp_mem_size);
1139
1140 memset(mem, 0, nesqp->qp_mem_size);
1141
1142 nesqp->hwqp.sq_vbase = mem;
1143 mem += sizeof(struct nes_hw_qp_wqe) * sq_size;
1144
1145 nesqp->hwqp.rq_vbase = mem;
1146 nesqp->hwqp.rq_pbase = nesqp->hwqp.sq_pbase +
1147 sizeof(struct nes_hw_qp_wqe) * sq_size;
1148 mem += sizeof(struct nes_hw_qp_wqe) * rq_size;
1149
1150 nesqp->hwqp.q2_vbase = mem;
1151 nesqp->hwqp.q2_pbase = nesqp->hwqp.rq_pbase +
1152 sizeof(struct nes_hw_qp_wqe) * rq_size;
1153 mem += 256;
1154 memset(nesqp->hwqp.q2_vbase, 0, 256);
1155
1156 nesqp->nesqp_context = mem;
1157 nesqp->nesqp_context_pbase = nesqp->hwqp.q2_pbase + 256;
1158 memset(nesqp->nesqp_context, 0, sizeof(*nesqp->nesqp_context));
1159 return 0;
1160}
1161
1162
1163
1164
1165
1166static inline void nes_free_qp_mem(struct nes_device *nesdev,
1167 struct nes_qp *nesqp, int virt_wqs)
1168{
1169 unsigned long flags;
1170 struct nes_adapter *nesadapter = nesdev->nesadapter;
1171 if (!virt_wqs) {
1172 pci_free_consistent(nesdev->pcidev, nesqp->qp_mem_size,
1173 nesqp->hwqp.sq_vbase, nesqp->hwqp.sq_pbase);
1174 }else {
1175 spin_lock_irqsave(&nesadapter->pbl_lock, flags);
1176 nesadapter->free_256pbl++;
1177 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1178 pci_free_consistent(nesdev->pcidev, nesqp->qp_mem_size, nesqp->hwqp.q2_vbase, nesqp->hwqp.q2_pbase);
1179 pci_free_consistent(nesdev->pcidev, 256, nesqp->pbl_vbase, nesqp->pbl_pbase );
1180 nesqp->pbl_vbase = NULL;
1181 kunmap(nesqp->page);
1182 }
1183}
1184
1185
1186
1187
1188
1189static struct ib_qp *nes_create_qp(struct ib_pd *ibpd,
1190 struct ib_qp_init_attr *init_attr, struct ib_udata *udata)
1191{
1192 u64 u64temp= 0;
1193 u64 u64nesqp = 0;
1194 struct nes_pd *nespd = to_nespd(ibpd);
1195 struct nes_vnic *nesvnic = to_nesvnic(ibpd->device);
1196 struct nes_device *nesdev = nesvnic->nesdev;
1197 struct nes_adapter *nesadapter = nesdev->nesadapter;
1198 struct nes_qp *nesqp;
1199 struct nes_cq *nescq;
1200 struct nes_ucontext *nes_ucontext;
1201 struct nes_hw_cqp_wqe *cqp_wqe;
1202 struct nes_cqp_request *cqp_request;
1203 struct nes_create_qp_req req;
1204 struct nes_create_qp_resp uresp;
1205 struct nes_pbl *nespbl = NULL;
1206 u32 qp_num = 0;
1207 u32 opcode = 0;
1208
1209 void *mem;
1210 unsigned long flags;
1211 int ret;
1212 int err;
1213 int virt_wqs = 0;
1214 int sq_size;
1215 int rq_size;
1216 u8 sq_encoded_size;
1217 u8 rq_encoded_size;
1218
1219
1220 if (init_attr->create_flags)
1221 return ERR_PTR(-EINVAL);
1222
1223 atomic_inc(&qps_created);
1224 switch (init_attr->qp_type) {
1225 case IB_QPT_RC:
1226 if (nes_drv_opt & NES_DRV_OPT_NO_INLINE_DATA) {
1227 init_attr->cap.max_inline_data = 0;
1228 } else {
1229 init_attr->cap.max_inline_data = 64;
1230 }
1231 sq_size = init_attr->cap.max_send_wr;
1232 rq_size = init_attr->cap.max_recv_wr;
1233
1234
1235 sq_encoded_size = nes_get_encoded_size(&sq_size);
1236 rq_encoded_size = nes_get_encoded_size(&rq_size);
1237
1238 if ((!sq_encoded_size) || (!rq_encoded_size)) {
1239 nes_debug(NES_DBG_QP, "ERROR bad rq (%u) or sq (%u) size\n",
1240 rq_size, sq_size);
1241 return ERR_PTR(-EINVAL);
1242 }
1243
1244 init_attr->cap.max_send_wr = sq_size -2;
1245 init_attr->cap.max_recv_wr = rq_size -1;
1246 nes_debug(NES_DBG_QP, "RQ size=%u, SQ Size=%u\n", rq_size, sq_size);
1247
1248 ret = nes_alloc_resource(nesadapter, nesadapter->allocated_qps,
1249 nesadapter->max_qp, &qp_num, &nesadapter->next_qp);
1250 if (ret) {
1251 return ERR_PTR(ret);
1252 }
1253
1254
1255 mem = kzalloc(sizeof(*nesqp)+NES_SW_CONTEXT_ALIGN-1, GFP_KERNEL);
1256 if (!mem) {
1257 nes_free_resource(nesadapter, nesadapter->allocated_qps, qp_num);
1258 nes_debug(NES_DBG_QP, "Unable to allocate QP\n");
1259 return ERR_PTR(-ENOMEM);
1260 }
1261 u64nesqp = (unsigned long)mem;
1262 u64nesqp += ((u64)NES_SW_CONTEXT_ALIGN) - 1;
1263 u64temp = ((u64)NES_SW_CONTEXT_ALIGN) - 1;
1264 u64nesqp &= ~u64temp;
1265 nesqp = (struct nes_qp *)(unsigned long)u64nesqp;
1266
1267
1268 nesqp->allocated_buffer = mem;
1269
1270 if (udata) {
1271 if (ib_copy_from_udata(&req, udata, sizeof(struct nes_create_qp_req))) {
1272 nes_free_resource(nesadapter, nesadapter->allocated_qps, qp_num);
1273 kfree(nesqp->allocated_buffer);
1274 nes_debug(NES_DBG_QP, "ib_copy_from_udata() Failed \n");
1275 return NULL;
1276 }
1277 if (req.user_wqe_buffers) {
1278 virt_wqs = 1;
1279 }
1280 if ((ibpd->uobject) && (ibpd->uobject->context)) {
1281 nesqp->user_mode = 1;
1282 nes_ucontext = to_nesucontext(ibpd->uobject->context);
1283 if (virt_wqs) {
1284 err = 1;
1285 list_for_each_entry(nespbl, &nes_ucontext->qp_reg_mem_list, list) {
1286 if (nespbl->user_base == (unsigned long )req.user_wqe_buffers) {
1287 list_del(&nespbl->list);
1288 err = 0;
1289 nes_debug(NES_DBG_QP, "Found PBL for virtual QP. nespbl=%p. user_base=0x%lx\n",
1290 nespbl, nespbl->user_base);
1291 break;
1292 }
1293 }
1294 if (err) {
1295 nes_debug(NES_DBG_QP, "Didn't Find PBL for virtual QP. address = %llx.\n",
1296 (long long unsigned int)req.user_wqe_buffers);
1297 nes_free_resource(nesadapter, nesadapter->allocated_qps, qp_num);
1298 kfree(nesqp->allocated_buffer);
1299 return ERR_PTR(-EFAULT);
1300 }
1301 }
1302
1303 nes_ucontext = to_nesucontext(ibpd->uobject->context);
1304 nesqp->mmap_sq_db_index =
1305 find_next_zero_bit(nes_ucontext->allocated_wqs,
1306 NES_MAX_USER_WQ_REGIONS, nes_ucontext->first_free_wq);
1307
1308
1309 if (nesqp->mmap_sq_db_index >= NES_MAX_USER_WQ_REGIONS) {
1310 nes_debug(NES_DBG_QP,
1311 "db index > max user regions, failing create QP\n");
1312 nes_free_resource(nesadapter, nesadapter->allocated_qps, qp_num);
1313 if (virt_wqs) {
1314 pci_free_consistent(nesdev->pcidev, nespbl->pbl_size, nespbl->pbl_vbase,
1315 nespbl->pbl_pbase);
1316 kfree(nespbl);
1317 }
1318 kfree(nesqp->allocated_buffer);
1319 return ERR_PTR(-ENOMEM);
1320 }
1321 set_bit(nesqp->mmap_sq_db_index, nes_ucontext->allocated_wqs);
1322 nes_ucontext->mmap_nesqp[nesqp->mmap_sq_db_index] = nesqp;
1323 nes_ucontext->first_free_wq = nesqp->mmap_sq_db_index + 1;
1324 } else {
1325 nes_free_resource(nesadapter, nesadapter->allocated_qps, qp_num);
1326 kfree(nesqp->allocated_buffer);
1327 return ERR_PTR(-EFAULT);
1328 }
1329 }
1330 err = (!virt_wqs) ? nes_setup_mmap_qp(nesqp, nesvnic, sq_size, rq_size) :
1331 nes_setup_virt_qp(nesqp, nespbl, nesvnic, sq_size, rq_size);
1332 if (err) {
1333 nes_debug(NES_DBG_QP,
1334 "error geting qp mem code = %d\n", err);
1335 nes_free_resource(nesadapter, nesadapter->allocated_qps, qp_num);
1336 kfree(nesqp->allocated_buffer);
1337 return ERR_PTR(-ENOMEM);
1338 }
1339
1340 nesqp->hwqp.sq_size = sq_size;
1341 nesqp->hwqp.sq_encoded_size = sq_encoded_size;
1342 nesqp->hwqp.sq_head = 1;
1343 nesqp->hwqp.rq_size = rq_size;
1344 nesqp->hwqp.rq_encoded_size = rq_encoded_size;
1345
1346
1347
1348 nesqp->hwqp.qp_id = qp_num;
1349 nesqp->ibqp.qp_num = nesqp->hwqp.qp_id;
1350 nesqp->nespd = nespd;
1351
1352 nescq = to_nescq(init_attr->send_cq);
1353 nesqp->nesscq = nescq;
1354 nescq = to_nescq(init_attr->recv_cq);
1355 nesqp->nesrcq = nescq;
1356
1357 nesqp->nesqp_context->misc |= cpu_to_le32((u32)PCI_FUNC(nesdev->pcidev->devfn) <<
1358 NES_QPCONTEXT_MISC_PCI_FCN_SHIFT);
1359 nesqp->nesqp_context->misc |= cpu_to_le32((u32)nesqp->hwqp.rq_encoded_size <<
1360 NES_QPCONTEXT_MISC_RQ_SIZE_SHIFT);
1361 nesqp->nesqp_context->misc |= cpu_to_le32((u32)nesqp->hwqp.sq_encoded_size <<
1362 NES_QPCONTEXT_MISC_SQ_SIZE_SHIFT);
1363 nesqp->nesqp_context->misc |= cpu_to_le32(NES_QPCONTEXT_MISC_PRIV_EN);
1364 nesqp->nesqp_context->misc |= cpu_to_le32(NES_QPCONTEXT_MISC_FAST_REGISTER_EN);
1365 nesqp->nesqp_context->cqs = cpu_to_le32(nesqp->nesscq->hw_cq.cq_number +
1366 ((u32)nesqp->nesrcq->hw_cq.cq_number << 16));
1367 u64temp = (u64)nesqp->hwqp.sq_pbase;
1368 nesqp->nesqp_context->sq_addr_low = cpu_to_le32((u32)u64temp);
1369 nesqp->nesqp_context->sq_addr_high = cpu_to_le32((u32)(u64temp >> 32));
1370
1371
1372 if (!virt_wqs) {
1373 u64temp = (u64)nesqp->hwqp.sq_pbase;
1374 nesqp->nesqp_context->sq_addr_low = cpu_to_le32((u32)u64temp);
1375 nesqp->nesqp_context->sq_addr_high = cpu_to_le32((u32)(u64temp >> 32));
1376 u64temp = (u64)nesqp->hwqp.rq_pbase;
1377 nesqp->nesqp_context->rq_addr_low = cpu_to_le32((u32)u64temp);
1378 nesqp->nesqp_context->rq_addr_high = cpu_to_le32((u32)(u64temp >> 32));
1379 } else {
1380 u64temp = (u64)nesqp->pbl_pbase;
1381 nesqp->nesqp_context->rq_addr_low = cpu_to_le32((u32)u64temp);
1382 nesqp->nesqp_context->rq_addr_high = cpu_to_le32((u32)(u64temp >> 32));
1383 }
1384
1385
1386
1387
1388 spin_lock_irqsave(&nesdev->cqp.lock, flags);
1389 nesqp->nesqp_context->misc2 |= cpu_to_le32(
1390 (u32)nesvnic->qp_nic_index[nesvnic->next_qp_nic_index] <<
1391 NES_QPCONTEXT_MISC2_NIC_INDEX_SHIFT);
1392 nesvnic->next_qp_nic_index++;
1393 if ((nesvnic->next_qp_nic_index > 3) ||
1394 (nesvnic->qp_nic_index[nesvnic->next_qp_nic_index] == 0xf)) {
1395 nesvnic->next_qp_nic_index = 0;
1396 }
1397 spin_unlock_irqrestore(&nesdev->cqp.lock, flags);
1398
1399 nesqp->nesqp_context->pd_index_wscale |= cpu_to_le32((u32)nesqp->nespd->pd_id << 16);
1400 u64temp = (u64)nesqp->hwqp.q2_pbase;
1401 nesqp->nesqp_context->q2_addr_low = cpu_to_le32((u32)u64temp);
1402 nesqp->nesqp_context->q2_addr_high = cpu_to_le32((u32)(u64temp >> 32));
1403 nesqp->nesqp_context->aeq_token_low = cpu_to_le32((u32)((unsigned long)(nesqp)));
1404 nesqp->nesqp_context->aeq_token_high = cpu_to_le32((u32)(upper_32_bits((unsigned long)(nesqp))));
1405 nesqp->nesqp_context->ird_ord_sizes = cpu_to_le32(NES_QPCONTEXT_ORDIRD_ALSMM |
1406 ((((u32)nesadapter->max_irrq_wr) <<
1407 NES_QPCONTEXT_ORDIRD_IRDSIZE_SHIFT) & NES_QPCONTEXT_ORDIRD_IRDSIZE_MASK));
1408 if (disable_mpa_crc) {
1409 nes_debug(NES_DBG_QP, "Disabling MPA crc checking due to module option.\n");
1410 nesqp->nesqp_context->ird_ord_sizes |= cpu_to_le32(NES_QPCONTEXT_ORDIRD_RNMC);
1411 }
1412
1413
1414
1415 cqp_request = nes_get_cqp_request(nesdev);
1416 if (cqp_request == NULL) {
1417 nes_debug(NES_DBG_QP, "Failed to get a cqp_request\n");
1418 nes_free_resource(nesadapter, nesadapter->allocated_qps, qp_num);
1419 nes_free_qp_mem(nesdev, nesqp,virt_wqs);
1420 kfree(nesqp->allocated_buffer);
1421 return ERR_PTR(-ENOMEM);
1422 }
1423 cqp_request->waiting = 1;
1424 cqp_wqe = &cqp_request->cqp_wqe;
1425
1426 if (!virt_wqs) {
1427 opcode = NES_CQP_CREATE_QP | NES_CQP_QP_TYPE_IWARP |
1428 NES_CQP_QP_IWARP_STATE_IDLE;
1429 } else {
1430 opcode = NES_CQP_CREATE_QP | NES_CQP_QP_TYPE_IWARP | NES_CQP_QP_VIRT_WQS |
1431 NES_CQP_QP_IWARP_STATE_IDLE;
1432 }
1433 opcode |= NES_CQP_QP_CQS_VALID;
1434 nes_fill_init_cqp_wqe(cqp_wqe, nesdev);
1435 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_OPCODE_IDX, opcode);
1436 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_ID_IDX, nesqp->hwqp.qp_id);
1437
1438 u64temp = (u64)nesqp->nesqp_context_pbase;
1439 set_wqe_64bit_value(cqp_wqe->wqe_words, NES_CQP_QP_WQE_CONTEXT_LOW_IDX, u64temp);
1440
1441 atomic_set(&cqp_request->refcount, 2);
1442 nes_post_cqp_request(nesdev, cqp_request);
1443
1444
1445 nes_debug(NES_DBG_QP, "Waiting for create iWARP QP%u to complete.\n",
1446 nesqp->hwqp.qp_id);
1447 ret = wait_event_timeout(cqp_request->waitq,
1448 (cqp_request->request_done != 0), NES_EVENT_TIMEOUT);
1449 nes_debug(NES_DBG_QP, "Create iwarp QP%u completed, wait_event_timeout ret=%u,"
1450 " nesdev->cqp_head = %u, nesdev->cqp.sq_tail = %u,"
1451 " CQP Major:Minor codes = 0x%04X:0x%04X.\n",
1452 nesqp->hwqp.qp_id, ret, nesdev->cqp.sq_head, nesdev->cqp.sq_tail,
1453 cqp_request->major_code, cqp_request->minor_code);
1454 if ((!ret) || (cqp_request->major_code)) {
1455 nes_put_cqp_request(nesdev, cqp_request);
1456 nes_free_resource(nesadapter, nesadapter->allocated_qps, qp_num);
1457 nes_free_qp_mem(nesdev, nesqp,virt_wqs);
1458 kfree(nesqp->allocated_buffer);
1459 if (!ret) {
1460 return ERR_PTR(-ETIME);
1461 } else {
1462 return ERR_PTR(-EIO);
1463 }
1464 }
1465
1466 nes_put_cqp_request(nesdev, cqp_request);
1467
1468 if (ibpd->uobject) {
1469 uresp.mmap_sq_db_index = nesqp->mmap_sq_db_index;
1470 uresp.actual_sq_size = sq_size;
1471 uresp.actual_rq_size = rq_size;
1472 uresp.qp_id = nesqp->hwqp.qp_id;
1473 uresp.nes_drv_opt = nes_drv_opt;
1474 if (ib_copy_to_udata(udata, &uresp, sizeof uresp)) {
1475 nes_free_resource(nesadapter, nesadapter->allocated_qps, qp_num);
1476 nes_free_qp_mem(nesdev, nesqp,virt_wqs);
1477 kfree(nesqp->allocated_buffer);
1478 return ERR_PTR(-EFAULT);
1479 }
1480 }
1481
1482 nes_debug(NES_DBG_QP, "QP%u structure located @%p.Size = %u.\n",
1483 nesqp->hwqp.qp_id, nesqp, (u32)sizeof(*nesqp));
1484 spin_lock_init(&nesqp->lock);
1485 init_waitqueue_head(&nesqp->state_waitq);
1486 init_waitqueue_head(&nesqp->kick_waitq);
1487 nes_add_ref(&nesqp->ibqp);
1488 break;
1489 default:
1490 nes_debug(NES_DBG_QP, "Invalid QP type: %d\n", init_attr->qp_type);
1491 return ERR_PTR(-EINVAL);
1492 }
1493
1494
1495 nesdev->nesadapter->qp_table[nesqp->hwqp.qp_id-NES_FIRST_QPN] = nesqp;
1496 nes_debug(NES_DBG_QP, "netdev refcnt=%u\n",
1497 atomic_read(&nesvnic->netdev->refcnt));
1498
1499 return &nesqp->ibqp;
1500}
1501
1502
1503
1504
1505
1506static int nes_destroy_qp(struct ib_qp *ibqp)
1507{
1508 struct nes_qp *nesqp = to_nesqp(ibqp);
1509
1510 struct nes_ucontext *nes_ucontext;
1511 struct ib_qp_attr attr;
1512 struct iw_cm_id *cm_id;
1513 struct iw_cm_event cm_event;
1514 int ret;
1515
1516 atomic_inc(&sw_qps_destroyed);
1517 nesqp->destroyed = 1;
1518
1519
1520 if (nesqp->ibqp_state >= IB_QPS_INIT && nesqp->ibqp_state <= IB_QPS_RTS) {
1521
1522 attr.qp_state = IB_QPS_ERR;
1523 nes_modify_qp(&nesqp->ibqp, &attr, IB_QP_STATE, NULL);
1524 }
1525
1526 if (((nesqp->ibqp_state == IB_QPS_INIT) ||
1527 (nesqp->ibqp_state == IB_QPS_RTR)) && (nesqp->cm_id)) {
1528 cm_id = nesqp->cm_id;
1529 cm_event.event = IW_CM_EVENT_CONNECT_REPLY;
1530 cm_event.status = IW_CM_EVENT_STATUS_TIMEOUT;
1531 cm_event.local_addr = cm_id->local_addr;
1532 cm_event.remote_addr = cm_id->remote_addr;
1533 cm_event.private_data = NULL;
1534 cm_event.private_data_len = 0;
1535
1536 nes_debug(NES_DBG_QP, "Generating a CM Timeout Event for "
1537 "QP%u. cm_id = %p, refcount = %u. \n",
1538 nesqp->hwqp.qp_id, cm_id, atomic_read(&nesqp->refcount));
1539
1540 cm_id->rem_ref(cm_id);
1541 ret = cm_id->event_handler(cm_id, &cm_event);
1542 if (ret)
1543 nes_debug(NES_DBG_QP, "OFA CM event_handler returned, ret=%d\n", ret);
1544 }
1545
1546
1547 if (nesqp->user_mode) {
1548 if ((ibqp->uobject)&&(ibqp->uobject->context)) {
1549 nes_ucontext = to_nesucontext(ibqp->uobject->context);
1550 clear_bit(nesqp->mmap_sq_db_index, nes_ucontext->allocated_wqs);
1551 nes_ucontext->mmap_nesqp[nesqp->mmap_sq_db_index] = NULL;
1552 if (nes_ucontext->first_free_wq > nesqp->mmap_sq_db_index) {
1553 nes_ucontext->first_free_wq = nesqp->mmap_sq_db_index;
1554 }
1555 }
1556 if (nesqp->pbl_pbase)
1557 kunmap(nesqp->page);
1558 }
1559
1560 nes_rem_ref(&nesqp->ibqp);
1561 return 0;
1562}
1563
1564
1565
1566
1567
1568static struct ib_cq *nes_create_cq(struct ib_device *ibdev, int entries,
1569 int comp_vector,
1570 struct ib_ucontext *context, struct ib_udata *udata)
1571{
1572 u64 u64temp;
1573 struct nes_vnic *nesvnic = to_nesvnic(ibdev);
1574 struct nes_device *nesdev = nesvnic->nesdev;
1575 struct nes_adapter *nesadapter = nesdev->nesadapter;
1576 struct nes_cq *nescq;
1577 struct nes_ucontext *nes_ucontext = NULL;
1578 struct nes_cqp_request *cqp_request;
1579 void *mem = NULL;
1580 struct nes_hw_cqp_wqe *cqp_wqe;
1581 struct nes_pbl *nespbl = NULL;
1582 struct nes_create_cq_req req;
1583 struct nes_create_cq_resp resp;
1584 u32 cq_num = 0;
1585 u32 opcode = 0;
1586 u32 pbl_entries = 1;
1587 int err;
1588 unsigned long flags;
1589 int ret;
1590
1591 err = nes_alloc_resource(nesadapter, nesadapter->allocated_cqs,
1592 nesadapter->max_cq, &cq_num, &nesadapter->next_cq);
1593 if (err) {
1594 return ERR_PTR(err);
1595 }
1596
1597 nescq = kzalloc(sizeof(struct nes_cq), GFP_KERNEL);
1598 if (!nescq) {
1599 nes_free_resource(nesadapter, nesadapter->allocated_cqs, cq_num);
1600 nes_debug(NES_DBG_CQ, "Unable to allocate nes_cq struct\n");
1601 return ERR_PTR(-ENOMEM);
1602 }
1603
1604 nescq->hw_cq.cq_size = max(entries + 1, 5);
1605 nescq->hw_cq.cq_number = cq_num;
1606 nescq->ibcq.cqe = nescq->hw_cq.cq_size - 1;
1607
1608
1609 if (context) {
1610 nes_ucontext = to_nesucontext(context);
1611 if (ib_copy_from_udata(&req, udata, sizeof (struct nes_create_cq_req))) {
1612 nes_free_resource(nesadapter, nesadapter->allocated_cqs, cq_num);
1613 kfree(nescq);
1614 return ERR_PTR(-EFAULT);
1615 }
1616 nesvnic->mcrq_ucontext = nes_ucontext;
1617 nes_ucontext->mcrqf = req.mcrqf;
1618 if (nes_ucontext->mcrqf) {
1619 if (nes_ucontext->mcrqf & 0x80000000)
1620 nescq->hw_cq.cq_number = nesvnic->nic.qp_id + 28 + 2 * ((nes_ucontext->mcrqf & 0xf) - 1);
1621 else if (nes_ucontext->mcrqf & 0x40000000)
1622 nescq->hw_cq.cq_number = nes_ucontext->mcrqf & 0xffff;
1623 else
1624 nescq->hw_cq.cq_number = nesvnic->mcrq_qp_id + nes_ucontext->mcrqf-1;
1625 nes_free_resource(nesadapter, nesadapter->allocated_cqs, cq_num);
1626 }
1627 nes_debug(NES_DBG_CQ, "CQ Virtual Address = %08lX, size = %u.\n",
1628 (unsigned long)req.user_cq_buffer, entries);
1629 err = 1;
1630 list_for_each_entry(nespbl, &nes_ucontext->cq_reg_mem_list, list) {
1631 if (nespbl->user_base == (unsigned long )req.user_cq_buffer) {
1632 list_del(&nespbl->list);
1633 err = 0;
1634 nes_debug(NES_DBG_CQ, "Found PBL for virtual CQ. nespbl=%p.\n",
1635 nespbl);
1636 break;
1637 }
1638 }
1639 if (err) {
1640 nes_free_resource(nesadapter, nesadapter->allocated_cqs, cq_num);
1641 kfree(nescq);
1642 return ERR_PTR(-EFAULT);
1643 }
1644
1645 pbl_entries = nespbl->pbl_size >> 3;
1646 nescq->cq_mem_size = 0;
1647 } else {
1648 nescq->cq_mem_size = nescq->hw_cq.cq_size * sizeof(struct nes_hw_cqe);
1649 nes_debug(NES_DBG_CQ, "Attempting to allocate pci memory (%u entries, %u bytes) for CQ%u.\n",
1650 entries, nescq->cq_mem_size, nescq->hw_cq.cq_number);
1651
1652
1653 mem = pci_alloc_consistent(nesdev->pcidev, nescq->cq_mem_size,
1654 &nescq->hw_cq.cq_pbase);
1655 if (!mem) {
1656 printk(KERN_ERR PFX "Unable to allocate pci memory for cq\n");
1657 nes_free_resource(nesadapter, nesadapter->allocated_cqs, cq_num);
1658 kfree(nescq);
1659 return ERR_PTR(-ENOMEM);
1660 }
1661
1662 memset(mem, 0, nescq->cq_mem_size);
1663 nescq->hw_cq.cq_vbase = mem;
1664 nescq->hw_cq.cq_head = 0;
1665 nes_debug(NES_DBG_CQ, "CQ%u virtual address @ %p, phys = 0x%08X\n",
1666 nescq->hw_cq.cq_number, nescq->hw_cq.cq_vbase,
1667 (u32)nescq->hw_cq.cq_pbase);
1668 }
1669
1670 nescq->hw_cq.ce_handler = nes_iwarp_ce_handler;
1671 spin_lock_init(&nescq->lock);
1672
1673
1674 cqp_request = nes_get_cqp_request(nesdev);
1675 if (cqp_request == NULL) {
1676 nes_debug(NES_DBG_CQ, "Failed to get a cqp_request.\n");
1677 if (!context)
1678 pci_free_consistent(nesdev->pcidev, nescq->cq_mem_size, mem,
1679 nescq->hw_cq.cq_pbase);
1680 nes_free_resource(nesadapter, nesadapter->allocated_cqs, cq_num);
1681 kfree(nescq);
1682 return ERR_PTR(-ENOMEM);
1683 }
1684 cqp_request->waiting = 1;
1685 cqp_wqe = &cqp_request->cqp_wqe;
1686
1687 opcode = NES_CQP_CREATE_CQ | NES_CQP_CQ_CEQ_VALID |
1688 NES_CQP_CQ_CHK_OVERFLOW |
1689 NES_CQP_CQ_CEQE_MASK | ((u32)nescq->hw_cq.cq_size << 16);
1690
1691 spin_lock_irqsave(&nesadapter->pbl_lock, flags);
1692
1693 if (pbl_entries != 1) {
1694 if (pbl_entries > 32) {
1695
1696 nes_debug(NES_DBG_CQ, "pbl_entries=%u, use a 4k PBL\n", pbl_entries);
1697 if (nesadapter->free_4kpbl == 0) {
1698 if (cqp_request->dynamic) {
1699 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1700 kfree(cqp_request);
1701 } else {
1702 list_add_tail(&cqp_request->list, &nesdev->cqp_avail_reqs);
1703 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1704 }
1705 if (!context)
1706 pci_free_consistent(nesdev->pcidev, nescq->cq_mem_size, mem,
1707 nescq->hw_cq.cq_pbase);
1708 nes_free_resource(nesadapter, nesadapter->allocated_cqs, cq_num);
1709 kfree(nescq);
1710 return ERR_PTR(-ENOMEM);
1711 } else {
1712 opcode |= (NES_CQP_CQ_VIRT | NES_CQP_CQ_4KB_CHUNK);
1713 nescq->virtual_cq = 2;
1714 nesadapter->free_4kpbl--;
1715 }
1716 } else {
1717
1718 nes_debug(NES_DBG_CQ, "pbl_entries=%u, use a 256 byte PBL\n", pbl_entries);
1719 if (nesadapter->free_256pbl == 0) {
1720 if (cqp_request->dynamic) {
1721 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1722 kfree(cqp_request);
1723 } else {
1724 list_add_tail(&cqp_request->list, &nesdev->cqp_avail_reqs);
1725 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1726 }
1727 if (!context)
1728 pci_free_consistent(nesdev->pcidev, nescq->cq_mem_size, mem,
1729 nescq->hw_cq.cq_pbase);
1730 nes_free_resource(nesadapter, nesadapter->allocated_cqs, cq_num);
1731 kfree(nescq);
1732 return ERR_PTR(-ENOMEM);
1733 } else {
1734 opcode |= NES_CQP_CQ_VIRT;
1735 nescq->virtual_cq = 1;
1736 nesadapter->free_256pbl--;
1737 }
1738 }
1739 }
1740
1741 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1742
1743 nes_fill_init_cqp_wqe(cqp_wqe, nesdev);
1744 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_OPCODE_IDX, opcode);
1745 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_ID_IDX,
1746 (nescq->hw_cq.cq_number | ((u32)nesdev->ceq_index << 16)));
1747
1748 if (context) {
1749 if (pbl_entries != 1)
1750 u64temp = (u64)nespbl->pbl_pbase;
1751 else
1752 u64temp = le64_to_cpu(nespbl->pbl_vbase[0]);
1753 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_CQ_WQE_DOORBELL_INDEX_HIGH_IDX,
1754 nes_ucontext->mmap_db_index[0]);
1755 } else {
1756 u64temp = (u64)nescq->hw_cq.cq_pbase;
1757 cqp_wqe->wqe_words[NES_CQP_CQ_WQE_DOORBELL_INDEX_HIGH_IDX] = 0;
1758 }
1759 set_wqe_64bit_value(cqp_wqe->wqe_words, NES_CQP_CQ_WQE_PBL_LOW_IDX, u64temp);
1760 cqp_wqe->wqe_words[NES_CQP_CQ_WQE_CQ_CONTEXT_HIGH_IDX] = 0;
1761 u64temp = (u64)(unsigned long)&nescq->hw_cq;
1762 cqp_wqe->wqe_words[NES_CQP_CQ_WQE_CQ_CONTEXT_LOW_IDX] =
1763 cpu_to_le32((u32)(u64temp >> 1));
1764 cqp_wqe->wqe_words[NES_CQP_CQ_WQE_CQ_CONTEXT_HIGH_IDX] =
1765 cpu_to_le32(((u32)((u64temp) >> 33)) & 0x7FFFFFFF);
1766
1767 atomic_set(&cqp_request->refcount, 2);
1768 nes_post_cqp_request(nesdev, cqp_request);
1769
1770
1771 nes_debug(NES_DBG_CQ, "Waiting for create iWARP CQ%u to complete.\n",
1772 nescq->hw_cq.cq_number);
1773 ret = wait_event_timeout(cqp_request->waitq, (0 != cqp_request->request_done),
1774 NES_EVENT_TIMEOUT * 2);
1775 nes_debug(NES_DBG_CQ, "Create iWARP CQ%u completed, wait_event_timeout ret = %d.\n",
1776 nescq->hw_cq.cq_number, ret);
1777 if ((!ret) || (cqp_request->major_code)) {
1778 nes_put_cqp_request(nesdev, cqp_request);
1779 if (!context)
1780 pci_free_consistent(nesdev->pcidev, nescq->cq_mem_size, mem,
1781 nescq->hw_cq.cq_pbase);
1782 nes_free_resource(nesadapter, nesadapter->allocated_cqs, cq_num);
1783 kfree(nescq);
1784 return ERR_PTR(-EIO);
1785 }
1786 nes_put_cqp_request(nesdev, cqp_request);
1787
1788 if (context) {
1789
1790 pci_free_consistent(nesdev->pcidev, nespbl->pbl_size, nespbl->pbl_vbase,
1791 nespbl->pbl_pbase);
1792 kfree(nespbl);
1793 resp.cq_id = nescq->hw_cq.cq_number;
1794 resp.cq_size = nescq->hw_cq.cq_size;
1795 resp.mmap_db_index = 0;
1796 if (ib_copy_to_udata(udata, &resp, sizeof resp)) {
1797 nes_free_resource(nesadapter, nesadapter->allocated_cqs, cq_num);
1798 kfree(nescq);
1799 return ERR_PTR(-EFAULT);
1800 }
1801 }
1802
1803 return &nescq->ibcq;
1804}
1805
1806
1807
1808
1809
1810static int nes_destroy_cq(struct ib_cq *ib_cq)
1811{
1812 struct nes_cq *nescq;
1813 struct nes_device *nesdev;
1814 struct nes_vnic *nesvnic;
1815 struct nes_adapter *nesadapter;
1816 struct nes_hw_cqp_wqe *cqp_wqe;
1817 struct nes_cqp_request *cqp_request;
1818 unsigned long flags;
1819 u32 opcode = 0;
1820 int ret;
1821
1822 if (ib_cq == NULL)
1823 return 0;
1824
1825 nescq = to_nescq(ib_cq);
1826 nesvnic = to_nesvnic(ib_cq->device);
1827 nesdev = nesvnic->nesdev;
1828 nesadapter = nesdev->nesadapter;
1829
1830 nes_debug(NES_DBG_CQ, "Destroy CQ%u\n", nescq->hw_cq.cq_number);
1831
1832
1833 cqp_request = nes_get_cqp_request(nesdev);
1834 if (cqp_request == NULL) {
1835 nes_debug(NES_DBG_CQ, "Failed to get a cqp_request.\n");
1836 return -ENOMEM;
1837 }
1838 cqp_request->waiting = 1;
1839 cqp_wqe = &cqp_request->cqp_wqe;
1840 opcode = NES_CQP_DESTROY_CQ | (nescq->hw_cq.cq_size << 16);
1841 spin_lock_irqsave(&nesadapter->pbl_lock, flags);
1842 if (nescq->virtual_cq == 1) {
1843 nesadapter->free_256pbl++;
1844 if (nesadapter->free_256pbl > nesadapter->max_256pbl) {
1845 printk(KERN_ERR PFX "%s: free 256B PBLs(%u) has exceeded the max(%u)\n",
1846 __func__, nesadapter->free_256pbl, nesadapter->max_256pbl);
1847 }
1848 } else if (nescq->virtual_cq == 2) {
1849 nesadapter->free_4kpbl++;
1850 if (nesadapter->free_4kpbl > nesadapter->max_4kpbl) {
1851 printk(KERN_ERR PFX "%s: free 4K PBLs(%u) has exceeded the max(%u)\n",
1852 __func__, nesadapter->free_4kpbl, nesadapter->max_4kpbl);
1853 }
1854 opcode |= NES_CQP_CQ_4KB_CHUNK;
1855 }
1856
1857 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1858
1859 nes_fill_init_cqp_wqe(cqp_wqe, nesdev);
1860 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_OPCODE_IDX, opcode);
1861 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_ID_IDX,
1862 (nescq->hw_cq.cq_number | ((u32)PCI_FUNC(nesdev->pcidev->devfn) << 16)));
1863 nes_free_resource(nesadapter, nesadapter->allocated_cqs, nescq->hw_cq.cq_number);
1864 atomic_set(&cqp_request->refcount, 2);
1865 nes_post_cqp_request(nesdev, cqp_request);
1866
1867
1868 nes_debug(NES_DBG_CQ, "Waiting for destroy iWARP CQ%u to complete.\n",
1869 nescq->hw_cq.cq_number);
1870 ret = wait_event_timeout(cqp_request->waitq, (0 != cqp_request->request_done),
1871 NES_EVENT_TIMEOUT);
1872 nes_debug(NES_DBG_CQ, "Destroy iWARP CQ%u completed, wait_event_timeout ret = %u,"
1873 " CQP Major:Minor codes = 0x%04X:0x%04X.\n",
1874 nescq->hw_cq.cq_number, ret, cqp_request->major_code,
1875 cqp_request->minor_code);
1876 if (!ret) {
1877 nes_debug(NES_DBG_CQ, "iWARP CQ%u destroy timeout expired\n",
1878 nescq->hw_cq.cq_number);
1879 ret = -ETIME;
1880 } else if (cqp_request->major_code) {
1881 nes_debug(NES_DBG_CQ, "iWARP CQ%u destroy failed\n",
1882 nescq->hw_cq.cq_number);
1883 ret = -EIO;
1884 } else {
1885 ret = 0;
1886 }
1887 nes_put_cqp_request(nesdev, cqp_request);
1888
1889 if (nescq->cq_mem_size)
1890 pci_free_consistent(nesdev->pcidev, nescq->cq_mem_size,
1891 nescq->hw_cq.cq_vbase, nescq->hw_cq.cq_pbase);
1892 kfree(nescq);
1893
1894 return ret;
1895}
1896
1897
1898
1899
1900
1901static int nes_reg_mr(struct nes_device *nesdev, struct nes_pd *nespd,
1902 u32 stag, u64 region_length, struct nes_root_vpbl *root_vpbl,
1903 dma_addr_t single_buffer, u16 pbl_count, u16 residual_page_count,
1904 int acc, u64 *iova_start)
1905{
1906 struct nes_hw_cqp_wqe *cqp_wqe;
1907 struct nes_cqp_request *cqp_request;
1908 unsigned long flags;
1909 int ret;
1910 struct nes_adapter *nesadapter = nesdev->nesadapter;
1911
1912 u32 opcode = 0;
1913 u16 major_code;
1914
1915
1916 cqp_request = nes_get_cqp_request(nesdev);
1917 if (cqp_request == NULL) {
1918 nes_debug(NES_DBG_MR, "Failed to get a cqp_request.\n");
1919 return -ENOMEM;
1920 }
1921 cqp_request->waiting = 1;
1922 cqp_wqe = &cqp_request->cqp_wqe;
1923
1924 spin_lock_irqsave(&nesadapter->pbl_lock, flags);
1925
1926 if (pbl_count != 0) {
1927 if (pbl_count > 1) {
1928
1929 if ((pbl_count+1) > nesadapter->free_4kpbl) {
1930 nes_debug(NES_DBG_MR, "Out of 4KB Pbls for two level request.\n");
1931 if (cqp_request->dynamic) {
1932 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1933 kfree(cqp_request);
1934 } else {
1935 list_add_tail(&cqp_request->list, &nesdev->cqp_avail_reqs);
1936 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1937 }
1938 return -ENOMEM;
1939 } else {
1940 nesadapter->free_4kpbl -= pbl_count+1;
1941 }
1942 } else if (residual_page_count > 32) {
1943 if (pbl_count > nesadapter->free_4kpbl) {
1944 nes_debug(NES_DBG_MR, "Out of 4KB Pbls.\n");
1945 if (cqp_request->dynamic) {
1946 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1947 kfree(cqp_request);
1948 } else {
1949 list_add_tail(&cqp_request->list, &nesdev->cqp_avail_reqs);
1950 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1951 }
1952 return -ENOMEM;
1953 } else {
1954 nesadapter->free_4kpbl -= pbl_count;
1955 }
1956 } else {
1957 if (pbl_count > nesadapter->free_256pbl) {
1958 nes_debug(NES_DBG_MR, "Out of 256B Pbls.\n");
1959 if (cqp_request->dynamic) {
1960 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1961 kfree(cqp_request);
1962 } else {
1963 list_add_tail(&cqp_request->list, &nesdev->cqp_avail_reqs);
1964 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1965 }
1966 return -ENOMEM;
1967 } else {
1968 nesadapter->free_256pbl -= pbl_count;
1969 }
1970 }
1971 }
1972
1973 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
1974
1975 opcode = NES_CQP_REGISTER_STAG | NES_CQP_STAG_RIGHTS_LOCAL_READ |
1976 NES_CQP_STAG_VA_TO | NES_CQP_STAG_MR;
1977 if (acc & IB_ACCESS_LOCAL_WRITE)
1978 opcode |= NES_CQP_STAG_RIGHTS_LOCAL_WRITE;
1979 if (acc & IB_ACCESS_REMOTE_WRITE)
1980 opcode |= NES_CQP_STAG_RIGHTS_REMOTE_WRITE | NES_CQP_STAG_REM_ACC_EN;
1981 if (acc & IB_ACCESS_REMOTE_READ)
1982 opcode |= NES_CQP_STAG_RIGHTS_REMOTE_READ | NES_CQP_STAG_REM_ACC_EN;
1983 if (acc & IB_ACCESS_MW_BIND)
1984 opcode |= NES_CQP_STAG_RIGHTS_WINDOW_BIND | NES_CQP_STAG_REM_ACC_EN;
1985
1986 nes_fill_init_cqp_wqe(cqp_wqe, nesdev);
1987 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_OPCODE_IDX, opcode);
1988 set_wqe_64bit_value(cqp_wqe->wqe_words, NES_CQP_STAG_WQE_VA_LOW_IDX, *iova_start);
1989 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_STAG_WQE_LEN_LOW_IDX, region_length);
1990
1991 cqp_wqe->wqe_words[NES_CQP_STAG_WQE_LEN_HIGH_PD_IDX] =
1992 cpu_to_le32((u32)(region_length >> 8) & 0xff000000);
1993 cqp_wqe->wqe_words[NES_CQP_STAG_WQE_LEN_HIGH_PD_IDX] |=
1994 cpu_to_le32(nespd->pd_id & 0x00007fff);
1995 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_STAG_WQE_STAG_IDX, stag);
1996
1997 if (pbl_count == 0) {
1998 set_wqe_64bit_value(cqp_wqe->wqe_words, NES_CQP_STAG_WQE_PA_LOW_IDX, single_buffer);
1999 } else {
2000 set_wqe_64bit_value(cqp_wqe->wqe_words, NES_CQP_STAG_WQE_PA_LOW_IDX, root_vpbl->pbl_pbase);
2001 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_STAG_WQE_PBL_BLK_COUNT_IDX, pbl_count);
2002 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_STAG_WQE_PBL_LEN_IDX,
2003 (((pbl_count - 1) * 4096) + (residual_page_count*8)));
2004
2005 if ((pbl_count > 1) || (residual_page_count > 32))
2006 cqp_wqe->wqe_words[NES_CQP_WQE_OPCODE_IDX] |= cpu_to_le32(NES_CQP_STAG_PBL_BLK_SIZE);
2007 }
2008 barrier();
2009
2010 atomic_set(&cqp_request->refcount, 2);
2011 nes_post_cqp_request(nesdev, cqp_request);
2012
2013
2014 ret = wait_event_timeout(cqp_request->waitq, (0 != cqp_request->request_done),
2015 NES_EVENT_TIMEOUT);
2016 nes_debug(NES_DBG_MR, "Register STag 0x%08X completed, wait_event_timeout ret = %u,"
2017 " CQP Major:Minor codes = 0x%04X:0x%04X.\n",
2018 stag, ret, cqp_request->major_code, cqp_request->minor_code);
2019 major_code = cqp_request->major_code;
2020 nes_put_cqp_request(nesdev, cqp_request);
2021
2022 if (!ret)
2023 return -ETIME;
2024 else if (major_code)
2025 return -EIO;
2026 else
2027 return 0;
2028
2029 return 0;
2030}
2031
2032
2033
2034
2035
2036static struct ib_mr *nes_reg_phys_mr(struct ib_pd *ib_pd,
2037 struct ib_phys_buf *buffer_list, int num_phys_buf, int acc,
2038 u64 * iova_start)
2039{
2040 u64 region_length;
2041 struct nes_pd *nespd = to_nespd(ib_pd);
2042 struct nes_vnic *nesvnic = to_nesvnic(ib_pd->device);
2043 struct nes_device *nesdev = nesvnic->nesdev;
2044 struct nes_adapter *nesadapter = nesdev->nesadapter;
2045 struct nes_mr *nesmr;
2046 struct ib_mr *ibmr;
2047 struct nes_vpbl vpbl;
2048 struct nes_root_vpbl root_vpbl;
2049 u32 stag;
2050 u32 i;
2051 u32 stag_index = 0;
2052 u32 next_stag_index = 0;
2053 u32 driver_key = 0;
2054 u32 root_pbl_index = 0;
2055 u32 cur_pbl_index = 0;
2056 int err = 0, pbl_depth = 0;
2057 int ret = 0;
2058 u16 pbl_count = 0;
2059 u8 single_page = 1;
2060 u8 stag_key = 0;
2061
2062 pbl_depth = 0;
2063 region_length = 0;
2064 vpbl.pbl_vbase = NULL;
2065 root_vpbl.pbl_vbase = NULL;
2066 root_vpbl.pbl_pbase = 0;
2067
2068 get_random_bytes(&next_stag_index, sizeof(next_stag_index));
2069 stag_key = (u8)next_stag_index;
2070
2071 driver_key = 0;
2072
2073 next_stag_index >>= 8;
2074 next_stag_index %= nesadapter->max_mr;
2075 if (num_phys_buf > (1024*512)) {
2076 return ERR_PTR(-E2BIG);
2077 }
2078
2079 err = nes_alloc_resource(nesadapter, nesadapter->allocated_mrs, nesadapter->max_mr,
2080 &stag_index, &next_stag_index);
2081 if (err) {
2082 return ERR_PTR(err);
2083 }
2084
2085 nesmr = kzalloc(sizeof(*nesmr), GFP_KERNEL);
2086 if (!nesmr) {
2087 nes_free_resource(nesadapter, nesadapter->allocated_mrs, stag_index);
2088 return ERR_PTR(-ENOMEM);
2089 }
2090
2091 for (i = 0; i < num_phys_buf; i++) {
2092
2093 if ((i & 0x01FF) == 0) {
2094 if (root_pbl_index == 1) {
2095
2096 root_vpbl.pbl_vbase = pci_alloc_consistent(nesdev->pcidev, 8192,
2097 &root_vpbl.pbl_pbase);
2098 nes_debug(NES_DBG_MR, "Allocating root PBL, va = %p, pa = 0x%08X\n",
2099 root_vpbl.pbl_vbase, (unsigned int)root_vpbl.pbl_pbase);
2100 if (!root_vpbl.pbl_vbase) {
2101 pci_free_consistent(nesdev->pcidev, 4096, vpbl.pbl_vbase,
2102 vpbl.pbl_pbase);
2103 nes_free_resource(nesadapter, nesadapter->allocated_mrs, stag_index);
2104 kfree(nesmr);
2105 return ERR_PTR(-ENOMEM);
2106 }
2107 root_vpbl.leaf_vpbl = kzalloc(sizeof(*root_vpbl.leaf_vpbl)*1024, GFP_KERNEL);
2108 if (!root_vpbl.leaf_vpbl) {
2109 pci_free_consistent(nesdev->pcidev, 8192, root_vpbl.pbl_vbase,
2110 root_vpbl.pbl_pbase);
2111 pci_free_consistent(nesdev->pcidev, 4096, vpbl.pbl_vbase,
2112 vpbl.pbl_pbase);
2113 nes_free_resource(nesadapter, nesadapter->allocated_mrs, stag_index);
2114 kfree(nesmr);
2115 return ERR_PTR(-ENOMEM);
2116 }
2117 root_vpbl.pbl_vbase[0].pa_low = cpu_to_le32((u32)vpbl.pbl_pbase);
2118 root_vpbl.pbl_vbase[0].pa_high =
2119 cpu_to_le32((u32)((((u64)vpbl.pbl_pbase) >> 32)));
2120 root_vpbl.leaf_vpbl[0] = vpbl;
2121 }
2122
2123 vpbl.pbl_vbase = pci_alloc_consistent(nesdev->pcidev, 4096,
2124 &vpbl.pbl_pbase);
2125 nes_debug(NES_DBG_MR, "Allocating leaf PBL, va = %p, pa = 0x%016lX\n",
2126 vpbl.pbl_vbase, (unsigned long)vpbl.pbl_pbase);
2127 if (!vpbl.pbl_vbase) {
2128 nes_free_resource(nesadapter, nesadapter->allocated_mrs, stag_index);
2129 ibmr = ERR_PTR(-ENOMEM);
2130 kfree(nesmr);
2131 goto reg_phys_err;
2132 }
2133
2134 if (1 <= root_pbl_index) {
2135 root_vpbl.pbl_vbase[root_pbl_index].pa_low =
2136 cpu_to_le32((u32)vpbl.pbl_pbase);
2137 root_vpbl.pbl_vbase[root_pbl_index].pa_high =
2138 cpu_to_le32((u32)((((u64)vpbl.pbl_pbase) >> 32)));
2139 root_vpbl.leaf_vpbl[root_pbl_index] = vpbl;
2140 }
2141 root_pbl_index++;
2142 cur_pbl_index = 0;
2143 }
2144 if (buffer_list[i].addr & ~PAGE_MASK) {
2145
2146 nes_free_resource(nesadapter, nesadapter->allocated_mrs, stag_index);
2147 nes_debug(NES_DBG_MR, "Unaligned Memory Buffer: 0x%x\n",
2148 (unsigned int) buffer_list[i].addr);
2149 ibmr = ERR_PTR(-EINVAL);
2150 kfree(nesmr);
2151 goto reg_phys_err;
2152 }
2153
2154 if (!buffer_list[i].size) {
2155 nes_free_resource(nesadapter, nesadapter->allocated_mrs, stag_index);
2156 nes_debug(NES_DBG_MR, "Invalid Buffer Size\n");
2157 ibmr = ERR_PTR(-EINVAL);
2158 kfree(nesmr);
2159 goto reg_phys_err;
2160 }
2161
2162 region_length += buffer_list[i].size;
2163 if ((i != 0) && (single_page)) {
2164 if ((buffer_list[i-1].addr+PAGE_SIZE) != buffer_list[i].addr)
2165 single_page = 0;
2166 }
2167 vpbl.pbl_vbase[cur_pbl_index].pa_low = cpu_to_le32((u32)buffer_list[i].addr);
2168 vpbl.pbl_vbase[cur_pbl_index++].pa_high =
2169 cpu_to_le32((u32)((((u64)buffer_list[i].addr) >> 32)));
2170 }
2171
2172 stag = stag_index << 8;
2173 stag |= driver_key;
2174 stag += (u32)stag_key;
2175
2176 nes_debug(NES_DBG_MR, "Registering STag 0x%08X, VA = 0x%016lX,"
2177 " length = 0x%016lX, index = 0x%08X\n",
2178 stag, (unsigned long)*iova_start, (unsigned long)region_length, stag_index);
2179
2180 region_length -= (*iova_start)&PAGE_MASK;
2181
2182
2183 if (root_pbl_index == 1) {
2184 root_vpbl.pbl_pbase = vpbl.pbl_pbase;
2185 }
2186
2187 if (single_page) {
2188 pbl_count = 0;
2189 } else {
2190 pbl_count = root_pbl_index;
2191 }
2192 ret = nes_reg_mr(nesdev, nespd, stag, region_length, &root_vpbl,
2193 buffer_list[0].addr, pbl_count, (u16)cur_pbl_index, acc, iova_start);
2194
2195 if (ret == 0) {
2196 nesmr->ibmr.rkey = stag;
2197 nesmr->ibmr.lkey = stag;
2198 nesmr->mode = IWNES_MEMREG_TYPE_MEM;
2199 ibmr = &nesmr->ibmr;
2200 nesmr->pbl_4k = ((pbl_count > 1) || (cur_pbl_index > 32)) ? 1 : 0;
2201 nesmr->pbls_used = pbl_count;
2202 if (pbl_count > 1) {
2203 nesmr->pbls_used++;
2204 }
2205 } else {
2206 kfree(nesmr);
2207 ibmr = ERR_PTR(-ENOMEM);
2208 }
2209
2210 reg_phys_err:
2211
2212 if (root_pbl_index == 1) {
2213
2214 pci_free_consistent(nesdev->pcidev, 4096, vpbl.pbl_vbase, vpbl.pbl_pbase);
2215 } else {
2216 for (i=0; i<root_pbl_index; i++) {
2217 pci_free_consistent(nesdev->pcidev, 4096, root_vpbl.leaf_vpbl[i].pbl_vbase,
2218 root_vpbl.leaf_vpbl[i].pbl_pbase);
2219 }
2220 kfree(root_vpbl.leaf_vpbl);
2221 pci_free_consistent(nesdev->pcidev, 8192, root_vpbl.pbl_vbase,
2222 root_vpbl.pbl_pbase);
2223 }
2224
2225 return ibmr;
2226}
2227
2228
2229
2230
2231
2232static struct ib_mr *nes_get_dma_mr(struct ib_pd *pd, int acc)
2233{
2234 struct ib_phys_buf bl;
2235 u64 kva = 0;
2236
2237 nes_debug(NES_DBG_MR, "\n");
2238
2239 bl.size = (u64)0xffffffffffULL;
2240 bl.addr = 0;
2241 return nes_reg_phys_mr(pd, &bl, 1, acc, &kva);
2242}
2243
2244
2245
2246
2247
2248static struct ib_mr *nes_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
2249 u64 virt, int acc, struct ib_udata *udata)
2250{
2251 u64 iova_start;
2252 __le64 *pbl;
2253 u64 region_length;
2254 dma_addr_t last_dma_addr = 0;
2255 dma_addr_t first_dma_addr = 0;
2256 struct nes_pd *nespd = to_nespd(pd);
2257 struct nes_vnic *nesvnic = to_nesvnic(pd->device);
2258 struct nes_device *nesdev = nesvnic->nesdev;
2259 struct nes_adapter *nesadapter = nesdev->nesadapter;
2260 struct ib_mr *ibmr = ERR_PTR(-EINVAL);
2261 struct ib_umem_chunk *chunk;
2262 struct nes_ucontext *nes_ucontext;
2263 struct nes_pbl *nespbl;
2264 struct nes_mr *nesmr;
2265 struct ib_umem *region;
2266 struct nes_mem_reg_req req;
2267 struct nes_vpbl vpbl;
2268 struct nes_root_vpbl root_vpbl;
2269 int nmap_index, page_index;
2270 int page_count = 0;
2271 int err, pbl_depth = 0;
2272 int chunk_pages;
2273 int ret;
2274 u32 stag;
2275 u32 stag_index = 0;
2276 u32 next_stag_index;
2277 u32 driver_key;
2278 u32 root_pbl_index = 0;
2279 u32 cur_pbl_index = 0;
2280 u32 skip_pages;
2281 u16 pbl_count;
2282 u8 single_page = 1;
2283 u8 stag_key;
2284
2285 region = ib_umem_get(pd->uobject->context, start, length, acc, 0);
2286 if (IS_ERR(region)) {
2287 return (struct ib_mr *)region;
2288 }
2289
2290 nes_debug(NES_DBG_MR, "User base = 0x%lX, Virt base = 0x%lX, length = %u,"
2291 " offset = %u, page size = %u.\n",
2292 (unsigned long int)start, (unsigned long int)virt, (u32)length,
2293 region->offset, region->page_size);
2294
2295 skip_pages = ((u32)region->offset) >> 12;
2296
2297 if (ib_copy_from_udata(&req, udata, sizeof(req)))
2298 return ERR_PTR(-EFAULT);
2299 nes_debug(NES_DBG_MR, "Memory Registration type = %08X.\n", req.reg_type);
2300
2301 switch (req.reg_type) {
2302 case IWNES_MEMREG_TYPE_MEM:
2303 pbl_depth = 0;
2304 region_length = 0;
2305 vpbl.pbl_vbase = NULL;
2306 root_vpbl.pbl_vbase = NULL;
2307 root_vpbl.pbl_pbase = 0;
2308
2309 get_random_bytes(&next_stag_index, sizeof(next_stag_index));
2310 stag_key = (u8)next_stag_index;
2311
2312 driver_key = next_stag_index & 0x70000000;
2313
2314 next_stag_index >>= 8;
2315 next_stag_index %= nesadapter->max_mr;
2316
2317 err = nes_alloc_resource(nesadapter, nesadapter->allocated_mrs,
2318 nesadapter->max_mr, &stag_index, &next_stag_index);
2319 if (err) {
2320 ib_umem_release(region);
2321 return ERR_PTR(err);
2322 }
2323
2324 nesmr = kzalloc(sizeof(*nesmr), GFP_KERNEL);
2325 if (!nesmr) {
2326 ib_umem_release(region);
2327 nes_free_resource(nesadapter, nesadapter->allocated_mrs, stag_index);
2328 return ERR_PTR(-ENOMEM);
2329 }
2330 nesmr->region = region;
2331
2332 list_for_each_entry(chunk, ®ion->chunk_list, list) {
2333 nes_debug(NES_DBG_MR, "Chunk: nents = %u, nmap = %u .\n",
2334 chunk->nents, chunk->nmap);
2335 for (nmap_index = 0; nmap_index < chunk->nmap; ++nmap_index) {
2336 if (sg_dma_address(&chunk->page_list[nmap_index]) & ~PAGE_MASK) {
2337 ib_umem_release(region);
2338 nes_free_resource(nesadapter, nesadapter->allocated_mrs, stag_index);
2339 nes_debug(NES_DBG_MR, "Unaligned Memory Buffer: 0x%x\n",
2340 (unsigned int) sg_dma_address(&chunk->page_list[nmap_index]));
2341 ibmr = ERR_PTR(-EINVAL);
2342 kfree(nesmr);
2343 goto reg_user_mr_err;
2344 }
2345
2346 if (!sg_dma_len(&chunk->page_list[nmap_index])) {
2347 ib_umem_release(region);
2348 nes_free_resource(nesadapter, nesadapter->allocated_mrs,
2349 stag_index);
2350 nes_debug(NES_DBG_MR, "Invalid Buffer Size\n");
2351 ibmr = ERR_PTR(-EINVAL);
2352 kfree(nesmr);
2353 goto reg_user_mr_err;
2354 }
2355
2356 region_length += sg_dma_len(&chunk->page_list[nmap_index]);
2357 chunk_pages = sg_dma_len(&chunk->page_list[nmap_index]) >> 12;
2358 region_length -= skip_pages << 12;
2359 for (page_index=skip_pages; page_index < chunk_pages; page_index++) {
2360 skip_pages = 0;
2361 if ((page_count!=0)&&(page_count<<12)-(region->offset&(4096-1))>=region->length)
2362 goto enough_pages;
2363 if ((page_count&0x01FF) == 0) {
2364 if (page_count >= 1024 * 512) {
2365 ib_umem_release(region);
2366 nes_free_resource(nesadapter,
2367 nesadapter->allocated_mrs, stag_index);
2368 kfree(nesmr);
2369 ibmr = ERR_PTR(-E2BIG);
2370 goto reg_user_mr_err;
2371 }
2372 if (root_pbl_index == 1) {
2373 root_vpbl.pbl_vbase = pci_alloc_consistent(nesdev->pcidev,
2374 8192, &root_vpbl.pbl_pbase);
2375 nes_debug(NES_DBG_MR, "Allocating root PBL, va = %p, pa = 0x%08X\n",
2376 root_vpbl.pbl_vbase, (unsigned int)root_vpbl.pbl_pbase);
2377 if (!root_vpbl.pbl_vbase) {
2378 ib_umem_release(region);
2379 pci_free_consistent(nesdev->pcidev, 4096, vpbl.pbl_vbase,
2380 vpbl.pbl_pbase);
2381 nes_free_resource(nesadapter, nesadapter->allocated_mrs,
2382 stag_index);
2383 kfree(nesmr);
2384 ibmr = ERR_PTR(-ENOMEM);
2385 goto reg_user_mr_err;
2386 }
2387 root_vpbl.leaf_vpbl = kzalloc(sizeof(*root_vpbl.leaf_vpbl)*1024,
2388 GFP_KERNEL);
2389 if (!root_vpbl.leaf_vpbl) {
2390 ib_umem_release(region);
2391 pci_free_consistent(nesdev->pcidev, 8192, root_vpbl.pbl_vbase,
2392 root_vpbl.pbl_pbase);
2393 pci_free_consistent(nesdev->pcidev, 4096, vpbl.pbl_vbase,
2394 vpbl.pbl_pbase);
2395 nes_free_resource(nesadapter, nesadapter->allocated_mrs,
2396 stag_index);
2397 kfree(nesmr);
2398 ibmr = ERR_PTR(-ENOMEM);
2399 goto reg_user_mr_err;
2400 }
2401 root_vpbl.pbl_vbase[0].pa_low =
2402 cpu_to_le32((u32)vpbl.pbl_pbase);
2403 root_vpbl.pbl_vbase[0].pa_high =
2404 cpu_to_le32((u32)((((u64)vpbl.pbl_pbase) >> 32)));
2405 root_vpbl.leaf_vpbl[0] = vpbl;
2406 }
2407 vpbl.pbl_vbase = pci_alloc_consistent(nesdev->pcidev, 4096,
2408 &vpbl.pbl_pbase);
2409 nes_debug(NES_DBG_MR, "Allocating leaf PBL, va = %p, pa = 0x%08X\n",
2410 vpbl.pbl_vbase, (unsigned int)vpbl.pbl_pbase);
2411 if (!vpbl.pbl_vbase) {
2412 ib_umem_release(region);
2413 nes_free_resource(nesadapter, nesadapter->allocated_mrs, stag_index);
2414 ibmr = ERR_PTR(-ENOMEM);
2415 kfree(nesmr);
2416 goto reg_user_mr_err;
2417 }
2418 if (1 <= root_pbl_index) {
2419 root_vpbl.pbl_vbase[root_pbl_index].pa_low =
2420 cpu_to_le32((u32)vpbl.pbl_pbase);
2421 root_vpbl.pbl_vbase[root_pbl_index].pa_high =
2422 cpu_to_le32((u32)((((u64)vpbl.pbl_pbase)>>32)));
2423 root_vpbl.leaf_vpbl[root_pbl_index] = vpbl;
2424 }
2425 root_pbl_index++;
2426 cur_pbl_index = 0;
2427 }
2428 if (single_page) {
2429 if (page_count != 0) {
2430 if ((last_dma_addr+4096) !=
2431 (sg_dma_address(&chunk->page_list[nmap_index])+
2432 (page_index*4096)))
2433 single_page = 0;
2434 last_dma_addr = sg_dma_address(&chunk->page_list[nmap_index])+
2435 (page_index*4096);
2436 } else {
2437 first_dma_addr = sg_dma_address(&chunk->page_list[nmap_index])+
2438 (page_index*4096);
2439 last_dma_addr = first_dma_addr;
2440 }
2441 }
2442
2443 vpbl.pbl_vbase[cur_pbl_index].pa_low =
2444 cpu_to_le32((u32)(sg_dma_address(&chunk->page_list[nmap_index])+
2445 (page_index*4096)));
2446 vpbl.pbl_vbase[cur_pbl_index].pa_high =
2447 cpu_to_le32((u32)((((u64)(sg_dma_address(&chunk->page_list[nmap_index])+
2448 (page_index*4096))) >> 32)));
2449 cur_pbl_index++;
2450 page_count++;
2451 }
2452 }
2453 }
2454 enough_pages:
2455 nes_debug(NES_DBG_MR, "calculating stag, stag_index=0x%08x, driver_key=0x%08x,"
2456 " stag_key=0x%08x\n",
2457 stag_index, driver_key, stag_key);
2458 stag = stag_index << 8;
2459 stag |= driver_key;
2460 stag += (u32)stag_key;
2461 if (stag == 0) {
2462 stag = 1;
2463 }
2464
2465 iova_start = virt;
2466
2467 if (root_pbl_index == 1) {
2468 root_vpbl.pbl_pbase = vpbl.pbl_pbase;
2469 }
2470
2471 if (single_page) {
2472 pbl_count = 0;
2473 } else {
2474 pbl_count = root_pbl_index;
2475 first_dma_addr = 0;
2476 }
2477 nes_debug(NES_DBG_MR, "Registering STag 0x%08X, VA = 0x%08X, length = 0x%08X,"
2478 " index = 0x%08X, region->length=0x%08llx, pbl_count = %u\n",
2479 stag, (unsigned int)iova_start,
2480 (unsigned int)region_length, stag_index,
2481 (unsigned long long)region->length, pbl_count);
2482 ret = nes_reg_mr( nesdev, nespd, stag, region->length, &root_vpbl,
2483 first_dma_addr, pbl_count, (u16)cur_pbl_index, acc, &iova_start);
2484
2485 nes_debug(NES_DBG_MR, "ret=%d\n", ret);
2486
2487 if (ret == 0) {
2488 nesmr->ibmr.rkey = stag;
2489 nesmr->ibmr.lkey = stag;
2490 nesmr->mode = IWNES_MEMREG_TYPE_MEM;
2491 ibmr = &nesmr->ibmr;
2492 nesmr->pbl_4k = ((pbl_count > 1) || (cur_pbl_index > 32)) ? 1 : 0;
2493 nesmr->pbls_used = pbl_count;
2494 if (pbl_count > 1) {
2495 nesmr->pbls_used++;
2496 }
2497 } else {
2498 ib_umem_release(region);
2499 kfree(nesmr);
2500 ibmr = ERR_PTR(-ENOMEM);
2501 }
2502
2503 reg_user_mr_err:
2504
2505 if (root_pbl_index == 1) {
2506 pci_free_consistent(nesdev->pcidev, 4096, vpbl.pbl_vbase,
2507 vpbl.pbl_pbase);
2508 } else {
2509 for (page_index=0; page_index<root_pbl_index; page_index++) {
2510 pci_free_consistent(nesdev->pcidev, 4096,
2511 root_vpbl.leaf_vpbl[page_index].pbl_vbase,
2512 root_vpbl.leaf_vpbl[page_index].pbl_pbase);
2513 }
2514 kfree(root_vpbl.leaf_vpbl);
2515 pci_free_consistent(nesdev->pcidev, 8192, root_vpbl.pbl_vbase,
2516 root_vpbl.pbl_pbase);
2517 }
2518
2519 nes_debug(NES_DBG_MR, "Leaving, ibmr=%p", ibmr);
2520
2521 return ibmr;
2522 case IWNES_MEMREG_TYPE_QP:
2523 case IWNES_MEMREG_TYPE_CQ:
2524 nespbl = kzalloc(sizeof(*nespbl), GFP_KERNEL);
2525 if (!nespbl) {
2526 nes_debug(NES_DBG_MR, "Unable to allocate PBL\n");
2527 ib_umem_release(region);
2528 return ERR_PTR(-ENOMEM);
2529 }
2530 nesmr = kzalloc(sizeof(*nesmr), GFP_KERNEL);
2531 if (!nesmr) {
2532 ib_umem_release(region);
2533 kfree(nespbl);
2534 nes_debug(NES_DBG_MR, "Unable to allocate nesmr\n");
2535 return ERR_PTR(-ENOMEM);
2536 }
2537 nesmr->region = region;
2538 nes_ucontext = to_nesucontext(pd->uobject->context);
2539 pbl_depth = region->length >> 12;
2540 pbl_depth += (region->length & (4096-1)) ? 1 : 0;
2541 nespbl->pbl_size = pbl_depth*sizeof(u64);
2542 if (req.reg_type == IWNES_MEMREG_TYPE_QP) {
2543 nes_debug(NES_DBG_MR, "Attempting to allocate QP PBL memory");
2544 } else {
2545 nes_debug(NES_DBG_MR, "Attempting to allocate CP PBL memory");
2546 }
2547
2548 nes_debug(NES_DBG_MR, " %u bytes, %u entries.\n",
2549 nespbl->pbl_size, pbl_depth);
2550 pbl = pci_alloc_consistent(nesdev->pcidev, nespbl->pbl_size,
2551 &nespbl->pbl_pbase);
2552 if (!pbl) {
2553 ib_umem_release(region);
2554 kfree(nesmr);
2555 kfree(nespbl);
2556 nes_debug(NES_DBG_MR, "Unable to allocate PBL memory\n");
2557 return ERR_PTR(-ENOMEM);
2558 }
2559
2560 nespbl->pbl_vbase = (u64 *)pbl;
2561 nespbl->user_base = start;
2562 nes_debug(NES_DBG_MR, "Allocated PBL memory, %u bytes, pbl_pbase=%lx,"
2563 " pbl_vbase=%p user_base=0x%lx\n",
2564 nespbl->pbl_size, (unsigned long) nespbl->pbl_pbase,
2565 (void *) nespbl->pbl_vbase, nespbl->user_base);
2566
2567 list_for_each_entry(chunk, ®ion->chunk_list, list) {
2568 for (nmap_index = 0; nmap_index < chunk->nmap; ++nmap_index) {
2569 chunk_pages = sg_dma_len(&chunk->page_list[nmap_index]) >> 12;
2570 chunk_pages += (sg_dma_len(&chunk->page_list[nmap_index]) & (4096-1)) ? 1 : 0;
2571 nespbl->page = sg_page(&chunk->page_list[0]);
2572 for (page_index=0; page_index<chunk_pages; page_index++) {
2573 ((__le32 *)pbl)[0] = cpu_to_le32((u32)
2574 (sg_dma_address(&chunk->page_list[nmap_index])+
2575 (page_index*4096)));
2576 ((__le32 *)pbl)[1] = cpu_to_le32(((u64)
2577 (sg_dma_address(&chunk->page_list[nmap_index])+
2578 (page_index*4096)))>>32);
2579 nes_debug(NES_DBG_MR, "pbl=%p, *pbl=0x%016llx, 0x%08x%08x\n", pbl,
2580 (unsigned long long)*pbl,
2581 le32_to_cpu(((__le32 *)pbl)[1]), le32_to_cpu(((__le32 *)pbl)[0]));
2582 pbl++;
2583 }
2584 }
2585 }
2586 if (req.reg_type == IWNES_MEMREG_TYPE_QP) {
2587 list_add_tail(&nespbl->list, &nes_ucontext->qp_reg_mem_list);
2588 } else {
2589 list_add_tail(&nespbl->list, &nes_ucontext->cq_reg_mem_list);
2590 }
2591 nesmr->ibmr.rkey = -1;
2592 nesmr->ibmr.lkey = -1;
2593 nesmr->mode = req.reg_type;
2594 return &nesmr->ibmr;
2595 }
2596
2597 return ERR_PTR(-ENOSYS);
2598}
2599
2600
2601
2602
2603
2604static int nes_dereg_mr(struct ib_mr *ib_mr)
2605{
2606 struct nes_mr *nesmr = to_nesmr(ib_mr);
2607 struct nes_vnic *nesvnic = to_nesvnic(ib_mr->device);
2608 struct nes_device *nesdev = nesvnic->nesdev;
2609 struct nes_adapter *nesadapter = nesdev->nesadapter;
2610 struct nes_hw_cqp_wqe *cqp_wqe;
2611 struct nes_cqp_request *cqp_request;
2612 unsigned long flags;
2613 int ret;
2614 u16 major_code;
2615 u16 minor_code;
2616
2617 if (nesmr->region) {
2618 ib_umem_release(nesmr->region);
2619 }
2620 if (nesmr->mode != IWNES_MEMREG_TYPE_MEM) {
2621 kfree(nesmr);
2622 return 0;
2623 }
2624
2625
2626
2627 cqp_request = nes_get_cqp_request(nesdev);
2628 if (cqp_request == NULL) {
2629 nes_debug(NES_DBG_MR, "Failed to get a cqp_request.\n");
2630 return -ENOMEM;
2631 }
2632 cqp_request->waiting = 1;
2633 cqp_wqe = &cqp_request->cqp_wqe;
2634
2635 spin_lock_irqsave(&nesadapter->pbl_lock, flags);
2636 if (nesmr->pbls_used != 0) {
2637 if (nesmr->pbl_4k) {
2638 nesadapter->free_4kpbl += nesmr->pbls_used;
2639 if (nesadapter->free_4kpbl > nesadapter->max_4kpbl) {
2640 printk(KERN_ERR PFX "free 4KB PBLs(%u) has exceeded the max(%u)\n",
2641 nesadapter->free_4kpbl, nesadapter->max_4kpbl);
2642 }
2643 } else {
2644 nesadapter->free_256pbl += nesmr->pbls_used;
2645 if (nesadapter->free_256pbl > nesadapter->max_256pbl) {
2646 printk(KERN_ERR PFX "free 256B PBLs(%u) has exceeded the max(%u)\n",
2647 nesadapter->free_256pbl, nesadapter->max_256pbl);
2648 }
2649 }
2650 }
2651
2652 spin_unlock_irqrestore(&nesadapter->pbl_lock, flags);
2653 nes_fill_init_cqp_wqe(cqp_wqe, nesdev);
2654 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_OPCODE_IDX,
2655 NES_CQP_DEALLOCATE_STAG | NES_CQP_STAG_VA_TO |
2656 NES_CQP_STAG_DEALLOC_PBLS | NES_CQP_STAG_MR);
2657 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_STAG_WQE_STAG_IDX, ib_mr->rkey);
2658
2659 atomic_set(&cqp_request->refcount, 2);
2660 nes_post_cqp_request(nesdev, cqp_request);
2661
2662
2663 nes_debug(NES_DBG_MR, "Waiting for deallocate STag 0x%08X completed\n", ib_mr->rkey);
2664 ret = wait_event_timeout(cqp_request->waitq, (cqp_request->request_done != 0),
2665 NES_EVENT_TIMEOUT);
2666 nes_debug(NES_DBG_MR, "Deallocate STag 0x%08X completed, wait_event_timeout ret = %u,"
2667 " CQP Major:Minor codes = 0x%04X:0x%04X\n",
2668 ib_mr->rkey, ret, cqp_request->major_code, cqp_request->minor_code);
2669
2670 nes_free_resource(nesadapter, nesadapter->allocated_mrs,
2671 (ib_mr->rkey & 0x0fffff00) >> 8);
2672
2673 kfree(nesmr);
2674
2675 major_code = cqp_request->major_code;
2676 minor_code = cqp_request->minor_code;
2677
2678 nes_put_cqp_request(nesdev, cqp_request);
2679
2680 if (!ret) {
2681 nes_debug(NES_DBG_MR, "Timeout waiting to destroy STag,"
2682 " ib_mr=%p, rkey = 0x%08X\n",
2683 ib_mr, ib_mr->rkey);
2684 return -ETIME;
2685 } else if (major_code) {
2686 nes_debug(NES_DBG_MR, "Error (0x%04X:0x%04X) while attempting"
2687 " to destroy STag, ib_mr=%p, rkey = 0x%08X\n",
2688 major_code, minor_code, ib_mr, ib_mr->rkey);
2689 return -EIO;
2690 } else
2691 return 0;
2692}
2693
2694
2695
2696
2697
2698static ssize_t show_rev(struct device *dev, struct device_attribute *attr,
2699 char *buf)
2700{
2701 struct nes_ib_device *nesibdev =
2702 container_of(dev, struct nes_ib_device, ibdev.dev);
2703 struct nes_vnic *nesvnic = nesibdev->nesvnic;
2704
2705 nes_debug(NES_DBG_INIT, "\n");
2706 return sprintf(buf, "%x\n", nesvnic->nesdev->nesadapter->hw_rev);
2707}
2708
2709
2710
2711
2712
2713static ssize_t show_fw_ver(struct device *dev, struct device_attribute *attr,
2714 char *buf)
2715{
2716 struct nes_ib_device *nesibdev =
2717 container_of(dev, struct nes_ib_device, ibdev.dev);
2718 struct nes_vnic *nesvnic = nesibdev->nesvnic;
2719
2720 nes_debug(NES_DBG_INIT, "\n");
2721 return sprintf(buf, "%x.%x.%x\n",
2722 (int)(nesvnic->nesdev->nesadapter->fw_ver >> 32),
2723 (int)(nesvnic->nesdev->nesadapter->fw_ver >> 16) & 0xffff,
2724 (int)(nesvnic->nesdev->nesadapter->fw_ver & 0xffff));
2725}
2726
2727
2728
2729
2730
2731static ssize_t show_hca(struct device *dev, struct device_attribute *attr,
2732 char *buf)
2733{
2734 nes_debug(NES_DBG_INIT, "\n");
2735 return sprintf(buf, "NES020\n");
2736}
2737
2738
2739
2740
2741
2742static ssize_t show_board(struct device *dev, struct device_attribute *attr,
2743 char *buf)
2744{
2745 nes_debug(NES_DBG_INIT, "\n");
2746 return sprintf(buf, "%.*s\n", 32, "NES020 Board ID");
2747}
2748
2749
2750static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL);
2751static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL);
2752static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL);
2753static DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL);
2754
2755static struct device_attribute *nes_dev_attributes[] = {
2756 &dev_attr_hw_rev,
2757 &dev_attr_fw_ver,
2758 &dev_attr_hca_type,
2759 &dev_attr_board_id
2760};
2761
2762
2763
2764
2765
2766static int nes_query_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
2767 int attr_mask, struct ib_qp_init_attr *init_attr)
2768{
2769 struct nes_qp *nesqp = to_nesqp(ibqp);
2770
2771 nes_debug(NES_DBG_QP, "\n");
2772
2773 attr->qp_access_flags = 0;
2774 attr->cap.max_send_wr = nesqp->hwqp.sq_size;
2775 attr->cap.max_recv_wr = nesqp->hwqp.rq_size;
2776 attr->cap.max_recv_sge = 1;
2777 if (nes_drv_opt & NES_DRV_OPT_NO_INLINE_DATA) {
2778 init_attr->cap.max_inline_data = 0;
2779 } else {
2780 init_attr->cap.max_inline_data = 64;
2781 }
2782
2783 init_attr->event_handler = nesqp->ibqp.event_handler;
2784 init_attr->qp_context = nesqp->ibqp.qp_context;
2785 init_attr->send_cq = nesqp->ibqp.send_cq;
2786 init_attr->recv_cq = nesqp->ibqp.recv_cq;
2787 init_attr->srq = nesqp->ibqp.srq = nesqp->ibqp.srq;
2788 init_attr->cap = attr->cap;
2789
2790 return 0;
2791}
2792
2793
2794
2795
2796
2797int nes_hw_modify_qp(struct nes_device *nesdev, struct nes_qp *nesqp,
2798 u32 next_iwarp_state, u32 wait_completion)
2799{
2800 struct nes_hw_cqp_wqe *cqp_wqe;
2801
2802
2803 struct nes_cqp_request *cqp_request;
2804 int ret;
2805 u16 major_code;
2806
2807 nes_debug(NES_DBG_MOD_QP, "QP%u, refcount=%d\n",
2808 nesqp->hwqp.qp_id, atomic_read(&nesqp->refcount));
2809
2810 cqp_request = nes_get_cqp_request(nesdev);
2811 if (cqp_request == NULL) {
2812 nes_debug(NES_DBG_MOD_QP, "Failed to get a cqp_request.\n");
2813 return -ENOMEM;
2814 }
2815 if (wait_completion) {
2816 cqp_request->waiting = 1;
2817 } else {
2818 cqp_request->waiting = 0;
2819 }
2820 cqp_wqe = &cqp_request->cqp_wqe;
2821
2822 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_OPCODE_IDX,
2823 NES_CQP_MODIFY_QP | NES_CQP_QP_TYPE_IWARP | next_iwarp_state);
2824 nes_debug(NES_DBG_MOD_QP, "using next_iwarp_state=%08x, wqe_words=%08x\n",
2825 next_iwarp_state, le32_to_cpu(cqp_wqe->wqe_words[NES_CQP_WQE_OPCODE_IDX]));
2826 nes_fill_init_cqp_wqe(cqp_wqe, nesdev);
2827 set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_ID_IDX, nesqp->hwqp.qp_id);
2828 set_wqe_64bit_value(cqp_wqe->wqe_words, NES_CQP_QP_WQE_CONTEXT_LOW_IDX, (u64)nesqp->nesqp_context_pbase);
2829
2830 atomic_set(&cqp_request->refcount, 2);
2831 nes_post_cqp_request(nesdev, cqp_request);
2832
2833
2834 if (wait_completion) {
2835
2836
2837 ret = wait_event_timeout(cqp_request->waitq, (cqp_request->request_done != 0),
2838 NES_EVENT_TIMEOUT);
2839 nes_debug(NES_DBG_MOD_QP, "Modify iwarp QP%u completed, wait_event_timeout ret=%u, "
2840 "CQP Major:Minor codes = 0x%04X:0x%04X.\n",
2841 nesqp->hwqp.qp_id, ret, cqp_request->major_code, cqp_request->minor_code);
2842 major_code = cqp_request->major_code;
2843 if (major_code) {
2844 nes_debug(NES_DBG_MOD_QP, "Modify iwarp QP%u failed"
2845 "CQP Major:Minor codes = 0x%04X:0x%04X, intended next state = 0x%08X.\n",
2846 nesqp->hwqp.qp_id, cqp_request->major_code,
2847 cqp_request->minor_code, next_iwarp_state);
2848 }
2849
2850 nes_put_cqp_request(nesdev, cqp_request);
2851
2852 if (!ret)
2853 return -ETIME;
2854 else if (major_code)
2855 return -EIO;
2856 else
2857 return 0;
2858 } else {
2859 return 0;
2860 }
2861}
2862
2863
2864
2865
2866
2867int nes_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
2868 int attr_mask, struct ib_udata *udata)
2869{
2870 struct nes_qp *nesqp = to_nesqp(ibqp);
2871 struct nes_vnic *nesvnic = to_nesvnic(ibqp->device);
2872 struct nes_device *nesdev = nesvnic->nesdev;
2873
2874
2875 u32 next_iwarp_state = 0;
2876 int err;
2877 unsigned long qplockflags;
2878 int ret;
2879 u16 original_last_aeq;
2880 u8 issue_modify_qp = 0;
2881 u8 issue_disconnect = 0;
2882 u8 dont_wait = 0;
2883
2884 nes_debug(NES_DBG_MOD_QP, "QP%u: QP State=%u, cur QP State=%u,"
2885 " iwarp_state=0x%X, refcount=%d\n",
2886 nesqp->hwqp.qp_id, attr->qp_state, nesqp->ibqp_state,
2887 nesqp->iwarp_state, atomic_read(&nesqp->refcount));
2888
2889 spin_lock_irqsave(&nesqp->lock, qplockflags);
2890
2891 nes_debug(NES_DBG_MOD_QP, "QP%u: hw_iwarp_state=0x%X, hw_tcp_state=0x%X,"
2892 " QP Access Flags=0x%X, attr_mask = 0x%0x\n",
2893 nesqp->hwqp.qp_id, nesqp->hw_iwarp_state,
2894 nesqp->hw_tcp_state, attr->qp_access_flags, attr_mask);
2895
2896 if (attr_mask & IB_QP_STATE) {
2897 switch (attr->qp_state) {
2898 case IB_QPS_INIT:
2899 nes_debug(NES_DBG_MOD_QP, "QP%u: new state = init\n",
2900 nesqp->hwqp.qp_id);
2901 if (nesqp->iwarp_state > (u32)NES_CQP_QP_IWARP_STATE_IDLE) {
2902 spin_unlock_irqrestore(&nesqp->lock, qplockflags);
2903 return -EINVAL;
2904 }
2905 next_iwarp_state = NES_CQP_QP_IWARP_STATE_IDLE;
2906 issue_modify_qp = 1;
2907 break;
2908 case IB_QPS_RTR:
2909 nes_debug(NES_DBG_MOD_QP, "QP%u: new state = rtr\n",
2910 nesqp->hwqp.qp_id);
2911 if (nesqp->iwarp_state>(u32)NES_CQP_QP_IWARP_STATE_IDLE) {
2912 spin_unlock_irqrestore(&nesqp->lock, qplockflags);
2913 return -EINVAL;
2914 }
2915 next_iwarp_state = NES_CQP_QP_IWARP_STATE_IDLE;
2916 issue_modify_qp = 1;
2917 break;
2918 case IB_QPS_RTS:
2919 nes_debug(NES_DBG_MOD_QP, "QP%u: new state = rts\n",
2920 nesqp->hwqp.qp_id);
2921 if (nesqp->iwarp_state>(u32)NES_CQP_QP_IWARP_STATE_RTS) {
2922 spin_unlock_irqrestore(&nesqp->lock, qplockflags);
2923 return -EINVAL;
2924 }
2925 if (nesqp->cm_id == NULL) {
2926 nes_debug(NES_DBG_MOD_QP, "QP%u: Failing attempt to move QP to RTS without a CM_ID. \n",
2927 nesqp->hwqp.qp_id );
2928 spin_unlock_irqrestore(&nesqp->lock, qplockflags);
2929 return -EINVAL;
2930 }
2931 next_iwarp_state = NES_CQP_QP_IWARP_STATE_RTS;
2932 if (nesqp->iwarp_state != NES_CQP_QP_IWARP_STATE_RTS)
2933 next_iwarp_state |= NES_CQP_QP_CONTEXT_VALID |
2934 NES_CQP_QP_ARP_VALID | NES_CQP_QP_ORD_VALID;
2935 issue_modify_qp = 1;
2936 nesqp->hw_tcp_state = NES_AEQE_TCP_STATE_ESTABLISHED;
2937 nesqp->hw_iwarp_state = NES_AEQE_IWARP_STATE_RTS;
2938 nesqp->hte_added = 1;
2939 break;
2940 case IB_QPS_SQD:
2941 issue_modify_qp = 1;
2942 nes_debug(NES_DBG_MOD_QP, "QP%u: new state=closing. SQ head=%u, SQ tail=%u\n",
2943 nesqp->hwqp.qp_id, nesqp->hwqp.sq_head, nesqp->hwqp.sq_tail);
2944 if (nesqp->iwarp_state == (u32)NES_CQP_QP_IWARP_STATE_CLOSING) {
2945 spin_unlock_irqrestore(&nesqp->lock, qplockflags);
2946 return 0;
2947 } else {
2948 if (nesqp->iwarp_state > (u32)NES_CQP_QP_IWARP_STATE_CLOSING) {
2949 nes_debug(NES_DBG_MOD_QP, "QP%u: State change to closing"
2950 " ignored due to current iWARP state\n",
2951 nesqp->hwqp.qp_id);
2952 spin_unlock_irqrestore(&nesqp->lock, qplockflags);
2953 return -EINVAL;
2954 }
2955 if (nesqp->hw_iwarp_state != NES_AEQE_IWARP_STATE_RTS) {
2956 nes_debug(NES_DBG_MOD_QP, "QP%u: State change to closing"
2957 " already done based on hw state.\n",
2958 nesqp->hwqp.qp_id);
2959 issue_modify_qp = 0;
2960 nesqp->in_disconnect = 0;
2961 }
2962 switch (nesqp->hw_iwarp_state) {
2963 case NES_AEQE_IWARP_STATE_CLOSING:
2964 next_iwarp_state = NES_CQP_QP_IWARP_STATE_CLOSING;
2965 case NES_AEQE_IWARP_STATE_TERMINATE:
2966 next_iwarp_state = NES_CQP_QP_IWARP_STATE_TERMINATE;
2967 break;
2968 case NES_AEQE_IWARP_STATE_ERROR:
2969 next_iwarp_state = NES_CQP_QP_IWARP_STATE_ERROR;
2970 break;
2971 default:
2972 next_iwarp_state = NES_CQP_QP_IWARP_STATE_CLOSING;
2973 nesqp->in_disconnect = 1;
2974 nesqp->hw_iwarp_state = NES_AEQE_IWARP_STATE_CLOSING;
2975 break;
2976 }
2977 }
2978 break;
2979 case IB_QPS_SQE:
2980 nes_debug(NES_DBG_MOD_QP, "QP%u: new state = terminate\n",
2981 nesqp->hwqp.qp_id);
2982 if (nesqp->iwarp_state>=(u32)NES_CQP_QP_IWARP_STATE_TERMINATE) {
2983 spin_unlock_irqrestore(&nesqp->lock, qplockflags);
2984 return -EINVAL;
2985 }
2986
2987 next_iwarp_state = NES_CQP_QP_IWARP_STATE_TERMINATE;
2988 nesqp->hw_iwarp_state = NES_AEQE_IWARP_STATE_TERMINATE;
2989 issue_modify_qp = 1;
2990 nesqp->in_disconnect = 1;
2991 break;
2992 case IB_QPS_ERR:
2993 case IB_QPS_RESET:
2994 if (nesqp->iwarp_state == (u32)NES_CQP_QP_IWARP_STATE_ERROR) {
2995 spin_unlock_irqrestore(&nesqp->lock, qplockflags);
2996 return -EINVAL;
2997 }
2998 nes_debug(NES_DBG_MOD_QP, "QP%u: new state = error\n",
2999 nesqp->hwqp.qp_id);
3000 next_iwarp_state = NES_CQP_QP_IWARP_STATE_ERROR;
3001
3002 if (nesqp->hte_added) {
3003 nes_debug(NES_DBG_MOD_QP, "set CQP_QP_DEL_HTE\n");
3004 next_iwarp_state |= NES_CQP_QP_DEL_HTE;
3005 nesqp->hte_added = 0;
3006 }
3007 if ((nesqp->hw_tcp_state > NES_AEQE_TCP_STATE_CLOSED) &&
3008 (nesqp->hw_tcp_state != NES_AEQE_TCP_STATE_TIME_WAIT)) {
3009 next_iwarp_state |= NES_CQP_QP_RESET;
3010 nesqp->in_disconnect = 1;
3011 } else {
3012 nes_debug(NES_DBG_MOD_QP, "QP%u NOT setting NES_CQP_QP_RESET since TCP state = %u\n",
3013 nesqp->hwqp.qp_id, nesqp->hw_tcp_state);
3014 dont_wait = 1;
3015 }
3016 issue_modify_qp = 1;
3017 nesqp->hw_iwarp_state = NES_AEQE_IWARP_STATE_ERROR;
3018 break;
3019 default:
3020 spin_unlock_irqrestore(&nesqp->lock, qplockflags);
3021 return -EINVAL;
3022 break;
3023 }
3024
3025 nesqp->ibqp_state = attr->qp_state;
3026 if (((nesqp->iwarp_state & NES_CQP_QP_IWARP_STATE_MASK) ==
3027 (u32)NES_CQP_QP_IWARP_STATE_RTS) &&
3028 ((next_iwarp_state & NES_CQP_QP_IWARP_STATE_MASK) >
3029 (u32)NES_CQP_QP_IWARP_STATE_RTS)) {
3030 nesqp->iwarp_state = next_iwarp_state & NES_CQP_QP_IWARP_STATE_MASK;
3031 nes_debug(NES_DBG_MOD_QP, "Change nesqp->iwarp_state=%08x\n",
3032 nesqp->iwarp_state);
3033 issue_disconnect = 1;
3034 } else {
3035 nesqp->iwarp_state = next_iwarp_state & NES_CQP_QP_IWARP_STATE_MASK;
3036 nes_debug(NES_DBG_MOD_QP, "Change nesqp->iwarp_state=%08x\n",
3037 nesqp->iwarp_state);
3038 }
3039 }
3040
3041 if (attr_mask & IB_QP_ACCESS_FLAGS) {
3042 if (attr->qp_access_flags & IB_ACCESS_LOCAL_WRITE) {
3043 nesqp->nesqp_context->misc |= cpu_to_le32(NES_QPCONTEXT_MISC_RDMA_WRITE_EN |
3044 NES_QPCONTEXT_MISC_RDMA_READ_EN);
3045 issue_modify_qp = 1;
3046 }
3047 if (attr->qp_access_flags & IB_ACCESS_REMOTE_WRITE) {
3048 nesqp->nesqp_context->misc |= cpu_to_le32(NES_QPCONTEXT_MISC_RDMA_WRITE_EN);
3049 issue_modify_qp = 1;
3050 }
3051 if (attr->qp_access_flags & IB_ACCESS_REMOTE_READ) {
3052 nesqp->nesqp_context->misc |= cpu_to_le32(NES_QPCONTEXT_MISC_RDMA_READ_EN);
3053 issue_modify_qp = 1;
3054 }
3055 if (attr->qp_access_flags & IB_ACCESS_MW_BIND) {
3056 nesqp->nesqp_context->misc |= cpu_to_le32(NES_QPCONTEXT_MISC_WBIND_EN);
3057 issue_modify_qp = 1;
3058 }
3059
3060 if (nesqp->user_mode) {
3061 nesqp->nesqp_context->misc |= cpu_to_le32(NES_QPCONTEXT_MISC_RDMA_WRITE_EN |
3062 NES_QPCONTEXT_MISC_RDMA_READ_EN);
3063 issue_modify_qp = 1;
3064 }
3065 }
3066
3067 original_last_aeq = nesqp->last_aeq;
3068 spin_unlock_irqrestore(&nesqp->lock, qplockflags);
3069
3070 nes_debug(NES_DBG_MOD_QP, "issue_modify_qp=%u\n", issue_modify_qp);
3071
3072 ret = 0;
3073
3074
3075 if (issue_modify_qp) {
3076 nes_debug(NES_DBG_MOD_QP, "call nes_hw_modify_qp\n");
3077 ret = nes_hw_modify_qp(nesdev, nesqp, next_iwarp_state, 1);
3078 if (ret)
3079 nes_debug(NES_DBG_MOD_QP, "nes_hw_modify_qp (next_iwarp_state = 0x%08X)"
3080 " failed for QP%u.\n",
3081 next_iwarp_state, nesqp->hwqp.qp_id);
3082
3083 }
3084
3085 if ((issue_modify_qp) && (nesqp->ibqp_state > IB_QPS_RTS)) {
3086 nes_debug(NES_DBG_MOD_QP, "QP%u Issued ModifyQP refcount (%d),"
3087 " original_last_aeq = 0x%04X. last_aeq = 0x%04X.\n",
3088 nesqp->hwqp.qp_id, atomic_read(&nesqp->refcount),
3089 original_last_aeq, nesqp->last_aeq);
3090 if ((!ret) ||
3091 ((original_last_aeq != NES_AEQE_AEID_RDMAP_ROE_BAD_LLP_CLOSE) &&
3092 (ret))) {
3093 if (dont_wait) {
3094 if (nesqp->cm_id && nesqp->hw_tcp_state != 0) {
3095 nes_debug(NES_DBG_MOD_QP, "QP%u Queuing fake disconnect for QP refcount (%d),"
3096 " original_last_aeq = 0x%04X. last_aeq = 0x%04X.\n",
3097 nesqp->hwqp.qp_id, atomic_read(&nesqp->refcount),
3098 original_last_aeq, nesqp->last_aeq);
3099
3100 spin_lock_irqsave(&nesqp->lock, qplockflags);
3101 nesqp->hw_tcp_state = NES_AEQE_TCP_STATE_CLOSED;
3102 nesqp->last_aeq = NES_AEQE_AEID_RESET_SENT;
3103 spin_unlock_irqrestore(&nesqp->lock, qplockflags);
3104 nes_cm_disconn(nesqp);
3105 } else {
3106 nes_debug(NES_DBG_MOD_QP, "QP%u No fake disconnect, QP refcount=%d\n",
3107 nesqp->hwqp.qp_id, atomic_read(&nesqp->refcount));
3108 }
3109 } else {
3110 spin_lock_irqsave(&nesqp->lock, qplockflags);
3111 if (nesqp->cm_id) {
3112
3113 if (atomic_inc_return(&nesqp->close_timer_started) == 1) {
3114 nesqp->cm_id->add_ref(nesqp->cm_id);
3115 nes_debug(NES_DBG_MOD_QP, "QP%u Not decrementing QP refcount (%d),"
3116 " need ae to finish up, original_last_aeq = 0x%04X."
3117 " last_aeq = 0x%04X, scheduling timer.\n",
3118 nesqp->hwqp.qp_id, atomic_read(&nesqp->refcount),
3119 original_last_aeq, nesqp->last_aeq);
3120 schedule_nes_timer(nesqp->cm_node, (struct sk_buff *) nesqp, NES_TIMER_TYPE_CLOSE, 1, 0);
3121 }
3122 spin_unlock_irqrestore(&nesqp->lock, qplockflags);
3123 } else {
3124 spin_unlock_irqrestore(&nesqp->lock, qplockflags);
3125 nes_debug(NES_DBG_MOD_QP, "QP%u Not decrementing QP refcount (%d),"
3126 " need ae to finish up, original_last_aeq = 0x%04X."
3127 " last_aeq = 0x%04X.\n",
3128 nesqp->hwqp.qp_id, atomic_read(&nesqp->refcount),
3129 original_last_aeq, nesqp->last_aeq);
3130 }
3131 }
3132 } else {
3133 nes_debug(NES_DBG_MOD_QP, "QP%u Decrementing QP refcount (%d), No ae to finish up,"
3134 " original_last_aeq = 0x%04X. last_aeq = 0x%04X.\n",
3135 nesqp->hwqp.qp_id, atomic_read(&nesqp->refcount),
3136 original_last_aeq, nesqp->last_aeq);
3137 }
3138 } else {
3139 nes_debug(NES_DBG_MOD_QP, "QP%u Decrementing QP refcount (%d), No ae to finish up,"
3140 " original_last_aeq = 0x%04X. last_aeq = 0x%04X.\n",
3141 nesqp->hwqp.qp_id, atomic_read(&nesqp->refcount),
3142 original_last_aeq, nesqp->last_aeq);
3143 }
3144
3145 err = 0;
3146
3147 nes_debug(NES_DBG_MOD_QP, "QP%u Leaving, refcount=%d\n",
3148 nesqp->hwqp.qp_id, atomic_read(&nesqp->refcount));
3149
3150 return err;
3151}
3152
3153
3154
3155
3156
3157static int nes_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
3158{
3159 nes_debug(NES_DBG_INIT, "\n");
3160 return -ENOSYS;
3161}
3162
3163
3164
3165
3166
3167static int nes_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
3168{
3169 nes_debug(NES_DBG_INIT, "\n");
3170 return -ENOSYS;
3171}
3172
3173
3174
3175
3176
3177static int nes_process_mad(struct ib_device *ibdev, int mad_flags,
3178 u8 port_num, struct ib_wc *in_wc, struct ib_grh *in_grh,
3179 struct ib_mad *in_mad, struct ib_mad *out_mad)
3180{
3181 nes_debug(NES_DBG_INIT, "\n");
3182 return -ENOSYS;
3183}
3184
3185static inline void
3186fill_wqe_sg_send(struct nes_hw_qp_wqe *wqe, struct ib_send_wr *ib_wr, u32 uselkey)
3187{
3188 int sge_index;
3189 int total_payload_length = 0;
3190 for (sge_index = 0; sge_index < ib_wr->num_sge; sge_index++) {
3191 set_wqe_64bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_FRAG0_LOW_IDX+(sge_index*4),
3192 ib_wr->sg_list[sge_index].addr);
3193 set_wqe_32bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_LENGTH0_IDX + (sge_index*4),
3194 ib_wr->sg_list[sge_index].length);
3195 if (uselkey)
3196 set_wqe_32bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_STAG0_IDX + (sge_index*4),
3197 (ib_wr->sg_list[sge_index].lkey));
3198 else
3199 set_wqe_32bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_STAG0_IDX + (sge_index*4), 0);
3200
3201 total_payload_length += ib_wr->sg_list[sge_index].length;
3202 }
3203 nes_debug(NES_DBG_IW_TX, "UC UC UC, sending total_payload_length=%u \n",
3204 total_payload_length);
3205 set_wqe_32bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_TOTAL_PAYLOAD_IDX,
3206 total_payload_length);
3207}
3208
3209
3210
3211
3212static int nes_post_send(struct ib_qp *ibqp, struct ib_send_wr *ib_wr,
3213 struct ib_send_wr **bad_wr)
3214{
3215 u64 u64temp;
3216 unsigned long flags = 0;
3217 struct nes_vnic *nesvnic = to_nesvnic(ibqp->device);
3218 struct nes_device *nesdev = nesvnic->nesdev;
3219 struct nes_qp *nesqp = to_nesqp(ibqp);
3220 struct nes_hw_qp_wqe *wqe;
3221 int err;
3222 u32 qsize = nesqp->hwqp.sq_size;
3223 u32 head;
3224 u32 wqe_misc;
3225 u32 wqe_count;
3226 u32 counter;
3227 u32 total_payload_length;
3228
3229 err = 0;
3230 wqe_misc = 0;
3231 wqe_count = 0;
3232 total_payload_length = 0;
3233
3234 if (nesqp->ibqp_state > IB_QPS_RTS)
3235 return -EINVAL;
3236
3237 spin_lock_irqsave(&nesqp->lock, flags);
3238
3239 head = nesqp->hwqp.sq_head;
3240
3241 while (ib_wr) {
3242
3243 if (((head + (2 * qsize) - nesqp->hwqp.sq_tail) % qsize) == (qsize - 1)) {
3244 err = -EINVAL;
3245 break;
3246 }
3247
3248 wqe = &nesqp->hwqp.sq_vbase[head];
3249
3250
3251 nes_fill_init_qp_wqe(wqe, nesqp, head);
3252 u64temp = (u64)(ib_wr->wr_id);
3253 set_wqe_64bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_COMP_SCRATCH_LOW_IDX,
3254 u64temp);
3255 switch (ib_wr->opcode) {
3256 case IB_WR_SEND:
3257 if (ib_wr->send_flags & IB_SEND_SOLICITED) {
3258 wqe_misc = NES_IWARP_SQ_OP_SENDSE;
3259 } else {
3260 wqe_misc = NES_IWARP_SQ_OP_SEND;
3261 }
3262 if (ib_wr->num_sge > nesdev->nesadapter->max_sge) {
3263 err = -EINVAL;
3264 break;
3265 }
3266 if (ib_wr->send_flags & IB_SEND_FENCE) {
3267 wqe_misc |= NES_IWARP_SQ_WQE_LOCAL_FENCE;
3268 }
3269 if ((ib_wr->send_flags & IB_SEND_INLINE) &&
3270 ((nes_drv_opt & NES_DRV_OPT_NO_INLINE_DATA) == 0) &&
3271 (ib_wr->sg_list[0].length <= 64)) {
3272 memcpy(&wqe->wqe_words[NES_IWARP_SQ_WQE_IMM_DATA_START_IDX],
3273 (void *)(unsigned long)ib_wr->sg_list[0].addr, ib_wr->sg_list[0].length);
3274 set_wqe_32bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_TOTAL_PAYLOAD_IDX,
3275 ib_wr->sg_list[0].length);
3276 wqe_misc |= NES_IWARP_SQ_WQE_IMM_DATA;
3277 } else {
3278 fill_wqe_sg_send(wqe, ib_wr, 1);
3279 }
3280
3281 break;
3282 case IB_WR_RDMA_WRITE:
3283 wqe_misc = NES_IWARP_SQ_OP_RDMAW;
3284 if (ib_wr->num_sge > nesdev->nesadapter->max_sge) {
3285 nes_debug(NES_DBG_IW_TX, "Exceeded max sge, ib_wr=%u, max=%u\n",
3286 ib_wr->num_sge,
3287 nesdev->nesadapter->max_sge);
3288 err = -EINVAL;
3289 break;
3290 }
3291 if (ib_wr->send_flags & IB_SEND_FENCE) {
3292 wqe_misc |= NES_IWARP_SQ_WQE_LOCAL_FENCE;
3293 }
3294
3295 set_wqe_32bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_RDMA_STAG_IDX,
3296 ib_wr->wr.rdma.rkey);
3297 set_wqe_64bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_RDMA_TO_LOW_IDX,
3298 ib_wr->wr.rdma.remote_addr);
3299
3300 if ((ib_wr->send_flags & IB_SEND_INLINE) &&
3301 ((nes_drv_opt & NES_DRV_OPT_NO_INLINE_DATA) == 0) &&
3302 (ib_wr->sg_list[0].length <= 64)) {
3303 memcpy(&wqe->wqe_words[NES_IWARP_SQ_WQE_IMM_DATA_START_IDX],
3304 (void *)(unsigned long)ib_wr->sg_list[0].addr, ib_wr->sg_list[0].length);
3305 set_wqe_32bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_TOTAL_PAYLOAD_IDX,
3306 ib_wr->sg_list[0].length);
3307 wqe_misc |= NES_IWARP_SQ_WQE_IMM_DATA;
3308 } else {
3309 fill_wqe_sg_send(wqe, ib_wr, 1);
3310 }
3311 wqe->wqe_words[NES_IWARP_SQ_WQE_RDMA_LENGTH_IDX] =
3312 wqe->wqe_words[NES_IWARP_SQ_WQE_TOTAL_PAYLOAD_IDX];
3313 break;
3314 case IB_WR_RDMA_READ:
3315
3316 if (ib_wr->num_sge > 1) {
3317 nes_debug(NES_DBG_IW_TX, "Exceeded max sge, ib_wr=%u, max=1\n",
3318 ib_wr->num_sge);
3319 err = -EINVAL;
3320 break;
3321 }
3322 wqe_misc = NES_IWARP_SQ_OP_RDMAR;
3323 set_wqe_64bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_RDMA_TO_LOW_IDX,
3324 ib_wr->wr.rdma.remote_addr);
3325 set_wqe_32bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_RDMA_STAG_IDX,
3326 ib_wr->wr.rdma.rkey);
3327 set_wqe_32bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_RDMA_LENGTH_IDX,
3328 ib_wr->sg_list->length);
3329 set_wqe_64bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_FRAG0_LOW_IDX,
3330 ib_wr->sg_list->addr);
3331 set_wqe_32bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_STAG0_IDX,
3332 ib_wr->sg_list->lkey);
3333 break;
3334 default:
3335
3336 err = -EINVAL;
3337 break;
3338 }
3339
3340 if (ib_wr->send_flags & IB_SEND_SIGNALED) {
3341 wqe_misc |= NES_IWARP_SQ_WQE_SIGNALED_COMPL;
3342 }
3343 wqe->wqe_words[NES_IWARP_SQ_WQE_MISC_IDX] = cpu_to_le32(wqe_misc);
3344
3345 ib_wr = ib_wr->next;
3346 head++;
3347 wqe_count++;
3348 if (head >= qsize)
3349 head = 0;
3350
3351 }
3352
3353 nesqp->hwqp.sq_head = head;
3354 barrier();
3355 while (wqe_count) {
3356 counter = min(wqe_count, ((u32)255));
3357 wqe_count -= counter;
3358 nes_write32(nesdev->regs + NES_WQE_ALLOC,
3359 (counter << 24) | 0x00800000 | nesqp->hwqp.qp_id);
3360 }
3361
3362 spin_unlock_irqrestore(&nesqp->lock, flags);
3363
3364 if (err)
3365 *bad_wr = ib_wr;
3366 return err;
3367}
3368
3369
3370
3371
3372
3373static int nes_post_recv(struct ib_qp *ibqp, struct ib_recv_wr *ib_wr,
3374 struct ib_recv_wr **bad_wr)
3375{
3376 u64 u64temp;
3377 unsigned long flags = 0;
3378 struct nes_vnic *nesvnic = to_nesvnic(ibqp->device);
3379 struct nes_device *nesdev = nesvnic->nesdev;
3380 struct nes_qp *nesqp = to_nesqp(ibqp);
3381 struct nes_hw_qp_wqe *wqe;
3382 int err = 0;
3383 int sge_index;
3384 u32 qsize = nesqp->hwqp.rq_size;
3385 u32 head;
3386 u32 wqe_count = 0;
3387 u32 counter;
3388 u32 total_payload_length;
3389
3390 if (nesqp->ibqp_state > IB_QPS_RTS)
3391 return -EINVAL;
3392
3393 spin_lock_irqsave(&nesqp->lock, flags);
3394
3395 head = nesqp->hwqp.rq_head;
3396
3397 while (ib_wr) {
3398 if (ib_wr->num_sge > nesdev->nesadapter->max_sge) {
3399 err = -EINVAL;
3400 break;
3401 }
3402
3403 if (((head + (2 * qsize) - nesqp->hwqp.rq_tail) % qsize) == (qsize - 1)) {
3404 err = -EINVAL;
3405 break;
3406 }
3407
3408 nes_debug(NES_DBG_IW_RX, "ibwr sge count = %u.\n", ib_wr->num_sge);
3409 wqe = &nesqp->hwqp.rq_vbase[head];
3410
3411
3412
3413 nes_fill_init_qp_wqe(wqe, nesqp, head);
3414 u64temp = (u64)(ib_wr->wr_id);
3415 set_wqe_64bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_COMP_SCRATCH_LOW_IDX,
3416 u64temp);
3417 total_payload_length = 0;
3418 for (sge_index=0; sge_index < ib_wr->num_sge; sge_index++) {
3419 set_wqe_64bit_value(wqe->wqe_words, NES_IWARP_RQ_WQE_FRAG0_LOW_IDX+(sge_index*4),
3420 ib_wr->sg_list[sge_index].addr);
3421 set_wqe_32bit_value(wqe->wqe_words, NES_IWARP_RQ_WQE_LENGTH0_IDX+(sge_index*4),
3422 ib_wr->sg_list[sge_index].length);
3423 set_wqe_32bit_value(wqe->wqe_words,NES_IWARP_RQ_WQE_STAG0_IDX+(sge_index*4),
3424 ib_wr->sg_list[sge_index].lkey);
3425
3426 total_payload_length += ib_wr->sg_list[sge_index].length;
3427 }
3428 set_wqe_32bit_value(wqe->wqe_words, NES_IWARP_RQ_WQE_TOTAL_PAYLOAD_IDX,
3429 total_payload_length);
3430
3431 ib_wr = ib_wr->next;
3432 head++;
3433 wqe_count++;
3434 if (head >= qsize)
3435 head = 0;
3436 }
3437
3438 nesqp->hwqp.rq_head = head;
3439 barrier();
3440 while (wqe_count) {
3441 counter = min(wqe_count, ((u32)255));
3442 wqe_count -= counter;
3443 nes_write32(nesdev->regs+NES_WQE_ALLOC, (counter<<24) | nesqp->hwqp.qp_id);
3444 }
3445
3446 spin_unlock_irqrestore(&nesqp->lock, flags);
3447
3448 if (err)
3449 *bad_wr = ib_wr;
3450 return err;
3451}
3452
3453
3454
3455
3456
3457static int nes_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *entry)
3458{
3459 u64 u64temp;
3460 u64 wrid;
3461
3462 unsigned long flags = 0;
3463 struct nes_vnic *nesvnic = to_nesvnic(ibcq->device);
3464 struct nes_device *nesdev = nesvnic->nesdev;
3465 struct nes_cq *nescq = to_nescq(ibcq);
3466 struct nes_qp *nesqp;
3467 struct nes_hw_cqe cqe;
3468 u32 head;
3469 u32 wq_tail;
3470 u32 cq_size;
3471 u32 cqe_count = 0;
3472 u32 wqe_index;
3473 u32 u32temp;
3474
3475
3476 nes_debug(NES_DBG_CQ, "\n");
3477
3478 spin_lock_irqsave(&nescq->lock, flags);
3479
3480 head = nescq->hw_cq.cq_head;
3481 cq_size = nescq->hw_cq.cq_size;
3482
3483 while (cqe_count < num_entries) {
3484 if (le32_to_cpu(nescq->hw_cq.cq_vbase[head].cqe_words[NES_CQE_OPCODE_IDX]) &
3485 NES_CQE_VALID) {
3486
3487
3488
3489
3490 rmb();
3491
3492 cqe = nescq->hw_cq.cq_vbase[head];
3493 nescq->hw_cq.cq_vbase[head].cqe_words[NES_CQE_OPCODE_IDX] = 0;
3494 u32temp = le32_to_cpu(cqe.cqe_words[NES_CQE_COMP_COMP_CTX_LOW_IDX]);
3495 wqe_index = u32temp &
3496 (nesdev->nesadapter->max_qp_wr - 1);
3497 u32temp &= ~(NES_SW_CONTEXT_ALIGN-1);
3498
3499 u64temp = (((u64)(le32_to_cpu(cqe.cqe_words[NES_CQE_COMP_COMP_CTX_HIGH_IDX])))<<32) |
3500 ((u64)u32temp);
3501 nesqp = *((struct nes_qp **)&u64temp);
3502 memset(entry, 0, sizeof *entry);
3503 if (cqe.cqe_words[NES_CQE_ERROR_CODE_IDX] == 0) {
3504 entry->status = IB_WC_SUCCESS;
3505 } else {
3506 entry->status = IB_WC_WR_FLUSH_ERR;
3507 }
3508
3509 entry->qp = &nesqp->ibqp;
3510 entry->src_qp = nesqp->hwqp.qp_id;
3511
3512 if (le32_to_cpu(cqe.cqe_words[NES_CQE_OPCODE_IDX]) & NES_CQE_SQ) {
3513 if (nesqp->skip_lsmm) {
3514 nesqp->skip_lsmm = 0;
3515 wq_tail = nesqp->hwqp.sq_tail++;
3516 }
3517
3518
3519 wq_tail = wqe_index;
3520 nesqp->hwqp.sq_tail = (wqe_index+1)&(nesqp->hwqp.sq_size - 1);
3521 wrid = (((u64)(cpu_to_le32((u32)nesqp->hwqp.sq_vbase[wq_tail].
3522 wqe_words[NES_IWARP_SQ_WQE_COMP_SCRATCH_HIGH_IDX]))) << 32) |
3523 ((u64)(cpu_to_le32((u32)nesqp->hwqp.sq_vbase[wq_tail].
3524 wqe_words[NES_IWARP_SQ_WQE_COMP_SCRATCH_LOW_IDX])));
3525 entry->byte_len = le32_to_cpu(nesqp->hwqp.sq_vbase[wq_tail].
3526 wqe_words[NES_IWARP_SQ_WQE_TOTAL_PAYLOAD_IDX]);
3527
3528 switch (le32_to_cpu(nesqp->hwqp.sq_vbase[wq_tail].
3529 wqe_words[NES_IWARP_SQ_WQE_MISC_IDX]) & 0x3f) {
3530 case NES_IWARP_SQ_OP_RDMAW:
3531 nes_debug(NES_DBG_CQ, "Operation = RDMA WRITE.\n");
3532 entry->opcode = IB_WC_RDMA_WRITE;
3533 break;
3534 case NES_IWARP_SQ_OP_RDMAR:
3535 nes_debug(NES_DBG_CQ, "Operation = RDMA READ.\n");
3536 entry->opcode = IB_WC_RDMA_READ;
3537 entry->byte_len = le32_to_cpu(nesqp->hwqp.sq_vbase[wq_tail].
3538 wqe_words[NES_IWARP_SQ_WQE_RDMA_LENGTH_IDX]);
3539 break;
3540 case NES_IWARP_SQ_OP_SENDINV:
3541 case NES_IWARP_SQ_OP_SENDSEINV:
3542 case NES_IWARP_SQ_OP_SEND:
3543 case NES_IWARP_SQ_OP_SENDSE:
3544 nes_debug(NES_DBG_CQ, "Operation = Send.\n");
3545 entry->opcode = IB_WC_SEND;
3546 break;
3547 }
3548 } else {
3549
3550 wq_tail = wqe_index;
3551 nesqp->hwqp.rq_tail = (wqe_index+1)&(nesqp->hwqp.rq_size - 1);
3552 entry->byte_len = le32_to_cpu(cqe.cqe_words[NES_CQE_PAYLOAD_LENGTH_IDX]);
3553 wrid = ((u64)(le32_to_cpu(nesqp->hwqp.rq_vbase[wq_tail].wqe_words[NES_IWARP_RQ_WQE_COMP_SCRATCH_LOW_IDX]))) |
3554 ((u64)(le32_to_cpu(nesqp->hwqp.rq_vbase[wq_tail].wqe_words[NES_IWARP_RQ_WQE_COMP_SCRATCH_HIGH_IDX]))<<32);
3555 entry->opcode = IB_WC_RECV;
3556 }
3557 entry->wr_id = wrid;
3558
3559 if (++head >= cq_size)
3560 head = 0;
3561 cqe_count++;
3562 nescq->polled_completions++;
3563 if ((nescq->polled_completions > (cq_size / 2)) ||
3564 (nescq->polled_completions == 255)) {
3565 nes_debug(NES_DBG_CQ, "CQ%u Issuing CQE Allocate since more than half of cqes"
3566 " are pending %u of %u.\n",
3567 nescq->hw_cq.cq_number, nescq->polled_completions, cq_size);
3568 nes_write32(nesdev->regs+NES_CQE_ALLOC,
3569 nescq->hw_cq.cq_number | (nescq->polled_completions << 16));
3570 nescq->polled_completions = 0;
3571 }
3572 entry++;
3573 } else
3574 break;
3575 }
3576
3577 if (nescq->polled_completions) {
3578 nes_write32(nesdev->regs+NES_CQE_ALLOC,
3579 nescq->hw_cq.cq_number | (nescq->polled_completions << 16));
3580 nescq->polled_completions = 0;
3581 }
3582
3583 nescq->hw_cq.cq_head = head;
3584 nes_debug(NES_DBG_CQ, "Reporting %u completions for CQ%u.\n",
3585 cqe_count, nescq->hw_cq.cq_number);
3586
3587 spin_unlock_irqrestore(&nescq->lock, flags);
3588
3589 return cqe_count;
3590}
3591
3592
3593
3594
3595
3596static int nes_req_notify_cq(struct ib_cq *ibcq, enum ib_cq_notify_flags notify_flags)
3597 {
3598 struct nes_vnic *nesvnic = to_nesvnic(ibcq->device);
3599 struct nes_device *nesdev = nesvnic->nesdev;
3600 struct nes_cq *nescq = to_nescq(ibcq);
3601 u32 cq_arm;
3602
3603 nes_debug(NES_DBG_CQ, "Requesting notification for CQ%u.\n",
3604 nescq->hw_cq.cq_number);
3605
3606 cq_arm = nescq->hw_cq.cq_number;
3607 if ((notify_flags & IB_CQ_SOLICITED_MASK) == IB_CQ_NEXT_COMP)
3608 cq_arm |= NES_CQE_ALLOC_NOTIFY_NEXT;
3609 else if ((notify_flags & IB_CQ_SOLICITED_MASK) == IB_CQ_SOLICITED)
3610 cq_arm |= NES_CQE_ALLOC_NOTIFY_SE;
3611 else
3612 return -EINVAL;
3613
3614 nes_write32(nesdev->regs+NES_CQE_ALLOC, cq_arm);
3615 nes_read32(nesdev->regs+NES_CQE_ALLOC);
3616
3617 return 0;
3618}
3619
3620
3621
3622
3623
3624struct nes_ib_device *nes_init_ofa_device(struct net_device *netdev)
3625{
3626 struct nes_ib_device *nesibdev;
3627 struct nes_vnic *nesvnic = netdev_priv(netdev);
3628 struct nes_device *nesdev = nesvnic->nesdev;
3629
3630 nesibdev = (struct nes_ib_device *)ib_alloc_device(sizeof(struct nes_ib_device));
3631 if (nesibdev == NULL) {
3632 return NULL;
3633 }
3634 strlcpy(nesibdev->ibdev.name, "nes%d", IB_DEVICE_NAME_MAX);
3635 nesibdev->ibdev.owner = THIS_MODULE;
3636
3637 nesibdev->ibdev.node_type = RDMA_NODE_RNIC;
3638 memset(&nesibdev->ibdev.node_guid, 0, sizeof(nesibdev->ibdev.node_guid));
3639 memcpy(&nesibdev->ibdev.node_guid, netdev->dev_addr, 6);
3640
3641 nesibdev->ibdev.uverbs_cmd_mask =
3642 (1ull << IB_USER_VERBS_CMD_GET_CONTEXT) |
3643 (1ull << IB_USER_VERBS_CMD_QUERY_DEVICE) |
3644 (1ull << IB_USER_VERBS_CMD_QUERY_PORT) |
3645 (1ull << IB_USER_VERBS_CMD_ALLOC_PD) |
3646 (1ull << IB_USER_VERBS_CMD_DEALLOC_PD) |
3647 (1ull << IB_USER_VERBS_CMD_REG_MR) |
3648 (1ull << IB_USER_VERBS_CMD_DEREG_MR) |
3649 (1ull << IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL) |
3650 (1ull << IB_USER_VERBS_CMD_CREATE_CQ) |
3651 (1ull << IB_USER_VERBS_CMD_DESTROY_CQ) |
3652 (1ull << IB_USER_VERBS_CMD_CREATE_AH) |
3653 (1ull << IB_USER_VERBS_CMD_DESTROY_AH) |
3654 (1ull << IB_USER_VERBS_CMD_REQ_NOTIFY_CQ) |
3655 (1ull << IB_USER_VERBS_CMD_CREATE_QP) |
3656 (1ull << IB_USER_VERBS_CMD_MODIFY_QP) |
3657 (1ull << IB_USER_VERBS_CMD_POLL_CQ) |
3658 (1ull << IB_USER_VERBS_CMD_DESTROY_QP) |
3659 (1ull << IB_USER_VERBS_CMD_ALLOC_MW) |
3660 (1ull << IB_USER_VERBS_CMD_BIND_MW) |
3661 (1ull << IB_USER_VERBS_CMD_DEALLOC_MW) |
3662 (1ull << IB_USER_VERBS_CMD_POST_RECV) |
3663 (1ull << IB_USER_VERBS_CMD_POST_SEND);
3664
3665 nesibdev->ibdev.phys_port_cnt = 1;
3666 nesibdev->ibdev.num_comp_vectors = 1;
3667 nesibdev->ibdev.dma_device = &nesdev->pcidev->dev;
3668 nesibdev->ibdev.dev.parent = &nesdev->pcidev->dev;
3669 nesibdev->ibdev.query_device = nes_query_device;
3670 nesibdev->ibdev.query_port = nes_query_port;
3671 nesibdev->ibdev.modify_port = nes_modify_port;
3672 nesibdev->ibdev.query_pkey = nes_query_pkey;
3673 nesibdev->ibdev.query_gid = nes_query_gid;
3674 nesibdev->ibdev.alloc_ucontext = nes_alloc_ucontext;
3675 nesibdev->ibdev.dealloc_ucontext = nes_dealloc_ucontext;
3676 nesibdev->ibdev.mmap = nes_mmap;
3677 nesibdev->ibdev.alloc_pd = nes_alloc_pd;
3678 nesibdev->ibdev.dealloc_pd = nes_dealloc_pd;
3679 nesibdev->ibdev.create_ah = nes_create_ah;
3680 nesibdev->ibdev.destroy_ah = nes_destroy_ah;
3681 nesibdev->ibdev.create_qp = nes_create_qp;
3682 nesibdev->ibdev.modify_qp = nes_modify_qp;
3683 nesibdev->ibdev.query_qp = nes_query_qp;
3684 nesibdev->ibdev.destroy_qp = nes_destroy_qp;
3685 nesibdev->ibdev.create_cq = nes_create_cq;
3686 nesibdev->ibdev.destroy_cq = nes_destroy_cq;
3687 nesibdev->ibdev.poll_cq = nes_poll_cq;
3688 nesibdev->ibdev.get_dma_mr = nes_get_dma_mr;
3689 nesibdev->ibdev.reg_phys_mr = nes_reg_phys_mr;
3690 nesibdev->ibdev.reg_user_mr = nes_reg_user_mr;
3691 nesibdev->ibdev.dereg_mr = nes_dereg_mr;
3692 nesibdev->ibdev.alloc_mw = nes_alloc_mw;
3693 nesibdev->ibdev.dealloc_mw = nes_dealloc_mw;
3694 nesibdev->ibdev.bind_mw = nes_bind_mw;
3695
3696 nesibdev->ibdev.alloc_fmr = nes_alloc_fmr;
3697 nesibdev->ibdev.unmap_fmr = nes_unmap_fmr;
3698 nesibdev->ibdev.dealloc_fmr = nes_dealloc_fmr;
3699 nesibdev->ibdev.map_phys_fmr = nes_map_phys_fmr;
3700
3701 nesibdev->ibdev.attach_mcast = nes_multicast_attach;
3702 nesibdev->ibdev.detach_mcast = nes_multicast_detach;
3703 nesibdev->ibdev.process_mad = nes_process_mad;
3704
3705 nesibdev->ibdev.req_notify_cq = nes_req_notify_cq;
3706 nesibdev->ibdev.post_send = nes_post_send;
3707 nesibdev->ibdev.post_recv = nes_post_recv;
3708
3709 nesibdev->ibdev.iwcm = kzalloc(sizeof(*nesibdev->ibdev.iwcm), GFP_KERNEL);
3710 if (nesibdev->ibdev.iwcm == NULL) {
3711 ib_dealloc_device(&nesibdev->ibdev);
3712 return NULL;
3713 }
3714 nesibdev->ibdev.iwcm->add_ref = nes_add_ref;
3715 nesibdev->ibdev.iwcm->rem_ref = nes_rem_ref;
3716 nesibdev->ibdev.iwcm->get_qp = nes_get_qp;
3717 nesibdev->ibdev.iwcm->connect = nes_connect;
3718 nesibdev->ibdev.iwcm->accept = nes_accept;
3719 nesibdev->ibdev.iwcm->reject = nes_reject;
3720 nesibdev->ibdev.iwcm->create_listen = nes_create_listen;
3721 nesibdev->ibdev.iwcm->destroy_listen = nes_destroy_listen;
3722
3723 return nesibdev;
3724}
3725
3726
3727
3728
3729
3730void nes_destroy_ofa_device(struct nes_ib_device *nesibdev)
3731{
3732 if (nesibdev == NULL)
3733 return;
3734
3735 nes_unregister_ofa_device(nesibdev);
3736
3737 kfree(nesibdev->ibdev.iwcm);
3738 ib_dealloc_device(&nesibdev->ibdev);
3739}
3740
3741
3742
3743
3744
3745int nes_register_ofa_device(struct nes_ib_device *nesibdev)
3746{
3747 struct nes_vnic *nesvnic = nesibdev->nesvnic;
3748 struct nes_device *nesdev = nesvnic->nesdev;
3749 struct nes_adapter *nesadapter = nesdev->nesadapter;
3750 int i, ret;
3751
3752 ret = ib_register_device(&nesvnic->nesibdev->ibdev);
3753 if (ret) {
3754 return ret;
3755 }
3756
3757
3758 nesibdev->max_cq = (nesadapter->max_cq-NES_FIRST_QPN) / nesadapter->port_count;
3759 nesibdev->max_mr = nesadapter->max_mr / nesadapter->port_count;
3760 nesibdev->max_qp = (nesadapter->max_qp-NES_FIRST_QPN) / nesadapter->port_count;
3761 nesibdev->max_pd = nesadapter->max_pd / nesadapter->port_count;
3762
3763 for (i = 0; i < ARRAY_SIZE(nes_dev_attributes); ++i) {
3764 ret = device_create_file(&nesibdev->ibdev.dev, nes_dev_attributes[i]);
3765 if (ret) {
3766 while (i > 0) {
3767 i--;
3768 device_remove_file(&nesibdev->ibdev.dev,
3769 nes_dev_attributes[i]);
3770 }
3771 ib_unregister_device(&nesibdev->ibdev);
3772 return ret;
3773 }
3774 }
3775
3776 nesvnic->of_device_registered = 1;
3777
3778 return 0;
3779}
3780
3781
3782
3783
3784
3785static void nes_unregister_ofa_device(struct nes_ib_device *nesibdev)
3786{
3787 struct nes_vnic *nesvnic = nesibdev->nesvnic;
3788 int i;
3789
3790 for (i = 0; i < ARRAY_SIZE(nes_dev_attributes); ++i) {
3791 device_remove_file(&nesibdev->ibdev.dev, nes_dev_attributes[i]);
3792 }
3793
3794 if (nesvnic->of_device_registered) {
3795 ib_unregister_device(&nesibdev->ibdev);
3796 }
3797
3798 nesvnic->of_device_registered = 0;
3799}