type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
functions | int kgsl_resume(struct device *dev)
{
struct kgsl_device *device = dev_get_drvdata(dev);
return kgsl_resume_device(device);
} |
functions | int kgsl_runtime_suspend(struct device *dev)
{
return 0;
} |
functions | int kgsl_runtime_resume(struct device *dev)
{
return 0;
} |
functions | int kgsl_suspend_driver(struct platform_device *pdev,
pm_message_t state)
{
struct kgsl_device *device = dev_get_drvdata(&pdev->dev);
return kgsl_suspend_device(device, state);
} |
functions | int kgsl_resume_driver(struct platform_device *pdev)
{
struct kgsl_device *device = dev_get_drvdata(&pdev->dev);
return kgsl_resume_device(device);
} |
functions | void kgsl_destroy_process_private(struct kref *kref)
{
struct kgsl_process_private *private = container_of(kref,
struct kgsl_process_private, refcount);
/*
* Remove this process from global process list
* We do not acquire a lock first as it is expected that
* kgsl_destroy_process_private() is only going to... |
functions | void
kgsl_process_private_put(struct kgsl_process_private *private)
{
mutex_lock(&kgsl_driver.process_mutex);
/*
* kref_put() returns 1 when the refcnt has reached 0 and the destroy
* function is called. Mutex is released in the destroy function if
* its called, so only release mutex if kref_put() return 0
*... |
functions | int kgsl_close_device(struct kgsl_device *device)
{
int result = 0;
device->open_count--;
if (device->open_count == 0) {
/* Wait for the active count to go to 0 */
kgsl_active_count_wait(device, 0);
/* Fail if the wait times out */
BUG_ON(atomic_read(&device->active_cnt) > 0);
/* Force power on to do th... |
functions | int kgsl_release(struct inode *inodep, struct file *filep)
{
int result = 0;
struct kgsl_device_private *dev_priv = filep->private_data;
struct kgsl_process_private *private = dev_priv->process_priv;
struct kgsl_device *device = dev_priv->device;
struct kgsl_context *context;
struct kgsl_mem_entry *entry;
int ne... |
functions | int kgsl_open_device(struct kgsl_device *device)
{
int result = 0;
if (device->open_count == 0) {
/*
* active_cnt special case: we are starting up for the first
* time, so use this sequence instead of the kgsl_pwrctrl_wake()
* which will be called by kgsl_active_count_get().
*/
atomic_inc(&device->act... |
functions | int kgsl_open(struct inode *inodep, struct file *filep)
{
int result;
struct kgsl_device_private *dev_priv;
struct kgsl_device *device;
unsigned int minor = iminor(inodep);
device = kgsl_get_minor(minor);
BUG_ON(device == NULL);
if (filep->f_flags & O_EXCL) {
KGSL_DRV_ERR(device, "O_EXCL not allowed\n");
r... |
functions | __must_check
kgsl_sharedmem_find_region(struct kgsl_process_private *private,
unsigned int gpuaddr, size_t size)
{
struct rb_node *node;
if (!kgsl_mmu_gpuaddr_in_range(private->pagetable, gpuaddr))
return NULL;
spin_lock(&private->mem_lock);
node = private->mem_rb.rb_node;
while (node != NULL) {
struct kgsl... |
functions | __must_check
kgsl_sharedmem_find(struct kgsl_process_private *private, unsigned int gpuaddr)
{
return kgsl_sharedmem_find_region(private, gpuaddr, 1);
} |
functions | int
kgsl_sharedmem_region_empty(struct kgsl_process_private *private,
unsigned int gpuaddr, size_t size,
struct kgsl_mem_entry **collision_entry)
{
int result = 1;
unsigned int gpuaddr_end = gpuaddr + size;
struct rb_node *node;
assert_spin_locked(&private->mem_lock);
if (!kgsl_mmu_gpuaddr_in_range(private->p... |
functions | __must_check
kgsl_sharedmem_find_id(struct kgsl_process_private *process, unsigned int id)
{
int result = 0;
struct kgsl_mem_entry *entry;
spin_lock(&process->mem_lock);
entry = idr_find(&process->mem_idr, id);
if (entry)
result = kgsl_mem_entry_get(entry);
spin_unlock(&process->mem_lock);
if (!result)
ret... |
functions | bool kgsl_mem_entry_set_pend(struct kgsl_mem_entry *entry)
{
bool ret = false;
if (entry == NULL)
return false;
spin_lock(&entry->priv->mem_lock);
if (!entry->pending_free) {
entry->pending_free = 1;
ret = true;
} |
functions | long kgsl_ioctl_device_getproperty(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
{
int result = 0;
struct kgsl_device_getproperty *param = data;
switch (param->type) {
case KGSL_PROP_VERSION:
{
struct kgsl_version version;
if (param->sizebytes != sizeof(version)) {
result = -EI... |
functions | long kgsl_ioctl_device_setproperty(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
{
int result = 0;
/* The getproperty struct is reused for setproperty too */
struct kgsl_device_getproperty *param = data;
if (dev_priv->device->ftbl->setproperty)
result = dev_priv->device->ftbl->setpro... |
functions | long _device_waittimestamp(struct kgsl_device_private *dev_priv,
struct kgsl_context *context,
unsigned int timestamp,
unsigned int timeout)
{
int result = 0;
struct kgsl_device *device = dev_priv->device;
unsigned int context_id = context ? context->id : KGSL_MEMSTORE_GLOBAL;
trace_kgsl_waittimestamp_entry(... |
functions | long kgsl_ioctl_device_waittimestamp(struct kgsl_device_private
*dev_priv, unsigned int cmd,
void *data)
{
struct kgsl_device_waittimestamp *param = data;
struct kgsl_device *device = dev_priv->device;
long result = -EINVAL;
kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
result = _device_waitt... |
functions | long kgsl_ioctl_device_waittimestamp_ctxtid(struct kgsl_device_private
*dev_priv, unsigned int cmd,
void *data)
{
struct kgsl_device_waittimestamp_ctxtid *param = data;
struct kgsl_context *context;
struct kgsl_device *device = dev_priv->device;
long result = -EINVAL;
kgsl_mutex_lock(&device->mutex, &... |
functions | void kgsl_dump_syncpoints(struct kgsl_device *device,
struct kgsl_cmdbatch *cmdbatch)
{
struct kgsl_cmdbatch_sync_event *event;
/* Print all the pending sync objects */
list_for_each_entry(event, &cmdbatch->synclist, node) {
switch (event->type) {
case KGSL_CMD_SYNCPOINT_TYPE_TIMESTAMP: {
unsigned int reti... |
functions | void _kgsl_cmdbatch_timer(unsigned long data)
{
struct kgsl_device *device;
struct kgsl_cmdbatch *cmdbatch = (struct kgsl_cmdbatch *) data;
struct kgsl_cmdbatch_sync_event *event;
if (cmdbatch == NULL || cmdbatch->context == NULL)
return;
spin_lock(&cmdbatch->lock);
if (list_empty(&cmdbatch->synclist))
goto... |
functions | void kgsl_cmdbatch_sync_event_destroy(struct kref *kref)
{
struct kgsl_cmdbatch_sync_event *event = container_of(kref,
struct kgsl_cmdbatch_sync_event, refcount);
kgsl_cmdbatch_put(event->cmdbatch);
kfree(event);
} |
functions | void kgsl_cmdbatch_sync_event_put(
struct kgsl_cmdbatch_sync_event *event)
{
kref_put(&event->refcount, kgsl_cmdbatch_sync_event_destroy);
} |
functions | void kgsl_cmdbatch_destroy_object(struct kref *kref)
{
struct kgsl_cmdbatch *cmdbatch = container_of(kref,
struct kgsl_cmdbatch, refcount);
kgsl_context_put(cmdbatch->context);
kfree(cmdbatch);
} |
functions | void kgsl_cmdbatch_sync_expire(struct kgsl_device *device,
struct kgsl_cmdbatch_sync_event *event)
{
struct kgsl_cmdbatch_sync_event *e, *tmp;
int sched = 0;
int removed = 0;
spin_lock(&event->cmdbatch->lock);
/*
* sync events that are contained by a cmdbatch which has been
* destroyed may have already been... |
functions | void kgsl_cmdbatch_sync_func(struct kgsl_device *device,
struct kgsl_context *context, void *priv, int result)
{
struct kgsl_cmdbatch_sync_event *event = priv;
trace_syncpoint_timestamp_expire(event->cmdbatch,
event->context, event->timestamp);
kgsl_cmdbatch_sync_expire(device, event);
kgsl_context_put(event-... |
functions | void _free_memobj_list(struct list_head *list)
{
struct kgsl_memobj_node *mem, *tmpmem;
/* Free the cmd mem here */
list_for_each_entry_safe(mem, tmpmem, list, node) {
list_del_init(&mem->node);
kmem_cache_free(memobjs_cache, mem);
} |
functions | void kgsl_cmdbatch_destroy(struct kgsl_cmdbatch *cmdbatch)
{
struct kgsl_cmdbatch_sync_event *event, *tmpsync;
LIST_HEAD(cancel_synclist);
/* Zap the canary timer */
del_timer_sync(&cmdbatch->timer);
spin_lock(&cmdbatch->lock);
/* Empty the synclist before canceling events */
list_splice_init(&cmdbatch->syncl... |
functions | else if (event->type == KGSL_CMD_SYNCPOINT_TYPE_FENCE) {
/* Put events that are successfully canceled */
if (kgsl_sync_fence_async_cancel(event->handle))
kgsl_cmdbatch_sync_event_put(event);
} |
functions | void kgsl_cmdbatch_sync_fence_func(void *priv)
{
struct kgsl_cmdbatch_sync_event *event = priv;
trace_syncpoint_fence_expire(event->cmdbatch,
event->handle ? event->handle->name : "unknown");
kgsl_cmdbatch_sync_expire(event->device, event);
/* Put events that have signaled */
kgsl_cmdbatch_sync_event_put(event... |
functions | int kgsl_cmdbatch_add_sync_fence(struct kgsl_device *device,
struct kgsl_cmdbatch *cmdbatch, void *priv)
{
struct kgsl_cmd_syncpoint_fence *sync = priv;
struct kgsl_cmdbatch_sync_event *event;
event = kzalloc(sizeof(*event), GFP_KERNEL);
if (event == NULL)
return -ENOMEM;
kref_get(&cmdbatch->refcount);
ev... |
functions | int kgsl_cmdbatch_add_sync_timestamp(struct kgsl_device *device,
struct kgsl_cmdbatch *cmdbatch, void *priv)
{
struct kgsl_cmd_syncpoint_timestamp *sync = priv;
struct kgsl_context *context = kgsl_context_get(cmdbatch->device,
sync->context_id);
struct kgsl_cmdbatch_sync_event *event;
int ret = -EINVAL;
if (c... |
functions | int kgsl_cmdbatch_add_sync(struct kgsl_device *device,
struct kgsl_cmdbatch *cmdbatch,
struct kgsl_cmd_syncpoint *sync)
{
void *priv;
int ret, psize;
int (*func)(struct kgsl_device *device, struct kgsl_cmdbatch *cmdbatch,
void *priv);
switch (sync->type) {
case KGSL_CMD_SYNCPOINT_TYPE_TIMESTAMP:
psize = si... |
functions | int kgsl_cmdbatch_add_memobj(struct kgsl_cmdbatch *cmdbatch,
struct kgsl_ibdesc *ibdesc)
{
struct kgsl_memobj_node *mem;
mem = kmem_cache_alloc(memobjs_cache, GFP_KERNEL);
if (mem == NULL)
return -ENOMEM;
mem->gpuaddr = ibdesc->gpuaddr;
mem->sizedwords = ibdesc->sizedwords;
mem->priv = 0;
/* sanitize the i... |
functions | bool _kgsl_cmdbatch_verify(struct kgsl_device_private *dev_priv,
struct kgsl_cmdbatch *cmdbatch)
{
struct kgsl_process_private *private = dev_priv->process_priv;
struct kgsl_memobj_node *ib;
list_for_each_entry(ib, &cmdbatch->cmdlist, node) {
if (ib->sizedwords == 0) {
KGSL_DRV_ERR(dev_priv->device,
"inva... |
functions | long kgsl_ioctl_rb_issueibcmds(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
{
struct kgsl_ringbuffer_issueibcmds *param = data;
struct kgsl_device *device = dev_priv->device;
struct kgsl_context *context;
struct kgsl_cmdbatch *cmdbatch;
long result = -EINVAL;
/* The legacy functi... |
functions | long kgsl_ioctl_submit_commands(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
{
struct kgsl_submit_commands *param = data;
struct kgsl_device *device = dev_priv->device;
struct kgsl_context *context;
struct kgsl_cmdbatch *cmdbatch;
long result = -EINVAL;
/*
* The SYNC bit is su... |
functions | long _cmdstream_readtimestamp(struct kgsl_device_private *dev_priv,
struct kgsl_context *context, unsigned int type,
unsigned int *timestamp)
{
*timestamp = kgsl_readtimestamp(dev_priv->device, context, type);
trace_kgsl_readtimestamp(dev_priv->device,
context ? context->id : KGSL_MEMSTORE_GLOBAL,
type, *t... |
functions | long kgsl_ioctl_cmdstream_readtimestamp(struct kgsl_device_private
*dev_priv, unsigned int cmd,
void *data)
{
struct kgsl_cmdstream_readtimestamp *param = data;
struct kgsl_device *device = dev_priv->device;
long result = -EINVAL;
kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
result = _cmdstr... |
functions | long kgsl_ioctl_cmdstream_readtimestamp_ctxtid(struct kgsl_device_private
*dev_priv, unsigned int cmd,
void *data)
{
struct kgsl_cmdstream_readtimestamp_ctxtid *param = data;
struct kgsl_device *device = dev_priv->device;
struct kgsl_context *context;
long result = -EINVAL;
kgsl_mutex_lock(&device->mu... |
functions | void kgsl_freemem_event_cb(struct kgsl_device *device,
struct kgsl_context *context, void *priv, int result)
{
struct kgsl_mem_entry *entry = priv;
unsigned int timestamp;
timestamp = kgsl_readtimestamp(device, context, KGSL_TIMESTAMP_RETIRED);
/* Free the memory for all event types */
trace_kgsl_mem_timestamp... |
functions | long _cmdstream_freememontimestamp(struct kgsl_device_private *dev_priv,
unsigned int gpuaddr, struct kgsl_context *context,
unsigned int timestamp, unsigned int type)
{
int result = 0;
struct kgsl_mem_entry *entry = NULL;
struct kgsl_device *device = dev_priv->device;
unsigned int context_id = context ? contex... |
functions | long kgsl_ioctl_cmdstream_freememontimestamp(struct kgsl_device_private
*dev_priv, unsigned int cmd,
void *data)
{
struct kgsl_cmdstream_freememontimestamp *param = data;
struct kgsl_device *device = dev_priv->device;
long result = -EINVAL;
kgsl_mutex_lock(&device->mutex, &device->mutex_owner);... |
functions | long kgsl_ioctl_cmdstream_freememontimestamp_ctxtid(
struct kgsl_device_private
*dev_priv, unsigned int cmd,
void *data)
{
struct kgsl_cmdstream_freememontimestamp_ctxtid *param = data;
struct kgsl_context *context;
struct kgsl_device *device = dev_priv->device;
long result = -EINVAL;
kgsl_mutex... |
functions | long kgsl_ioctl_drawctxt_create(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
{
int result = 0;
struct kgsl_drawctxt_create *param = data;
struct kgsl_context *context = NULL;
struct kgsl_device *device = dev_priv->device;
kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
context ... |
functions | long kgsl_ioctl_drawctxt_destroy(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
{
struct kgsl_drawctxt_destroy *param = data;
struct kgsl_device *device = dev_priv->device;
struct kgsl_context *context;
long result;
kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
context = kgsl_c... |
functions | long _sharedmem_free_entry(struct kgsl_mem_entry *entry)
{
if (!kgsl_mem_entry_set_pend(entry)) {
kgsl_mem_entry_put(entry);
return -EBUSY;
} |
functions | long kgsl_ioctl_sharedmem_free(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
{
struct kgsl_sharedmem_free *param = data;
struct kgsl_process_private *private = dev_priv->process_priv;
struct kgsl_mem_entry *entry = NULL;
entry = kgsl_sharedmem_find(private, param->gpuaddr);
if (!entry) ... |
functions | long kgsl_ioctl_gpumem_free_id(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
{
struct kgsl_gpumem_free_id *param = data;
struct kgsl_process_private *private = dev_priv->process_priv;
struct kgsl_mem_entry *entry = NULL;
entry = kgsl_sharedmem_find_id(private, param->id);
if (!entry) {... |
functions | int _check_region(unsigned long start, unsigned long size,
uint64_t len)
{
uint64_t end = ((uint64_t) start) + size;
return (end > len);
} |
functions | int kgsl_get_phys_file(int fd, unsigned long *start, unsigned long *len,
unsigned long *vstart, struct file **filep)
{
struct file *fbfile;
int ret = 0;
dev_t rdev;
struct fb_info *info;
*start = 0;
*vstart = 0;
*len = 0;
*filep = NULL;
fbfile = fget(fd);
if (fbfile == NULL) {
KGSL_CORE_ERR("fget... |
functions | int kgsl_setup_phys_file(struct kgsl_mem_entry *entry,
struct kgsl_pagetable *pagetable,
unsigned int fd, unsigned int offset,
size_t size)
{
int ret;
unsigned long phys, virt, len;
struct file *filep;
ret = kgsl_get_phys_file(fd, &phys, &len, &virt, &filep);
if (ret)
return ret;
ret = -ERANGE;
... |
functions | int memdesc_sg_virt(struct kgsl_memdesc *memdesc,
unsigned long paddr, int size)
{
int i;
int sglen = PAGE_ALIGN(size) / PAGE_SIZE;
memdesc->sg = kgsl_sg_alloc(sglen);
if (memdesc->sg == NULL)
return -ENOMEM;
memdesc->sglen = sglen;
memdesc->sglen_alloc = sglen;
sg_init_table(memdesc->sg, sglen);
spin_l... |
functions | int kgsl_setup_useraddr(struct kgsl_mem_entry *entry,
struct kgsl_pagetable *pagetable,
unsigned long useraddr, unsigned int offset,
size_t size)
{
struct vm_area_struct *vma;
unsigned int len;
down_read(¤t->mm->mmap_sem);
vma = find_vma(current->mm, useraddr);
up_read(¤t->m... |
functions | int kgsl_setup_ashmem(struct kgsl_mem_entry *entry,
struct kgsl_pagetable *pagetable,
int fd, unsigned long useraddr, size_t size)
{
int ret;
struct vm_area_struct *vma;
struct file *filep, *vmfile;
unsigned long len;
vma = kgsl_get_vma_from_start_addr(useraddr);
if (vma == NULL)
return -EINVAL... |
functions | int kgsl_setup_ashmem(struct kgsl_mem_entry *entry,
struct kgsl_pagetable *pagetable,
int fd, unsigned long useraddr, size_t size)
{
return -EINVAL;
} |
functions | int kgsl_setup_ion(struct kgsl_mem_entry *entry,
struct kgsl_pagetable *pagetable, void *data,
struct kgsl_device *device)
{
struct scatterlist *s;
struct sg_table *sg_table;
struct kgsl_map_user_mem *param = data;
int fd = param->fd;
struct dma_buf *dmabuf;
struct dma_buf_attachment *attach;
struct kgsl_dma... |
functions | long kgsl_ioctl_map_user_mem(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
{
int result = -EINVAL;
struct kgsl_map_user_mem *param = data;
struct kgsl_mem_entry *entry = NULL;
struct kgsl_process_private *private = dev_priv->process_priv;
enum kgsl_user_mem_type memtype;
entry = kg... |
functions | int _kgsl_gpumem_sync_cache(struct kgsl_mem_entry *entry, int op)
{
int ret = 0;
int cacheop;
int mode;
/*
* Flush is defined as (clean | invalidate). If both bits are set, then
* do a flush, otherwise check for the individual bits and clean or inv
* as requested
*/
if ((op & KGSL_GPUMEM_CACHE_FLUSH) ==... |
functions | long
kgsl_ioctl_gpumem_sync_cache(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
{
struct kgsl_gpumem_sync_cache *param = data;
struct kgsl_process_private *private = dev_priv->process_priv;
struct kgsl_mem_entry *entry = NULL;
long ret;
if (param->id != 0) {
entry = kgsl_sharedmem_find_id... |
functions | else if (param->gpuaddr != 0) {
entry = kgsl_sharedmem_find(private, param->gpuaddr);
if (entry == NULL) {
KGSL_MEM_INFO(dev_priv->device,
"can't find gpuaddr %x\n",
param->gpuaddr);
return -EINVAL;
} |
functions | int mem_id_cmp(const void *_a, const void *_b)
{
const unsigned int *a = _a, *b = _b;
int cmp = a - b;
return (cmp < 0) ? -1 : (cmp > 0);
} |
functions | long
kgsl_ioctl_gpumem_sync_cache_bulk(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
{
int i;
struct kgsl_gpumem_sync_cache_bulk *param = data;
struct kgsl_process_private *private = dev_priv->process_priv;
unsigned int id, last_id = 0, *id_list = NULL, actual_count = 0;
struct kgsl_mem_entr... |
functions | long
kgsl_ioctl_sharedmem_flush_cache(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
{
struct kgsl_sharedmem_free *param = data;
struct kgsl_process_private *private = dev_priv->process_priv;
struct kgsl_mem_entry *entry = NULL;
long ret;
entry = kgsl_sharedmem_find(private, param->gpuad... |
functions | int
_gpumem_alloc(struct kgsl_device_private *dev_priv,
struct kgsl_mem_entry **ret_entry,
unsigned int size, unsigned int flags)
{
int result;
struct kgsl_process_private *private = dev_priv->process_priv;
struct kgsl_mem_entry *entry;
int align;
/*
* Mask off unknown flags from userspace. This way the cal... |
functions | long
kgsl_ioctl_gpumem_alloc(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
{
struct kgsl_process_private *private = dev_priv->process_priv;
struct kgsl_gpumem_alloc *param = data;
struct kgsl_mem_entry *entry = NULL;
int result;
param->flags &= ~KGSL_MEMFLAGS_USE_CPU_MAP;
result = _gpume... |
functions | long
kgsl_ioctl_gpumem_alloc_id(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
{
struct kgsl_process_private *private = dev_priv->process_priv;
struct kgsl_device *device = dev_priv->device;
struct kgsl_gpumem_alloc_id *param = data;
struct kgsl_mem_entry *entry = NULL;
int result;
if (!k... |
functions | long
kgsl_ioctl_gpumem_get_info(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
{
struct kgsl_process_private *private = dev_priv->process_priv;
struct kgsl_gpumem_get_info *param = data;
struct kgsl_mem_entry *entry = NULL;
int result = 0;
if (param->id != 0) {
entry = kgsl_sharedmem_fin... |
functions | else if (param->gpuaddr != 0) {
entry = kgsl_sharedmem_find(private, param->gpuaddr);
if (entry == NULL) {
KGSL_MEM_INFO(dev_priv->device,
"can't find gpuaddr %lx\n",
param->gpuaddr);
return -EINVAL;
} |
functions | long kgsl_ioctl_cff_syncmem(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
{
int result = 0;
struct kgsl_cff_syncmem *param = data;
struct kgsl_process_private *private = dev_priv->process_priv;
struct kgsl_mem_entry *entry = NULL;
entry = kgsl_sharedmem_find_region(private, param->gpuad... |
functions | long kgsl_ioctl_cff_user_event(struct kgsl_device_private *dev_priv,
unsigned int cmd, void *data)
{
int result = 0;
struct kgsl_cff_user_event *param = data;
kgsl_cffdump_user_event(dev_priv->device, param->cff_opcode,
param->op1, param->op2,
param->op3, param->op4, param->op5);
return result;
} |
functions | void kgsl_genlock_event_cb(struct kgsl_device *device,
struct kgsl_context *context, void *priv, int result)
{
struct kgsl_genlock_event_priv *ev = priv;
int ret;
/* Signal the lock for every event type */
ret = genlock_lock(ev->handle, GENLOCK_UNLOCK, 0, 0);
if (ret)
KGSL_CORE_ERR("Error while unlocking genlo... |
functions | int kgsl_add_genlock_event(struct kgsl_device *device,
u32 context_id, u32 timestamp, void __user *data, int len,
struct kgsl_device_private *owner)
{
struct kgsl_genlock_event_priv *event;
struct kgsl_timestamp_event_genlock priv;
struct kgsl_context *context = kgsl_context_get_owner(owner, context_id);
int ret;... |
functions | long kgsl_add_genlock_event(struct kgsl_device *device,
u32 context_id, u32 timestamp, void __user *data, int len,
struct kgsl_device_private *owner)
{
return -EINVAL;
} |
functions | 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->context_id, param->timestamp, param->priv,... |
functions | long kgsl_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
{
struct kgsl_device_private *dev_priv = filep->private_data;
unsigned int nr;
kgsl_ioctl_func_t func;
int ret;
char ustack[64];
void *uptr = NULL;
BUG_ON(dev_priv == NULL);
/* Workaround for an previously incorrectly defined ioctl code.... |
functions | int
kgsl_mmap_memstore(struct kgsl_device *device, struct vm_area_struct *vma)
{
struct kgsl_memdesc *memdesc = &device->memstore;
int result;
unsigned int vma_size = vma->vm_end - vma->vm_start;
/* The memstore can only be mapped as read only */
if (vma->vm_flags & VM_WRITE)
return -EPERM;
if (memdesc->size... |
functions | void kgsl_gpumem_vm_open(struct vm_area_struct *vma)
{
struct kgsl_mem_entry *entry = vma->vm_private_data;
if (!kgsl_mem_entry_get(entry))
vma->vm_private_data = NULL;
} |
functions | int
kgsl_gpumem_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
{
struct kgsl_mem_entry *entry = vma->vm_private_data;
if (!entry)
return VM_FAULT_SIGBUS;
if (!entry->memdesc.ops || !entry->memdesc.ops->vmfault)
return VM_FAULT_SIGBUS;
return entry->memdesc.ops->vmfault(&entry->memdesc, vma, vmf);
... |
functions | void
kgsl_gpumem_vm_close(struct vm_area_struct *vma)
{
struct kgsl_mem_entry *entry = vma->vm_private_data;
if (!entry)
return;
entry->memdesc.useraddr = 0;
kgsl_mem_entry_put(entry);
} |
functions | int
get_mmap_entry(struct kgsl_process_private *private,
struct kgsl_mem_entry **out_entry, unsigned long pgoff,
unsigned long len)
{
int ret = 0;
struct kgsl_mem_entry *entry;
entry = kgsl_sharedmem_find_id(private, pgoff);
if (entry == NULL) {
entry = kgsl_sharedmem_find(private, pgoff << PAGE_SHIFT);
} |
functions | bool
mmap_range_valid(unsigned long addr, unsigned long len)
{
return ((ULONG_MAX - addr) > len) && ((addr + len) < TASK_SIZE);
} |
functions | int kgsl_check_gpu_addr_collision(
struct kgsl_process_private *private,
struct kgsl_mem_entry *entry,
unsigned long addr, unsigned long len,
unsigned long *gpumap_free_addr,
bool flag_top_down,
unsigned int align)
{
int ret = -EAGAIN;
struct kgsl_mem_entry *collision_entry = NULL;
spin_lock(... |
functions | long
kgsl_get_unmapped_area(struct file *file, unsigned long addr,
unsigned long len, unsigned long pgoff,
unsigned long flags)
{
unsigned long ret = 0, orig_len = len;
unsigned long vma_offset = pgoff << PAGE_SHIFT;
struct kgsl_device_private *dev_priv = file->private_data;
struct kgsl_process_private *priva... |
functions | int kgsl_mmap(struct file *file, struct vm_area_struct *vma)
{
unsigned int ret, cache;
unsigned long vma_offset = vma->vm_pgoff << PAGE_SHIFT;
struct kgsl_device_private *dev_priv = file->private_data;
struct kgsl_process_private *private = dev_priv->process_priv;
struct kgsl_mem_entry *entry = NULL;
struct kgsl... |
functions | irqreturn_t kgsl_irq_handler(int irq, void *data)
{
struct kgsl_device *device = data;
return device->ftbl->irq_handler(device);
} |
functions | void _unregister_device(struct kgsl_device *device)
{
int minor;
mutex_lock(&kgsl_driver.devlock);
for (minor = 0; minor < KGSL_DEVICE_MAX; minor++) {
if (device == kgsl_driver.devp[minor])
break;
} |
functions | int _register_device(struct kgsl_device *device)
{
int minor, ret;
dev_t dev;
/* Find a minor for the device */
mutex_lock(&kgsl_driver.devlock);
for (minor = 0; minor < KGSL_DEVICE_MAX; minor++) {
if (kgsl_driver.devp[minor] == NULL) {
kgsl_driver.devp[minor] = device;
break;
} |
functions | int kgsl_device_platform_probe(struct kgsl_device *device)
{
int result;
int status = -EINVAL;
struct resource *res;
struct platform_device *pdev =
container_of(device->parentdev, struct platform_device, dev);
status = _register_device(device);
if (status)
return status;
/* Initialize logging first, so tha... |
functions | void kgsl_device_platform_remove(struct kgsl_device *device)
{
kgsl_del_event_group(&device->global_events);
kgsl_del_event_group(&device->iommu_events);
destroy_workqueue(device->events_wq);
kgsl_device_snapshot_close(device);
kgsl_pwrctrl_uninit_sysfs(device);
pm_qos_remove_request(&device->pwrctrl.pm_qos_r... |
functions | __devinit
kgsl_ptdata_init(void)
{
kgsl_driver.ptpool = kgsl_mmu_ptpool_init(kgsl_pagetable_count);
if (!kgsl_driver.ptpool)
return -ENOMEM;
return 0;
} |
functions | void kgsl_core_exit(void)
{
kgsl_mmu_ptpool_destroy(kgsl_driver.ptpool);
kgsl_driver.ptpool = NULL;
kgsl_events_exit();
kgsl_drm_exit();
kgsl_cffdump_destroy();
kgsl_core_debugfs_close();
/*
* We call kgsl_sharedmem_uninit_sysfs() and device_unregister()
* only if kgsl_driver.virtdev has been populated.
... |
functions | __init kgsl_core_init(void)
{
int result = 0;
/* alloc major and minor device numbers */
result = alloc_chrdev_region(&kgsl_driver.major, 0, KGSL_DEVICE_MAX,
KGSL_NAME);
if (result < 0) {
KGSL_CORE_ERR("alloc_chrdev_region failed err = %d\n", result);
goto err;
} |
includes |
#include <linux/version.h> |
includes | #include <lustre_param.h> |
includes | #include <lprocfs_status.h> |
includes | #include <obd_support.h> |
defines | #define DEBUG_SUBSYSTEM S_LLITE |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.