[linux-2.6-block.git] / drivers / infiniband / hw / ipath / ipath_cq.c

/*
 * Copyright (c) 2005, 2006 PathScale, Inc. All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <linux/err.h>
#include <linux/vmalloc.h>

#include "ipath_verbs.h"

/**
 * ipath_cq_enter - add a new entry to the completion queue
 * @cq: completion queue
 * @entry: work completion entry to add
 * @sig: true if @entry is a solicitated entry
 *
 * This may be called with one of the qp->s_lock or qp->r_rq.lock held.
 */
void ipath_cq_enter(struct ipath_cq *cq, struct ib_wc *entry, int solicited)
{
	unsigned long flags;
	u32 next;

	spin_lock_irqsave(&cq->lock, flags);

	if (cq->head == cq->ibcq.cqe)
		next = 0;
	else
		next = cq->head + 1;
	if (unlikely(next == cq->tail)) {
		spin_unlock_irqrestore(&cq->lock, flags);
		if (cq->ibcq.event_handler) {
			struct ib_event ev;

			ev.device = cq->ibcq.device;
			ev.element.cq = &cq->ibcq;
			ev.event = IB_EVENT_CQ_ERR;
			cq->ibcq.event_handler(&ev, cq->ibcq.cq_context);
		}
		return;
	}
	cq->queue[cq->head] = *entry;
	cq->head = next;

	if (cq->notify == IB_CQ_NEXT_COMP ||
	    (cq->notify == IB_CQ_SOLICITED && solicited)) {
		cq->notify = IB_CQ_NONE;
		cq->triggered++;
		/*
		 * This will cause send_complete() to be called in
		 * another thread.
		 */
		tasklet_hi_schedule(&cq->comptask);
	}

	spin_unlock_irqrestore(&cq->lock, flags);

	if (entry->status != IB_WC_SUCCESS)
		to_idev(cq->ibcq.device)->n_wqe_errs++;
}

/**
 * ipath_poll_cq - poll for work completion entries
 * @ibcq: the completion queue to poll
 * @num_entries: the maximum number of entries to return
 * @entry: pointer to array where work completions are placed
 *
 * Returns the number of completion entries polled.
 *
 * This may be called from interrupt context.  Also called by ib_poll_cq()
 * in the generic verbs code.
 */
int ipath_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *entry)
{
	struct ipath_cq *cq = to_icq(ibcq);
	unsigned long flags;
	int npolled;

	spin_lock_irqsave(&cq->lock, flags);

	for (npolled = 0; npolled < num_entries; ++npolled, ++entry) {
		if (cq->tail == cq->head)
			break;
		*entry = cq->queue[cq->tail];
		if (cq->tail == cq->ibcq.cqe)
			cq->tail = 0;
		else
			cq->tail++;
	}

	spin_unlock_irqrestore(&cq->lock, flags);

	return npolled;
}

static void send_complete(unsigned long data)
{
	struct ipath_cq *cq = (struct ipath_cq *)data;

	/*
	 * The completion handler will most likely rearm the notification
	 * and poll for all pending entries.  If a new completion entry
	 * is added while we are in this routine, tasklet_hi_schedule()
	 * won't call us again until we return so we check triggered to
	 * see if we need to call the handler again.
	 */
	for (;;) {
		u8 triggered = cq->triggered;

		cq->ibcq.comp_handler(&cq->ibcq, cq->ibcq.cq_context);

		if (cq->triggered == triggered)
			return;
	}
}

/**
 * ipath_create_cq - create a completion queue
 * @ibdev: the device this completion queue is attached to
 * @entries: the minimum size of the completion queue
 * @context: unused by the InfiniPath driver
 * @udata: unused by the InfiniPath driver
 *
 * Returns a pointer to the completion queue or negative errno values
 * for failure.
 *
 * Called by ib_create_cq() in the generic verbs code.
 */
struct ib_cq *ipath_create_cq(struct ib_device *ibdev, int entries,
			      struct ib_ucontext *context,
			      struct ib_udata *udata)
{
	struct ipath_cq *cq;
	struct ib_wc *wc;
	struct ib_cq *ret;

	/*
	 * Need to use vmalloc() if we want to support large #s of
	 * entries.
	 */
	cq = kmalloc(sizeof(*cq), GFP_KERNEL);
	if (!cq) {
		ret = ERR_PTR(-ENOMEM);
		goto bail;
	}

	/*
	 * Need to use vmalloc() if we want to support large #s of entries.
	 */
	wc = vmalloc(sizeof(*wc) * (entries + 1));
	if (!wc) {
		kfree(cq);
		ret = ERR_PTR(-ENOMEM);
		goto bail;
	}
	/*
	 * ib_create_cq() will initialize cq->ibcq except for cq->ibcq.cqe.
	 * The number of entries should be >= the number requested or return
	 * an error.
	 */
	cq->ibcq.cqe = entries;
	cq->notify = IB_CQ_NONE;
	cq->triggered = 0;
	spin_lock_init(&cq->lock);
	tasklet_init(&cq->comptask, send_complete, (unsigned long)cq);
	cq->head = 0;
	cq->tail = 0;
	cq->queue = wc;

	ret = &cq->ibcq;

bail:
	return ret;
}

/**
 * ipath_destroy_cq - destroy a completion queue
 * @ibcq: the completion queue to destroy.
 *
 * Returns 0 for success.
 *
 * Called by ib_destroy_cq() in the generic verbs code.
 */
int ipath_destroy_cq(struct ib_cq *ibcq)
{
	struct ipath_cq *cq = to_icq(ibcq);

	tasklet_kill(&cq->comptask);
	vfree(cq->queue);
	kfree(cq);

	return 0;
}

/**
 * ipath_req_notify_cq - change the notification type for a completion queue
 * @ibcq: the completion queue
 * @notify: the type of notification to request
 *
 * Returns 0 for success.
 *
 * This may be called from interrupt context.  Also called by
 * ib_req_notify_cq() in the generic verbs code.
 */
int ipath_req_notify_cq(struct ib_cq *ibcq, enum ib_cq_notify notify)
{
	struct ipath_cq *cq = to_icq(ibcq);
	unsigned long flags;

	spin_lock_irqsave(&cq->lock, flags);
	/*
	 * Don't change IB_CQ_NEXT_COMP to IB_CQ_SOLICITED but allow
	 * any other transitions.
	 */
	if (cq->notify != IB_CQ_NEXT_COMP)
		cq->notify = notify;
	spin_unlock_irqrestore(&cq->lock, flags);
	return 0;
}

int ipath_resize_cq(struct ib_cq *ibcq, int cqe, struct ib_udata *udata)
{
	struct ipath_cq *cq = to_icq(ibcq);
	struct ib_wc *wc, *old_wc;
	u32 n;
	int ret;

	/*
	 * Need to use vmalloc() if we want to support large #s of entries.
	 */
	wc = vmalloc(sizeof(*wc) * (cqe + 1));
	if (!wc) {
		ret = -ENOMEM;
		goto bail;
	}

	spin_lock_irq(&cq->lock);
	if (cq->head < cq->tail)
		n = cq->ibcq.cqe + 1 + cq->head - cq->tail;
	else
		n = cq->head - cq->tail;
	if (unlikely((u32)cqe < n)) {
		spin_unlock_irq(&cq->lock);
		vfree(wc);
		ret = -EOVERFLOW;
		goto bail;
	}
	for (n = 0; cq->tail != cq->head; n++) {
		wc[n] = cq->queue[cq->tail];
		if (cq->tail == cq->ibcq.cqe)
			cq->tail = 0;
		else
			cq->tail++;
	}
	cq->ibcq.cqe = cqe;
	cq->head = n;
	cq->tail = 0;
	old_wc = cq->queue;
	cq->queue = wc;
	spin_unlock_irq(&cq->lock);

	vfree(old_wc);

	ret = 0;

bail:
	return ret;
}
Commit	Line	Data
cef1cce5 BS	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	}