projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland...
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / infiniband / hw / ehca / ehca_main.c
1 /*
2 * IBM eServer eHCA Infiniband device driver for Linux on POWER
3 *
4 * module start stop, hca detection
5 *
6 * Authors: Heiko J Schick <schickhj@de.ibm.com>
7 * Hoang-Nam Nguyen <hnguyen@de.ibm.com>
8 * Joachim Fenkes <fenkes@de.ibm.com>
9 *
10 * Copyright (c) 2005 IBM Corporation
11 *
12 * All rights reserved.
13 *
14 * This source code is distributed under a dual license of GPL v2.0 and OpenIB
15 * BSD.
16 *
17 * OpenIB BSD License
18 *
19 * Redistribution and use in source and binary forms, with or without
20 * modification, are permitted provided that the following conditions are met:
21 *
22 * Redistributions of source code must retain the above copyright notice, this
23 * list of conditions and the following disclaimer.
24 *
25 * Redistributions in binary form must reproduce the above copyright notice,
26 * this list of conditions and the following disclaimer in the documentation
27 * and/or other materials
28 * provided with the distribution.
29 *
30 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
31 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
32 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
33 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
34 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
35 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
36 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
37 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
38 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
39 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
40 * POSSIBILITY OF SUCH DAMAGE.
41 */
42
43 #ifdef CONFIG_PPC_64K_PAGES
44 #include <linux/slab.h>
45 #endif
46 #include "ehca_classes.h"
47 #include "ehca_iverbs.h"
48 #include "ehca_mrmw.h"
49 #include "ehca_tools.h"
50 #include "hcp_if.h"
51
52 #define HCAD_VERSION "0024"
53
54 MODULE_LICENSE("Dual BSD/GPL");
55 MODULE_AUTHOR("Christoph Raisch <raisch@de.ibm.com>");
56 MODULE_DESCRIPTION("IBM eServer HCA InfiniBand Device Driver");
57 MODULE_VERSION(HCAD_VERSION);
58
59 int ehca_open_aqp1 = 0;
60 int ehca_debug_level = 0;
61 int ehca_hw_level = 0;
62 int ehca_nr_ports = 2;
63 int ehca_use_hp_mr = 0;
64 int ehca_port_act_time = 30;
65 int ehca_poll_all_eqs = 1;
66 int ehca_static_rate = -1;
67 int ehca_scaling_code = 0;
68 int ehca_mr_largepage = 1;
69
70 module_param_named(open_aqp1, ehca_open_aqp1, int, S_IRUGO);
71 module_param_named(debug_level, ehca_debug_level, int, S_IRUGO);
72 module_param_named(hw_level, ehca_hw_level, int, S_IRUGO);
73 module_param_named(nr_ports, ehca_nr_ports, int, S_IRUGO);
74 module_param_named(use_hp_mr, ehca_use_hp_mr, int, S_IRUGO);
75 module_param_named(port_act_time, ehca_port_act_time, int, S_IRUGO);
76 module_param_named(poll_all_eqs, ehca_poll_all_eqs, int, S_IRUGO);
77 module_param_named(static_rate, ehca_static_rate, int, S_IRUGO);
78 module_param_named(scaling_code, ehca_scaling_code, int, S_IRUGO);
79 module_param_named(mr_largepage, ehca_mr_largepage, int, S_IRUGO);
80
81 MODULE_PARM_DESC(open_aqp1,
82 "AQP1 on startup (0: no (default), 1: yes)");
83 MODULE_PARM_DESC(debug_level,
84 "debug level"
85 " (0: no debug traces (default), 1: with debug traces)");
86 MODULE_PARM_DESC(hw_level,
87 "hardware level"
88 " (0: autosensing (default), 1: v. 0.20, 2: v. 0.21)");
89 MODULE_PARM_DESC(nr_ports,
90 "number of connected ports (default: 2)");
91 MODULE_PARM_DESC(use_hp_mr,
92 "high performance MRs (0: no (default), 1: yes)");
93 MODULE_PARM_DESC(port_act_time,
94 "time to wait for port activation (default: 30 sec)");
95 MODULE_PARM_DESC(poll_all_eqs,
96 "polls all event queues periodically"
97 " (0: no, 1: yes (default))");
98 MODULE_PARM_DESC(static_rate,
99 "set permanent static rate (default: disabled)");
100 MODULE_PARM_DESC(scaling_code,
101 "set scaling code (0: disabled/default, 1: enabled)");
102 MODULE_PARM_DESC(mr_largepage,
103 "use large page for MR (0: use PAGE_SIZE (default), "
104 "1: use large page depending on MR size");
105
106 DEFINE_RWLOCK(ehca_qp_idr_lock);
107 DEFINE_RWLOCK(ehca_cq_idr_lock);
108 DEFINE_IDR(ehca_qp_idr);
109 DEFINE_IDR(ehca_cq_idr);
110
111 static LIST_HEAD(shca_list); /* list of all registered ehcas */
112 static DEFINE_SPINLOCK(shca_list_lock);
113
114 static struct timer_list poll_eqs_timer;
115
116 #ifdef CONFIG_PPC_64K_PAGES
117 static struct kmem_cache *ctblk_cache;
118
119 void *ehca_alloc_fw_ctrlblock(gfp_t flags)
120 {
121 void *ret = kmem_cache_zalloc(ctblk_cache, flags);
122 if (!ret)
123 ehca_gen_err("Out of memory for ctblk");
124 return ret;
125 }
126
127 void ehca_free_fw_ctrlblock(void *ptr)
128 {
129 if (ptr)
130 kmem_cache_free(ctblk_cache, ptr);
131
132 }
133 #endif
134
135 int ehca2ib_return_code(u64 ehca_rc)
136 {
137 switch (ehca_rc) {
138 case H_SUCCESS:
139 return 0;
140 case H_RESOURCE: /* Resource in use */
141 case H_BUSY:
142 return -EBUSY;
143 case H_NOT_ENOUGH_RESOURCES: /* insufficient resources */
144 case H_CONSTRAINED: /* resource constraint */
145 case H_NO_MEM:
146 return -ENOMEM;
147 default:
148 return -EINVAL;
149 }
150 }
151
152 static int ehca_create_slab_caches(void)
153 {
154 int ret;
155
156 ret = ehca_init_pd_cache();
157 if (ret) {
158 ehca_gen_err("Cannot create PD SLAB cache.");
159 return ret;
160 }
161
162 ret = ehca_init_cq_cache();
163 if (ret) {
164 ehca_gen_err("Cannot create CQ SLAB cache.");
165 goto create_slab_caches2;
166 }
167
168 ret = ehca_init_qp_cache();
169 if (ret) {
170 ehca_gen_err("Cannot create QP SLAB cache.");
171 goto create_slab_caches3;
172 }
173
174 ret = ehca_init_av_cache();
175 if (ret) {
176 ehca_gen_err("Cannot create AV SLAB cache.");
177 goto create_slab_caches4;
178 }
179
180 ret = ehca_init_mrmw_cache();
181 if (ret) {
182 ehca_gen_err("Cannot create MR&MW SLAB cache.");
183 goto create_slab_caches5;
184 }
185
186 ret = ehca_init_small_qp_cache();
187 if (ret) {
188 ehca_gen_err("Cannot create small queue SLAB cache.");
189 goto create_slab_caches6;
190 }
191
192 #ifdef CONFIG_PPC_64K_PAGES
193 ctblk_cache = kmem_cache_create("ehca_cache_ctblk",
194 EHCA_PAGESIZE, H_CB_ALIGNMENT,
195 SLAB_HWCACHE_ALIGN,
196 NULL);
197 if (!ctblk_cache) {
198 ehca_gen_err("Cannot create ctblk SLAB cache.");
199 ehca_cleanup_small_qp_cache();
200 goto create_slab_caches6;
201 }
202 #endif
203 return 0;
204
205 create_slab_caches6:
206 ehca_cleanup_mrmw_cache();
207
208 create_slab_caches5:
209 ehca_cleanup_av_cache();
210
211 create_slab_caches4:
212 ehca_cleanup_qp_cache();
213
214 create_slab_caches3:
215 ehca_cleanup_cq_cache();
216
217 create_slab_caches2:
218 ehca_cleanup_pd_cache();
219
220 return ret;
221 }
222
223 static void ehca_destroy_slab_caches(void)
224 {
225 ehca_cleanup_small_qp_cache();
226 ehca_cleanup_mrmw_cache();
227 ehca_cleanup_av_cache();
228 ehca_cleanup_qp_cache();
229 ehca_cleanup_cq_cache();
230 ehca_cleanup_pd_cache();
231 #ifdef CONFIG_PPC_64K_PAGES
232 if (ctblk_cache)
233 kmem_cache_destroy(ctblk_cache);
234 #endif
235 }
236
237 #define EHCA_HCAAVER EHCA_BMASK_IBM(32, 39)
238 #define EHCA_REVID EHCA_BMASK_IBM(40, 63)
239
240 static struct cap_descr {
241 u64 mask;
242 char *descr;
243 } hca_cap_descr[] = {
244 { HCA_CAP_AH_PORT_NR_CHECK, "HCA_CAP_AH_PORT_NR_CHECK" },
245 { HCA_CAP_ATOMIC, "HCA_CAP_ATOMIC" },
246 { HCA_CAP_AUTO_PATH_MIG, "HCA_CAP_AUTO_PATH_MIG" },
247 { HCA_CAP_BAD_P_KEY_CTR, "HCA_CAP_BAD_P_KEY_CTR" },
248 { HCA_CAP_SQD_RTS_PORT_CHANGE, "HCA_CAP_SQD_RTS_PORT_CHANGE" },
249 { HCA_CAP_CUR_QP_STATE_MOD, "HCA_CAP_CUR_QP_STATE_MOD" },
250 { HCA_CAP_INIT_TYPE, "HCA_CAP_INIT_TYPE" },
251 { HCA_CAP_PORT_ACTIVE_EVENT, "HCA_CAP_PORT_ACTIVE_EVENT" },
252 { HCA_CAP_Q_KEY_VIOL_CTR, "HCA_CAP_Q_KEY_VIOL_CTR" },
253 { HCA_CAP_WQE_RESIZE, "HCA_CAP_WQE_RESIZE" },
254 { HCA_CAP_RAW_PACKET_MCAST, "HCA_CAP_RAW_PACKET_MCAST" },
255 { HCA_CAP_SHUTDOWN_PORT, "HCA_CAP_SHUTDOWN_PORT" },
256 { HCA_CAP_RC_LL_QP, "HCA_CAP_RC_LL_QP" },
257 { HCA_CAP_SRQ, "HCA_CAP_SRQ" },
258 { HCA_CAP_UD_LL_QP, "HCA_CAP_UD_LL_QP" },
259 { HCA_CAP_RESIZE_MR, "HCA_CAP_RESIZE_MR" },
260 { HCA_CAP_MINI_QP, "HCA_CAP_MINI_QP" },
261 };
262
263 static int ehca_sense_attributes(struct ehca_shca *shca)
264 {
265 int i, ret = 0;
266 u64 h_ret;
267 struct hipz_query_hca *rblock;
268 struct hipz_query_port *port;
269
270 static const u32 pgsize_map[] = {
271 HCA_CAP_MR_PGSIZE_4K, 0x1000,
272 HCA_CAP_MR_PGSIZE_64K, 0x10000,
273 HCA_CAP_MR_PGSIZE_1M, 0x100000,
274 HCA_CAP_MR_PGSIZE_16M, 0x1000000,
275 };
276
277 rblock = ehca_alloc_fw_ctrlblock(GFP_KERNEL);
278 if (!rblock) {
279 ehca_gen_err("Cannot allocate rblock memory.");
280 return -ENOMEM;
281 }
282
283 h_ret = hipz_h_query_hca(shca->ipz_hca_handle, rblock);
284 if (h_ret != H_SUCCESS) {
285 ehca_gen_err("Cannot query device properties. h_ret=%li",
286 h_ret);
287 ret = -EPERM;
288 goto sense_attributes1;
289 }
290
291 if (ehca_nr_ports == 1)
292 shca->num_ports = 1;
293 else
294 shca->num_ports = (u8)rblock->num_ports;
295
296 ehca_gen_dbg(" ... found %x ports", rblock->num_ports);
297
298 if (ehca_hw_level == 0) {
299 u32 hcaaver;
300 u32 revid;
301
302 hcaaver = EHCA_BMASK_GET(EHCA_HCAAVER, rblock->hw_ver);
303 revid = EHCA_BMASK_GET(EHCA_REVID, rblock->hw_ver);
304
305 ehca_gen_dbg(" ... hardware version=%x:%x", hcaaver, revid);
306
307 if (hcaaver == 1) {
308 if (revid <= 3)
309 shca->hw_level = 0x10 | (revid + 1);
310 else
311 shca->hw_level = 0x14;
312 } else if (hcaaver == 2) {
313 if (revid == 0)
314 shca->hw_level = 0x21;
315 else if (revid == 0x10)
316 shca->hw_level = 0x22;
317 else if (revid == 0x20 || revid == 0x21)
318 shca->hw_level = 0x23;
319 }
320
321 if (!shca->hw_level) {
322 ehca_gen_warn("unknown hardware version"
323 " - assuming default level");
324 shca->hw_level = 0x22;
325 }
326 } else
327 shca->hw_level = ehca_hw_level;
328 ehca_gen_dbg(" ... hardware level=%x", shca->hw_level);
329
330 shca->sport[0].rate = IB_RATE_30_GBPS;
331 shca->sport[1].rate = IB_RATE_30_GBPS;
332
333 shca->hca_cap = rblock->hca_cap_indicators;
334 ehca_gen_dbg(" ... HCA capabilities:");
335 for (i = 0; i < ARRAY_SIZE(hca_cap_descr); i++)
336 if (EHCA_BMASK_GET(hca_cap_descr[i].mask, shca->hca_cap))
337 ehca_gen_dbg(" %s", hca_cap_descr[i].descr);
338
339 /* translate supported MR page sizes; always support 4K */
340 shca->hca_cap_mr_pgsize = EHCA_PAGESIZE;
341 if (ehca_mr_largepage) { /* support extra sizes only if enabled */
342 for (i = 0; i < ARRAY_SIZE(pgsize_map); i += 2)
343 if (rblock->memory_page_size_supported & pgsize_map[i])
344 shca->hca_cap_mr_pgsize |= pgsize_map[i + 1];
345 }
346
347 /* query max MTU from first port -- it's the same for all ports */
348 port = (struct hipz_query_port *)rblock;
349 h_ret = hipz_h_query_port(shca->ipz_hca_handle, 1, port);
350 if (h_ret != H_SUCCESS) {
351 ehca_gen_err("Cannot query port properties. h_ret=%li",
352 h_ret);
353 ret = -EPERM;
354 goto sense_attributes1;
355 }
356
357 shca->max_mtu = port->max_mtu;
358
359 sense_attributes1:
360 ehca_free_fw_ctrlblock(rblock);
361 return ret;
362 }
363
364 static int init_node_guid(struct ehca_shca *shca)
365 {
366 int ret = 0;
367 struct hipz_query_hca *rblock;
368
369 rblock = ehca_alloc_fw_ctrlblock(GFP_KERNEL);
370 if (!rblock) {
371 ehca_err(&shca->ib_device, "Can't allocate rblock memory.");
372 return -ENOMEM;
373 }
374
375 if (hipz_h_query_hca(shca->ipz_hca_handle, rblock) != H_SUCCESS) {
376 ehca_err(&shca->ib_device, "Can't query device properties");
377 ret = -EINVAL;
378 goto init_node_guid1;
379 }
380
381 memcpy(&shca->ib_device.node_guid, &rblock->node_guid, sizeof(u64));
382
383 init_node_guid1:
384 ehca_free_fw_ctrlblock(rblock);
385 return ret;
386 }
387
388 int ehca_init_device(struct ehca_shca *shca)
389 {
390 int ret;
391
392 ret = init_node_guid(shca);
393 if (ret)
394 return ret;
395
396 strlcpy(shca->ib_device.name, "ehca%d", IB_DEVICE_NAME_MAX);
397 shca->ib_device.owner = THIS_MODULE;
398
399 shca->ib_device.uverbs_abi_ver = 8;
400 shca->ib_device.uverbs_cmd_mask =
401 (1ull << IB_USER_VERBS_CMD_GET_CONTEXT) |
402 (1ull << IB_USER_VERBS_CMD_QUERY_DEVICE) |
403 (1ull << IB_USER_VERBS_CMD_QUERY_PORT) |
404 (1ull << IB_USER_VERBS_CMD_ALLOC_PD) |
405 (1ull << IB_USER_VERBS_CMD_DEALLOC_PD) |
406 (1ull << IB_USER_VERBS_CMD_REG_MR) |
407 (1ull << IB_USER_VERBS_CMD_DEREG_MR) |
408 (1ull << IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL) |
409 (1ull << IB_USER_VERBS_CMD_CREATE_CQ) |
410 (1ull << IB_USER_VERBS_CMD_DESTROY_CQ) |
411 (1ull << IB_USER_VERBS_CMD_CREATE_QP) |
412 (1ull << IB_USER_VERBS_CMD_MODIFY_QP) |
413 (1ull << IB_USER_VERBS_CMD_QUERY_QP) |
414 (1ull << IB_USER_VERBS_CMD_DESTROY_QP) |
415 (1ull << IB_USER_VERBS_CMD_ATTACH_MCAST) |
416 (1ull << IB_USER_VERBS_CMD_DETACH_MCAST);
417
418 shca->ib_device.node_type = RDMA_NODE_IB_CA;
419 shca->ib_device.phys_port_cnt = shca->num_ports;
420 shca->ib_device.num_comp_vectors = 1;
421 shca->ib_device.dma_device = &shca->ofdev->dev;
422 shca->ib_device.query_device = ehca_query_device;
423 shca->ib_device.query_port = ehca_query_port;
424 shca->ib_device.query_gid = ehca_query_gid;
425 shca->ib_device.query_pkey = ehca_query_pkey;
426 /* shca->in_device.modify_device = ehca_modify_device */
427 shca->ib_device.modify_port = ehca_modify_port;
428 shca->ib_device.alloc_ucontext = ehca_alloc_ucontext;
429 shca->ib_device.dealloc_ucontext = ehca_dealloc_ucontext;
430 shca->ib_device.alloc_pd = ehca_alloc_pd;
431 shca->ib_device.dealloc_pd = ehca_dealloc_pd;
432 shca->ib_device.create_ah = ehca_create_ah;
433 /* shca->ib_device.modify_ah = ehca_modify_ah; */
434 shca->ib_device.query_ah = ehca_query_ah;
435 shca->ib_device.destroy_ah = ehca_destroy_ah;
436 shca->ib_device.create_qp = ehca_create_qp;
437 shca->ib_device.modify_qp = ehca_modify_qp;
438 shca->ib_device.query_qp = ehca_query_qp;
439 shca->ib_device.destroy_qp = ehca_destroy_qp;
440 shca->ib_device.post_send = ehca_post_send;
441 shca->ib_device.post_recv = ehca_post_recv;
442 shca->ib_device.create_cq = ehca_create_cq;
443 shca->ib_device.destroy_cq = ehca_destroy_cq;
444 shca->ib_device.resize_cq = ehca_resize_cq;
445 shca->ib_device.poll_cq = ehca_poll_cq;
446 /* shca->ib_device.peek_cq = ehca_peek_cq; */
447 shca->ib_device.req_notify_cq = ehca_req_notify_cq;
448 /* shca->ib_device.req_ncomp_notif = ehca_req_ncomp_notif; */
449 shca->ib_device.get_dma_mr = ehca_get_dma_mr;
450 shca->ib_device.reg_phys_mr = ehca_reg_phys_mr;
451 shca->ib_device.reg_user_mr = ehca_reg_user_mr;
452 shca->ib_device.query_mr = ehca_query_mr;
453 shca->ib_device.dereg_mr = ehca_dereg_mr;
454 shca->ib_device.rereg_phys_mr = ehca_rereg_phys_mr;
455 shca->ib_device.alloc_mw = ehca_alloc_mw;
456 shca->ib_device.bind_mw = ehca_bind_mw;
457 shca->ib_device.dealloc_mw = ehca_dealloc_mw;
458 shca->ib_device.alloc_fmr = ehca_alloc_fmr;
459 shca->ib_device.map_phys_fmr = ehca_map_phys_fmr;
460 shca->ib_device.unmap_fmr = ehca_unmap_fmr;
461 shca->ib_device.dealloc_fmr = ehca_dealloc_fmr;
462 shca->ib_device.attach_mcast = ehca_attach_mcast;
463 shca->ib_device.detach_mcast = ehca_detach_mcast;
464 /* shca->ib_device.process_mad = ehca_process_mad; */
465 shca->ib_device.mmap = ehca_mmap;
466
467 if (EHCA_BMASK_GET(HCA_CAP_SRQ, shca->hca_cap)) {
468 shca->ib_device.uverbs_cmd_mask |=
469 (1ull << IB_USER_VERBS_CMD_CREATE_SRQ) |
470 (1ull << IB_USER_VERBS_CMD_MODIFY_SRQ) |
471 (1ull << IB_USER_VERBS_CMD_QUERY_SRQ) |
472 (1ull << IB_USER_VERBS_CMD_DESTROY_SRQ);
473
474 shca->ib_device.create_srq = ehca_create_srq;
475 shca->ib_device.modify_srq = ehca_modify_srq;
476 shca->ib_device.query_srq = ehca_query_srq;
477 shca->ib_device.destroy_srq = ehca_destroy_srq;
478 shca->ib_device.post_srq_recv = ehca_post_srq_recv;
479 }
480
481 return ret;
482 }
483
484 static int ehca_create_aqp1(struct ehca_shca *shca, u32 port)
485 {
486 struct ehca_sport *sport = &shca->sport[port - 1];
487 struct ib_cq *ibcq;
488 struct ib_qp *ibqp;
489 struct ib_qp_init_attr qp_init_attr;
490 int ret;
491
492 if (sport->ibcq_aqp1) {
493 ehca_err(&shca->ib_device, "AQP1 CQ is already created.");
494 return -EPERM;
495 }
496
497 ibcq = ib_create_cq(&shca->ib_device, NULL, NULL, (void *)(-1), 10, 0);
498 if (IS_ERR(ibcq)) {
499 ehca_err(&shca->ib_device, "Cannot create AQP1 CQ.");
500 return PTR_ERR(ibcq);
501 }
502 sport->ibcq_aqp1 = ibcq;
503
504 if (sport->ibqp_aqp1) {
505 ehca_err(&shca->ib_device, "AQP1 QP is already created.");
506 ret = -EPERM;
507 goto create_aqp1;
508 }
509
510 memset(&qp_init_attr, 0, sizeof(struct ib_qp_init_attr));
511 qp_init_attr.send_cq = ibcq;
512 qp_init_attr.recv_cq = ibcq;
513 qp_init_attr.sq_sig_type = IB_SIGNAL_ALL_WR;
514 qp_init_attr.cap.max_send_wr = 100;
515 qp_init_attr.cap.max_recv_wr = 100;
516 qp_init_attr.cap.max_send_sge = 2;
517 qp_init_attr.cap.max_recv_sge = 1;
518 qp_init_attr.qp_type = IB_QPT_GSI;
519 qp_init_attr.port_num = port;
520 qp_init_attr.qp_context = NULL;
521 qp_init_attr.event_handler = NULL;
522 qp_init_attr.srq = NULL;
523
524 ibqp = ib_create_qp(&shca->pd->ib_pd, &qp_init_attr);
525 if (IS_ERR(ibqp)) {
526 ehca_err(&shca->ib_device, "Cannot create AQP1 QP.");
527 ret = PTR_ERR(ibqp);
528 goto create_aqp1;
529 }
530 sport->ibqp_aqp1 = ibqp;
531
532 return 0;
533
534 create_aqp1:
535 ib_destroy_cq(sport->ibcq_aqp1);
536 return ret;
537 }
538
539 static int ehca_destroy_aqp1(struct ehca_sport *sport)
540 {
541 int ret;
542
543 ret = ib_destroy_qp(sport->ibqp_aqp1);
544 if (ret) {
545 ehca_gen_err("Cannot destroy AQP1 QP. ret=%i", ret);
546 return ret;
547 }
548
549 ret = ib_destroy_cq(sport->ibcq_aqp1);
550 if (ret)
551 ehca_gen_err("Cannot destroy AQP1 CQ. ret=%i", ret);
552
553 return ret;
554 }
555
556 static ssize_t ehca_show_debug_level(struct device_driver *ddp, char *buf)
557 {
558 return snprintf(buf, PAGE_SIZE, "%d\n",
559 ehca_debug_level);
560 }
561
562 static ssize_t ehca_store_debug_level(struct device_driver *ddp,
563 const char *buf, size_t count)
564 {
565 int value = (*buf) - '0';
566 if (value >= 0 && value <= 9)
567 ehca_debug_level = value;
568 return 1;
569 }
570
571 DRIVER_ATTR(debug_level, S_IRUSR | S_IWUSR,
572 ehca_show_debug_level, ehca_store_debug_level);
573
574 static struct attribute *ehca_drv_attrs[] = {
575 &driver_attr_debug_level.attr,
576 NULL
577 };
578
579 static struct attribute_group ehca_drv_attr_grp = {
580 .attrs = ehca_drv_attrs
581 };
582
583 #define EHCA_RESOURCE_ATTR(name) \
584 static ssize_t ehca_show_##name(struct device *dev, \
585 struct device_attribute *attr, \
586 char *buf) \
587 { \
588 struct ehca_shca *shca; \
589 struct hipz_query_hca *rblock; \
590 int data; \
591 \
592 shca = dev->driver_data; \
593 \
594 rblock = ehca_alloc_fw_ctrlblock(GFP_KERNEL); \
595 if (!rblock) { \
596 dev_err(dev, "Can't allocate rblock memory.\n"); \
597 return 0; \
598 } \
599 \
600 if (hipz_h_query_hca(shca->ipz_hca_handle, rblock) != H_SUCCESS) { \
601 dev_err(dev, "Can't query device properties\n"); \
602 ehca_free_fw_ctrlblock(rblock); \
603 return 0; \
604 } \
605 \
606 data = rblock->name; \
607 ehca_free_fw_ctrlblock(rblock); \
608 \
609 if ((strcmp(#name, "num_ports") == 0) && (ehca_nr_ports == 1)) \
610 return snprintf(buf, 256, "1\n"); \
611 else \
612 return snprintf(buf, 256, "%d\n", data); \
613 \
614 } \
615 static DEVICE_ATTR(name, S_IRUGO, ehca_show_##name, NULL);
616
617 EHCA_RESOURCE_ATTR(num_ports);
618 EHCA_RESOURCE_ATTR(hw_ver);
619 EHCA_RESOURCE_ATTR(max_eq);
620 EHCA_RESOURCE_ATTR(cur_eq);
621 EHCA_RESOURCE_ATTR(max_cq);
622 EHCA_RESOURCE_ATTR(cur_cq);
623 EHCA_RESOURCE_ATTR(max_qp);
624 EHCA_RESOURCE_ATTR(cur_qp);
625 EHCA_RESOURCE_ATTR(max_mr);
626 EHCA_RESOURCE_ATTR(cur_mr);
627 EHCA_RESOURCE_ATTR(max_mw);
628 EHCA_RESOURCE_ATTR(cur_mw);
629 EHCA_RESOURCE_ATTR(max_pd);
630 EHCA_RESOURCE_ATTR(max_ah);
631
632 static ssize_t ehca_show_adapter_handle(struct device *dev,
633 struct device_attribute *attr,
634 char *buf)
635 {
636 struct ehca_shca *shca = dev->driver_data;
637
638 return sprintf(buf, "%lx\n", shca->ipz_hca_handle.handle);
639
640 }
641 static DEVICE_ATTR(adapter_handle, S_IRUGO, ehca_show_adapter_handle, NULL);
642
643 static ssize_t ehca_show_mr_largepage(struct device *dev,
644 struct device_attribute *attr,
645 char *buf)
646 {
647 return sprintf(buf, "%d\n", ehca_mr_largepage);
648 }
649 static DEVICE_ATTR(mr_largepage, S_IRUGO, ehca_show_mr_largepage, NULL);
650
651 static struct attribute *ehca_dev_attrs[] = {
652 &dev_attr_adapter_handle.attr,
653 &dev_attr_num_ports.attr,
654 &dev_attr_hw_ver.attr,
655 &dev_attr_max_eq.attr,
656 &dev_attr_cur_eq.attr,
657 &dev_attr_max_cq.attr,
658 &dev_attr_cur_cq.attr,
659 &dev_attr_max_qp.attr,
660 &dev_attr_cur_qp.attr,
661 &dev_attr_max_mr.attr,
662 &dev_attr_cur_mr.attr,
663 &dev_attr_max_mw.attr,
664 &dev_attr_cur_mw.attr,
665 &dev_attr_max_pd.attr,
666 &dev_attr_max_ah.attr,
667 &dev_attr_mr_largepage.attr,
668 NULL
669 };
670
671 static struct attribute_group ehca_dev_attr_grp = {
672 .attrs = ehca_dev_attrs
673 };
674
675 static int __devinit ehca_probe(struct of_device *dev,
676 const struct of_device_id *id)
677 {
678 struct ehca_shca *shca;
679 const u64 *handle;
680 struct ib_pd *ibpd;
681 int ret;
682
683 handle = of_get_property(dev->node, "ibm,hca-handle", NULL);
684 if (!handle) {
685 ehca_gen_err("Cannot get eHCA handle for adapter: %s.",
686 dev->node->full_name);
687 return -ENODEV;
688 }
689
690 if (!(*handle)) {
691 ehca_gen_err("Wrong eHCA handle for adapter: %s.",
692 dev->node->full_name);
693 return -ENODEV;
694 }
695
696 shca = (struct ehca_shca *)ib_alloc_device(sizeof(*shca));
697 if (!shca) {
698 ehca_gen_err("Cannot allocate shca memory.");
699 return -ENOMEM;
700 }
701 mutex_init(&shca->modify_mutex);
702
703 shca->ofdev = dev;
704 shca->ipz_hca_handle.handle = *handle;
705 dev->dev.driver_data = shca;
706
707 ret = ehca_sense_attributes(shca);
708 if (ret < 0) {
709 ehca_gen_err("Cannot sense eHCA attributes.");
710 goto probe1;
711 }
712
713 ret = ehca_init_device(shca);
714 if (ret) {
715 ehca_gen_err("Cannot init ehca device struct");
716 goto probe1;
717 }
718
719 /* create event queues */
720 ret = ehca_create_eq(shca, &shca->eq, EHCA_EQ, 2048);
721 if (ret) {
722 ehca_err(&shca->ib_device, "Cannot create EQ.");
723 goto probe1;
724 }
725
726 ret = ehca_create_eq(shca, &shca->neq, EHCA_NEQ, 513);
727 if (ret) {
728 ehca_err(&shca->ib_device, "Cannot create NEQ.");
729 goto probe3;
730 }
731
732 /* create internal protection domain */
733 ibpd = ehca_alloc_pd(&shca->ib_device, (void *)(-1), NULL);
734 if (IS_ERR(ibpd)) {
735 ehca_err(&shca->ib_device, "Cannot create internal PD.");
736 ret = PTR_ERR(ibpd);
737 goto probe4;
738 }
739
740 shca->pd = container_of(ibpd, struct ehca_pd, ib_pd);
741 shca->pd->ib_pd.device = &shca->ib_device;
742
743 /* create internal max MR */
744 ret = ehca_reg_internal_maxmr(shca, shca->pd, &shca->maxmr);
745
746 if (ret) {
747 ehca_err(&shca->ib_device, "Cannot create internal MR ret=%i",
748 ret);
749 goto probe5;
750 }
751
752 ret = ib_register_device(&shca->ib_device);
753 if (ret) {
754 ehca_err(&shca->ib_device,
755 "ib_register_device() failed ret=%i", ret);
756 goto probe6;
757 }
758
759 /* create AQP1 for port 1 */
760 if (ehca_open_aqp1 == 1) {
761 shca->sport[0].port_state = IB_PORT_DOWN;
762 ret = ehca_create_aqp1(shca, 1);
763 if (ret) {
764 ehca_err(&shca->ib_device,
765 "Cannot create AQP1 for port 1.");
766 goto probe7;
767 }
768 }
769
770 /* create AQP1 for port 2 */
771 if ((ehca_open_aqp1 == 1) && (shca->num_ports == 2)) {
772 shca->sport[1].port_state = IB_PORT_DOWN;
773 ret = ehca_create_aqp1(shca, 2);
774 if (ret) {
775 ehca_err(&shca->ib_device,
776 "Cannot create AQP1 for port 2.");
777 goto probe8;
778 }
779 }
780
781 ret = sysfs_create_group(&dev->dev.kobj, &ehca_dev_attr_grp);
782 if (ret) /* only complain; we can live without attributes */
783 ehca_err(&shca->ib_device,
784 "Cannot create device attributes ret=%d", ret);
785
786 spin_lock(&shca_list_lock);
787 list_add(&shca->shca_list, &shca_list);
788 spin_unlock(&shca_list_lock);
789
790 return 0;
791
792 probe8:
793 ret = ehca_destroy_aqp1(&shca->sport[0]);
794 if (ret)
795 ehca_err(&shca->ib_device,
796 "Cannot destroy AQP1 for port 1. ret=%i", ret);
797
798 probe7:
799 ib_unregister_device(&shca->ib_device);
800
801 probe6:
802 ret = ehca_dereg_internal_maxmr(shca);
803 if (ret)
804 ehca_err(&shca->ib_device,
805 "Cannot destroy internal MR. ret=%x", ret);
806
807 probe5:
808 ret = ehca_dealloc_pd(&shca->pd->ib_pd);
809 if (ret)
810 ehca_err(&shca->ib_device,
811 "Cannot destroy internal PD. ret=%x", ret);
812
813 probe4:
814 ret = ehca_destroy_eq(shca, &shca->neq);
815 if (ret)
816 ehca_err(&shca->ib_device,
817 "Cannot destroy NEQ. ret=%x", ret);
818
819 probe3:
820 ret = ehca_destroy_eq(shca, &shca->eq);
821 if (ret)
822 ehca_err(&shca->ib_device,
823 "Cannot destroy EQ. ret=%x", ret);
824
825 probe1:
826 ib_dealloc_device(&shca->ib_device);
827
828 return -EINVAL;
829 }
830
831 static int __devexit ehca_remove(struct of_device *dev)
832 {
833 struct ehca_shca *shca = dev->dev.driver_data;
834 int ret;
835
836 sysfs_remove_group(&dev->dev.kobj, &ehca_dev_attr_grp);
837
838 if (ehca_open_aqp1 == 1) {
839 int i;
840 for (i = 0; i < shca->num_ports; i++) {
841 ret = ehca_destroy_aqp1(&shca->sport[i]);
842 if (ret)
843 ehca_err(&shca->ib_device,
844 "Cannot destroy AQP1 for port %x "
845 "ret=%i", ret, i);
846 }
847 }
848
849 ib_unregister_device(&shca->ib_device);
850
851 ret = ehca_dereg_internal_maxmr(shca);
852 if (ret)
853 ehca_err(&shca->ib_device,
854 "Cannot destroy internal MR. ret=%i", ret);
855
856 ret = ehca_dealloc_pd(&shca->pd->ib_pd);
857 if (ret)
858 ehca_err(&shca->ib_device,
859 "Cannot destroy internal PD. ret=%i", ret);
860
861 ret = ehca_destroy_eq(shca, &shca->eq);
862 if (ret)
863 ehca_err(&shca->ib_device, "Cannot destroy EQ. ret=%i", ret);
864
865 ret = ehca_destroy_eq(shca, &shca->neq);
866 if (ret)
867 ehca_err(&shca->ib_device, "Canot destroy NEQ. ret=%i", ret);
868
869 ib_dealloc_device(&shca->ib_device);
870
871 spin_lock(&shca_list_lock);
872 list_del(&shca->shca_list);
873 spin_unlock(&shca_list_lock);
874
875 return ret;
876 }
877
878 static struct of_device_id ehca_device_table[] =
879 {
880 {
881 .name = "lhca",
882 .compatible = "IBM,lhca",
883 },
884 {},
885 };
886
887 static struct of_platform_driver ehca_driver = {
888 .name = "ehca",
889 .match_table = ehca_device_table,
890 .probe = ehca_probe,
891 .remove = ehca_remove,
892 };
893
894 void ehca_poll_eqs(unsigned long data)
895 {
896 struct ehca_shca *shca;
897
898 spin_lock(&shca_list_lock);
899 list_for_each_entry(shca, &shca_list, shca_list) {
900 if (shca->eq.is_initialized) {
901 /* call deadman proc only if eq ptr does not change */
902 struct ehca_eq *eq = &shca->eq;
903 int max = 3;
904 volatile u64 q_ofs, q_ofs2;
905 u64 flags;
906 spin_lock_irqsave(&eq->spinlock, flags);
907 q_ofs = eq->ipz_queue.current_q_offset;
908 spin_unlock_irqrestore(&eq->spinlock, flags);
909 do {
910 spin_lock_irqsave(&eq->spinlock, flags);
911 q_ofs2 = eq->ipz_queue.current_q_offset;
912 spin_unlock_irqrestore(&eq->spinlock, flags);
913 max--;
914 } while (q_ofs == q_ofs2 && max > 0);
915 if (q_ofs == q_ofs2)
916 ehca_process_eq(shca, 0);
917 }
918 }
919 mod_timer(&poll_eqs_timer, jiffies + HZ);
920 spin_unlock(&shca_list_lock);
921 }
922
923 int __init ehca_module_init(void)
924 {
925 int ret;
926
927 printk(KERN_INFO "eHCA Infiniband Device Driver "
928 "(Version " HCAD_VERSION ")\n");
929
930 ret = ehca_create_comp_pool();
931 if (ret) {
932 ehca_gen_err("Cannot create comp pool.");
933 return ret;
934 }
935
936 ret = ehca_create_slab_caches();
937 if (ret) {
938 ehca_gen_err("Cannot create SLAB caches");
939 ret = -ENOMEM;
940 goto module_init1;
941 }
942
943 ret = ibmebus_register_driver(&ehca_driver);
944 if (ret) {
945 ehca_gen_err("Cannot register eHCA device driver");
946 ret = -EINVAL;
947 goto module_init2;
948 }
949
950 ret = sysfs_create_group(&ehca_driver.driver.kobj, &ehca_drv_attr_grp);
951 if (ret) /* only complain; we can live without attributes */
952 ehca_gen_err("Cannot create driver attributes ret=%d", ret);
953
954 if (ehca_poll_all_eqs != 1) {
955 ehca_gen_err("WARNING!!!");
956 ehca_gen_err("It is possible to lose interrupts.");
957 } else {
958 init_timer(&poll_eqs_timer);
959 poll_eqs_timer.function = ehca_poll_eqs;
960 poll_eqs_timer.expires = jiffies + HZ;
961 add_timer(&poll_eqs_timer);
962 }
963
964 return 0;
965
966 module_init2:
967 ehca_destroy_slab_caches();
968
969 module_init1:
970 ehca_destroy_comp_pool();
971 return ret;
972 };
973
974 void __exit ehca_module_exit(void)
975 {
976 if (ehca_poll_all_eqs == 1)
977 del_timer_sync(&poll_eqs_timer);
978
979 sysfs_remove_group(&ehca_driver.driver.kobj, &ehca_drv_attr_grp);
980 ibmebus_unregister_driver(&ehca_driver);
981
982 ehca_destroy_slab_caches();
983
984 ehca_destroy_comp_pool();
985
986 idr_destroy(&ehca_cq_idr);
987 idr_destroy(&ehca_qp_idr);
988 };
989
990 module_init(ehca_module_init);
991 module_exit(ehca_module_exit);
kernel source for telekom puls (alcatel/mediatek)