Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d776655a authored by Mitchel Humpherys's avatar Mitchel Humpherys
Browse files

msm: ADSPRPC: Changes to support 64 bit address space 



Update the data types to handle 64 bit address space and
communicate 64 bit addresses to remote processor. Provide
compat ioctl call to allow for 32 bit user space to call
into the driver.

Change-Id: I954f07382bbc9998aed574a7bf74fab9299f0b45
Acked-by: default avatarSathish Ambley <sambley@qti.qualcomm.com>
Signed-off-by: default avatarMitchel Humpherys <mitchelh@codeaurora.org>
parent c774f9d2

drivers/char/Makefile

+3 −0
Original line number Diff line number Diff line
@@ -63,5 +63,8 @@ js-rtc-y = rtc.o 
obj-$(CONFIG_TILE_SROM)		+= tile-srom.o

obj-$(CONFIG_DIAG_CHAR)		+= diag/

obj-$(CONFIG_MSM_ADSPRPC)       += adsprpc.o

ifdef CONFIG_COMPAT

obj-$(CONFIG_MSM_ADSPRPC)       += adsprpc_compat.o

endif

obj-$(CONFIG_MSM_RDBG)       += rdbg.o

obj-$(CONFIG_MSM_SMD_PKT)       += msm_smd_pkt.o

drivers/char/adsprpc.c

+53 −36
Original line number Diff line number Diff line
@@ -11,7 +11,6 @@ 
 * GNU General Public License for more details.

 *

 */

#include "adsprpc_shared.h"



#include <linux/slab.h>

#include <linux/completion.h>
@@ -33,6 +32,8 @@ 
#include <linux/of.h>

#include <linux/iommu.h>

#include <linux/kref.h>

#include "adsprpc_shared.h"

#include "adsprpc_compat.h"



#ifndef ION_ADSPRPC_HEAP_ID

#define ION_ADSPRPC_HEAP_ID ION_AUDIO_HEAP_ID
@@ -59,22 +60,22 @@ 


#define IS_CACHE_ALIGNED(x) (((x) & ((L1_CACHE_BYTES)-1)) == 0)



static inline uint32_t buf_page_start(void *buf)

static inline uintptr_t buf_page_start(void *buf)

{

	uint32_t start = (uint32_t) buf & PAGE_MASK;

	uintptr_t start = (uintptr_t) buf & PAGE_MASK;

	return start;

}



static inline uint32_t buf_page_offset(void *buf)

static inline uintptr_t buf_page_offset(void *buf)

{

	uint32_t offset = (uint32_t) buf & (PAGE_SIZE - 1);

	uintptr_t offset = (uintptr_t) buf & (PAGE_SIZE - 1);

	return offset;

}



static inline int buf_num_pages(void *buf, int len)

static inline int buf_num_pages(void *buf, ssize_t len)

{

	uint32_t start = buf_page_start(buf) >> PAGE_SHIFT;

	uint32_t end = (((uint32_t) buf + len - 1) & PAGE_MASK) >> PAGE_SHIFT;

	uintptr_t start = buf_page_start(buf) >> PAGE_SHIFT;

	uintptr_t end = (((uintptr_t) buf + len - 1) & PAGE_MASK) >> PAGE_SHIFT;

	int nPages = end - start + 1;

	return nPages;

}
@@ -85,12 +86,13 @@ static inline uint32_t buf_page_size(uint32_t size) 
	return sz > PAGE_SIZE ? sz : PAGE_SIZE;

}



static inline int buf_get_pages(void *addr, int sz, int nr_pages, int access,

				  struct smq_phy_page *pages, int nr_elems)

static inline int buf_get_pages(void *addr, ssize_t sz, int nr_pages,

				int access, struct smq_phy_page *pages,

				int nr_elems)

{

	struct vm_area_struct *vma, *vmaend;

	uint32_t start = buf_page_start(addr);

	uint32_t end = buf_page_start((void *)((uint32_t)addr + sz - 1));

	uintptr_t start = buf_page_start(addr);

	uintptr_t end = buf_page_start((void *)((uintptr_t)addr + sz - 1));

	uint32_t len = nr_pages << PAGE_SHIFT;

	unsigned long pfn, pfnend;

	int n = -1, err = 0;
@@ -116,6 +118,9 @@ static inline int buf_get_pages(void *addr, int sz, int nr_pages, int access, 
	if (err)

		goto bail;

	VERIFY(err, nr_elems > 0);

	if (err)

		goto bail;

	VERIFY(err, __pfn_to_phys(pfnend) <= UINT_MAX);

	if (err)

		goto bail;

	pages->addr = __pfn_to_phys(pfn);
@@ -129,7 +134,7 @@ struct fastrpc_buf { 
	struct ion_handle *handle;

	void *virt;

	ion_phys_addr_t phys;

	int size;

	ssize_t size;

	int used;

};
@@ -184,6 +189,7 @@ struct fastrpc_apps { 
	struct class *class;

	struct mutex smd_mutex;

	dev_t dev_no;

	int compat;

	spinlock_t wrlock;

	spinlock_t hlock;

	struct hlist_head htbl[RPC_HASH_SZ];
@@ -194,9 +200,9 @@ struct fastrpc_mmap { 
	struct ion_handle *handle;

	void *virt;

	ion_phys_addr_t phys;

	uint32_t vaddrin;

	uint32_t vaddrout;

	int size;

	uintptr_t *vaddrin;

	uintptr_t vaddrout;

	ssize_t size;

};



struct file_data {
@@ -506,8 +512,9 @@ static int get_page_list(uint32_t kernel, struct smq_invoke_ctx *ctx, int cid) 
	struct fastrpc_buf *ibuf = &ctx->dev->buf;

	struct fastrpc_buf *obuf = &ctx->obuf;

	remote_arg_t *pra = ctx->pra;

	ssize_t rlen;

	uint32_t sc = ctx->sc;

	int i, rlen, err = 0;

	int i, err = 0;

	int inbufs = REMOTE_SCALARS_INBUFS(sc);

	int outbufs = REMOTE_SCALARS_OUTBUFS(sc);
@@ -517,9 +524,9 @@ static int get_page_list(uint32_t kernel, struct smq_invoke_ctx *ctx, int cid) 
	list = smq_invoke_buf_start((remote_arg_t *)obuf->virt, sc);

	pgstart = smq_phy_page_start(sc, list);

	pages = pgstart + 1;

	rlen = obuf->size - ((uint32_t)pages - (uint32_t)obuf->virt);

	rlen = obuf->size - ((uintptr_t)pages - (uintptr_t)obuf->virt);

	if (rlen < 0) {

		rlen = ((uint32_t)pages - (uint32_t)obuf->virt) - obuf->size;

		rlen = ((uintptr_t)pages - (uintptr_t)obuf->virt) - obuf->size;

		obuf->size += buf_page_size(rlen);

		VERIFY(err, 0 == alloc_mem(obuf, cid));

		if (err)
@@ -575,7 +582,7 @@ static int get_page_list(uint32_t kernel, struct smq_invoke_ctx *ctx, int cid) 
				goto bail;

			goto retry;

		}

		rlen = obuf->size - ((uint32_t) pages - (uint32_t) obuf->virt);

		rlen = obuf->size - ((uintptr_t)pages - (uintptr_t)obuf->virt);

	}

	obuf->used = obuf->size - rlen;

 bail:
@@ -597,8 +604,9 @@ static int get_args(uint32_t kernel, struct smq_invoke_ctx *ctx, 
	void *args;

	remote_arg_t *pra = ctx->pra;

	remote_arg_t *rpra = ctx->rpra;

	ssize_t rlen, used, size;

	uint32_t sc = ctx->sc, start;

	int i, rlen, size, used, inh, bufs = 0, err = 0;

	int i, inh, bufs = 0, err = 0;

	int inbufs = REMOTE_SCALARS_INBUFS(sc);

	int outbufs = REMOTE_SCALARS_OUTBUFS(sc);

	int *fds = ctx->fds, idx, num;
@@ -664,7 +672,7 @@ static int get_args(uint32_t kernel, struct smq_invoke_ctx *ctx, 
		}

		list[i].num = 1;

		pages[list[i].pgidx].addr =

			buf_page_start((void *)((uint32_t)pbuf->phys +

			buf_page_start((void *)((uintptr_t)pbuf->phys +

						 (pbuf->size - rlen)));

		pages[list[i].pgidx].size =

			buf_page_size(pra[i].buf.len);
@@ -747,7 +755,7 @@ static int put_args(uint32_t kernel, uint32_t sc, remote_arg_t *pra, 
static void inv_args_pre(uint32_t sc, remote_arg_t *rpra)

{

	int i, inbufs, outbufs;

	uint32_t end;

	uintptr_t end;



	inbufs = REMOTE_SCALARS_INBUFS(sc);

	outbufs = REMOTE_SCALARS_OUTBUFS(sc);
@@ -756,10 +764,10 @@ static void inv_args_pre(uint32_t sc, remote_arg_t *rpra) 
			continue;

		if (buf_page_start(rpra) == buf_page_start(rpra[i].buf.pv))

			continue;

		if (!IS_CACHE_ALIGNED((uint32_t)rpra[i].buf.pv))

		if (!IS_CACHE_ALIGNED((uintptr_t)rpra[i].buf.pv))

			dmac_flush_range(rpra[i].buf.pv,

				(char *)rpra[i].buf.pv + 1);

		end = (uint32_t)rpra[i].buf.pv + rpra[i].buf.len;

		end = (uintptr_t)rpra[i].buf.pv + rpra[i].buf.len;

		if (!IS_CACHE_ALIGNED(end))

			dmac_flush_range((char *)end,

				(char *)end + 1);
@@ -844,7 +852,7 @@ static void fastrpc_read_handler(int cid) 
static void smd_event_handler(void *priv, unsigned event)

{

	struct fastrpc_apps *me = &gfa;

	int cid = (int)priv;

	int cid = (int)(uintptr_t)priv;



	switch (event) {

	case SMD_EVENT_OPEN:
@@ -1111,17 +1119,17 @@ static int fastrpc_mmap_on_dsp(struct fastrpc_apps *me, 
	struct {

		int pid;

		uint32_t flags;

		uint32_t vaddrin;

		uintptr_t vaddrin;

		int num;

	} inargs;



	struct {

		uint32_t vaddrout;

		uintptr_t vaddrout;

	} routargs;

	inargs.pid = current->tgid;

	inargs.vaddrin = mmap->vaddrin;

	inargs.vaddrin = (uintptr_t)mmap->vaddrin;

	inargs.flags = mmap->flags;

	inargs.num = num;

	inargs.num = me->compat ? num * sizeof(*pages) : num;

	ra[0].buf.pv = &inargs;

	ra[0].buf.len = sizeof(inargs);
@@ -1132,12 +1140,15 @@ static int fastrpc_mmap_on_dsp(struct fastrpc_apps *me, 
	ra[2].buf.len = sizeof(routargs);



	ioctl.inv.handle = 1;

	if (me->compat)

		ioctl.inv.sc = REMOTE_SCALARS_MAKE(4, 2, 1);

	else

		ioctl.inv.sc = REMOTE_SCALARS_MAKE(2, 2, 1);

	ioctl.inv.pra = ra;

	ioctl.fds = 0;

	VERIFY(err, 0 == (err = fastrpc_internal_invoke(me,

		FASTRPC_MODE_PARALLEL, 1, &ioctl, cid)));

	mmap->vaddrout = routargs.vaddrout;

	mmap->vaddrout = (uintptr_t)routargs.vaddrout;

	if (err)

		goto bail;

bail:
@@ -1152,8 +1163,8 @@ static int fastrpc_munmap_on_dsp(struct fastrpc_apps *me, 
	int err = 0;

	struct {

		int pid;

		uint32_t vaddrout;

		int size;

		uintptr_t vaddrout;

		ssize_t size;

	} inargs;



	inargs.pid = current->tgid;
@@ -1163,6 +1174,9 @@ static int fastrpc_munmap_on_dsp(struct fastrpc_apps *me, 
	ra[0].buf.len = sizeof(inargs);



	ioctl.inv.handle = 1;

	if (me->compat)

		ioctl.inv.sc = REMOTE_SCALARS_MAKE(5, 1, 0);

	else

		ioctl.inv.sc = REMOTE_SCALARS_MAKE(3, 1, 0);

	ioctl.inv.pra = ra;

	ioctl.fds = 0;
@@ -1352,7 +1366,8 @@ static int fastrpc_device_open(struct inode *inode, struct file *filp) 
		VERIFY(err, 0 == smd_named_open_on_edge(

					FASTRPC_SMD_GUID,

					gcinfo[cid].channel,

					&me->channel[cid].chan, (void *)cid,

					&me->channel[cid].chan,

					(void *)(uintptr_t)cid,

					smd_event_handler));

		if (err)

			goto smd_bail;
@@ -1476,6 +1491,7 @@ static const struct file_operations fops = { 
	.open = fastrpc_device_open,

	.release = fastrpc_device_release,

	.unlocked_ioctl = fastrpc_device_ioctl,

	.compat_ioctl = compat_fastrpc_device_ioctl,

};



static int __init fastrpc_device_init(void)
@@ -1501,6 +1517,7 @@ static int __init fastrpc_device_init(void) 
	VERIFY(err, !IS_ERR(me->class));

	if (err)

		goto class_create_bail;

	me->compat = (NULL == fops.compat_ioctl) ? 0 : 1;

	for (i = 0; i < NUM_CHANNELS; i++) {

		me->channel[i].dev = device_create(me->class, NULL,

					MKDEV(MAJOR(me->dev_no), i),

drivers/char/adsprpc_compat.c

0 → 100644
+273 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2014 The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 */



#include <linux/compat.h>

#include <linux/fs.h>

#include <linux/uaccess.h>

#include <linux/msm_ion.h>



#include "adsprpc_compat.h"

#include "adsprpc_shared.h"



#define COMPAT_FASTRPC_IOCTL_INVOKE \

		_IOWR('R', 1, struct compat_fastrpc_ioctl_invoke)

#define COMPAT_FASTRPC_IOCTL_MMAP \

		_IOWR('R', 2, struct compat_fastrpc_ioctl_mmap)

#define COMPAT_FASTRPC_IOCTL_MUNMAP \

		_IOWR('R', 3, struct compat_fastrpc_ioctl_munmap)

#define COMPAT_FASTRPC_IOCTL_INVOKE_FD \

		_IOWR('R', 4, struct compat_fastrpc_ioctl_invoke_fd)



struct compat_remote_buf {

	compat_uptr_t pv;	/* buffer pointer */

	compat_ssize_t len;	/* length of buffer */

};



union compat_remote_arg {

	struct compat_remote_buf buf;

	compat_uint_t h;

};



struct compat_fastrpc_ioctl_invoke {

	compat_uint_t handle;	/* remote handle */

	compat_uint_t sc;	/* scalars describing the data */

	compat_uptr_t pra;	/* remote arguments list */

};



struct compat_fastrpc_ioctl_invoke_fd {

	struct compat_fastrpc_ioctl_invoke inv;

	compat_uptr_t fds;	/* fd list */

};



struct compat_fastrpc_ioctl_mmap {

	compat_int_t fd;	/* ion fd */

	compat_uint_t flags;	/* flags for dsp to map with */

	compat_uptr_t vaddrin;	/* optional virtual address */

	compat_ssize_t size;	/* size */

	compat_uptr_t vaddrout;	/* dsps virtual address */

};



struct compat_fastrpc_ioctl_munmap {

	compat_uptr_t vaddrout;	/* address to unmap */

	compat_ssize_t size;	/* size */

};



static int compat_get_fastrpc_ioctl_invoke(

			struct compat_fastrpc_ioctl_invoke_fd __user *inv32,

			struct fastrpc_ioctl_invoke_fd __user **inva,

			unsigned int cmd)

{

	compat_uint_t u, sc;

	compat_ssize_t s;

	compat_uptr_t p;

	struct fastrpc_ioctl_invoke_fd *inv;

	union compat_remote_arg *pra32;

	union remote_arg *pra;

	int err, len, num, j;



	err = get_user(sc, &inv32->inv.sc);

	if (err)

		return err;



	len = REMOTE_SCALARS_LENGTH(sc);

	VERIFY(err, NULL != (inv = compat_alloc_user_space(

				sizeof(*inv) + len * sizeof(*pra))));

	if (err)

		return -EFAULT;



	inv->inv.pra = (union remote_arg *)(inv + 1);

	err = put_user(sc, &inv->inv.sc);

	err |= get_user(u, &inv32->inv.handle);

	err |= put_user(u, &inv->inv.handle);

	err |= get_user(p, &inv32->inv.pra);

	if (err)

		return err;



	pra32 = compat_ptr(p);

	pra = inv->inv.pra;

	num = REMOTE_SCALARS_INBUFS(sc) + REMOTE_SCALARS_OUTBUFS(sc);

	for (j = 0; j < num; j++) {

		err |= get_user(p, &pra32[j].buf.pv);

		pra[j].buf.pv = NULL;

		err |= put_user(p, (compat_uptr_t *)&pra[j].buf.pv);

		err |= get_user(s, &pra32[j].buf.len);

		err |= put_user(s, &pra[j].buf.len);

	}

	for (j = 0; j < REMOTE_SCALARS_INHANDLES(sc); j++) {

		err |= get_user(u, &pra32[num + j].h);

		err |= put_user(u, &pra[num + j].h);

	}



	inv->fds = NULL;

	if (cmd == COMPAT_FASTRPC_IOCTL_INVOKE_FD) {

		err |= get_user(p, &inv32->fds);

		err |= put_user(p, (compat_uptr_t *)&inv->fds);

	}



	*inva = inv;

	return err;

}



static int compat_put_fastrpc_ioctl_invoke(

			struct compat_fastrpc_ioctl_invoke_fd __user *inv32,

			struct fastrpc_ioctl_invoke_fd __user *inv)

{

	compat_uptr_t p;

	compat_uint_t u, h;

	union compat_remote_arg *pra32;

	union remote_arg *pra;

	int err, i, num;



	err = get_user(u, &inv32->inv.sc);

	err |= get_user(p, &inv32->inv.pra);

	if (err)

		return err;



	pra32 = compat_ptr(p);

	pra = (union remote_arg *)(inv + 1);

	num = REMOTE_SCALARS_INBUFS(u) + REMOTE_SCALARS_OUTBUFS(u)

		+ REMOTE_SCALARS_INHANDLES(u);

	for (i = 0;  i < REMOTE_SCALARS_OUTHANDLES(u); i++) {

		err |= get_user(h, &pra[num + i].h);

		err |= put_user(h, &pra32[num + i].h);

	}



	return err;

}



static int compat_get_fastrpc_ioctl_mmap(

			struct compat_fastrpc_ioctl_mmap __user *map32,

			struct fastrpc_ioctl_mmap __user *map)

{

	compat_uint_t u;

	compat_int_t i;

	compat_ssize_t s;

	compat_uptr_t p;

	int err;



	err = get_user(i, &map32->fd);

	err |= put_user(i, &map->fd);

	err |= get_user(u, &map32->flags);

	err |= put_user(u, &map->flags);

	err |= get_user(p, &map32->vaddrin);

	map->vaddrin = NULL;

	err |= put_user(p, (compat_uptr_t *)&map->vaddrin);

	err |= get_user(s, &map32->size);

	err |= put_user(s, &map->size);



	return err;

}



static int compat_put_fastrpc_ioctl_mmap(

			struct compat_fastrpc_ioctl_mmap __user *map32,

			struct fastrpc_ioctl_mmap __user *map)

{

	compat_uptr_t p;

	int err;



	err = get_user(p, &map->vaddrout);

	err |= put_user(p, &map32->vaddrout);



	return err;

}



static int compat_get_fastrpc_ioctl_munmap(

			struct compat_fastrpc_ioctl_munmap __user *unmap32,

			struct fastrpc_ioctl_munmap __user *unmap)

{

	compat_uptr_t p;

	compat_ssize_t s;

	int err;



	err = get_user(p, &unmap32->vaddrout);

	err |= put_user(p, &unmap->vaddrout);

	err |= get_user(s, &unmap32->size);

	err |= put_user(s, &unmap->size);



	return err;

}



long compat_fastrpc_device_ioctl(struct file *filp, unsigned int cmd,

				unsigned long arg)

{

	int err = 0;



	if (!filp->f_op || !filp->f_op->unlocked_ioctl)

		return -ENOTTY;



	switch (cmd) {

	case COMPAT_FASTRPC_IOCTL_INVOKE:

	case COMPAT_FASTRPC_IOCTL_INVOKE_FD:

	{

		struct compat_fastrpc_ioctl_invoke_fd __user *inv32;

		struct fastrpc_ioctl_invoke_fd __user *inv;

		long ret;



		inv32 = compat_ptr(arg);

		VERIFY(err, 0 == compat_get_fastrpc_ioctl_invoke(inv32,

							&inv, cmd));

		if (err)

			return err;

		ret = filp->f_op->unlocked_ioctl(filp, FASTRPC_IOCTL_INVOKE_FD,

							(unsigned long)inv);

		if (ret)

			return ret;

		VERIFY(err, 0 == compat_put_fastrpc_ioctl_invoke(inv32, inv));

		return err;

	}

	case COMPAT_FASTRPC_IOCTL_MMAP:

	{

		struct compat_fastrpc_ioctl_mmap __user *map32;

		struct fastrpc_ioctl_mmap __user *map;

		long ret;



		map32 = compat_ptr(arg);

		VERIFY(err, NULL != (map = compat_alloc_user_space(

							sizeof(*map))));

		if (err)

			return -EFAULT;

		VERIFY(err, 0 == compat_get_fastrpc_ioctl_mmap(map32, map));

		if (err)

			return err;

		ret = filp->f_op->unlocked_ioctl(filp, FASTRPC_IOCTL_MMAP,

							(unsigned long)map);

		if (ret)

			return ret;

		VERIFY(err, 0 == compat_put_fastrpc_ioctl_mmap(map32, map));

		return err;

	}

	case COMPAT_FASTRPC_IOCTL_MUNMAP:

	{

		struct compat_fastrpc_ioctl_munmap __user *unmap32;

		struct fastrpc_ioctl_munmap __user *unmap;



		unmap32 = compat_ptr(arg);

		VERIFY(err, NULL != (unmap = compat_alloc_user_space(

							sizeof(*unmap))));

		if (err)

			return -EFAULT;

		VERIFY(err, 0 == compat_get_fastrpc_ioctl_munmap(unmap32,

							unmap));

		if (err)

			return err;

		return filp->f_op->unlocked_ioctl(filp, FASTRPC_IOCTL_MUNMAP,

							(unsigned long)unmap);

	}

	case FASTRPC_IOCTL_SETMODE:

		return filp->f_op->unlocked_ioctl(filp, cmd,

						(unsigned long)compat_ptr(arg));

	default:

		return -ENOIOCTLCMD;

	}

}

drivers/char/adsprpc_compat.h

0 → 100644
+26 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2014 The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 */

#ifndef ADSPRPC_COMPAT_H

#define ADSPRPC_COMPAT_H



#ifdef CONFIG_COMPAT



long compat_fastrpc_device_ioctl(struct file *filp, unsigned int cmd,

				unsigned long arg);

#else



#define compat_fastrpc_device_ioctl	NULL



#endif /* CONFIG_COMPAT */

#endif /* ADSPRPC_COMPAT_H */

drivers/char/adsprpc_shared.h

+11 −17
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.

 * Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and
@@ -88,7 +88,7 @@ do {\ 


struct remote_buf {

	void *pv;		/* buffer pointer */

	int len;		/* length of buffer */

	ssize_t len;		/* length of buffer */

};



union remote_arg {
@@ -108,17 +108,17 @@ struct fastrpc_ioctl_invoke_fd { 
};



struct fastrpc_ioctl_munmap {

	uint32_t vaddrout;	/* address to unmap */

	int  size;		/* size */

	uintptr_t vaddrout;	/* address to unmap */

	ssize_t size;		/* size */

};





struct fastrpc_ioctl_mmap {

	int fd;				/* ion fd */

	uint32_t flags;			/* flags for dsp to map with */

	uint32_t vaddrin;	/* optional virtual address */

	int  size;		/* size */

	uint32_t vaddrout;	/* dsps virtual address */

	uintptr_t __user *vaddrin;	/* optional virtual address */

	ssize_t size;			/* size */

	uintptr_t vaddrout;		/* dsps virtual address */

};



struct smq_null_invoke {
@@ -128,8 +128,8 @@ struct smq_null_invoke { 
};



struct smq_phy_page {

	uint32_t addr;		/* physical address */

	uint32_t size;		/* size of contiguous region */

	ion_phys_addr_t addr;	/* physical address */

	ssize_t size;		/* size of contiguous region */

};



struct smq_invoke_buf {
@@ -167,10 +167,4 @@ static inline struct smq_phy_page *smq_phy_page_start(uint32_t sc, 
	return (struct smq_phy_page *)(&buf[nTotal]);

}



static inline int smq_invoke_buf_size(uint32_t sc, int nPages)

{

	struct smq_phy_page *start = smq_phy_page_start(sc, 0);

	return (int)(&(start[nPages]));

}



#endif