msm: kgsl: Add ION as an external memory source
Allow ION buffers to be attached via IOCTL_KGSL_MAP_USER_MEM
This commit is contained in:
SecureCRT
parent
91bbe54c4f
commit
a19d2698cc
23
arch/arm/mach-msm/include/mach/ion.h
Executable file
23
arch/arm/mach-msm/include/mach/ion.h
Executable file
@ -0,0 +1,23 @@
|
||||
/**
|
||||
*
|
||||
* Copyright (c) 2011, Code Aurora Forum. 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 __MACH_ION_H_
|
||||
#define __MACH_ION_H_
|
||||
|
||||
enum ion_memory_types {
|
||||
ION_EBI_TYPE,
|
||||
ION_SMI_TYPE,
|
||||
};
|
||||
|
||||
#endif
|
||||
@ -1,5 +1,4 @@
|
||||
/* Copyright (c) 2008-2011, Code Aurora Forum. All rights reserved.
|
||||
* Copyright (C) 2011 Sony Ericsson Mobile Communications AB.
|
||||
*
|
||||
* 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
|
||||
@ -21,10 +20,10 @@
|
||||
#include <linux/android_pmem.h>
|
||||
#include <linux/vmalloc.h>
|
||||
#include <linux/pm_runtime.h>
|
||||
#include <linux/genlock.h>
|
||||
|
||||
#include <linux/ashmem.h>
|
||||
#include <linux/major.h>
|
||||
#include <linux/ion.h>
|
||||
|
||||
#include "kgsl.h"
|
||||
#include "kgsl_debugfs.h"
|
||||
@ -45,62 +44,7 @@ module_param_named(mmutype, ksgl_mmu_type, charp, 0);
|
||||
MODULE_PARM_DESC(ksgl_mmu_type,
|
||||
"Type of MMU to be used for graphics. Valid values are 'iommu' or 'gpummu' or 'nommu'");
|
||||
|
||||
#ifdef CONFIG_GENLOCK
|
||||
|
||||
/**
|
||||
* kgsl_add_event - Add a new timstamp event for the KGSL device
|
||||
* @device - KGSL device for the new event
|
||||
* @ts - the timestamp to trigger the event on
|
||||
* @cb - callback function to call when the timestamp expires
|
||||
* @priv - private data for the specific event type
|
||||
*
|
||||
* @returns - 0 on success or error code on failure
|
||||
*/
|
||||
|
||||
static int kgsl_add_event(struct kgsl_device *device, u32 ts,
|
||||
void (*cb)(struct kgsl_device *, void *, u32), void *priv)
|
||||
{
|
||||
struct kgsl_event *event;
|
||||
struct list_head *n;
|
||||
unsigned int cur = device->ftbl->readtimestamp(device,
|
||||
KGSL_TIMESTAMP_RETIRED);
|
||||
|
||||
if (cb == NULL)
|
||||
return -EINVAL;
|
||||
|
||||
/* Check to see if the requested timestamp has already fired */
|
||||
|
||||
if (timestamp_cmp(cur, ts) >= 0) {
|
||||
cb(device, priv, cur);
|
||||
return 0;
|
||||
}
|
||||
|
||||
event = kzalloc(sizeof(*event), GFP_KERNEL);
|
||||
if (event == NULL)
|
||||
return -ENOMEM;
|
||||
|
||||
event->timestamp = ts;
|
||||
event->priv = priv;
|
||||
event->func = cb;
|
||||
|
||||
/* Add the event in order to the list */
|
||||
|
||||
for (n = device->events.next ; n != &device->events; n = n->next) {
|
||||
struct kgsl_event *e =
|
||||
list_entry(n, struct kgsl_event, list);
|
||||
|
||||
if (timestamp_cmp(e->timestamp, ts) > 0) {
|
||||
list_add(&event->list, n->prev);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (n == &device->events)
|
||||
list_add_tail(&event->list, &device->events);
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
static struct ion_client *kgsl_ion_client;
|
||||
|
||||
static inline struct kgsl_mem_entry *
|
||||
kgsl_mem_entry_create(void)
|
||||
@ -127,6 +71,17 @@ kgsl_mem_entry_destroy(struct kref *kref)
|
||||
if (entry->memtype != KGSL_MEM_ENTRY_KERNEL)
|
||||
kgsl_driver.stats.mapped -= entry->memdesc.size;
|
||||
|
||||
/*
|
||||
* Ion takes care of freeing the sglist for us (how nice </sarcasm>) so
|
||||
* unmap the dma before freeing the sharedmem so kgsl_sharedmem_free
|
||||
* doesn't try to free it again
|
||||
*/
|
||||
|
||||
if (entry->memtype == KGSL_MEM_ENTRY_ION) {
|
||||
ion_unmap_dma(kgsl_ion_client, entry->priv_data);
|
||||
entry->memdesc.sg = NULL;
|
||||
}
|
||||
|
||||
kgsl_sharedmem_free(&entry->memdesc);
|
||||
|
||||
switch (entry->memtype) {
|
||||
@ -135,6 +90,9 @@ kgsl_mem_entry_destroy(struct kref *kref)
|
||||
if (entry->priv_data)
|
||||
fput(entry->priv_data);
|
||||
break;
|
||||
case KGSL_MEM_ENTRY_ION:
|
||||
ion_free(kgsl_ion_client, entry->priv_data);
|
||||
break;
|
||||
}
|
||||
|
||||
kfree(entry);
|
||||
@ -1502,6 +1460,51 @@ static int kgsl_setup_ashmem(struct kgsl_mem_entry *entry,
|
||||
}
|
||||
#endif
|
||||
|
||||
static int kgsl_setup_ion(struct kgsl_mem_entry *entry,
|
||||
struct kgsl_pagetable *pagetable, int fd)
|
||||
{
|
||||
struct ion_handle *handle;
|
||||
struct scatterlist *s;
|
||||
unsigned long flags;
|
||||
|
||||
if (kgsl_ion_client == NULL) {
|
||||
kgsl_ion_client = msm_ion_client_create(UINT_MAX, KGSL_NAME);
|
||||
if (kgsl_ion_client == NULL)
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
handle = ion_import_fd(kgsl_ion_client, fd);
|
||||
if (IS_ERR_OR_NULL(handle))
|
||||
return PTR_ERR(handle);
|
||||
|
||||
entry->memtype = KGSL_MEM_ENTRY_ION;
|
||||
entry->priv_data = handle;
|
||||
entry->memdesc.pagetable = pagetable;
|
||||
entry->memdesc.size = 0;
|
||||
|
||||
if (ion_handle_get_flags(kgsl_ion_client, handle, &flags))
|
||||
goto err;
|
||||
|
||||
entry->memdesc.sg = ion_map_dma(kgsl_ion_client, handle, flags);
|
||||
|
||||
if (IS_ERR_OR_NULL(entry->memdesc.sg))
|
||||
goto err;
|
||||
|
||||
/* Calculate the size of the memdesc from the sglist */
|
||||
|
||||
entry->memdesc.sglen = 0;
|
||||
|
||||
for (s = entry->memdesc.sg; s != NULL; s = sg_next(s)) {
|
||||
entry->memdesc.size += s->length;
|
||||
entry->memdesc.sglen++;
|
||||
}
|
||||
|
||||
return 0;
|
||||
err:
|
||||
ion_free(kgsl_ion_client, handle);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
static long kgsl_ioctl_map_user_mem(struct kgsl_device_private *dev_priv,
|
||||
unsigned int cmd, void *data)
|
||||
{
|
||||
@ -1566,6 +1569,10 @@ static long kgsl_ioctl_map_user_mem(struct kgsl_device_private *dev_priv,
|
||||
|
||||
entry->memtype = KGSL_MEM_ENTRY_ASHMEM;
|
||||
break;
|
||||
case KGSL_USER_MEM_TYPE_ION:
|
||||
result = kgsl_setup_ion(entry, private->pagetable,
|
||||
param->fd);
|
||||
break;
|
||||
default:
|
||||
KGSL_CORE_ERR("Invalid memory type: %x\n", memtype);
|
||||
break;
|
||||
@ -1694,114 +1701,6 @@ static long kgsl_ioctl_cff_user_event(struct kgsl_device_private *dev_priv,
|
||||
return result;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_GENLOCK
|
||||
struct kgsl_genlock_event_priv {
|
||||
struct genlock_handle *handle;
|
||||
struct genlock *lock;
|
||||
};
|
||||
|
||||
/**
|
||||
* kgsl_genlock_event_cb - Event callback for a genlock timestamp event
|
||||
* @device - The KGSL device that expired the timestamp
|
||||
* @priv - private data for the event
|
||||
* @timestamp - the timestamp that triggered the event
|
||||
*
|
||||
* Release a genlock lock following the expiration of a timestamp
|
||||
*/
|
||||
|
||||
static void kgsl_genlock_event_cb(struct kgsl_device *device,
|
||||
void *priv, u32 timestamp)
|
||||
{
|
||||
struct kgsl_genlock_event_priv *ev = priv;
|
||||
int ret;
|
||||
|
||||
ret = genlock_lock(ev->handle, GENLOCK_UNLOCK, 0, 0);
|
||||
if (ret)
|
||||
KGSL_CORE_ERR("Error while unlocking genlock: %d\n", ret);
|
||||
|
||||
genlock_put_handle(ev->handle);
|
||||
|
||||
kfree(ev);
|
||||
}
|
||||
|
||||
/**
|
||||
* kgsl_add_genlock-event - Create a new genlock event
|
||||
* @device - KGSL device to create the event on
|
||||
* @timestamp - Timestamp to trigger the event
|
||||
* @data - User space buffer containing struct kgsl_genlock_event_priv
|
||||
* @len - length of the userspace buffer
|
||||
* @returns 0 on success or error code on error
|
||||
*
|
||||
* Attack to a genlock handle and register an event to release the
|
||||
* genlock lock when the timestamp expires
|
||||
*/
|
||||
|
||||
static int kgsl_add_genlock_event(struct kgsl_device *device,
|
||||
u32 timestamp, void __user *data, int len)
|
||||
{
|
||||
struct kgsl_genlock_event_priv *event;
|
||||
struct kgsl_timestamp_event_genlock priv;
|
||||
int ret;
|
||||
|
||||
if (len != sizeof(priv))
|
||||
return -EINVAL;
|
||||
|
||||
if (copy_from_user(&priv, data, sizeof(priv)))
|
||||
return -EFAULT;
|
||||
|
||||
event = kzalloc(sizeof(*event), GFP_KERNEL);
|
||||
|
||||
if (event == NULL)
|
||||
return -ENOMEM;
|
||||
|
||||
event->handle = genlock_get_handle_fd(priv.handle);
|
||||
|
||||
if (IS_ERR(event->handle)) {
|
||||
int ret = PTR_ERR(event->handle);
|
||||
kfree(event);
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = kgsl_add_event(device, timestamp, kgsl_genlock_event_cb, event);
|
||||
if (ret)
|
||||
kfree(event);
|
||||
|
||||
return ret;
|
||||
}
|
||||
#else
|
||||
static long kgsl_add_genlock_event(struct kgsl_device *device,
|
||||
u32 timestamp, void __user *data, int len)
|
||||
{
|
||||
return -EINVAL;
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* kgsl_ioctl_timestamp_event - Register a new timestamp event from userspace
|
||||
* @dev_priv - pointer to the private device structure
|
||||
* @cmd - the ioctl cmd passed from kgsl_ioctl
|
||||
* @data - the user data buffer from kgsl_ioctl
|
||||
* @returns 0 on success or error code on failure
|
||||
*/
|
||||
|
||||
static long kgsl_ioctl_timestamp_event(struct kgsl_device_private *dev_priv,
|
||||
unsigned int cmd, void *data)
|
||||
{
|
||||
struct kgsl_timestamp_event *param = data;
|
||||
int ret;
|
||||
|
||||
switch (param->type) {
|
||||
case KGSL_TIMESTAMP_EVENT_GENLOCK:
|
||||
ret = kgsl_add_genlock_event(dev_priv->device,
|
||||
param->timestamp, param->priv, param->len);
|
||||
break;
|
||||
default:
|
||||
ret = -EINVAL;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
typedef long (*kgsl_ioctl_func_t)(struct kgsl_device_private *,
|
||||
unsigned int, void *);
|
||||
|
||||
@ -1843,8 +1742,6 @@ static const struct {
|
||||
kgsl_ioctl_cff_syncmem, 0),
|
||||
KGSL_IOCTL_FUNC(IOCTL_KGSL_CFF_USER_EVENT,
|
||||
kgsl_ioctl_cff_user_event, 0),
|
||||
KGSL_IOCTL_FUNC(IOCTL_KGSL_TIMESTAMP_EVENT,
|
||||
kgsl_ioctl_timestamp_event, 1),
|
||||
};
|
||||
|
||||
static long kgsl_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
|
||||
|
||||
@ -126,7 +126,8 @@ struct kgsl_memdesc {
|
||||
#define KGSL_MEM_ENTRY_PMEM 1
|
||||
#define KGSL_MEM_ENTRY_ASHMEM 2
|
||||
#define KGSL_MEM_ENTRY_USER 3
|
||||
#define KGSL_MEM_ENTRY_MAX 4
|
||||
#define KGSL_MEM_ENTRY_ION 4
|
||||
#define KGSL_MEM_ENTRY_MAX 5
|
||||
|
||||
struct kgsl_mem_entry {
|
||||
struct kref refcount;
|
||||
|
||||
@ -153,6 +153,9 @@ static struct mem_entry_stats mem_stats[] = {
|
||||
MEM_ENTRY_STAT(KGSL_MEM_ENTRY_ASHMEM, ashmem),
|
||||
#endif
|
||||
MEM_ENTRY_STAT(KGSL_MEM_ENTRY_USER, user),
|
||||
#ifdef CONFIG_ION
|
||||
MEM_ENTRY_STAT(KGSL_MEM_ENTRY_USER, ion),
|
||||
#endif
|
||||
};
|
||||
|
||||
void
|
||||
|
||||
548
include/linux/ion.h
Executable file
548
include/linux/ion.h
Executable file
@ -0,0 +1,548 @@
|
||||
/*
|
||||
* include/linux/ion.h
|
||||
*
|
||||
* Copyright (C) 2011 Google, Inc.
|
||||
*
|
||||
* This software is licensed under the terms of the GNU General Public
|
||||
* License version 2, as published by the Free Software Foundation, and
|
||||
* may be copied, distributed, and modified under those terms.
|
||||
*
|
||||
* 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 _LINUX_ION_H
|
||||
#define _LINUX_ION_H
|
||||
|
||||
#include <linux/ioctl.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
|
||||
struct ion_handle;
|
||||
/**
|
||||
* enum ion_heap_types - list of all possible types of heaps
|
||||
* @ION_HEAP_TYPE_SYSTEM: memory allocated via vmalloc
|
||||
* @ION_HEAP_TYPE_SYSTEM_CONTIG: memory allocated via kmalloc
|
||||
* @ION_HEAP_TYPE_CARVEOUT: memory allocated from a prereserved
|
||||
* carveout heap, allocations are physically
|
||||
* contiguous
|
||||
* @ION_HEAP_END: helper for iterating over heaps
|
||||
*/
|
||||
enum ion_heap_type {
|
||||
ION_HEAP_TYPE_SYSTEM,
|
||||
ION_HEAP_TYPE_SYSTEM_CONTIG,
|
||||
ION_HEAP_TYPE_CARVEOUT,
|
||||
ION_HEAP_TYPE_CUSTOM, /* must be last so device specific heaps always
|
||||
are at the end of this enum */
|
||||
ION_NUM_HEAPS,
|
||||
};
|
||||
|
||||
#define ION_HEAP_SYSTEM_MASK (1 << ION_HEAP_TYPE_SYSTEM)
|
||||
#define ION_HEAP_SYSTEM_CONTIG_MASK (1 << ION_HEAP_TYPE_SYSTEM_CONTIG)
|
||||
#define ION_HEAP_CARVEOUT_MASK (1 << ION_HEAP_TYPE_CARVEOUT)
|
||||
|
||||
|
||||
/**
|
||||
* These are the only ids that should be used for Ion heap ids.
|
||||
* The ids listed are the order in which allocation will be attempted
|
||||
* if specified. Don't swap the order of heap ids unless you know what
|
||||
* you are doing!
|
||||
*/
|
||||
|
||||
enum ion_heap_ids {
|
||||
ION_HEAP_SYSTEM_ID,
|
||||
ION_HEAP_SYSTEM_CONTIG_ID,
|
||||
ION_HEAP_EBI_ID,
|
||||
ION_HEAP_SMI_ID,
|
||||
ION_HEAP_ADSP_ID,
|
||||
ION_HEAP_AUDIO_ID,
|
||||
};
|
||||
|
||||
#define ION_KMALLOC_HEAP_NAME "kmalloc"
|
||||
#define ION_VMALLOC_HEAP_NAME "vmalloc"
|
||||
#define ION_EBI1_HEAP_NAME "EBI1"
|
||||
#define ION_ADSP_HEAP_NAME "adsp"
|
||||
#define ION_SMI_HEAP_NAME "smi"
|
||||
|
||||
#define CACHED 1
|
||||
#define UNCACHED 0
|
||||
|
||||
#define ION_CACHE_SHIFT 0
|
||||
|
||||
#define ION_SET_CACHE(__cache) ((__cache) << ION_CACHE_SHIFT)
|
||||
|
||||
#define ION_IS_CACHED(__flags) ((__flags) & (1 << ION_CACHE_SHIFT))
|
||||
|
||||
#ifdef __KERNEL__
|
||||
#include <linux/err.h>
|
||||
#include <mach/ion.h>
|
||||
struct ion_device;
|
||||
struct ion_heap;
|
||||
struct ion_mapper;
|
||||
struct ion_client;
|
||||
struct ion_buffer;
|
||||
|
||||
/* This should be removed some day when phys_addr_t's are fully
|
||||
plumbed in the kernel, and all instances of ion_phys_addr_t should
|
||||
be converted to phys_addr_t. For the time being many kernel interfaces
|
||||
do not accept phys_addr_t's that would have to */
|
||||
#define ion_phys_addr_t unsigned long
|
||||
|
||||
/**
|
||||
* struct ion_platform_heap - defines a heap in the given platform
|
||||
* @type: type of the heap from ion_heap_type enum
|
||||
* @id: unique identifier for heap. When allocating (lower numbers
|
||||
* will be allocated from first)
|
||||
* @name: used for debug purposes
|
||||
* @base: base address of heap in physical memory if applicable
|
||||
* @size: size of the heap in bytes if applicable
|
||||
*
|
||||
* Provided by the board file.
|
||||
*/
|
||||
struct ion_platform_heap {
|
||||
enum ion_heap_type type;
|
||||
unsigned int id;
|
||||
const char *name;
|
||||
ion_phys_addr_t base;
|
||||
size_t size;
|
||||
enum ion_memory_types memory_type;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct ion_platform_data - array of platform heaps passed from board file
|
||||
* @nr: number of structures in the array
|
||||
* @heaps: array of platform_heap structions
|
||||
*
|
||||
* Provided by the board file in the form of platform data to a platform device.
|
||||
*/
|
||||
struct ion_platform_data {
|
||||
int nr;
|
||||
struct ion_platform_heap heaps[];
|
||||
};
|
||||
|
||||
#ifdef CONFIG_ION
|
||||
|
||||
/**
|
||||
* ion_client_create() - allocate a client and returns it
|
||||
* @dev: the global ion device
|
||||
* @heap_mask: mask of heaps this client can allocate from
|
||||
* @name: used for debugging
|
||||
*/
|
||||
struct ion_client *ion_client_create(struct ion_device *dev,
|
||||
unsigned int heap_mask, const char *name);
|
||||
|
||||
/**
|
||||
* msm_ion_client_create - allocate a client using the ion_device specified in
|
||||
* drivers/gpu/ion/msm/msm_ion.c
|
||||
*
|
||||
* heap_mask and name are the same as ion_client_create, return values
|
||||
* are the same as ion_client_create.
|
||||
*/
|
||||
|
||||
struct ion_client *msm_ion_client_create(unsigned int heap_mask,
|
||||
const char *name);
|
||||
|
||||
/**
|
||||
* ion_client_destroy() - free's a client and all it's handles
|
||||
* @client: the client
|
||||
*
|
||||
* Free the provided client and all it's resources including
|
||||
* any handles it is holding.
|
||||
*/
|
||||
void ion_client_destroy(struct ion_client *client);
|
||||
|
||||
/**
|
||||
* ion_alloc - allocate ion memory
|
||||
* @client: the client
|
||||
* @len: size of the allocation
|
||||
* @align: requested allocation alignment, lots of hardware blocks have
|
||||
* alignment requirements of some kind
|
||||
* @flags: mask of heaps to allocate from, if multiple bits are set
|
||||
* heaps will be tried in order from lowest to highest order bit
|
||||
*
|
||||
* Allocate memory in one of the heaps provided in heap mask and return
|
||||
* an opaque handle to it.
|
||||
*/
|
||||
struct ion_handle *ion_alloc(struct ion_client *client, size_t len,
|
||||
size_t align, unsigned int flags);
|
||||
|
||||
/**
|
||||
* ion_free - free a handle
|
||||
* @client: the client
|
||||
* @handle: the handle to free
|
||||
*
|
||||
* Free the provided handle.
|
||||
*/
|
||||
void ion_free(struct ion_client *client, struct ion_handle *handle);
|
||||
|
||||
/**
|
||||
* ion_phys - returns the physical address and len of a handle
|
||||
* @client: the client
|
||||
* @handle: the handle
|
||||
* @addr: a pointer to put the address in
|
||||
* @len: a pointer to put the length in
|
||||
*
|
||||
* This function queries the heap for a particular handle to get the
|
||||
* handle's physical address. It't output is only correct if
|
||||
* a heap returns physically contiguous memory -- in other cases
|
||||
* this api should not be implemented -- ion_map_dma should be used
|
||||
* instead. Returns -EINVAL if the handle is invalid. This has
|
||||
* no implications on the reference counting of the handle --
|
||||
* the returned value may not be valid if the caller is not
|
||||
* holding a reference.
|
||||
*/
|
||||
int ion_phys(struct ion_client *client, struct ion_handle *handle,
|
||||
ion_phys_addr_t *addr, size_t *len);
|
||||
|
||||
/**
|
||||
* ion_map_kernel - create mapping for the given handle
|
||||
* @client: the client
|
||||
* @handle: handle to map
|
||||
* @flags: flags for this mapping
|
||||
*
|
||||
* Map the given handle into the kernel and return a kernel address that
|
||||
* can be used to access this address. If no flags are specified, this
|
||||
* will return a non-secure uncached mapping.
|
||||
*/
|
||||
void *ion_map_kernel(struct ion_client *client, struct ion_handle *handle,
|
||||
unsigned long flags);
|
||||
|
||||
/**
|
||||
* ion_unmap_kernel() - destroy a kernel mapping for a handle
|
||||
* @client: the client
|
||||
* @handle: handle to unmap
|
||||
*/
|
||||
void ion_unmap_kernel(struct ion_client *client, struct ion_handle *handle);
|
||||
|
||||
/**
|
||||
* ion_map_dma - create a dma mapping for a given handle
|
||||
* @client: the client
|
||||
* @handle: handle to map
|
||||
*
|
||||
* Return an sglist describing the given handle
|
||||
*/
|
||||
struct scatterlist *ion_map_dma(struct ion_client *client,
|
||||
struct ion_handle *handle,
|
||||
unsigned long flags);
|
||||
|
||||
/**
|
||||
* ion_unmap_dma() - destroy a dma mapping for a handle
|
||||
* @client: the client
|
||||
* @handle: handle to unmap
|
||||
*/
|
||||
void ion_unmap_dma(struct ion_client *client, struct ion_handle *handle);
|
||||
|
||||
/**
|
||||
* ion_share() - given a handle, obtain a buffer to pass to other clients
|
||||
* @client: the client
|
||||
* @handle: the handle to share
|
||||
*
|
||||
* Given a handle, return a buffer, which exists in a global name
|
||||
* space, and can be passed to other clients. Should be passed into ion_import
|
||||
* to obtain a new handle for this buffer.
|
||||
*
|
||||
* NOTE: This function does do not an extra reference. The burden is on the
|
||||
* caller to make sure the buffer doesn't go away while it's being passed to
|
||||
* another client. That is, ion_free should not be called on this handle until
|
||||
* the buffer has been imported into the other client.
|
||||
*/
|
||||
struct ion_buffer *ion_share(struct ion_client *client,
|
||||
struct ion_handle *handle);
|
||||
|
||||
/**
|
||||
* ion_import() - given an buffer in another client, import it
|
||||
* @client: this blocks client
|
||||
* @buffer: the buffer to import (as obtained from ion_share)
|
||||
*
|
||||
* Given a buffer, add it to the client and return the handle to use to refer
|
||||
* to it further. This is called to share a handle from one kernel client to
|
||||
* another.
|
||||
*/
|
||||
struct ion_handle *ion_import(struct ion_client *client,
|
||||
struct ion_buffer *buffer);
|
||||
|
||||
/**
|
||||
* ion_import_fd() - given an fd obtained via ION_IOC_SHARE ioctl, import it
|
||||
* @client: this blocks client
|
||||
* @fd: the fd
|
||||
*
|
||||
* A helper function for drivers that will be recieving ion buffers shared
|
||||
* with them from userspace. These buffers are represented by a file
|
||||
* descriptor obtained as the return from the ION_IOC_SHARE ioctl.
|
||||
* This function coverts that fd into the underlying buffer, and returns
|
||||
* the handle to use to refer to it further.
|
||||
*/
|
||||
struct ion_handle *ion_import_fd(struct ion_client *client, int fd);
|
||||
|
||||
/**
|
||||
* ion_handle_get_flags - get the flags for a given handle
|
||||
*
|
||||
* @client - client who allocated the handle
|
||||
* @handle - handle to get the flags
|
||||
* @flags - pointer to store the flags
|
||||
*
|
||||
* Gets the current flags for a handle. These flags indicate various options
|
||||
* of the buffer (caching, security, etc.)
|
||||
*/
|
||||
int ion_handle_get_flags(struct ion_client *client, struct ion_handle *handle,
|
||||
unsigned long *flags);
|
||||
|
||||
#else
|
||||
static inline struct ion_client *ion_client_create(struct ion_device *dev,
|
||||
unsigned int heap_mask, const char *name)
|
||||
{
|
||||
return ERR_PTR(-ENODEV);
|
||||
}
|
||||
|
||||
static inline struct ion_client *msm_ion_client_create(unsigned int heap_mask,
|
||||
const char *name)
|
||||
{
|
||||
return ERR_PTR(-ENODEV);
|
||||
}
|
||||
|
||||
static inline void ion_client_destroy(struct ion_client *client) { }
|
||||
|
||||
static inline struct ion_handle *ion_alloc(struct ion_client *client,
|
||||
size_t len, size_t align, unsigned int flags)
|
||||
{
|
||||
return ERR_PTR(-ENODEV);
|
||||
}
|
||||
|
||||
static inline void ion_free(struct ion_client *client,
|
||||
struct ion_handle *handle) { }
|
||||
|
||||
|
||||
static inline int ion_phys(struct ion_client *client,
|
||||
struct ion_handle *handle, ion_phys_addr_t *addr, size_t *len)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static inline void *ion_map_kernel(struct ion_client *client,
|
||||
struct ion_handle *handle, unsigned long flags)
|
||||
{
|
||||
return ERR_PTR(-ENODEV);
|
||||
}
|
||||
|
||||
static inline void ion_unmap_kernel(struct ion_client *client,
|
||||
struct ion_handle *handle) { }
|
||||
|
||||
static inline struct scatterlist *ion_map_dma(struct ion_client *client,
|
||||
struct ion_handle *handle, unsigned long flags)
|
||||
{
|
||||
return ERR_PTR(-ENODEV);
|
||||
}
|
||||
|
||||
static inline void ion_unmap_dma(struct ion_client *client,
|
||||
struct ion_handle *handle) { }
|
||||
|
||||
static inline struct ion_buffer *ion_share(struct ion_client *client,
|
||||
struct ion_handle *handle)
|
||||
{
|
||||
return ERR_PTR(-ENODEV);
|
||||
}
|
||||
|
||||
static inline struct ion_handle *ion_import(struct ion_client *client,
|
||||
struct ion_buffer *buffer)
|
||||
{
|
||||
return ERR_PTR(-ENODEV);
|
||||
}
|
||||
|
||||
static inline struct ion_handle *ion_import_fd(struct ion_client *client,
|
||||
int fd)
|
||||
{
|
||||
return ERR_PTR(-ENODEV);
|
||||
}
|
||||
|
||||
static inline int ion_handle_get_flags(struct ion_client *client,
|
||||
struct ion_handle *handle, unsigned long *flags)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
#endif /* CONFIG_ION */
|
||||
#endif /* __KERNEL__ */
|
||||
|
||||
/**
|
||||
* DOC: Ion Userspace API
|
||||
*
|
||||
* create a client by opening /dev/ion
|
||||
* most operations handled via following ioctls
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* struct ion_allocation_data - metadata passed from userspace for allocations
|
||||
* @len: size of the allocation
|
||||
* @align: required alignment of the allocation
|
||||
* @flags: flags passed to heap
|
||||
* @handle: pointer that will be populated with a cookie to use to refer
|
||||
* to this allocation
|
||||
*
|
||||
* Provided by userspace as an argument to the ioctl
|
||||
*/
|
||||
struct ion_allocation_data {
|
||||
size_t len;
|
||||
size_t align;
|
||||
unsigned int flags;
|
||||
struct ion_handle *handle;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct ion_fd_data - metadata passed to/from userspace for a handle/fd pair
|
||||
* @handle: a handle
|
||||
* @fd: a file descriptor representing that handle
|
||||
*
|
||||
* For ION_IOC_SHARE or ION_IOC_MAP userspace populates the handle field with
|
||||
* the handle returned from ion alloc, and the kernel returns the file
|
||||
* descriptor to share or map in the fd field. For ION_IOC_IMPORT, userspace
|
||||
* provides the file descriptor and the kernel returns the handle.
|
||||
*/
|
||||
struct ion_fd_data {
|
||||
struct ion_handle *handle;
|
||||
int fd;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct ion_handle_data - a handle passed to/from the kernel
|
||||
* @handle: a handle
|
||||
*/
|
||||
struct ion_handle_data {
|
||||
struct ion_handle *handle;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct ion_custom_data - metadata passed to/from userspace for a custom ioctl
|
||||
* @cmd: the custom ioctl function to call
|
||||
* @arg: additional data to pass to the custom ioctl, typically a user
|
||||
* pointer to a predefined structure
|
||||
*
|
||||
* This works just like the regular cmd and arg fields of an ioctl.
|
||||
*/
|
||||
struct ion_custom_data {
|
||||
unsigned int cmd;
|
||||
unsigned long arg;
|
||||
};
|
||||
|
||||
|
||||
/* struct ion_flush_data - data passed to ion for flushing caches
|
||||
*
|
||||
* @handle: handle with data to flush
|
||||
* @vaddr: userspace virtual address mapped with mmap
|
||||
* @offset: offset into the handle to flush
|
||||
* @length: length of handle to flush
|
||||
*
|
||||
* Performs cache operations on the handle. If p is the start address
|
||||
* of the handle, p + offset through p + offset + length will have
|
||||
* the cache operations performed
|
||||
*/
|
||||
struct ion_flush_data {
|
||||
struct ion_handle *handle;
|
||||
void *vaddr;
|
||||
unsigned int offset;
|
||||
unsigned int length;
|
||||
};
|
||||
|
||||
/* struct ion_flag_data - information about flags for this buffer
|
||||
*
|
||||
* @handle: handle to get flags from
|
||||
* @flags: flags of this handle
|
||||
*
|
||||
* Takes handle as an input and outputs the flags from the handle
|
||||
* in the flag field.
|
||||
*/
|
||||
struct ion_flag_data {
|
||||
struct ion_handle *handle;
|
||||
unsigned long flags;
|
||||
};
|
||||
|
||||
#define ION_IOC_MAGIC 'I'
|
||||
|
||||
/**
|
||||
* DOC: ION_IOC_ALLOC - allocate memory
|
||||
*
|
||||
* Takes an ion_allocation_data struct and returns it with the handle field
|
||||
* populated with the opaque handle for the allocation.
|
||||
*/
|
||||
#define ION_IOC_ALLOC _IOWR(ION_IOC_MAGIC, 0, \
|
||||
struct ion_allocation_data)
|
||||
|
||||
/**
|
||||
* DOC: ION_IOC_FREE - free memory
|
||||
*
|
||||
* Takes an ion_handle_data struct and frees the handle.
|
||||
*/
|
||||
#define ION_IOC_FREE _IOWR(ION_IOC_MAGIC, 1, struct ion_handle_data)
|
||||
|
||||
/**
|
||||
* DOC: ION_IOC_MAP - get a file descriptor to mmap
|
||||
*
|
||||
* Takes an ion_fd_data struct with the handle field populated with a valid
|
||||
* opaque handle. Returns the struct with the fd field set to a file
|
||||
* descriptor open in the current address space. This file descriptor
|
||||
* can then be used as an argument to mmap.
|
||||
*/
|
||||
#define ION_IOC_MAP _IOWR(ION_IOC_MAGIC, 2, struct ion_fd_data)
|
||||
|
||||
/**
|
||||
* DOC: ION_IOC_SHARE - creates a file descriptor to use to share an allocation
|
||||
*
|
||||
* Takes an ion_fd_data struct with the handle field populated with a valid
|
||||
* opaque handle. Returns the struct with the fd field set to a file
|
||||
* descriptor open in the current address space. This file descriptor
|
||||
* can then be passed to another process. The corresponding opaque handle can
|
||||
* be retrieved via ION_IOC_IMPORT.
|
||||
*/
|
||||
#define ION_IOC_SHARE _IOWR(ION_IOC_MAGIC, 4, struct ion_fd_data)
|
||||
|
||||
/**
|
||||
* DOC: ION_IOC_IMPORT - imports a shared file descriptor
|
||||
*
|
||||
* Takes an ion_fd_data struct with the fd field populated with a valid file
|
||||
* descriptor obtained from ION_IOC_SHARE and returns the struct with the handle
|
||||
* filed set to the corresponding opaque handle.
|
||||
*/
|
||||
#define ION_IOC_IMPORT _IOWR(ION_IOC_MAGIC, 5, int)
|
||||
|
||||
/**
|
||||
* DOC: ION_IOC_CUSTOM - call architecture specific ion ioctl
|
||||
*
|
||||
* Takes the argument of the architecture specific ioctl to call and
|
||||
* passes appropriate userdata for that ioctl
|
||||
*/
|
||||
#define ION_IOC_CUSTOM _IOWR(ION_IOC_MAGIC, 6, struct ion_custom_data)
|
||||
|
||||
|
||||
/**
|
||||
* DOC: ION_IOC_CLEAN_CACHES - clean the caches
|
||||
*
|
||||
* Clean the caches of the handle specified.
|
||||
*/
|
||||
#define ION_IOC_CLEAN_CACHES _IOWR(ION_IOC_MAGIC, 7, \
|
||||
struct ion_flush_data)
|
||||
/**
|
||||
* DOC: ION_MSM_IOC_INV_CACHES - invalidate the caches
|
||||
*
|
||||
* Invalidate the caches of the handle specified.
|
||||
*/
|
||||
#define ION_IOC_INV_CACHES _IOWR(ION_IOC_MAGIC, 8, \
|
||||
struct ion_flush_data)
|
||||
/**
|
||||
* DOC: ION_MSM_IOC_CLEAN_CACHES - clean and invalidate the caches
|
||||
*
|
||||
* Clean and invalidate the caches of the handle specified.
|
||||
*/
|
||||
#define ION_IOC_CLEAN_INV_CACHES _IOWR(ION_IOC_MAGIC, 9, \
|
||||
struct ion_flush_data)
|
||||
|
||||
/**
|
||||
* DOC: ION_IOC_GET_FLAGS - get the flags of the handle
|
||||
*
|
||||
* Gets the flags of the current handle which indicate cachability,
|
||||
* secure state etc.
|
||||
*/
|
||||
#define ION_IOC_GET_FLAGS _IOWR(ION_IOC_MAGIC, 10, \
|
||||
struct ion_flag_data)
|
||||
#endif /* _LINUX_ION_H */
|
||||
Loading…
x
Reference in New Issue
Block a user