自学教程：C++ ADRENO_CONTEXT函数代码示例

static int adreno_drawctxt_wait_global(struct adreno_device *adreno_dev,		struct kgsl_context *context,		uint32_t timestamp, unsigned int timeout){	struct kgsl_device *device = &adreno_dev->dev;	struct adreno_context *drawctxt = ADRENO_CONTEXT(context);	int ret = 0;	/* Needs to hold the device mutex */	BUG_ON(!mutex_is_locked(&device->mutex));	if (!_kgsl_context_get(context)) {		ret = -EINVAL;		goto done;	}	/*	 * If the context is invalid then return immediately - we may end up	 * waiting for a timestamp that will never come	 */	if (drawctxt->state == ADRENO_CONTEXT_STATE_INVALID) {		kgsl_context_put(context);		goto done;	}	trace_adreno_drawctxt_wait_start(KGSL_MEMSTORE_GLOBAL, timestamp);	ret = kgsl_add_event(device, &device->global_events, timestamp,		global_wait_callback, (void *) drawctxt);	if (ret) {		kgsl_context_put(context);		goto done;	}	kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);	if (timeout) {		ret = (int) wait_event_timeout(drawctxt->waiting,			_check_global_timestamp(device, drawctxt, timestamp),			msecs_to_jiffies(timeout));		if (ret == 0)			ret = -ETIMEDOUT;		else if (ret > 0)			ret = 0;	} else {		wait_event(drawctxt->waiting,			_check_global_timestamp(device, drawctxt, timestamp));	}	kgsl_mutex_lock(&device->mutex, &device->mutex_owner);	if (ret)		kgsl_cancel_events_timestamp(device, &device->global_events,			timestamp);done:	trace_adreno_drawctxt_wait_done(KGSL_MEMSTORE_GLOBAL, timestamp, ret);	return ret;}

/** * adreno_drawctxt_detach(): detach a context from the GPU * @context: Generic KGSL context container for the context * */void adreno_drawctxt_detach(struct kgsl_context *context){	struct kgsl_device *device;	struct adreno_device *adreno_dev;	struct adreno_context *drawctxt;	if (context == NULL)		return;	device = context->device;	adreno_dev = ADRENO_DEVICE(device);	drawctxt = ADRENO_CONTEXT(context);	/* deactivate context */	if (adreno_dev->drawctxt_active == drawctxt) {		/* no need to save GMEM or shader, the context is		 * being destroyed.		 */		drawctxt->flags &= ~(CTXT_FLAGS_GMEM_SAVE |				     CTXT_FLAGS_SHADER_SAVE |				     CTXT_FLAGS_GMEM_SHADOW |				     CTXT_FLAGS_STATE_SHADOW);		drawctxt->flags |= CTXT_FLAGS_BEING_DESTROYED;		adreno_drawctxt_switch(adreno_dev, NULL, 0);	}	if (device->state != KGSL_STATE_HUNG)		adreno_idle(device);	adreno_profile_process_results(device);	kgsl_sharedmem_free(&drawctxt->gpustate);	kgsl_sharedmem_free(&drawctxt->context_gmem_shadow.gmemshadow);}

/** * adreno_drawctxt_wait_rb() - Wait for the last RB timestamp at which this * context submitted a command to the corresponding RB * @adreno_dev: The device on which the timestamp is active * @context: The context which subbmitted command to RB * @timestamp: The RB timestamp of last command submitted to RB by context * @timeout: Timeout value for the wait */static int adreno_drawctxt_wait_rb(struct adreno_device *adreno_dev,		struct kgsl_context *context,		uint32_t timestamp, unsigned int timeout){	struct kgsl_device *device = &adreno_dev->dev;	struct adreno_context *drawctxt = ADRENO_CONTEXT(context);	int ret = 0;	/* Needs to hold the device mutex */	BUG_ON(!mutex_is_locked(&device->mutex));	/*	 * If the context is invalid then return immediately - we may end up	 * waiting for a timestamp that will never come	 */	if (kgsl_context_invalid(context))		goto done;	trace_adreno_drawctxt_wait_start(drawctxt->rb->id, context->id,					timestamp);	ret = adreno_ringbuffer_waittimestamp(drawctxt->rb, timestamp, timeout);done:	trace_adreno_drawctxt_wait_done(drawctxt->rb->id, context->id,					timestamp, ret);	return ret;}

/** * adreno_drawctxt_wait() - sleep until a timestamp expires * @adreno_dev: pointer to the adreno_device struct * @drawctxt: Pointer to the draw context to sleep for * @timetamp: Timestamp to wait on * @timeout: Number of jiffies to wait (0 for infinite) * * Register an event to wait for a timestamp on a context and sleep until it * has past.  Returns < 0 on error, -ETIMEDOUT if the timeout expires or 0 * on success */int adreno_drawctxt_wait(struct adreno_device *adreno_dev,		struct kgsl_context *context,		uint32_t timestamp, unsigned int timeout){	struct kgsl_device *device = &adreno_dev->dev;	struct adreno_context *drawctxt = ADRENO_CONTEXT(context);	int ret;	long ret_temp;	if (kgsl_context_detached(context))		return -EINVAL;	if (kgsl_context_invalid(context))		return -EDEADLK;	/* Needs to hold the device mutex */	BUG_ON(!mutex_is_locked(&device->mutex));	trace_adreno_drawctxt_wait_start(-1, context->id, timestamp);	ret = kgsl_add_event(device, &context->events, timestamp,		wait_callback, (void *) drawctxt);	if (ret)		goto done;	mutex_unlock(&device->mutex);	if (timeout) {		ret_temp = wait_event_interruptible_timeout(			drawctxt->waiting,			_check_context_timestamp(device, drawctxt, timestamp),			msecs_to_jiffies(timeout));		if (ret_temp == 0)			ret = -ETIMEDOUT;		else if (ret_temp > 0)			ret = 0;		else			ret = (int) ret_temp;	} else {		ret = wait_event_interruptible(drawctxt->waiting,			_check_context_timestamp(device, drawctxt, timestamp));	}	mutex_lock(&device->mutex);	/* -EDEADLK if the context was invalidated while we were waiting */	if (kgsl_context_invalid(context))		ret = -EDEADLK;	/* Return -EINVAL if the context was detached while we were waiting */	if (kgsl_context_detached(context))		ret = -EINVAL;done:	trace_adreno_drawctxt_wait_done(-1, context->id, timestamp, ret);	return ret;}

void adreno_drawctxt_destroy(struct kgsl_context *context){	struct adreno_context *drawctxt;	if (context == NULL)		return;	drawctxt = ADRENO_CONTEXT(context);	kfree(drawctxt);}

void adreno_drawctxt_destroy(struct kgsl_context *context){	struct adreno_context *drawctxt;	if (context == NULL)		return;	drawctxt = ADRENO_CONTEXT(context);	debugfs_remove_recursive(drawctxt->debug_root);	kfree(drawctxt);}

/** * adreno_drawctxt_wait() - sleep until a timestamp expires * @adreno_dev: pointer to the adreno_device struct * @drawctxt: Pointer to the draw context to sleep for * @timetamp: Timestamp to wait on * @timeout: Number of jiffies to wait (0 for infinite) * * Register an event to wait for a timestamp on a context and sleep until it * has past.  Returns < 0 on error, -ETIMEDOUT if the timeout expires or 0 * on success */int adreno_drawctxt_wait(struct adreno_device *adreno_dev,		struct kgsl_context *context,		uint32_t timestamp, unsigned int timeout){	struct kgsl_device *device = &adreno_dev->dev;	struct adreno_context *drawctxt = ADRENO_CONTEXT(context);	int ret;	long ret_temp;	if (kgsl_context_detached(context))		return -ENOENT;	if (kgsl_context_invalid(context))		return -EDEADLK;	trace_adreno_drawctxt_wait_start(-1, context->id, timestamp);	ret = kgsl_add_event(device, &context->events, timestamp,		wait_callback, (void *) drawctxt);	if (ret)		goto done;	/*	 * If timeout is 0, wait forever. msecs_to_jiffies will force	 * values larger than INT_MAX to an infinite timeout.	 */	if (timeout == 0)		timeout = UINT_MAX;	ret_temp = wait_event_interruptible_timeout(drawctxt->waiting,			_check_context_timestamp(device, context, timestamp),			msecs_to_jiffies(timeout));	if (ret_temp == 0) {		ret = -ETIMEDOUT;		goto done;	} else if (ret_temp < 0) {		ret = (int) ret_temp;		goto done;	}	ret = 0;	/* -EDEADLK if the context was invalidated while we were waiting */	if (kgsl_context_invalid(context))		ret = -EDEADLK;	/* Return -EINVAL if the context was detached while we were waiting */	if (kgsl_context_detached(context))		ret = -ENOENT;done:	trace_adreno_drawctxt_wait_done(-1, context->id, timestamp, ret);	return ret;}

int adreno_drawctxt_wait_global(struct adreno_device *adreno_dev,		struct kgsl_context *context,		uint32_t timestamp, unsigned int timeout){	struct kgsl_device *device = &adreno_dev->dev;	struct adreno_context *drawctxt = ADRENO_CONTEXT(context);	int ret = 0;		BUG_ON(!mutex_is_locked(&device->mutex));	if (!_kgsl_context_get(context)) {		ret = -EINVAL;		goto done;	}	if (drawctxt->state == ADRENO_CONTEXT_STATE_INVALID) {		kgsl_context_put(context);		goto done;	}	trace_adreno_drawctxt_wait_start(KGSL_MEMSTORE_GLOBAL, timestamp);	ret = kgsl_add_event(device, KGSL_MEMSTORE_GLOBAL, timestamp,		global_wait_callback, drawctxt, NULL);	if (ret) {		kgsl_context_put(context);		goto done;	}	mutex_unlock(&device->mutex);	if (timeout) {		ret = (int) wait_event_timeout(drawctxt->waiting,			_check_global_timestamp(device, drawctxt, timestamp),			msecs_to_jiffies(timeout));		if (ret == 0)			ret = -ETIMEDOUT;		else if (ret > 0)			ret = 0;	} else {		wait_event(drawctxt->waiting,			_check_global_timestamp(device, drawctxt, timestamp));	}	mutex_lock(&device->mutex);	if (ret)		kgsl_cancel_events_timestamp(device, NULL, timestamp);done:	trace_adreno_drawctxt_wait_done(KGSL_MEMSTORE_GLOBAL, timestamp, ret);	return ret;}

void adreno_drawctxt_set_bin_base_offset(struct kgsl_device *device,				      struct kgsl_context *context,				      unsigned int offset){	struct adreno_context *drawctxt;	if (context == NULL)		return;	drawctxt = ADRENO_CONTEXT(context);	drawctxt->bin_base_offset = offset;}

/** * adreno_drawctxt_invalidate() - Invalidate an adreno draw context * @device: Pointer to the KGSL device structure for the GPU * @context: Pointer to the KGSL context structure * * Invalidate the context and remove all queued commands and cancel any pending * waiters */void adreno_drawctxt_invalidate(struct kgsl_device *device,		struct kgsl_context *context){	struct adreno_context *drawctxt = ADRENO_CONTEXT(context);	trace_adreno_drawctxt_invalidate(drawctxt);	drawctxt->state = ADRENO_CONTEXT_STATE_INVALID;	/* Clear the pending queue */	mutex_lock(&drawctxt->mutex);	/*	 * set the timestamp to the last value since the context is invalidated	 * and we want the pending events for this context to go away	 */	kgsl_sharedmem_writel(device, &device->memstore,			KGSL_MEMSTORE_OFFSET(context->id, soptimestamp),			drawctxt->timestamp);	kgsl_sharedmem_writel(device, &device->memstore,			KGSL_MEMSTORE_OFFSET(context->id, eoptimestamp),			drawctxt->timestamp);	while (drawctxt->cmdqueue_head != drawctxt->cmdqueue_tail) {		struct kgsl_cmdbatch *cmdbatch =			drawctxt->cmdqueue[drawctxt->cmdqueue_head];		drawctxt->cmdqueue_head = (drawctxt->cmdqueue_head + 1) %			ADRENO_CONTEXT_CMDQUEUE_SIZE;		mutex_unlock(&drawctxt->mutex);		kgsl_mutex_lock(&device->mutex, &device->mutex_owner);		kgsl_cancel_events_timestamp(device, &context->events,			cmdbatch->timestamp);		kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);		kgsl_cmdbatch_destroy(cmdbatch);		mutex_lock(&drawctxt->mutex);	}	mutex_unlock(&drawctxt->mutex);	/* Give the bad news to everybody waiting around */	wake_up_all(&drawctxt->waiting);	wake_up_all(&drawctxt->wq);}

/** * adreno_drawctxt_dump() - dump information about a draw context * @device: KGSL device that owns the context * @context: KGSL context to dump information about * * Dump specific information about the context to the kernel log.  Used for * fence timeout callbacks */void adreno_drawctxt_dump(struct kgsl_device *device,		struct kgsl_context *context){	unsigned int queue, start, retire;	struct adreno_context *drawctxt = ADRENO_CONTEXT(context);	queue = kgsl_readtimestamp(device, context, KGSL_TIMESTAMP_QUEUED);	start = kgsl_readtimestamp(device, context, KGSL_TIMESTAMP_CONSUMED);	retire = kgsl_readtimestamp(device, context, KGSL_TIMESTAMP_RETIRED);	spin_lock(&drawctxt->lock);	dev_err(device->dev,		"  context[%d]: queue=%d, submit=%d, start=%d, retire=%d/n",		context->id, queue, drawctxt->submitted_timestamp,		start, retire);	if (drawctxt->cmdqueue_head != drawctxt->cmdqueue_tail) {		struct kgsl_cmdbatch *cmdbatch =			drawctxt->cmdqueue[drawctxt->cmdqueue_head];		if (test_bit(CMDBATCH_FLAG_FENCE_LOG, &cmdbatch->priv)) {			dev_err(device->dev,				"  possible deadlock. Context %d might be blocked for itself/n",				context->id);			goto done;		}		/*		 * We may have cmdbatch timer running, which also uses same		 * lock, take a lock with software interrupt disabled (bh)		 * to avoid spin lock recursion.		 */		spin_lock_bh(&cmdbatch->lock);		if (!list_empty(&cmdbatch->synclist)) {			dev_err(device->dev,				"  context[%d] (ts=%d) Active sync points:/n",				context->id, cmdbatch->timestamp);			kgsl_dump_syncpoints(device, cmdbatch);		}		spin_unlock_bh(&cmdbatch->lock);	}done:	spin_unlock(&drawctxt->lock);}

/** * adreno_drawctxt_invalidate() - Invalidate an adreno draw context * @device: Pointer to the KGSL device structure for the GPU * @context: Pointer to the KGSL context structure * * Invalidate the context and remove all queued commands and cancel any pending * waiters */void adreno_drawctxt_invalidate(struct kgsl_device *device,		struct kgsl_context *context){	struct adreno_context *drawctxt = ADRENO_CONTEXT(context);	trace_adreno_drawctxt_invalidate(drawctxt);	spin_lock(&drawctxt->lock);	set_bit(KGSL_CONTEXT_PRIV_INVALID, &context->priv);	/*	 * set the timestamp to the last value since the context is invalidated	 * and we want the pending events for this context to go away	 */	kgsl_sharedmem_writel(device, &device->memstore,			KGSL_MEMSTORE_OFFSET(context->id, soptimestamp),			drawctxt->timestamp);	kgsl_sharedmem_writel(device, &device->memstore,			KGSL_MEMSTORE_OFFSET(context->id, eoptimestamp),			drawctxt->timestamp);	/* Get rid of commands still waiting in the queue */	while (drawctxt->cmdqueue_head != drawctxt->cmdqueue_tail) {		struct kgsl_cmdbatch *cmdbatch =			drawctxt->cmdqueue[drawctxt->cmdqueue_head];		drawctxt->cmdqueue_head = (drawctxt->cmdqueue_head + 1) %			ADRENO_CONTEXT_CMDQUEUE_SIZE;		kgsl_cancel_events_timestamp(device, &context->events,			cmdbatch->timestamp);		kgsl_cmdbatch_destroy(cmdbatch);	}	spin_unlock(&drawctxt->lock);	/* Make sure all "retired" events are processed */	kgsl_process_event_group(device, &context->events);	/* Give the bad news to everybody waiting around */	wake_up_all(&drawctxt->waiting);	wake_up_all(&drawctxt->wq);}

void adreno_drawctxt_invalidate(struct kgsl_device *device,		struct kgsl_context *context){	struct adreno_context *drawctxt = ADRENO_CONTEXT(context);	trace_adreno_drawctxt_invalidate(drawctxt);	drawctxt->state = ADRENO_CONTEXT_STATE_INVALID;		mutex_lock(&drawctxt->mutex);	kgsl_sharedmem_writel(device, &device->memstore,			KGSL_MEMSTORE_OFFSET(context->id, soptimestamp),			drawctxt->timestamp);	kgsl_sharedmem_writel(device, &device->memstore,			KGSL_MEMSTORE_OFFSET(context->id, eoptimestamp),			drawctxt->timestamp);	while (drawctxt->cmdqueue_head != drawctxt->cmdqueue_tail) {		struct kgsl_cmdbatch *cmdbatch =			drawctxt->cmdqueue[drawctxt->cmdqueue_head];		drawctxt->cmdqueue_head = (drawctxt->cmdqueue_head + 1) %			ADRENO_CONTEXT_CMDQUEUE_SIZE;		mutex_unlock(&drawctxt->mutex);		mutex_lock(&device->mutex);		kgsl_cancel_events_timestamp(device, context,			cmdbatch->timestamp);		mutex_unlock(&device->mutex);		kgsl_cmdbatch_destroy(cmdbatch);		mutex_lock(&drawctxt->mutex);	}	mutex_unlock(&drawctxt->mutex);		wake_up_all(&drawctxt->waiting);	wake_up_all(&drawctxt->wq);}

/** * adreno_drawctxt_wait() - sleep until a timestamp expires * @adreno_dev: pointer to the adreno_device struct * @drawctxt: Pointer to the draw context to sleep for * @timetamp: Timestamp to wait on * @timeout: Number of jiffies to wait (0 for infinite) * * Register an event to wait for a timestamp on a context and sleep until it * has past.  Returns < 0 on error, -ETIMEDOUT if the timeout expires or 0 * on success */int adreno_drawctxt_wait(struct adreno_device *adreno_dev,		struct kgsl_context *context,		uint32_t timestamp, unsigned int timeout){	static unsigned int io_cnt;	struct kgsl_device *device = &adreno_dev->dev;	struct kgsl_pwrctrl *pwr = &device->pwrctrl;	struct adreno_context *drawctxt = ADRENO_CONTEXT(context);	int ret, io;	if (kgsl_context_detached(context))		return -EINVAL;	if (drawctxt->state == ADRENO_CONTEXT_STATE_INVALID)		return -EDEADLK;	/* Needs to hold the device mutex */	BUG_ON(!mutex_is_locked(&device->mutex));	trace_adreno_drawctxt_wait_start(context->id, timestamp);	ret = kgsl_add_event(device, &context->events, timestamp,		wait_callback, (void *) drawctxt);	if (ret)		goto done;	/*	 * For proper power accounting sometimes we need to call	 * io_wait_interruptible_timeout and sometimes we need to call	 * plain old wait_interruptible_timeout. We call the regular	 * timeout N times out of 100, where N is a number specified by	 * the current power level	 */	io_cnt = (io_cnt + 1) % 100;	io = (io_cnt < pwr->pwrlevels[pwr->active_pwrlevel].io_fraction)		? 0 : 1;	kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);	if (timeout) {		long ret_temp;		ret_temp = adreno_wait_event_interruptible_timeout(			drawctxt->waiting,			_check_context_timestamp(device, drawctxt, timestamp),			msecs_to_jiffies(timeout), io);		if (ret_temp == 0)			ret = -ETIMEDOUT;		else if (ret_temp > 0)			ret = 0;		else			ret = (int) ret_temp;	} else {		ret = (int) adreno_wait_event_interruptible(drawctxt->waiting,			_check_context_timestamp(device, drawctxt, timestamp),				io);	}	kgsl_mutex_lock(&device->mutex, &device->mutex_owner);	/* -EDEADLK if the context was invalidated while we were waiting */	if (drawctxt->state == ADRENO_CONTEXT_STATE_INVALID)		ret = -EDEADLK;	/* Return -EINVAL if the context was detached while we were waiting */	if (kgsl_context_detached(context))		ret = -EINVAL;done:	trace_adreno_drawctxt_wait_done(context->id, timestamp, ret);	return ret;}

/** * adreno_drawctxt_detach(): detach a context from the GPU * @context: Generic KGSL context container for the context * */int adreno_drawctxt_detach(struct kgsl_context *context){	struct kgsl_device *device;	struct adreno_device *adreno_dev;	struct adreno_context *drawctxt;	int ret;	if (context == NULL)		return 0;	device = context->device;	adreno_dev = ADRENO_DEVICE(device);	drawctxt = ADRENO_CONTEXT(context);	/* deactivate context */	if (adreno_dev->drawctxt_active == drawctxt)		adreno_drawctxt_switch(adreno_dev, NULL, 0);	mutex_lock(&drawctxt->mutex);	while (drawctxt->cmdqueue_head != drawctxt->cmdqueue_tail) {		struct kgsl_cmdbatch *cmdbatch =			drawctxt->cmdqueue[drawctxt->cmdqueue_head];		drawctxt->cmdqueue_head = (drawctxt->cmdqueue_head + 1) %			ADRENO_CONTEXT_CMDQUEUE_SIZE;		mutex_unlock(&drawctxt->mutex);		/*		 * Don't hold the drawctxt mutex while the cmdbatch is being		 * destroyed because the cmdbatch destroy takes the device		 * mutex and the world falls in on itself		 */		kgsl_cmdbatch_destroy(cmdbatch);		mutex_lock(&drawctxt->mutex);	}	mutex_unlock(&drawctxt->mutex);	/*	 * internal_timestamp is set in adreno_ringbuffer_addcmds,	 * which holds the device mutex. The entire context destroy	 * process requires the device mutex as well. But lets	 * make sure we notice if the locking changes.	 */	BUG_ON(!mutex_is_locked(&device->mutex));	/* Wait for the last global timestamp to pass before continuing */	ret = adreno_drawctxt_wait_global(adreno_dev, context,		drawctxt->internal_timestamp, 10 * 1000);	/*	 * If the wait for global fails then nothing after this point is likely	 * to work very well - BUG_ON() so we can take advantage of the debug	 * tools to figure out what the h - e - double hockey sticks happened	 */	BUG_ON(ret);	kgsl_sharedmem_writel(device, &device->memstore,			KGSL_MEMSTORE_OFFSET(context->id, soptimestamp),			drawctxt->timestamp);	kgsl_sharedmem_writel(device, &device->memstore,			KGSL_MEMSTORE_OFFSET(context->id, eoptimestamp),			drawctxt->timestamp);	adreno_profile_process_results(device);	/* wake threads waiting to submit commands from this context */	wake_up_all(&drawctxt->waiting);	wake_up_all(&drawctxt->wq);	return ret;}

/** * adreno_drawctxt_sched() - Schedule a previously blocked context * @device: pointer to a KGSL device * @drawctxt: drawctxt to rechedule * * This function is called by the core when it knows that a previously blocked * context has been unblocked.  The default adreno response is to reschedule the * context on the dispatcher */void adreno_drawctxt_sched(struct kgsl_device *device,		struct kgsl_context *context){	adreno_dispatcher_queue_context(device, ADRENO_CONTEXT(context));}

int adreno_drawctxt_detach(struct kgsl_context *context){	struct kgsl_device *device;	struct adreno_device *adreno_dev;	struct adreno_context *drawctxt;	int ret;	if (context == NULL)		return 0;	device = context->device;	adreno_dev = ADRENO_DEVICE(device);	drawctxt = ADRENO_CONTEXT(context);		if (adreno_dev->drawctxt_active == drawctxt)		adreno_drawctxt_switch(adreno_dev, NULL, 0);	mutex_lock(&drawctxt->mutex);	while (drawctxt->cmdqueue_head != drawctxt->cmdqueue_tail) {		struct kgsl_cmdbatch *cmdbatch =			drawctxt->cmdqueue[drawctxt->cmdqueue_head];		drawctxt->cmdqueue_head = (drawctxt->cmdqueue_head + 1) %			ADRENO_CONTEXT_CMDQUEUE_SIZE;		mutex_unlock(&drawctxt->mutex);		kgsl_cmdbatch_destroy(cmdbatch);		mutex_lock(&drawctxt->mutex);	}	mutex_unlock(&drawctxt->mutex);	BUG_ON(!mutex_is_locked(&device->mutex));		ret = adreno_drawctxt_wait_global(adreno_dev, context,		drawctxt->internal_timestamp, 10 * 1000);	BUG_ON(ret);	kgsl_sharedmem_writel(device, &device->memstore,			KGSL_MEMSTORE_OFFSET(context->id, soptimestamp),			drawctxt->timestamp);	kgsl_sharedmem_writel(device, &device->memstore,			KGSL_MEMSTORE_OFFSET(context->id, eoptimestamp),			drawctxt->timestamp);	adreno_profile_process_results(device);	if (drawctxt->ops && drawctxt->ops->detach)		drawctxt->ops->detach(drawctxt);		wake_up_all(&drawctxt->waiting);	wake_up_all(&drawctxt->wq);	return ret;}

/** * adreno_drawctxt_dump() - dump information about a draw context * @device: KGSL device that owns the context * @context: KGSL context to dump information about * * Dump specific information about the context to the kernel log.  Used for * fence timeout callbacks */void adreno_drawctxt_dump(struct kgsl_device *device,		struct kgsl_context *context){	unsigned int queue, start, retire;	struct adreno_context *drawctxt = ADRENO_CONTEXT(context);	int index, pos;	char buf[120];	kgsl_readtimestamp(device, context, KGSL_TIMESTAMP_QUEUED, &queue);	kgsl_readtimestamp(device, context, KGSL_TIMESTAMP_CONSUMED, &start);	kgsl_readtimestamp(device, context, KGSL_TIMESTAMP_RETIRED, &retire);	spin_lock(&drawctxt->lock);	dev_err(device->dev,		"  context[%d]: queue=%d, submit=%d, start=%d, retire=%d/n",		context->id, queue, drawctxt->submitted_timestamp,		start, retire);	if (drawctxt->cmdqueue_head != drawctxt->cmdqueue_tail) {		struct kgsl_cmdbatch *cmdbatch =			drawctxt->cmdqueue[drawctxt->cmdqueue_head];		if (test_bit(CMDBATCH_FLAG_FENCE_LOG, &cmdbatch->priv)) {			dev_err(device->dev,				"  possible deadlock. Context %d might be blocked for itself/n",				context->id);			goto stats;		}		/*		 * We may have cmdbatch timer running, which also uses same		 * lock, take a lock with software interrupt disabled (bh)		 * to avoid spin lock recursion.		 */		spin_lock_bh(&cmdbatch->lock);		if (!list_empty(&cmdbatch->synclist)) {			dev_err(device->dev,				"  context[%d] (ts=%d) Active sync points:/n",				context->id, cmdbatch->timestamp);			kgsl_dump_syncpoints(device, cmdbatch);		}		spin_unlock_bh(&cmdbatch->lock);	}stats:	memset(buf, 0, sizeof(buf));	pos = 0;	for (index = 0; index < SUBMIT_RETIRE_TICKS_SIZE; index++) {		uint64_t msecs;		unsigned int usecs;		if (!drawctxt->submit_retire_ticks[index])			continue;		msecs = drawctxt->submit_retire_ticks[index] * 10;		usecs = do_div(msecs, 192);		usecs = do_div(msecs, 1000);		pos += snprintf(buf + pos, sizeof(buf) - pos, "%d.%0d ",			(unsigned int)msecs, usecs);	}	dev_err(device->dev, "  context[%d]: submit times: %s/n",		context->id, buf);	spin_unlock(&drawctxt->lock);}

/** * adreno_drawctxt_detach(): detach a context from the GPU * @context: Generic KGSL context container for the context * */int adreno_drawctxt_detach(struct kgsl_context *context){	struct kgsl_device *device;	struct adreno_device *adreno_dev;	struct adreno_context *drawctxt;	struct adreno_ringbuffer *rb;	int ret;	if (context == NULL)		return 0;	device = context->device;	adreno_dev = ADRENO_DEVICE(device);	drawctxt = ADRENO_CONTEXT(context);	rb = drawctxt->rb;	/* deactivate context */	if (rb->drawctxt_active == drawctxt)		adreno_drawctxt_switch(adreno_dev, rb, NULL, 0);	spin_lock(&drawctxt->lock);	while (drawctxt->cmdqueue_head != drawctxt->cmdqueue_tail) {		struct kgsl_cmdbatch *cmdbatch =			drawctxt->cmdqueue[drawctxt->cmdqueue_head];		drawctxt->cmdqueue_head = (drawctxt->cmdqueue_head + 1) %			ADRENO_CONTEXT_CMDQUEUE_SIZE;		spin_unlock(&drawctxt->lock);		/*		 * If the context is deteached while we are waiting for		 * the next command in GFT SKIP CMD, print the context		 * detached status here.		 */		adreno_fault_skipcmd_detached(device, drawctxt, cmdbatch);		/*		 * Don't hold the drawctxt mutex while the cmdbatch is being		 * destroyed because the cmdbatch destroy takes the device		 * mutex and the world falls in on itself		 */		kgsl_cmdbatch_destroy(cmdbatch);		spin_lock(&drawctxt->lock);	}	spin_unlock(&drawctxt->lock);	/*	 * internal_timestamp is set in adreno_ringbuffer_addcmds,	 * which holds the device mutex. The entire context destroy	 * process requires the device mutex as well. But lets	 * make sure we notice if the locking changes.	 */	BUG_ON(!mutex_is_locked(&device->mutex));	/*	 * Wait for the last global timestamp to pass before continuing.	 * The maxumum wait time is 30s, some large IB's can take longer	 * than 10s and if hang happens then the time for the context's	 * commands to retire will be greater than 10s. 30s should be sufficient	 * time to wait for the commands even if a hang happens.	 */	ret = adreno_drawctxt_wait_rb(adreno_dev, context,		drawctxt->internal_timestamp, 30 * 1000);	/*	 * If the wait for global fails due to timeout then nothing after this	 * point is likely to work very well - BUG_ON() so we can take advantage	 * of the debug tools to figure out what the h - e - double hockey	 * sticks happened. If EAGAIN error is returned then recovery will kick	 * in and there will be no more commands in the RB pipe from this	 * context which is waht we are waiting for, so ignore -EAGAIN error	 */	if (-EAGAIN == ret)		ret = 0;	BUG_ON(ret);	kgsl_sharedmem_writel(device, &device->memstore,			KGSL_MEMSTORE_OFFSET(context->id, soptimestamp),			drawctxt->timestamp);	kgsl_sharedmem_writel(device, &device->memstore,			KGSL_MEMSTORE_OFFSET(context->id, eoptimestamp),			drawctxt->timestamp);	adreno_profile_process_results(adreno_dev);	/* wake threads waiting to submit commands from this context */	wake_up_all(&drawctxt->waiting);	wake_up_all(&drawctxt->wq);	return ret;}

int adreno_drawctxt_wait(struct adreno_device *adreno_dev,		struct kgsl_context *context,		uint32_t timestamp, unsigned int timeout){	static unsigned int io_cnt;	struct kgsl_device *device = &adreno_dev->dev;	struct kgsl_pwrctrl *pwr = &device->pwrctrl;	struct adreno_context *drawctxt = ADRENO_CONTEXT(context);	int ret, io;	if (kgsl_context_detached(context))		return -EINVAL;	if (drawctxt->state == ADRENO_CONTEXT_STATE_INVALID)		return -EDEADLK;		BUG_ON(!mutex_is_locked(&device->mutex));	trace_adreno_drawctxt_wait_start(context->id, timestamp);	ret = kgsl_add_event(device, context->id, timestamp,		wait_callback, drawctxt, NULL);	if (ret)		goto done;	io_cnt = (io_cnt + 1) % 100;	io = (io_cnt < pwr->pwrlevels[pwr->active_pwrlevel].io_fraction)		? 0 : 1;	mutex_unlock(&device->mutex);	if (timeout) {		ret = (int) adreno_wait_event_interruptible_timeout(			drawctxt->waiting,			_check_context_timestamp(device, drawctxt, timestamp),			msecs_to_jiffies(timeout), io);		if (ret == 0)			ret = -ETIMEDOUT;		else if (ret > 0)			ret = 0;	} else {		ret = (int) adreno_wait_event_interruptible(drawctxt->waiting,			_check_context_timestamp(device, drawctxt, timestamp),				io);	}	mutex_lock(&device->mutex);		if (drawctxt->state == ADRENO_CONTEXT_STATE_INVALID)		ret = -EDEADLK;		if (kgsl_context_detached(context))		ret = -EINVAL;done:	trace_adreno_drawctxt_wait_done(context->id, timestamp, ret);	return ret;}