dev/mthca/mthca_srq.c

97 static void mthca_tavor_init_srq_context(struct mthca_dev *dev,
115 		context->uar = cpu_to_be32(dev->driver_uar.index);
118 static void mthca_arbel_init_srq_context(struct mthca_dev *dev,
137 		context->logstride_usrpage |= cpu_to_be32(dev->driver_uar.index);
141 static void mthca_free_srq_buf(struct mthca_dev *dev, struct mthca_srq *srq)
143 	mthca_buf_free(dev, srq->max << srq->wqe_shift, &srq->queue,
148 static int mthca_alloc_srq_buf(struct mthca_dev *dev, struct mthca_pd *pd,
163 	err = mthca_buf_alloc(dev, srq->max << srq->wqe_shift,
200 int mthca_alloc_srq(struct mthca_dev *dev, struct mthca_pd *pd,
209 	if (attr->max_wr  > dev->limits.max_srq_wqes ||
210 	    attr->max_sge > dev->limits.max_srq_sge)
217 	if (mthca_is_memfree(dev))
226 	if (!mthca_is_memfree(dev) && (ds > dev->limits.max_desc_sz))
231 	srq->srqn = mthca_alloc(&dev->srq_table.alloc);
235 	if (mthca_is_memfree(dev)) {
236 		err = mthca_table_get(dev, dev->srq_table.table, srq->srqn);
241 			srq->db_index = mthca_alloc_db(dev, MTHCA_DB_TYPE_SRQ,
250 	mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
256 	err = mthca_alloc_srq_buf(dev, pd, srq, udata);
265 	if (mthca_is_memfree(dev))
266 		mthca_arbel_init_srq_context(dev, pd, srq, mailbox->buf, udata);
268 		mthca_tavor_init_srq_context(dev, pd, srq, mailbox->buf, udata);
270 	err = mthca_SW2HW_SRQ(dev, mailbox, srq->srqn);
273 		mthca_warn(dev, "SW2HW_SRQ failed (%d)\n", err);
277 	spin_lock_irq(&dev->srq_table.lock);
278 	if (mthca_array_set(&dev->srq_table.srq,
279 			    srq->srqn & (dev->limits.num_srqs - 1),
281 		spin_unlock_irq(&dev->srq_table.lock);
284 	spin_unlock_irq(&dev->srq_table.lock);
286 	mthca_free_mailbox(dev, mailbox);
297 	err = mthca_HW2SW_SRQ(dev, mailbox, srq->srqn);
299 		mthca_warn(dev, "HW2SW_SRQ failed (%d)\n", err);
303 		mthca_free_srq_buf(dev, srq);
306 	mthca_free_mailbox(dev, mailbox);
309 	if (!udata && mthca_is_memfree(dev))
310 		mthca_free_db(dev, MTHCA_DB_TYPE_SRQ, srq->db_index);
313 	mthca_table_put(dev, dev->srq_table.table, srq->srqn);
316 	mthca_free(&dev->srq_table.alloc, srq->srqn);
321 static inline int get_srq_refcount(struct mthca_dev *dev, struct mthca_srq *srq)
325 	spin_lock_irq(&dev->srq_table.lock);
327 	spin_unlock_irq(&dev->srq_table.lock);
332 void mthca_free_srq(struct mthca_dev *dev, struct mthca_srq *srq)
337 	mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
339 		mthca_warn(dev, "No memory for mailbox to free SRQ.\n");
343 	err = mthca_HW2SW_SRQ(dev, mailbox, srq->srqn);
345 		mthca_warn(dev, "HW2SW_SRQ failed (%d)\n", err);
347 	spin_lock_irq(&dev->srq_table.lock);
348 	mthca_array_clear(&dev->srq_table.srq,
349 			  srq->srqn & (dev->limits.num_srqs - 1));
351 	spin_unlock_irq(&dev->srq_table.lock);
353 	wait_event(srq->wait, !get_srq_refcount(dev, srq));
356 		mthca_free_srq_buf(dev, srq);
357 		if (mthca_is_memfree(dev))
358 			mthca_free_db(dev, MTHCA_DB_TYPE_SRQ, srq->db_index);
361 	mthca_table_put(dev, dev->srq_table.table, srq->srqn);
362 	mthca_free(&dev->srq_table.alloc, srq->srqn);
363 	mthca_free_mailbox(dev, mailbox);
369 	struct mthca_dev *dev = to_mdev(ibsrq->device);
378 		u32 max_wr = mthca_is_memfree(dev) ? srq->max - 1 : srq->max;
383 		ret = mthca_ARM_SRQ(dev, srq->srqn, attr->srq_limit);
392 	struct mthca_dev *dev = to_mdev(ibsrq->device);
399 	mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
403 	err = mthca_QUERY_SRQ(dev, srq->srqn, mailbox);
407 	if (mthca_is_memfree(dev)) {
419 	mthca_free_mailbox(dev, mailbox);
424 void mthca_srq_event(struct mthca_dev *dev, u32 srqn,
430 	spin_lock(&dev->srq_table.lock);
431 	srq = mthca_array_get(&dev->srq_table.srq, srqn & (dev->limits.num_srqs - 1));
434 	spin_unlock(&dev->srq_table.lock);
437 		mthca_warn(dev, "Async event for bogus SRQ %08x\n", srqn);
444 	event.device      = &dev->ib_dev;
450 	spin_lock(&dev->srq_table.lock);
453 	spin_unlock(&dev->srq_table.lock);
480 	struct mthca_dev *dev = to_mdev(ibsrq->device);
502 			mthca_err(dev, "SRQ %06x full\n", srq->srqn);
548 				      dev->kar + MTHCA_RECEIVE_DOORBELL,
549 				      MTHCA_GET_DOORBELL_LOCK(&dev->doorbell_lock));
563 			      dev->kar + MTHCA_RECEIVE_DOORBELL,
564 			      MTHCA_GET_DOORBELL_LOCK(&dev->doorbell_lock));
580 	struct mthca_dev *dev = to_mdev(ibsrq->device);
598 			mthca_err(dev, "SRQ %06x full\n", srq->srqn);
642 int mthca_max_srq_sge(struct mthca_dev *dev)
644 	if (mthca_is_memfree(dev))
645 		return dev->limits.max_sg;
661 	return min_t(int, dev->limits.max_sg,
662 		     ((1 << (fls(dev->limits.max_desc_sz) - 1)) -
667 int mthca_init_srq_table(struct mthca_dev *dev)
671 	if (!(dev->mthca_flags & MTHCA_FLAG_SRQ))
674 	spin_lock_init(&dev->srq_table.lock);
676 	err = mthca_alloc_init(&dev->srq_table.alloc,
677 			       dev->limits.num_srqs,
678 			       dev->limits.num_srqs - 1,
679 			       dev->limits.reserved_srqs);
683 	err = mthca_array_init(&dev->srq_table.srq,
684 			       dev->limits.num_srqs);
686 		mthca_alloc_cleanup(&dev->srq_table.alloc);
691 void mthca_cleanup_srq_table(struct mthca_dev *dev)
693 	if (!(dev->mthca_flags & MTHCA_FLAG_SRQ))
696 	mthca_array_cleanup(&dev->srq_table.srq, dev->limits.num_srqs);
697 	mthca_alloc_cleanup(&dev->srq_table.alloc);