1 /*
2 * IBM eServer eHCA Infiniband device driver for Linux on POWER
3 *
4 * Event queue handling
5 *
6 * Authors: Waleri Fomin <fomin@de.ibm.com>
7 * Khadija Souissi <souissi@de.ibm.com>
8 * Reinhard Ernst <rernst@de.ibm.com>
9 * Heiko J Schick <schickhj@de.ibm.com>
10 * Hoang-Nam Nguyen <hnguyen@de.ibm.com>
11 *
12 *
13 * Copyright (c) 2005 IBM Corporation
14 *
15 * All rights reserved.
16 *
17 * This source code is distributed under a dual license of GPL v2.0 and OpenIB
18 * BSD.
19 *
20 * OpenIB BSD License
21 *
22 * Redistribution and use in source and binary forms, with or without
23 * modification, are permitted provided that the following conditions are met:
24 *
25 * Redistributions of source code must retain the above copyright notice, this
26 * list of conditions and the following disclaimer.
27 *
28 * Redistributions in binary form must reproduce the above copyright notice,
29 * this list of conditions and the following disclaimer in the documentation
30 * and/or other materials
31 * provided with the distribution.
32 *
33 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
34 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
35 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
36 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
37 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
38 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
39 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
40 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
41 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
42 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
43 * POSSIBILITY OF SUCH DAMAGE.
44 */
45
46 #include "ehca_classes.h"
47 #include "ehca_irq.h"
48 #include "ehca_iverbs.h"
49 #include "ehca_qes.h"
50 #include "hcp_if.h"
51 #include "ipz_pt_fn.h"
52
ehca_create_eq(struct ehca_shca * shca,struct ehca_eq * eq,const enum ehca_eq_type type,const u32 length)53 int ehca_create_eq(struct ehca_shca *shca,
54 struct ehca_eq *eq,
55 const enum ehca_eq_type type, const u32 length)
56 {
57 int ret;
58 u64 h_ret;
59 u32 nr_pages;
60 u32 i;
61 void *vpage;
62 struct ib_device *ib_dev = &shca->ib_device;
63
64 spin_lock_init(&eq->spinlock);
65 spin_lock_init(&eq->irq_spinlock);
66 eq->is_initialized = 0;
67
68 if (type != EHCA_EQ && type != EHCA_NEQ) {
69 ehca_err(ib_dev, "Invalid EQ type %x. eq=%p", type, eq);
70 return -EINVAL;
71 }
72 if (!length) {
73 ehca_err(ib_dev, "EQ length must not be zero. eq=%p", eq);
74 return -EINVAL;
75 }
76
77 h_ret = hipz_h_alloc_resource_eq(shca->ipz_hca_handle,
78 &eq->pf,
79 type,
80 length,
81 &eq->ipz_eq_handle,
82 &eq->length,
83 &nr_pages, &eq->ist);
84
85 if (h_ret != H_SUCCESS) {
86 ehca_err(ib_dev, "Can't allocate EQ/NEQ. eq=%p", eq);
87 return -EINVAL;
88 }
89
90 ret = ipz_queue_ctor(NULL, &eq->ipz_queue, nr_pages,
91 EHCA_PAGESIZE, sizeof(struct ehca_eqe), 0, 0);
92 if (!ret) {
93 ehca_err(ib_dev, "Can't allocate EQ pages eq=%p", eq);
94 goto create_eq_exit1;
95 }
96
97 for (i = 0; i < nr_pages; i++) {
98 u64 rpage;
99
100 vpage = ipz_qpageit_get_inc(&eq->ipz_queue);
101 if (!vpage)
102 goto create_eq_exit2;
103
104 rpage = virt_to_abs(vpage);
105 h_ret = hipz_h_register_rpage_eq(shca->ipz_hca_handle,
106 eq->ipz_eq_handle,
107 &eq->pf,
108 0, 0, rpage, 1);
109
110 if (i == (nr_pages - 1)) {
111 /* last page */
112 vpage = ipz_qpageit_get_inc(&eq->ipz_queue);
113 if (h_ret != H_SUCCESS || vpage)
114 goto create_eq_exit2;
115 } else {
116 if (h_ret != H_PAGE_REGISTERED)
117 goto create_eq_exit2;
118 }
119 }
120
121 ipz_qeit_reset(&eq->ipz_queue);
122
123 /* register interrupt handlers and initialize work queues */
124 if (type == EHCA_EQ) {
125 tasklet_init(&eq->interrupt_task, ehca_tasklet_eq, (long)shca);
126
127 ret = ibmebus_request_irq(eq->ist, ehca_interrupt_eq,
128 IRQF_DISABLED, "ehca_eq",
129 (void *)shca);
130 if (ret < 0)
131 ehca_err(ib_dev, "Can't map interrupt handler.");
132 } else if (type == EHCA_NEQ) {
133 tasklet_init(&eq->interrupt_task, ehca_tasklet_neq, (long)shca);
134
135 ret = ibmebus_request_irq(eq->ist, ehca_interrupt_neq,
136 IRQF_DISABLED, "ehca_neq",
137 (void *)shca);
138 if (ret < 0)
139 ehca_err(ib_dev, "Can't map interrupt handler.");
140 }
141
142 eq->is_initialized = 1;
143
144 return 0;
145
146 create_eq_exit2:
147 ipz_queue_dtor(NULL, &eq->ipz_queue);
148
149 create_eq_exit1:
150 hipz_h_destroy_eq(shca->ipz_hca_handle, eq);
151
152 return -EINVAL;
153 }
154
ehca_poll_eq(struct ehca_shca * shca,struct ehca_eq * eq)155 void *ehca_poll_eq(struct ehca_shca *shca, struct ehca_eq *eq)
156 {
157 unsigned long flags;
158 void *eqe;
159
160 spin_lock_irqsave(&eq->spinlock, flags);
161 eqe = ipz_eqit_eq_get_inc_valid(&eq->ipz_queue);
162 spin_unlock_irqrestore(&eq->spinlock, flags);
163
164 return eqe;
165 }
166
ehca_destroy_eq(struct ehca_shca * shca,struct ehca_eq * eq)167 int ehca_destroy_eq(struct ehca_shca *shca, struct ehca_eq *eq)
168 {
169 unsigned long flags;
170 u64 h_ret;
171
172 ibmebus_free_irq(eq->ist, (void *)shca);
173
174 spin_lock_irqsave(&shca_list_lock, flags);
175 eq->is_initialized = 0;
176 spin_unlock_irqrestore(&shca_list_lock, flags);
177
178 tasklet_kill(&eq->interrupt_task);
179
180 h_ret = hipz_h_destroy_eq(shca->ipz_hca_handle, eq);
181
182 if (h_ret != H_SUCCESS) {
183 ehca_err(&shca->ib_device, "Can't free EQ resources.");
184 return -EINVAL;
185 }
186 ipz_queue_dtor(NULL, &eq->ipz_queue);
187
188 return 0;
189 }
190