IB/ipath: misc infiniband code, part 1 (cef1cce5) · Commits · e / devices / android_kernel_sony_msm8998

drivers/infiniband/hw/ipath/ipath_cq.c

0 → 100644

+295 −0

Original line number	Diff line number	Diff line
		/*
		* 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;
		}

drivers/infiniband/hw/ipath/ipath_keys.c

0 → 100644

+236 −0

Original line number	Diff line number	Diff line
		/*
		* 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 <asm/io.h>

		#include "ipath_verbs.h"

		/**
		* ipath_alloc_lkey - allocate an lkey
		* @rkt: lkey table in which to allocate the lkey
		* @mr: memory region that this lkey protects
		*
		* Returns 1 if successful, otherwise returns 0.
		*/

		int ipath_alloc_lkey(struct ipath_lkey_table rkt, struct ipath_mregion mr)
		{
		unsigned long flags;
		u32 r;
		u32 n;
		int ret;

		spin_lock_irqsave(&rkt->lock, flags);

		/* Find the next available LKEY */
		r = n = rkt->next;
		for (;;) {
		if (rkt->table[r] == NULL)
		break;
		r = (r + 1) & (rkt->max - 1);
		if (r == n) {
		spin_unlock_irqrestore(&rkt->lock, flags);
		_VERBS_INFO("LKEY table full\n");
		ret = 0;
		goto bail;
		}
		}
		rkt->next = (r + 1) & (rkt->max - 1);
		/*
		* Make sure lkey is never zero which is reserved to indicate an
		* unrestricted LKEY.
		*/
		rkt->gen++;
		mr->lkey = (r << (32 - ib_ipath_lkey_table_size)) \|
		((((1 << (24 - ib_ipath_lkey_table_size)) - 1) & rkt->gen)
		<< 8);
		if (mr->lkey == 0) {
		mr->lkey \|= 1 << 8;
		rkt->gen++;
		}
		rkt->table[r] = mr;
		spin_unlock_irqrestore(&rkt->lock, flags);

		ret = 1;

		bail:
		return ret;
		}

		/**
		* ipath_free_lkey - free an lkey
		* @rkt: table from which to free the lkey
		* @lkey: lkey id to free
		*/
		void ipath_free_lkey(struct ipath_lkey_table *rkt, u32 lkey)
		{
		unsigned long flags;
		u32 r;

		if (lkey == 0)
		return;
		r = lkey >> (32 - ib_ipath_lkey_table_size);
		spin_lock_irqsave(&rkt->lock, flags);
		rkt->table[r] = NULL;
		spin_unlock_irqrestore(&rkt->lock, flags);
		}

		/**
		* ipath_lkey_ok - check IB SGE for validity and initialize
		* @rkt: table containing lkey to check SGE against
		* @isge: outgoing internal SGE
		* @sge: SGE to check
		* @acc: access flags
		*
		* Return 1 if valid and successful, otherwise returns 0.
		*
		* Check the IB SGE for validity and initialize our internal version
		* of it.
		*/
		int ipath_lkey_ok(struct ipath_lkey_table rkt, struct ipath_sge isge,
		struct ib_sge *sge, int acc)
		{
		struct ipath_mregion *mr;
		size_t off;
		int ret;

		/*
		* We use LKEY == zero to mean a physical kmalloc() address.
		* This is a bit of a hack since we rely on dma_map_single()
		* being reversible by calling bus_to_virt().
		*/
		if (sge->lkey == 0) {
		isge->mr = NULL;
		isge->vaddr = bus_to_virt(sge->addr);
		isge->length = sge->length;
		isge->sge_length = sge->length;
		ret = 1;
		goto bail;
		}
		spin_lock(&rkt->lock);
		mr = rkt->table[(sge->lkey >> (32 - ib_ipath_lkey_table_size))];
		spin_unlock(&rkt->lock);
		if (unlikely(mr == NULL \|\| mr->lkey != sge->lkey)) {
		ret = 0;
		goto bail;
		}

		off = sge->addr - mr->user_base;
		if (unlikely(sge->addr < mr->user_base \|\|
		off + sge->length > mr->length \|\|
		(mr->access_flags & acc) != acc)) {
		ret = 0;
		goto bail;
		}

		off += mr->offset;
		isge->mr = mr;
		isge->m = 0;
		isge->n = 0;
		while (off >= mr->map[isge->m]->segs[isge->n].length) {
		off -= mr->map[isge->m]->segs[isge->n].length;
		isge->n++;
		if (isge->n >= IPATH_SEGSZ) {
		isge->m++;
		isge->n = 0;
		}
		}
		isge->vaddr = mr->map[isge->m]->segs[isge->n].vaddr + off;
		isge->length = mr->map[isge->m]->segs[isge->n].length - off;
		isge->sge_length = sge->length;

		ret = 1;

		bail:
		return ret;
		}

		/**
		* ipath_rkey_ok - check the IB virtual address, length, and RKEY
		* @dev: infiniband device
		* @ss: SGE state
		* @len: length of data
		* @vaddr: virtual address to place data
		* @rkey: rkey to check
		* @acc: access flags
		*
		* Return 1 if successful, otherwise 0.
		*
		* The QP r_rq.lock should be held.
		*/
		int ipath_rkey_ok(struct ipath_ibdev dev, struct ipath_sge_state ss,
		u32 len, u64 vaddr, u32 rkey, int acc)
		{
		struct ipath_lkey_table *rkt = &dev->lk_table;
		struct ipath_sge *sge = &ss->sge;
		struct ipath_mregion *mr;
		size_t off;
		int ret;

		spin_lock(&rkt->lock);
		mr = rkt->table[(rkey >> (32 - ib_ipath_lkey_table_size))];
		spin_unlock(&rkt->lock);
		if (unlikely(mr == NULL \|\| mr->lkey != rkey)) {
		ret = 0;
		goto bail;
		}

		off = vaddr - mr->iova;
		if (unlikely(vaddr < mr->iova \|\| off + len > mr->length \|\|
		(mr->access_flags & acc) == 0)) {
		ret = 0;
		goto bail;
		}

		off += mr->offset;
		sge->mr = mr;
		sge->m = 0;
		sge->n = 0;
		while (off >= mr->map[sge->m]->segs[sge->n].length) {
		off -= mr->map[sge->m]->segs[sge->n].length;
		sge->n++;
		if (sge->n >= IPATH_SEGSZ) {
		sge->m++;
		sge->n = 0;
		}
		}
		sge->vaddr = mr->map[sge->m]->segs[sge->n].vaddr + off;
		sge->length = mr->map[sge->m]->segs[sge->n].length - off;
		sge->sge_length = len;
		ss->sg_list = NULL;
		ss->num_sge = 1;

		ret = 1;

		bail:
		return ret;
		}

drivers/infiniband/hw/ipath/ipath_mr.c

0 → 100644

+383 −0

Original line number	Diff line number	Diff line
		/*
		* 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 <rdma/ib_pack.h>
		#include <rdma/ib_smi.h>

		#include "ipath_verbs.h"

		/**
		* ipath_get_dma_mr - get a DMA memory region
		* @pd: protection domain for this memory region
		* @acc: access flags
		*
		* Returns the memory region on success, otherwise returns an errno.
		*/
		struct ib_mr ipath_get_dma_mr(struct ib_pd pd, int acc)
		{
		struct ipath_mr *mr;
		struct ib_mr *ret;

		mr = kzalloc(sizeof *mr, GFP_KERNEL);
		if (!mr) {
		ret = ERR_PTR(-ENOMEM);
		goto bail;
		}

		mr->mr.access_flags = acc;
		ret = &mr->ibmr;

		bail:
		return ret;
		}

		static struct ipath_mr *alloc_mr(int count,
		struct ipath_lkey_table *lk_table)
		{
		struct ipath_mr *mr;
		int m, i = 0;

		/* Allocate struct plus pointers to first level page tables. */
		m = (count + IPATH_SEGSZ - 1) / IPATH_SEGSZ;
		mr = kmalloc(sizeof mr + m sizeof mr->mr.map[0], GFP_KERNEL);
		if (!mr)
		goto done;

		/* Allocate first level page tables. */
		for (; i < m; i++) {
		mr->mr.map[i] = kmalloc(sizeof *mr->mr.map[0], GFP_KERNEL);
		if (!mr->mr.map[i])
		goto bail;
		}
		mr->mr.mapsz = m;

		/*
		* ib_reg_phys_mr() will initialize mr->ibmr except for
		* lkey and rkey.
		*/
		if (!ipath_alloc_lkey(lk_table, &mr->mr))
		goto bail;
		mr->ibmr.rkey = mr->ibmr.lkey = mr->mr.lkey;

		goto done;

		bail:
		while (i) {
		i--;
		kfree(mr->mr.map[i]);
		}
		kfree(mr);
		mr = NULL;

		done:
		return mr;
		}

		/**
		* ipath_reg_phys_mr - register a physical memory region
		* @pd: protection domain for this memory region
		* @buffer_list: pointer to the list of physical buffers to register
		* @num_phys_buf: the number of physical buffers to register
		* @iova_start: the starting address passed over IB which maps to this MR
		*
		* Returns the memory region on success, otherwise returns an errno.
		*/
		struct ib_mr ipath_reg_phys_mr(struct ib_pd pd,
		struct ib_phys_buf *buffer_list,
		int num_phys_buf, int acc, u64 *iova_start)
		{
		struct ipath_mr *mr;
		int n, m, i;
		struct ib_mr *ret;

		mr = alloc_mr(num_phys_buf, &to_idev(pd->device)->lk_table);
		if (mr == NULL) {
		ret = ERR_PTR(-ENOMEM);
		goto bail;
		}

		mr->mr.user_base = *iova_start;
		mr->mr.iova = *iova_start;
		mr->mr.length = 0;
		mr->mr.offset = 0;
		mr->mr.access_flags = acc;
		mr->mr.max_segs = num_phys_buf;

		m = 0;
		n = 0;
		for (i = 0; i < num_phys_buf; i++) {
		mr->mr.map[m]->segs[n].vaddr =
		phys_to_virt(buffer_list[i].addr);
		mr->mr.map[m]->segs[n].length = buffer_list[i].size;
		mr->mr.length += buffer_list[i].size;
		n++;
		if (n == IPATH_SEGSZ) {
		m++;
		n = 0;
		}
		}

		ret = &mr->ibmr;

		bail:
		return ret;
		}

		/**
		* ipath_reg_user_mr - register a userspace memory region
		* @pd: protection domain for this memory region
		* @region: the user memory region
		* @mr_access_flags: access flags for this memory region
		* @udata: unused by the InfiniPath driver
		*
		* Returns the memory region on success, otherwise returns an errno.
		*/
		struct ib_mr ipath_reg_user_mr(struct ib_pd pd, struct ib_umem *region,
		int mr_access_flags, struct ib_udata *udata)
		{
		struct ipath_mr *mr;
		struct ib_umem_chunk *chunk;
		int n, m, i;
		struct ib_mr *ret;

		n = 0;
		list_for_each_entry(chunk, &region->chunk_list, list)
		n += chunk->nents;

		mr = alloc_mr(n, &to_idev(pd->device)->lk_table);
		if (!mr) {
		ret = ERR_PTR(-ENOMEM);
		goto bail;
		}

		mr->mr.user_base = region->user_base;
		mr->mr.iova = region->virt_base;
		mr->mr.length = region->length;
		mr->mr.offset = region->offset;
		mr->mr.access_flags = mr_access_flags;
		mr->mr.max_segs = n;

		m = 0;
		n = 0;
		list_for_each_entry(chunk, &region->chunk_list, list) {
		for (i = 0; i < chunk->nmap; i++) {
		mr->mr.map[m]->segs[n].vaddr =
		page_address(chunk->page_list[i].page);
		mr->mr.map[m]->segs[n].length = region->page_size;
		n++;
		if (n == IPATH_SEGSZ) {
		m++;
		n = 0;
		}
		}
		}
		ret = &mr->ibmr;

		bail:
		return ret;
		}

		/**
		* ipath_dereg_mr - unregister and free a memory region
		* @ibmr: the memory region to free
		*
		* Returns 0 on success.
		*
		* Note that this is called to free MRs created by ipath_get_dma_mr()
		* or ipath_reg_user_mr().
		*/
		int ipath_dereg_mr(struct ib_mr *ibmr)
		{
		struct ipath_mr *mr = to_imr(ibmr);
		int i;

		ipath_free_lkey(&to_idev(ibmr->device)->lk_table, ibmr->lkey);
		i = mr->mr.mapsz;
		while (i) {
		i--;
		kfree(mr->mr.map[i]);
		}
		kfree(mr);
		return 0;
		}

		/**
		* ipath_alloc_fmr - allocate a fast memory region
		* @pd: the protection domain for this memory region
		* @mr_access_flags: access flags for this memory region
		* @fmr_attr: fast memory region attributes
		*
		* Returns the memory region on success, otherwise returns an errno.
		*/
		struct ib_fmr ipath_alloc_fmr(struct ib_pd pd, int mr_access_flags,
		struct ib_fmr_attr *fmr_attr)
		{
		struct ipath_fmr *fmr;
		int m, i = 0;
		struct ib_fmr *ret;

		/* Allocate struct plus pointers to first level page tables. */
		m = (fmr_attr->max_pages + IPATH_SEGSZ - 1) / IPATH_SEGSZ;
		fmr = kmalloc(sizeof fmr + m sizeof fmr->mr.map[0], GFP_KERNEL);
		if (!fmr)
		goto bail;

		/* Allocate first level page tables. */
		for (; i < m; i++) {
		fmr->mr.map[i] = kmalloc(sizeof *fmr->mr.map[0],
		GFP_KERNEL);
		if (!fmr->mr.map[i])
		goto bail;
		}
		fmr->mr.mapsz = m;

		/*
		* ib_alloc_fmr() will initialize fmr->ibfmr except for lkey &
		* rkey.
		*/
		if (!ipath_alloc_lkey(&to_idev(pd->device)->lk_table, &fmr->mr))
		goto bail;
		fmr->ibfmr.rkey = fmr->ibfmr.lkey = fmr->mr.lkey;
		/*
		* Resources are allocated but no valid mapping (RKEY can't be
		* used).
		*/
		fmr->mr.user_base = 0;
		fmr->mr.iova = 0;
		fmr->mr.length = 0;
		fmr->mr.offset = 0;
		fmr->mr.access_flags = mr_access_flags;
		fmr->mr.max_segs = fmr_attr->max_pages;
		fmr->page_shift = fmr_attr->page_shift;

		ret = &fmr->ibfmr;
		goto done;

		bail:
		while (i)
		kfree(fmr->mr.map[--i]);
		kfree(fmr);
		ret = ERR_PTR(-ENOMEM);

		done:
		return ret;
		}

		/**
		* ipath_map_phys_fmr - set up a fast memory region
		* @ibmfr: the fast memory region to set up
		* @page_list: the list of pages to associate with the fast memory region
		* @list_len: the number of pages to associate with the fast memory region
		* @iova: the virtual address of the start of the fast memory region
		*
		* This may be called from interrupt context.
		*/

		int ipath_map_phys_fmr(struct ib_fmr ibfmr, u64 page_list,
		int list_len, u64 iova)
		{
		struct ipath_fmr *fmr = to_ifmr(ibfmr);
		struct ipath_lkey_table *rkt;
		unsigned long flags;
		int m, n, i;
		u32 ps;
		int ret;

		if (list_len > fmr->mr.max_segs) {
		ret = -EINVAL;
		goto bail;
		}
		rkt = &to_idev(ibfmr->device)->lk_table;
		spin_lock_irqsave(&rkt->lock, flags);
		fmr->mr.user_base = iova;
		fmr->mr.iova = iova;
		ps = 1 << fmr->page_shift;
		fmr->mr.length = list_len * ps;
		m = 0;
		n = 0;
		ps = 1 << fmr->page_shift;
		for (i = 0; i < list_len; i++) {
		fmr->mr.map[m]->segs[n].vaddr = phys_to_virt(page_list[i]);
		fmr->mr.map[m]->segs[n].length = ps;
		if (++n == IPATH_SEGSZ) {
		m++;
		n = 0;
		}
		}
		spin_unlock_irqrestore(&rkt->lock, flags);
		ret = 0;

		bail:
		return ret;
		}

		/**
		* ipath_unmap_fmr - unmap fast memory regions
		* @fmr_list: the list of fast memory regions to unmap
		*
		* Returns 0 on success.
		*/
		int ipath_unmap_fmr(struct list_head *fmr_list)
		{
		struct ipath_fmr *fmr;
		struct ipath_lkey_table *rkt;
		unsigned long flags;

		list_for_each_entry(fmr, fmr_list, ibfmr.list) {
		rkt = &to_idev(fmr->ibfmr.device)->lk_table;
		spin_lock_irqsave(&rkt->lock, flags);
		fmr->mr.user_base = 0;
		fmr->mr.iova = 0;
		fmr->mr.length = 0;
		spin_unlock_irqrestore(&rkt->lock, flags);
		}
		return 0;
		}

		/**
		* ipath_dealloc_fmr - deallocate a fast memory region
		* @ibfmr: the fast memory region to deallocate
		*
		* Returns 0 on success.
		*/
		int ipath_dealloc_fmr(struct ib_fmr *ibfmr)
		{
		struct ipath_fmr *fmr = to_ifmr(ibfmr);
		int i;

		ipath_free_lkey(&to_idev(ibfmr->device)->lk_table, ibfmr->lkey);
		i = fmr->mr.mapsz;
		while (i)
		kfree(fmr->mr.map[--i]);
		kfree(fmr);
		return 0;
		}

drivers/infiniband/hw/ipath/ipath_srq.c

0 → 100644

+273 −0

File added.

Preview size limit exceeded, changes collapsed.