Merge git://oss.sgi.com:8090/oss/git/xfs-2.6
[linux-2.6] / drivers / infiniband / hw / ipath / ipath_cq.c
1 /*
2  * Copyright (c) 2005, 2006 PathScale, Inc. All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  */
32
33 #include <linux/err.h>
34 #include <linux/vmalloc.h>
35
36 #include "ipath_verbs.h"
37
38 /**
39  * ipath_cq_enter - add a new entry to the completion queue
40  * @cq: completion queue
41  * @entry: work completion entry to add
42  * @sig: true if @entry is a solicitated entry
43  *
44  * This may be called with one of the qp->s_lock or qp->r_rq.lock held.
45  */
46 void ipath_cq_enter(struct ipath_cq *cq, struct ib_wc *entry, int solicited)
47 {
48         unsigned long flags;
49         u32 next;
50
51         spin_lock_irqsave(&cq->lock, flags);
52
53         if (cq->head == cq->ibcq.cqe)
54                 next = 0;
55         else
56                 next = cq->head + 1;
57         if (unlikely(next == cq->tail)) {
58                 spin_unlock_irqrestore(&cq->lock, flags);
59                 if (cq->ibcq.event_handler) {
60                         struct ib_event ev;
61
62                         ev.device = cq->ibcq.device;
63                         ev.element.cq = &cq->ibcq;
64                         ev.event = IB_EVENT_CQ_ERR;
65                         cq->ibcq.event_handler(&ev, cq->ibcq.cq_context);
66                 }
67                 return;
68         }
69         cq->queue[cq->head] = *entry;
70         cq->head = next;
71
72         if (cq->notify == IB_CQ_NEXT_COMP ||
73             (cq->notify == IB_CQ_SOLICITED && solicited)) {
74                 cq->notify = IB_CQ_NONE;
75                 cq->triggered++;
76                 /*
77                  * This will cause send_complete() to be called in
78                  * another thread.
79                  */
80                 tasklet_hi_schedule(&cq->comptask);
81         }
82
83         spin_unlock_irqrestore(&cq->lock, flags);
84
85         if (entry->status != IB_WC_SUCCESS)
86                 to_idev(cq->ibcq.device)->n_wqe_errs++;
87 }
88
89 /**
90  * ipath_poll_cq - poll for work completion entries
91  * @ibcq: the completion queue to poll
92  * @num_entries: the maximum number of entries to return
93  * @entry: pointer to array where work completions are placed
94  *
95  * Returns the number of completion entries polled.
96  *
97  * This may be called from interrupt context.  Also called by ib_poll_cq()
98  * in the generic verbs code.
99  */
100 int ipath_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *entry)
101 {
102         struct ipath_cq *cq = to_icq(ibcq);
103         unsigned long flags;
104         int npolled;
105
106         spin_lock_irqsave(&cq->lock, flags);
107
108         for (npolled = 0; npolled < num_entries; ++npolled, ++entry) {
109                 if (cq->tail == cq->head)
110                         break;
111                 *entry = cq->queue[cq->tail];
112                 if (cq->tail == cq->ibcq.cqe)
113                         cq->tail = 0;
114                 else
115                         cq->tail++;
116         }
117
118         spin_unlock_irqrestore(&cq->lock, flags);
119
120         return npolled;
121 }
122
123 static void send_complete(unsigned long data)
124 {
125         struct ipath_cq *cq = (struct ipath_cq *)data;
126
127         /*
128          * The completion handler will most likely rearm the notification
129          * and poll for all pending entries.  If a new completion entry
130          * is added while we are in this routine, tasklet_hi_schedule()
131          * won't call us again until we return so we check triggered to
132          * see if we need to call the handler again.
133          */
134         for (;;) {
135                 u8 triggered = cq->triggered;
136
137                 cq->ibcq.comp_handler(&cq->ibcq, cq->ibcq.cq_context);
138
139                 if (cq->triggered == triggered)
140                         return;
141         }
142 }
143
144 /**
145  * ipath_create_cq - create a completion queue
146  * @ibdev: the device this completion queue is attached to
147  * @entries: the minimum size of the completion queue
148  * @context: unused by the InfiniPath driver
149  * @udata: unused by the InfiniPath driver
150  *
151  * Returns a pointer to the completion queue or negative errno values
152  * for failure.
153  *
154  * Called by ib_create_cq() in the generic verbs code.
155  */
156 struct ib_cq *ipath_create_cq(struct ib_device *ibdev, int entries,
157                               struct ib_ucontext *context,
158                               struct ib_udata *udata)
159 {
160         struct ipath_cq *cq;
161         struct ib_wc *wc;
162         struct ib_cq *ret;
163
164         /*
165          * Need to use vmalloc() if we want to support large #s of
166          * entries.
167          */
168         cq = kmalloc(sizeof(*cq), GFP_KERNEL);
169         if (!cq) {
170                 ret = ERR_PTR(-ENOMEM);
171                 goto bail;
172         }
173
174         /*
175          * Need to use vmalloc() if we want to support large #s of entries.
176          */
177         wc = vmalloc(sizeof(*wc) * (entries + 1));
178         if (!wc) {
179                 kfree(cq);
180                 ret = ERR_PTR(-ENOMEM);
181                 goto bail;
182         }
183         /*
184          * ib_create_cq() will initialize cq->ibcq except for cq->ibcq.cqe.
185          * The number of entries should be >= the number requested or return
186          * an error.
187          */
188         cq->ibcq.cqe = entries;
189         cq->notify = IB_CQ_NONE;
190         cq->triggered = 0;
191         spin_lock_init(&cq->lock);
192         tasklet_init(&cq->comptask, send_complete, (unsigned long)cq);
193         cq->head = 0;
194         cq->tail = 0;
195         cq->queue = wc;
196
197         ret = &cq->ibcq;
198
199 bail:
200         return ret;
201 }
202
203 /**
204  * ipath_destroy_cq - destroy a completion queue
205  * @ibcq: the completion queue to destroy.
206  *
207  * Returns 0 for success.
208  *
209  * Called by ib_destroy_cq() in the generic verbs code.
210  */
211 int ipath_destroy_cq(struct ib_cq *ibcq)
212 {
213         struct ipath_cq *cq = to_icq(ibcq);
214
215         tasklet_kill(&cq->comptask);
216         vfree(cq->queue);
217         kfree(cq);
218
219         return 0;
220 }
221
222 /**
223  * ipath_req_notify_cq - change the notification type for a completion queue
224  * @ibcq: the completion queue
225  * @notify: the type of notification to request
226  *
227  * Returns 0 for success.
228  *
229  * This may be called from interrupt context.  Also called by
230  * ib_req_notify_cq() in the generic verbs code.
231  */
232 int ipath_req_notify_cq(struct ib_cq *ibcq, enum ib_cq_notify notify)
233 {
234         struct ipath_cq *cq = to_icq(ibcq);
235         unsigned long flags;
236
237         spin_lock_irqsave(&cq->lock, flags);
238         /*
239          * Don't change IB_CQ_NEXT_COMP to IB_CQ_SOLICITED but allow
240          * any other transitions.
241          */
242         if (cq->notify != IB_CQ_NEXT_COMP)
243                 cq->notify = notify;
244         spin_unlock_irqrestore(&cq->lock, flags);
245         return 0;
246 }
247
248 int ipath_resize_cq(struct ib_cq *ibcq, int cqe, struct ib_udata *udata)
249 {
250         struct ipath_cq *cq = to_icq(ibcq);
251         struct ib_wc *wc, *old_wc;
252         u32 n;
253         int ret;
254
255         /*
256          * Need to use vmalloc() if we want to support large #s of entries.
257          */
258         wc = vmalloc(sizeof(*wc) * (cqe + 1));
259         if (!wc) {
260                 ret = -ENOMEM;
261                 goto bail;
262         }
263
264         spin_lock_irq(&cq->lock);
265         if (cq->head < cq->tail)
266                 n = cq->ibcq.cqe + 1 + cq->head - cq->tail;
267         else
268                 n = cq->head - cq->tail;
269         if (unlikely((u32)cqe < n)) {
270                 spin_unlock_irq(&cq->lock);
271                 vfree(wc);
272                 ret = -EOVERFLOW;
273                 goto bail;
274         }
275         for (n = 0; cq->tail != cq->head; n++) {
276                 wc[n] = cq->queue[cq->tail];
277                 if (cq->tail == cq->ibcq.cqe)
278                         cq->tail = 0;
279                 else
280                         cq->tail++;
281         }
282         cq->ibcq.cqe = cqe;
283         cq->head = n;
284         cq->tail = 0;
285         old_wc = cq->queue;
286         cq->queue = wc;
287         spin_unlock_irq(&cq->lock);
288
289         vfree(old_wc);
290
291         ret = 0;
292
293 bail:
294         return ret;
295 }