drivers/infiniband/hw/ehca/ehca_uverbs.c - kernel/msm - Gitiles

 /*
  *  IBM eServer eHCA Infiniband device driver for Linux on POWER
  *
  *  userspace support verbs
  *
  *  Authors: Christoph Raisch <raisch@de.ibm.com>
  *           Hoang-Nam Nguyen <hnguyen@de.ibm.com>
  *           Heiko J Schick <schickhj@de.ibm.com>
  *
  *  Copyright (c) 2005 IBM Corporation
  *
  *  All rights reserved.
  *
  *  This source code is distributed under a dual license of GPL v2.0 and OpenIB
  *  BSD.
  *
  * OpenIB BSD License
  *
  * 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.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */

 #include <asm/current.h>

 #include "ehca_classes.h"
 #include "ehca_iverbs.h"
 #include "ehca_mrmw.h"
 #include "ehca_tools.h"
 #include "hcp_if.h"

 struct ib_ucontext *ehca_alloc_ucontext(struct ib_device *device,
 					struct ib_udata *udata)
 {
 	struct ehca_ucontext *my_context;

 	my_context = kzalloc(sizeof *my_context, GFP_KERNEL);
 	if (!my_context) {
 		ehca_err(device, "Out of memory device=%p", device);
 		return ERR_PTR(-ENOMEM);
 	}

 	return &my_context->ib_ucontext;
 }

 int ehca_dealloc_ucontext(struct ib_ucontext *context)
 {
 	kfree(container_of(context, struct ehca_ucontext, ib_ucontext));
 	return 0;
 }

 struct page *ehca_nopage(struct vm_area_struct *vma,
 			 unsigned long address, int *type)
 {
 	struct page *mypage = NULL;
 	u64 fileoffset = vma->vm_pgoff << PAGE_SHIFT;
 	u32 idr_handle = fileoffset >> 32;
 	u32 q_type = (fileoffset >> 28) & 0xF;	  /* CQ, QP,...        */
 	u32 rsrc_type = (fileoffset >> 24) & 0xF; /* sq,rq,cmnd_window */
 	u32 cur_pid = current->tgid;
 	unsigned long flags;
 	struct ehca_cq *cq;
 	struct ehca_qp *qp;
 	struct ehca_pd *pd;
 	u64 offset;
 	void *vaddr;

 	switch (q_type) {
 	case 1: /* CQ */
 		spin_lock_irqsave(&ehca_cq_idr_lock, flags);
 		cq = idr_find(&ehca_cq_idr, idr_handle);
 		spin_unlock_irqrestore(&ehca_cq_idr_lock, flags);

 		/* make sure this mmap really belongs to the authorized user */
 		if (!cq) {
 			ehca_gen_err("cq is NULL ret=NOPAGE_SIGBUS");
 			return NOPAGE_SIGBUS;
 		}

 		if (cq->ownpid != cur_pid) {
 			ehca_err(cq->ib_cq.device,
 				 "Invalid caller pid=%x ownpid=%x",
 				 cur_pid, cq->ownpid);
 			return NOPAGE_SIGBUS;
 		}

 		if (rsrc_type == 2) {
 			ehca_dbg(cq->ib_cq.device, "cq=%p cq queuearea", cq);
 			offset = address - vma->vm_start;
 			vaddr = ipz_qeit_calc(&cq->ipz_queue, offset);
 			ehca_dbg(cq->ib_cq.device, "offset=%lx vaddr=%p",
 				 offset, vaddr);
 			mypage = virt_to_page(vaddr);
 		}
 		break;

 	case 2: /* QP */
 		spin_lock_irqsave(&ehca_qp_idr_lock, flags);
 		qp = idr_find(&ehca_qp_idr, idr_handle);
 		spin_unlock_irqrestore(&ehca_qp_idr_lock, flags);

 		/* make sure this mmap really belongs to the authorized user */
 		if (!qp) {
 			ehca_gen_err("qp is NULL ret=NOPAGE_SIGBUS");
 			return NOPAGE_SIGBUS;
 		}

 		pd = container_of(qp->ib_qp.pd, struct ehca_pd, ib_pd);
 		if (pd->ownpid != cur_pid) {
 			ehca_err(qp->ib_qp.device,
 				 "Invalid caller pid=%x ownpid=%x",
 				 cur_pid, pd->ownpid);
 			return NOPAGE_SIGBUS;
 		}

 		if (rsrc_type == 2) {	/* rqueue */
 			ehca_dbg(qp->ib_qp.device, "qp=%p qp rqueuearea", qp);
 			offset = address - vma->vm_start;
 			vaddr = ipz_qeit_calc(&qp->ipz_rqueue, offset);
 			ehca_dbg(qp->ib_qp.device, "offset=%lx vaddr=%p",
 				 offset, vaddr);
 			mypage = virt_to_page(vaddr);
 		} else if (rsrc_type == 3) {	/* squeue */
 			ehca_dbg(qp->ib_qp.device, "qp=%p qp squeuearea", qp);
 			offset = address - vma->vm_start;
 			vaddr = ipz_qeit_calc(&qp->ipz_squeue, offset);
 			ehca_dbg(qp->ib_qp.device, "offset=%lx vaddr=%p",
 				 offset, vaddr);
 			mypage = virt_to_page(vaddr);
 		}
 		break;

 	default:
 		ehca_gen_err("bad queue type %x", q_type);
 		return NOPAGE_SIGBUS;
 	}

 	if (!mypage) {
 		ehca_gen_err("Invalid page adr==NULL ret=NOPAGE_SIGBUS");
 		return NOPAGE_SIGBUS;
 	}
 	get_page(mypage);

 	return mypage;
 }

 static struct vm_operations_struct ehcau_vm_ops = {
 	.nopage = ehca_nopage,
 };

 int ehca_mmap(struct ib_ucontext *context, struct vm_area_struct *vma)
 {
 	u64 fileoffset = vma->vm_pgoff << PAGE_SHIFT;
 	u32 idr_handle = fileoffset >> 32;
 	u32 q_type = (fileoffset >> 28) & 0xF;	  /* CQ, QP,...        */
 	u32 rsrc_type = (fileoffset >> 24) & 0xF; /* sq,rq,cmnd_window */
 	u32 cur_pid = current->tgid;
 	u32 ret;
 	u64 vsize, physical;
 	unsigned long flags;
 	struct ehca_cq *cq;
 	struct ehca_qp *qp;
 	struct ehca_pd *pd;

 	switch (q_type) {
 	case  1: /* CQ */
 		spin_lock_irqsave(&ehca_cq_idr_lock, flags);
 		cq = idr_find(&ehca_cq_idr, idr_handle);
 		spin_unlock_irqrestore(&ehca_cq_idr_lock, flags);

 		/* make sure this mmap really belongs to the authorized user */
 		if (!cq)
 			return -EINVAL;

 		if (cq->ownpid != cur_pid) {
 			ehca_err(cq->ib_cq.device,
 				 "Invalid caller pid=%x ownpid=%x",
 				 cur_pid, cq->ownpid);
 			return -ENOMEM;
 		}

 		if (!cq->ib_cq.uobject || cq->ib_cq.uobject->context != context)
 			return -EINVAL;

 		switch (rsrc_type) {
 		case 1: /* galpa fw handle */
 			ehca_dbg(cq->ib_cq.device, "cq=%p cq triggerarea", cq);
 			vma->vm_flags |= VM_RESERVED;
 			vsize = vma->vm_end - vma->vm_start;
 			if (vsize != EHCA_PAGESIZE) {
 				ehca_err(cq->ib_cq.device, "invalid vsize=%lx",
 					 vma->vm_end - vma->vm_start);
 				return -EINVAL;
 			}

 			physical = cq->galpas.user.fw_handle;
 			vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 			vma->vm_flags |= VM_IO | VM_RESERVED;

 			ehca_dbg(cq->ib_cq.device,
 				 "vsize=%lx physical=%lx", vsize, physical);
 			ret = remap_pfn_range(vma, vma->vm_start,
 					      physical >> PAGE_SHIFT, vsize,
 					      vma->vm_page_prot);
 			if (ret) {
 				ehca_err(cq->ib_cq.device,
 					 "remap_pfn_range() failed ret=%x",
 					 ret);
 				return -ENOMEM;
 			}
 			break;

 		case 2: /* cq queue_addr */
 			ehca_dbg(cq->ib_cq.device, "cq=%p cq q_addr", cq);
 			vma->vm_flags |= VM_RESERVED;
 			vma->vm_ops = &ehcau_vm_ops;
 			break;

 		default:
 			ehca_err(cq->ib_cq.device, "bad resource type %x",
 				 rsrc_type);
 			return -EINVAL;
 		}
 		break;

 	case 2: /* QP */
 		spin_lock_irqsave(&ehca_qp_idr_lock, flags);
 		qp = idr_find(&ehca_qp_idr, idr_handle);
 		spin_unlock_irqrestore(&ehca_qp_idr_lock, flags);

 		/* make sure this mmap really belongs to the authorized user */
 		if (!qp)
 			return -EINVAL;

 		pd = container_of(qp->ib_qp.pd, struct ehca_pd, ib_pd);
 		if (pd->ownpid != cur_pid) {
 			ehca_err(qp->ib_qp.device,
 				 "Invalid caller pid=%x ownpid=%x",
 				 cur_pid, pd->ownpid);
 			return -ENOMEM;
 		}

 		if (!qp->ib_qp.uobject || qp->ib_qp.uobject->context != context)
 			return -EINVAL;

 		switch (rsrc_type) {
 		case 1: /* galpa fw handle */
 			ehca_dbg(qp->ib_qp.device, "qp=%p qp triggerarea", qp);
 			vma->vm_flags |= VM_RESERVED;
 			vsize = vma->vm_end - vma->vm_start;
 			if (vsize != EHCA_PAGESIZE) {
 				ehca_err(qp->ib_qp.device, "invalid vsize=%lx",
 					 vma->vm_end - vma->vm_start);
 				return -EINVAL;
 			}

 			physical = qp->galpas.user.fw_handle;
 			vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 			vma->vm_flags |= VM_IO | VM_RESERVED;

 			ehca_dbg(qp->ib_qp.device, "vsize=%lx physical=%lx",
 				 vsize, physical);
 			ret = remap_pfn_range(vma, vma->vm_start,
 					      physical >> PAGE_SHIFT, vsize,
 					      vma->vm_page_prot);
 			if (ret) {
 				ehca_err(qp->ib_qp.device,
 					 "remap_pfn_range() failed ret=%x",
 					 ret);
 				return -ENOMEM;
 			}
 			break;

 		case 2: /* qp rqueue_addr */
 			ehca_dbg(qp->ib_qp.device, "qp=%p qp rqueue_addr", qp);
 			vma->vm_flags |= VM_RESERVED;
 			vma->vm_ops = &ehcau_vm_ops;
 			break;

 		case 3: /* qp squeue_addr */
 			ehca_dbg(qp->ib_qp.device, "qp=%p qp squeue_addr", qp);
 			vma->vm_flags |= VM_RESERVED;
 			vma->vm_ops = &ehcau_vm_ops;
 			break;

 		default:
 			ehca_err(qp->ib_qp.device, "bad resource type %x",
 				 rsrc_type);
 			return -EINVAL;
 		}
 		break;

 	default:
 		ehca_gen_err("bad queue type %x", q_type);
 		return -EINVAL;
 	}

 	return 0;
 }

 int ehca_mmap_nopage(u64 foffset, u64 length, void **mapped,
 		     struct vm_area_struct **vma)
 {
 	down_write(&current->mm->mmap_sem);
 	*mapped = (void*)do_mmap(NULL,0, length, PROT_WRITE,
 				 MAP_SHARED | MAP_ANONYMOUS,
 				 foffset);
 	up_write(&current->mm->mmap_sem);
 	if (!(*mapped)) {
 		ehca_gen_err("couldn't mmap foffset=%lx length=%lx",
 			     foffset, length);
 		return -EINVAL;
 	}

 	*vma = find_vma(current->mm, (u64)*mapped);
 	if (!(*vma)) {
 		down_write(&current->mm->mmap_sem);
 		do_munmap(current->mm, 0, length);
 		up_write(&current->mm->mmap_sem);
 		ehca_gen_err("couldn't find vma queue=%p", *mapped);
 		return -EINVAL;
 	}
 	(*vma)->vm_flags |= VM_RESERVED;
 	(*vma)->vm_ops = &ehcau_vm_ops;

 	return 0;
 }

 int ehca_mmap_register(u64 physical, void **mapped,
 		       struct vm_area_struct **vma)
 {
 	int ret;
 	unsigned long vsize;
 	/* ehca hw supports only 4k page */
 	ret = ehca_mmap_nopage(0, EHCA_PAGESIZE, mapped, vma);
 	if (ret) {
 		ehca_gen_err("could'nt mmap physical=%lx", physical);
 		return ret;
 	}

 	(*vma)->vm_flags |= VM_RESERVED;
 	vsize = (*vma)->vm_end - (*vma)->vm_start;
 	if (vsize != EHCA_PAGESIZE) {
 		ehca_gen_err("invalid vsize=%lx",
 			     (*vma)->vm_end - (*vma)->vm_start);
 		return -EINVAL;
 	}

 	(*vma)->vm_page_prot = pgprot_noncached((*vma)->vm_page_prot);
 	(*vma)->vm_flags |= VM_IO | VM_RESERVED;

 	ret = remap_pfn_range((*vma), (*vma)->vm_start,
 			      physical >> PAGE_SHIFT, vsize,
 			      (*vma)->vm_page_prot);
 	if (ret) {
 		ehca_gen_err("remap_pfn_range() failed ret=%x", ret);
 		return -ENOMEM;
 	}

 	return 0;

 }

 int ehca_munmap(unsigned long addr, size_t len) {
 	int ret = 0;
 	struct mm_struct *mm = current->mm;
 	if (mm) {
 		down_write(&mm->mmap_sem);
 		ret = do_munmap(mm, addr, len);
 		up_write(&mm->mmap_sem);
 	}
 	return ret;
 }
	/*
	* IBM eServer eHCA Infiniband device driver for Linux on POWER
	*
	* userspace support verbs
	*
	* Authors: Christoph Raisch <raisch@de.ibm.com>
	* Hoang-Nam Nguyen <hnguyen@de.ibm.com>
	* Heiko J Schick <schickhj@de.ibm.com>
	*
	* Copyright (c) 2005 IBM Corporation
	*
	* All rights reserved.
	*
	* This source code is distributed under a dual license of GPL v2.0 and OpenIB
	* BSD.
	*
	* OpenIB BSD License
	*
	* 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.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
	* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	* POSSIBILITY OF SUCH DAMAGE.
	*/

	#include <asm/current.h>

	#include "ehca_classes.h"
	#include "ehca_iverbs.h"
	#include "ehca_mrmw.h"
	#include "ehca_tools.h"
	#include "hcp_if.h"

	struct ib_ucontext ehca_alloc_ucontext(struct ib_device device,
	struct ib_udata *udata)
	{
	struct ehca_ucontext *my_context;

	my_context = kzalloc(sizeof *my_context, GFP_KERNEL);
	if (!my_context) {
	ehca_err(device, "Out of memory device=%p", device);
	return ERR_PTR(-ENOMEM);
	}

	return &my_context->ib_ucontext;
	}

	int ehca_dealloc_ucontext(struct ib_ucontext *context)
	{
	kfree(container_of(context, struct ehca_ucontext, ib_ucontext));
	return 0;
	}

	struct page ehca_nopage(struct vm_area_struct vma,
	unsigned long address, int *type)
	{
	struct page *mypage = NULL;
	u64 fileoffset = vma->vm_pgoff << PAGE_SHIFT;
	u32 idr_handle = fileoffset >> 32;
	u32 q_type = (fileoffset >> 28) & 0xF; /* CQ, QP,... */
	u32 rsrc_type = (fileoffset >> 24) & 0xF; /* sq,rq,cmnd_window */
	u32 cur_pid = current->tgid;
	unsigned long flags;
	struct ehca_cq *cq;
	struct ehca_qp *qp;
	struct ehca_pd *pd;
	u64 offset;
	void *vaddr;

	switch (q_type) {
	case 1: /* CQ */
	spin_lock_irqsave(&ehca_cq_idr_lock, flags);
	cq = idr_find(&ehca_cq_idr, idr_handle);
	spin_unlock_irqrestore(&ehca_cq_idr_lock, flags);

	/* make sure this mmap really belongs to the authorized user */
	if (!cq) {
	ehca_gen_err("cq is NULL ret=NOPAGE_SIGBUS");
	return NOPAGE_SIGBUS;
	}

	if (cq->ownpid != cur_pid) {
	ehca_err(cq->ib_cq.device,
	"Invalid caller pid=%x ownpid=%x",
	cur_pid, cq->ownpid);
	return NOPAGE_SIGBUS;
	}

	if (rsrc_type == 2) {
	ehca_dbg(cq->ib_cq.device, "cq=%p cq queuearea", cq);
	offset = address - vma->vm_start;
	vaddr = ipz_qeit_calc(&cq->ipz_queue, offset);
	ehca_dbg(cq->ib_cq.device, "offset=%lx vaddr=%p",
	offset, vaddr);
	mypage = virt_to_page(vaddr);
	}
	break;

	case 2: /* QP */
	spin_lock_irqsave(&ehca_qp_idr_lock, flags);
	qp = idr_find(&ehca_qp_idr, idr_handle);
	spin_unlock_irqrestore(&ehca_qp_idr_lock, flags);

	/* make sure this mmap really belongs to the authorized user */
	if (!qp) {
	ehca_gen_err("qp is NULL ret=NOPAGE_SIGBUS");
	return NOPAGE_SIGBUS;
	}

	pd = container_of(qp->ib_qp.pd, struct ehca_pd, ib_pd);
	if (pd->ownpid != cur_pid) {
	ehca_err(qp->ib_qp.device,
	"Invalid caller pid=%x ownpid=%x",
	cur_pid, pd->ownpid);
	return NOPAGE_SIGBUS;
	}

	if (rsrc_type == 2) { /* rqueue */
	ehca_dbg(qp->ib_qp.device, "qp=%p qp rqueuearea", qp);
	offset = address - vma->vm_start;
	vaddr = ipz_qeit_calc(&qp->ipz_rqueue, offset);
	ehca_dbg(qp->ib_qp.device, "offset=%lx vaddr=%p",
	offset, vaddr);
	mypage = virt_to_page(vaddr);
	} else if (rsrc_type == 3) { /* squeue */
	ehca_dbg(qp->ib_qp.device, "qp=%p qp squeuearea", qp);
	offset = address - vma->vm_start;
	vaddr = ipz_qeit_calc(&qp->ipz_squeue, offset);
	ehca_dbg(qp->ib_qp.device, "offset=%lx vaddr=%p",
	offset, vaddr);
	mypage = virt_to_page(vaddr);
	}
	break;

	default:
	ehca_gen_err("bad queue type %x", q_type);
	return NOPAGE_SIGBUS;
	}

	if (!mypage) {
	ehca_gen_err("Invalid page adr==NULL ret=NOPAGE_SIGBUS");
	return NOPAGE_SIGBUS;
	}
	get_page(mypage);

	return mypage;
	}

	static struct vm_operations_struct ehcau_vm_ops = {
	.nopage = ehca_nopage,
	};

	int ehca_mmap(struct ib_ucontext context, struct vm_area_struct vma)
	{
	u64 fileoffset = vma->vm_pgoff << PAGE_SHIFT;
	u32 idr_handle = fileoffset >> 32;
	u32 q_type = (fileoffset >> 28) & 0xF; /* CQ, QP,... */
	u32 rsrc_type = (fileoffset >> 24) & 0xF; /* sq,rq,cmnd_window */
	u32 cur_pid = current->tgid;
	u32 ret;
	u64 vsize, physical;
	unsigned long flags;
	struct ehca_cq *cq;
	struct ehca_qp *qp;
	struct ehca_pd *pd;

	switch (q_type) {
	case 1: /* CQ */
	spin_lock_irqsave(&ehca_cq_idr_lock, flags);
	cq = idr_find(&ehca_cq_idr, idr_handle);
	spin_unlock_irqrestore(&ehca_cq_idr_lock, flags);

	/* make sure this mmap really belongs to the authorized user */
	if (!cq)
	return -EINVAL;

	if (cq->ownpid != cur_pid) {
	ehca_err(cq->ib_cq.device,
	"Invalid caller pid=%x ownpid=%x",
	cur_pid, cq->ownpid);
	return -ENOMEM;
	}

	if (!cq->ib_cq.uobject \|\| cq->ib_cq.uobject->context != context)
	return -EINVAL;

	switch (rsrc_type) {
	case 1: /* galpa fw handle */
	ehca_dbg(cq->ib_cq.device, "cq=%p cq triggerarea", cq);
	vma->vm_flags \|= VM_RESERVED;
	vsize = vma->vm_end - vma->vm_start;
	if (vsize != EHCA_PAGESIZE) {
	ehca_err(cq->ib_cq.device, "invalid vsize=%lx",
	vma->vm_end - vma->vm_start);
	return -EINVAL;
	}

	physical = cq->galpas.user.fw_handle;
	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
	vma->vm_flags \|= VM_IO \| VM_RESERVED;

	ehca_dbg(cq->ib_cq.device,
	"vsize=%lx physical=%lx", vsize, physical);
	ret = remap_pfn_range(vma, vma->vm_start,
	physical >> PAGE_SHIFT, vsize,
	vma->vm_page_prot);
	if (ret) {
	ehca_err(cq->ib_cq.device,
	"remap_pfn_range() failed ret=%x",
	ret);
	return -ENOMEM;
	}
	break;

	case 2: /* cq queue_addr */
	ehca_dbg(cq->ib_cq.device, "cq=%p cq q_addr", cq);
	vma->vm_flags \|= VM_RESERVED;
	vma->vm_ops = &ehcau_vm_ops;
	break;

	default:
	ehca_err(cq->ib_cq.device, "bad resource type %x",
	rsrc_type);
	return -EINVAL;
	}
	break;

	case 2: /* QP */
	spin_lock_irqsave(&ehca_qp_idr_lock, flags);
	qp = idr_find(&ehca_qp_idr, idr_handle);
	spin_unlock_irqrestore(&ehca_qp_idr_lock, flags);

	/* make sure this mmap really belongs to the authorized user */
	if (!qp)
	return -EINVAL;

	pd = container_of(qp->ib_qp.pd, struct ehca_pd, ib_pd);
	if (pd->ownpid != cur_pid) {
	ehca_err(qp->ib_qp.device,
	"Invalid caller pid=%x ownpid=%x",
	cur_pid, pd->ownpid);
	return -ENOMEM;
	}

	if (!qp->ib_qp.uobject \|\| qp->ib_qp.uobject->context != context)
	return -EINVAL;

	switch (rsrc_type) {
	case 1: /* galpa fw handle */
	ehca_dbg(qp->ib_qp.device, "qp=%p qp triggerarea", qp);
	vma->vm_flags \|= VM_RESERVED;
	vsize = vma->vm_end - vma->vm_start;
	if (vsize != EHCA_PAGESIZE) {
	ehca_err(qp->ib_qp.device, "invalid vsize=%lx",
	vma->vm_end - vma->vm_start);
	return -EINVAL;
	}

	physical = qp->galpas.user.fw_handle;
	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
	vma->vm_flags \|= VM_IO \| VM_RESERVED;

	ehca_dbg(qp->ib_qp.device, "vsize=%lx physical=%lx",
	vsize, physical);
	ret = remap_pfn_range(vma, vma->vm_start,
	physical >> PAGE_SHIFT, vsize,
	vma->vm_page_prot);
	if (ret) {
	ehca_err(qp->ib_qp.device,
	"remap_pfn_range() failed ret=%x",
	ret);
	return -ENOMEM;
	}
	break;

	case 2: /* qp rqueue_addr */
	ehca_dbg(qp->ib_qp.device, "qp=%p qp rqueue_addr", qp);
	vma->vm_flags \|= VM_RESERVED;
	vma->vm_ops = &ehcau_vm_ops;
	break;

	case 3: /* qp squeue_addr */
	ehca_dbg(qp->ib_qp.device, "qp=%p qp squeue_addr", qp);
	vma->vm_flags \|= VM_RESERVED;
	vma->vm_ops = &ehcau_vm_ops;
	break;

	default:
	ehca_err(qp->ib_qp.device, "bad resource type %x",
	rsrc_type);
	return -EINVAL;
	}
	break;

	default:
	ehca_gen_err("bad queue type %x", q_type);
	return -EINVAL;
	}

	return 0;
	}

	int ehca_mmap_nopage(u64 foffset, u64 length, void **mapped,
	struct vm_area_struct **vma)
	{
	down_write(&current->mm->mmap_sem);
	mapped = (void)do_mmap(NULL,0, length, PROT_WRITE,
	MAP_SHARED \| MAP_ANONYMOUS,
	foffset);
	up_write(&current->mm->mmap_sem);
	if (!(*mapped)) {
	ehca_gen_err("couldn't mmap foffset=%lx length=%lx",
	foffset, length);
	return -EINVAL;
	}

	vma = find_vma(current->mm, (u64)mapped);
	if (!(*vma)) {
	down_write(&current->mm->mmap_sem);
	do_munmap(current->mm, 0, length);
	up_write(&current->mm->mmap_sem);
	ehca_gen_err("couldn't find vma queue=%p", *mapped);
	return -EINVAL;
	}
	(*vma)->vm_flags \|= VM_RESERVED;
	(*vma)->vm_ops = &ehcau_vm_ops;

	return 0;
	}

	int ehca_mmap_register(u64 physical, void **mapped,
	struct vm_area_struct **vma)
	{
	int ret;
	unsigned long vsize;
	/* ehca hw supports only 4k page */
	ret = ehca_mmap_nopage(0, EHCA_PAGESIZE, mapped, vma);
	if (ret) {
	ehca_gen_err("could'nt mmap physical=%lx", physical);
	return ret;
	}

	(*vma)->vm_flags \|= VM_RESERVED;
	vsize = (vma)->vm_end - (vma)->vm_start;
	if (vsize != EHCA_PAGESIZE) {
	ehca_gen_err("invalid vsize=%lx",
	(vma)->vm_end - (vma)->vm_start);
	return -EINVAL;
	}

	(vma)->vm_page_prot = pgprot_noncached((vma)->vm_page_prot);
	(*vma)->vm_flags \|= VM_IO \| VM_RESERVED;

	ret = remap_pfn_range((vma), (vma)->vm_start,
	physical >> PAGE_SHIFT, vsize,
	(*vma)->vm_page_prot);
	if (ret) {
	ehca_gen_err("remap_pfn_range() failed ret=%x", ret);
	return -ENOMEM;
	}

	return 0;

	}

	int ehca_munmap(unsigned long addr, size_t len) {
	int ret = 0;
	struct mm_struct *mm = current->mm;
	if (mm) {
	down_write(&mm->mmap_sem);
	ret = do_munmap(mm, addr, len);
	up_write(&mm->mmap_sem);
	}
	return ret;
	}