void kgsl_intr_decode(gsl_device_t *device, gsl_intrblock_t block_id) { const gsl_intrblock_reg_t *block = &gsl_cfg_intrblock_reg[block_id]; gsl_intrid_t id; unsigned int status; // read the block's interrupt status bits kgsl_device_regread(device->id, block->status_reg, &status); // mask off any interrupts which are disabled status &= device->intr.enabled[block->id]; // acknowledge the block's interrupts kgsl_device_regwrite(device->id, block->clear_reg, status); // loop through the block's masks, determine which interrupt bits are active, and call callback (or TODO queue DPC) for (id = block->first_id; id <= block->last_id; id++) { if (status & gsl_cfg_intr_mask[id]) { device->intr.handler[id].callback(id, device->intr.handler[id].cookie); } } }
static long gsl_kmod_ioctl(struct file *fd, unsigned int cmd, unsigned long arg) { int kgslStatus = GSL_FAILURE; switch (cmd) { case IOCTL_KGSL_DEVICE_START: { kgsl_device_start_t param; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_device_start_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_device_start(param.device_id, param.flags); break; } case IOCTL_KGSL_DEVICE_STOP: { kgsl_device_stop_t param; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_device_stop_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_device_stop(param.device_id); break; } case IOCTL_KGSL_DEVICE_IDLE: { kgsl_device_idle_t param; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_device_idle_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_device_idle(param.device_id, param.timeout); break; } case IOCTL_KGSL_DEVICE_ISIDLE: { kgsl_device_isidle_t param; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_device_isidle_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_device_isidle(param.device_id); break; } case IOCTL_KGSL_DEVICE_GETPROPERTY: { kgsl_device_getproperty_t param; void *tmp; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_device_getproperty_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } tmp = kmalloc(param.sizebytes, GFP_KERNEL); if (!tmp) { printk(KERN_ERR "%s:kmalloc error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_device_getproperty(param.device_id, param.type, tmp, param.sizebytes); if (kgslStatus == GSL_SUCCESS) { if (copy_to_user(param.value, tmp, param.sizebytes)) { printk(KERN_ERR "%s: copy_to_user error\n", __func__); kgslStatus = GSL_FAILURE; kfree(tmp); break; } } else { printk(KERN_ERR "%s: kgsl_device_getproperty error\n", __func__); } kfree(tmp); break; } case IOCTL_KGSL_DEVICE_SETPROPERTY: { kgsl_device_setproperty_t param; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_device_setproperty_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_device_setproperty(param.device_id, param.type, param.value, param.sizebytes); if (kgslStatus != GSL_SUCCESS) { printk(KERN_ERR "%s: kgsl_device_setproperty error\n", __func__); } break; } case IOCTL_KGSL_DEVICE_REGREAD: { kgsl_device_regread_t param; unsigned int tmp; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_device_regread_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_device_regread(param.device_id, param.offsetwords, &tmp); if (kgslStatus == GSL_SUCCESS) { if (copy_to_user(param.value, &tmp, sizeof(unsigned int))) { printk(KERN_ERR "%s: copy_to_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } } break; } case IOCTL_KGSL_DEVICE_REGWRITE: { kgsl_device_regwrite_t param; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_device_regwrite_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_device_regwrite(param.device_id, param.offsetwords, param.value); break; } case IOCTL_KGSL_DEVICE_WAITIRQ: { kgsl_device_waitirq_t param; unsigned int count; printk(KERN_ERR "IOCTL_KGSL_DEVICE_WAITIRQ obsoleted!\n"); // kgslStatus = -ENOTTY; break; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_device_waitirq_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_device_waitirq(param.device_id, param.intr_id, &count, param.timeout); if (kgslStatus == GSL_SUCCESS) { if (copy_to_user(param.count, &count, sizeof(unsigned int))) { printk(KERN_ERR "%s: copy_to_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } } break; } case IOCTL_KGSL_CMDSTREAM_ISSUEIBCMDS: { kgsl_cmdstream_issueibcmds_t param; gsl_timestamp_t tmp; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_cmdstream_issueibcmds_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_cmdstream_issueibcmds(param.device_id, param.drawctxt_index, param.ibaddr, param.sizedwords, &tmp, param.flags); if (kgslStatus == GSL_SUCCESS) { if (copy_to_user(param.timestamp, &tmp, sizeof(gsl_timestamp_t))) { printk(KERN_ERR "%s: copy_to_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } } break; } case IOCTL_KGSL_CMDSTREAM_READTIMESTAMP: { kgsl_cmdstream_readtimestamp_t param; gsl_timestamp_t tmp; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_cmdstream_readtimestamp_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } tmp = kgsl_cmdstream_readtimestamp(param.device_id, param.type); if (copy_to_user(param.timestamp, &tmp, sizeof(gsl_timestamp_t))) { printk(KERN_ERR "%s: copy_to_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = GSL_SUCCESS; break; } case IOCTL_KGSL_CMDSTREAM_FREEMEMONTIMESTAMP: { int err; kgsl_cmdstream_freememontimestamp_t param; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_cmdstream_freememontimestamp_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } err = del_memblock_from_allocated_list(fd, param.memdesc); if(err) { /* tried to remove a block of memory that is not allocated! * NOTE that -EINVAL is Linux kernel's error codes! * the drivers error codes COULD mix up with kernel's. */ kgslStatus = -EINVAL; } else { kgslStatus = kgsl_cmdstream_freememontimestamp(param.device_id, param.memdesc, param.timestamp, param.type); } break; } case IOCTL_KGSL_CMDSTREAM_WAITTIMESTAMP: { kgsl_cmdstream_waittimestamp_t param; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_cmdstream_waittimestamp_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_cmdstream_waittimestamp(param.device_id, param.timestamp, param.timeout); break; } case IOCTL_KGSL_CMDWINDOW_WRITE: { kgsl_cmdwindow_write_t param; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_cmdwindow_write_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_cmdwindow_write(param.device_id, param.target, param.addr, param.data); break; } case IOCTL_KGSL_CONTEXT_CREATE: { kgsl_context_create_t param; unsigned int tmp; int tmpStatus; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_context_create_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_context_create(param.device_id, param.type, &tmp, param.flags); if (kgslStatus == GSL_SUCCESS) { if (copy_to_user(param.drawctxt_id, &tmp, sizeof(unsigned int))) { tmpStatus = kgsl_context_destroy(param.device_id, tmp); /* is asserting ok? Basicly we should return the error from copy_to_user * but will the user space interpret it correctly? Will the user space * always check against GSL_SUCCESS or GSL_FAILURE as they are not the only * return values. */ KOS_ASSERT(tmpStatus == GSL_SUCCESS); printk(KERN_ERR "%s: copy_to_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } else { add_device_context_to_array(fd, param.device_id, tmp); } } break; } case IOCTL_KGSL_CONTEXT_DESTROY: { kgsl_context_destroy_t param; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_context_destroy_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_context_destroy(param.device_id, param.drawctxt_id); del_device_context_from_array(fd, param.device_id, param.drawctxt_id); break; } case IOCTL_KGSL_DRAWCTXT_BIND_GMEM_SHADOW: { kgsl_drawctxt_bind_gmem_shadow_t param; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_drawctxt_bind_gmem_shadow_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_drawctxt_bind_gmem_shadow(param.device_id, param.drawctxt_id, param.gmem_rect, param.shadow_x, param.shadow_y, param.shadow_buffer, param.buffer_id); break; } case IOCTL_KGSL_SHAREDMEM_ALLOC: { kgsl_sharedmem_alloc_t param; gsl_memdesc_t tmp; int tmpStatus; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_sharedmem_alloc_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_sharedmem_alloc(param.device_id, param.flags, param.sizebytes, &tmp); if (kgslStatus == GSL_SUCCESS) { if (copy_to_user(param.memdesc, &tmp, sizeof(gsl_memdesc_t))) { tmpStatus = kgsl_sharedmem_free(&tmp); KOS_ASSERT(tmpStatus == GSL_SUCCESS); printk(KERN_ERR "%s: copy_to_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } else { add_memblock_to_allocated_list(fd, &tmp); } } break; } case IOCTL_KGSL_SHAREDMEM_FREE: { kgsl_sharedmem_free_t param; gsl_memdesc_t tmp; int err; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_sharedmem_free_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } if (copy_from_user(&tmp, (void __user *)param.memdesc, sizeof(gsl_memdesc_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } err = del_memblock_from_allocated_list(fd, &tmp); if(err) { printk(KERN_ERR "%s: tried to free memdesc that was not allocated!\n", __func__); kgslStatus = err; break; } kgslStatus = kgsl_sharedmem_free(&tmp); if (kgslStatus == GSL_SUCCESS) { if (copy_to_user(param.memdesc, &tmp, sizeof(gsl_memdesc_t))) { printk(KERN_ERR "%s: copy_to_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } } break; } case IOCTL_KGSL_SHAREDMEM_READ: { kgsl_sharedmem_read_t param; gsl_memdesc_t memdesc; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_sharedmem_read_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } if (copy_from_user(&memdesc, (void __user *)param.memdesc, sizeof(gsl_memdesc_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_sharedmem_read(&memdesc, param.dst, param.offsetbytes, param.sizebytes, true); if (kgslStatus != GSL_SUCCESS) { printk(KERN_ERR "%s: kgsl_sharedmem_read failed\n", __func__); } break; } case IOCTL_KGSL_SHAREDMEM_WRITE: { kgsl_sharedmem_write_t param; gsl_memdesc_t memdesc; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_sharedmem_write_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } if (copy_from_user(&memdesc, (void __user *)param.memdesc, sizeof(gsl_memdesc_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_sharedmem_write(&memdesc, param.offsetbytes, param.src, param.sizebytes, true); if (kgslStatus != GSL_SUCCESS) { printk(KERN_ERR "%s: kgsl_sharedmem_write failed\n", __func__); } break; } case IOCTL_KGSL_SHAREDMEM_SET: { kgsl_sharedmem_set_t param; gsl_memdesc_t memdesc; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_sharedmem_set_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } if (copy_from_user(&memdesc, (void __user *)param.memdesc, sizeof(gsl_memdesc_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_sharedmem_set(&memdesc, param.offsetbytes, param.value, param.sizebytes); break; } case IOCTL_KGSL_SHAREDMEM_LARGESTFREEBLOCK: { kgsl_sharedmem_largestfreeblock_t param; unsigned int largestfreeblock; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_sharedmem_largestfreeblock_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } largestfreeblock = kgsl_sharedmem_largestfreeblock(param.device_id, param.flags); if (copy_to_user(param.largestfreeblock, &largestfreeblock, sizeof(unsigned int))) { printk(KERN_ERR "%s: copy_to_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = GSL_SUCCESS; break; } case IOCTL_KGSL_SHAREDMEM_CACHEOPERATION: { kgsl_sharedmem_cacheoperation_t param; gsl_memdesc_t memdesc; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_sharedmem_cacheoperation_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } if (copy_from_user(&memdesc, (void __user *)param.memdesc, sizeof(gsl_memdesc_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_sharedmem_cacheoperation(&memdesc, param.offsetbytes, param.sizebytes, param.operation); break; } case IOCTL_KGSL_SHAREDMEM_FROMHOSTPOINTER: { kgsl_sharedmem_fromhostpointer_t param; gsl_memdesc_t memdesc; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_sharedmem_fromhostpointer_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } if (copy_from_user(&memdesc, (void __user *)param.memdesc, sizeof(gsl_memdesc_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_sharedmem_fromhostpointer(param.device_id, &memdesc, param.hostptr); break; } case IOCTL_KGSL_ADD_TIMESTAMP: { kgsl_add_timestamp_t param; gsl_timestamp_t tmp; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_add_timestamp_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } tmp = kgsl_add_timestamp(param.device_id, &tmp); if (copy_to_user(param.timestamp, &tmp, sizeof(gsl_timestamp_t))) { printk(KERN_ERR "%s: copy_to_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = GSL_SUCCESS; break; } case IOCTL_KGSL_DEVICE_CLOCK: { kgsl_device_clock_t param; if (copy_from_user(¶m, (void __user *)arg, sizeof(kgsl_device_clock_t))) { printk(KERN_ERR "%s: copy_from_user error\n", __func__); kgslStatus = GSL_FAILURE; break; } kgslStatus = kgsl_device_clock(param.device, param.enable); break; } default: kgslStatus = -ENOTTY; break; } return kgslStatus; }