int
kgsl_g12_cmdstream_issueibcmds(struct kgsl_device *device,
struct kgsl_pagetable *pagetable,
int drawctxt_index,
uint32_t ibaddr,
int sizedwords,
int *timestamp,
unsigned int ctrl)
{
unsigned int ofs = PACKETSIZE_STATESTREAM * sizeof(unsigned int);
unsigned int cnt = 5;
unsigned int nextbuf = (g_z1xx.curr + 1) % GSL_HAL_NUMCMDBUFFERS;
unsigned int nextaddr = g_z1xx.cmdbufdesc[nextbuf].physaddr;
unsigned int nextcnt = 0x9000 | 5;
struct kgsl_memdesc tmp = {0};
unsigned int cmd;
cmd = ibaddr;
tmp.hostptr = (void *)*timestamp;
/* context switch */
if (drawctxt_index != (int)g_z1xx.prevctx) {
kgsl_mmu_setstate(device, pagetable);
cnt = PACKETSIZE_STATESTREAM;
ofs = 0;
} else {
kgsl_setstate(device, device->mmu.tlb_flags);
}
device->current_timestamp++;
*timestamp = device->current_timestamp;
g_z1xx.prevctx = drawctxt_index;
g_z1xx.offs = 10;
beginpacket(&g_z1xx, cmd + ofs, cnt);
tmp.hostptr = (void *)(tmp.hostptr +
(sizedwords * sizeof(unsigned int)));
tmp.size = 12;
kgsl_sharedmem_writel(&tmp, 4, nextaddr);
kgsl_sharedmem_writel(&tmp, 8, nextcnt);
/* sync mem */
kgsl_sharedmem_write((const struct kgsl_memdesc *)
&g_z1xx.cmdbufdesc[g_z1xx.curr], 0,
g_z1xx.cmdbuf[g_z1xx.curr],
(512 + 13) * sizeof(unsigned int));
g_z1xx.offs = 0;
g_z1xx.curr = nextbuf;
kgsl_g12_cmdwindow_write(device,
KGSL_CMDWINDOW_2D, ADDR_VGV3_CONTROL, ctrl);
kgsl_g12_cmdwindow_write(device,
KGSL_CMDWINDOW_2D, ADDR_VGV3_CONTROL, 0);
return KGSL_SUCCESS;
}
/* functions */
void kgsl_cp_intrcallback(struct kgsl_device *device)
{
unsigned int status = 0;
struct kgsl_ringbuffer *rb = &device->ringbuffer;
KGSL_CMD_VDBG("enter (device=%p)\n", device);
kgsl_yamato_regread(device, REG_CP_INT_STATUS, &status);
if (status & CP_INT_CNTL__RB_INT_MASK) {
/* signal intr completion event */
int init_reftimestamp = 0x7fffffff;
int enableflag = 0;
kgsl_sharedmem_write(&rb->device->memstore,
KGSL_DEVICE_MEMSTORE_OFFSET(ts_cmp_enable),
&enableflag, 4);
kgsl_sharedmem_write(&rb->device->memstore,
KGSL_DEVICE_MEMSTORE_OFFSET(ref_wait_ts),
&init_reftimestamp, 4);
KGSL_CMD_WARN("ringbuffer rb interrupt\n");
}
if (status & (CP_INT_CNTL__IB1_INT_MASK | CP_INT_CNTL__RB_INT_MASK)) {
KGSL_CMD_WARN("ringbuffer ib1/rb interrupt\n");
wake_up_interruptible_all(&device->ib1_wq);
}
if (status & CP_INT_CNTL__T0_PACKET_IN_IB_MASK) {
KGSL_CMD_FATAL("ringbuffer TO packet in IB interrupt\n");
kgsl_yamato_regwrite(rb->device, REG_CP_INT_CNTL, 0);
kgsl_ringbuffer_dump(rb);
}
if (status & CP_INT_CNTL__OPCODE_ERROR_MASK) {
KGSL_CMD_FATAL("ringbuffer opcode error interrupt\n");
kgsl_yamato_regwrite(rb->device, REG_CP_INT_CNTL, 0);
kgsl_ringbuffer_dump(rb);
}
if (status & CP_INT_CNTL__PROTECTED_MODE_ERROR_MASK) {
KGSL_CMD_FATAL("ringbuffer protected mode error interrupt\n");
kgsl_yamato_regwrite(rb->device, REG_CP_INT_CNTL, 0);
kgsl_ringbuffer_dump(rb);
}
if (status & CP_INT_CNTL__RESERVED_BIT_ERROR_MASK) {
KGSL_CMD_FATAL("ringbuffer reserved bit error interrupt\n");
kgsl_yamato_regwrite(rb->device, REG_CP_INT_CNTL, 0);
kgsl_ringbuffer_dump(rb);
}
if (status & CP_INT_CNTL__IB_ERROR_MASK) {
KGSL_CMD_FATAL("ringbuffer IB error interrupt\n");
kgsl_yamato_regwrite(rb->device, REG_CP_INT_CNTL, 0);
kgsl_ringbuffer_dump(rb);
}
if (status & CP_INT_CNTL__SW_INT_MASK)
KGSL_CMD_DBG("ringbuffer software interrupt\n");
if (status & CP_INT_CNTL__IB2_INT_MASK)
KGSL_CMD_DBG("ringbuffer ib2 interrupt\n");
if (status & (~GSL_CP_INT_MASK))
KGSL_CMD_DBG("bad bits in REG_CP_INT_STATUS %08x\n", status);
/* only ack bits we understand */
status &= GSL_CP_INT_MASK;
kgsl_yamato_regwrite(device, REG_CP_INT_ACK, status);
KGSL_CMD_VDBG("return\n");
}
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;
}
int
kgsl_g12_drawctxt_create(struct kgsl_device *device,
uint32_t ctxt_id_mask,
unsigned int *drawctxt_id)
{
int i;
int cmd;
int result;
unsigned int ctx_id;
if (g_z1xx.numcontext == 0) {
for (i = 0; i < GSL_HAL_NUMCMDBUFFERS; i++) {
int flags = 0;
if (kgsl_sharedmem_alloc(flags, GSL_HAL_CMDBUFFERSIZE,
&g_z1xx.cmdbufdesc[i]) != 0)
return -ENOMEM;
g_z1xx.cmdbuf[i] = kzalloc(GSL_HAL_CMDBUFFERSIZE,
GFP_KERNEL);
g_z1xx.curr = i;
g_z1xx.offs = 0;
addmarker(&g_z1xx);
kgsl_sharedmem_write(&g_z1xx.cmdbufdesc[i], 0,
g_z1xx.cmdbuf[i],
(512 + 13) *
sizeof(unsigned int));
}
g_z1xx.curr = 0;
cmd = (int)(((VGV3_NEXTCMD_JUMP) &
VGV3_NEXTCMD_NEXTCMD_FMASK)
<< VGV3_NEXTCMD_NEXTCMD_FSHIFT);
/* set cmd stream buffer to hw */
result = kgsl_g12_cmdwindow_write(device, KGSL_CMDWINDOW_2D,
ADDR_VGV3_MODE, 4);
if (result != 0)
return result;
result = kgsl_g12_cmdwindow_write(device, KGSL_CMDWINDOW_2D,
ADDR_VGV3_NEXTADDR,
g_z1xx.cmdbufdesc[0].physaddr);
if (result != 0)
return result;
result = kgsl_g12_cmdwindow_write(device, KGSL_CMDWINDOW_2D,
ADDR_VGV3_NEXTCMD, cmd | 5);
if (result != 0)
return result;
cmd = (int)(((1) & VGV3_CONTROL_MARKADD_FMASK)
<< VGV3_CONTROL_MARKADD_FSHIFT);
result = kgsl_g12_cmdwindow_write(device, KGSL_CMDWINDOW_2D,
ADDR_VGV3_CONTROL, cmd);
if (result != 0)
return result;
result = kgsl_g12_cmdwindow_write(device, KGSL_CMDWINDOW_2D,
ADDR_VGV3_CONTROL, 0);
if (result != 0)
return result;
}
ctx_id = ffz(ctxt_id_mask);
g_z1xx.numcontext++;
if (g_z1xx.numcontext > KGSL_G12_CONTEXT_MAX) {
*drawctxt_id = 0;
return KGSL_FAILURE;
}
*drawctxt_id = ctx_id;
return KGSL_SUCCESS;
}
