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