uint32_t _process( struct iothreads * parent, struct iothread * thread, struct taskqueue * doqueue )
{
uint32_t nprocess = 0;
// 交换任务队列
msgqueue_swap( thread->queue, doqueue );
// 获取最大任务数
nprocess = QUEUE_COUNT(taskqueue)(doqueue);
// 处理任务
for( ; QUEUE_COUNT(taskqueue)(doqueue) > 0; )
{
struct task task;
QUEUE_POP(taskqueue)( doqueue, &task );
// 网络任务处理
if ( task.type == eTaskType_User )
{
parent->processor( parent->context,
thread->index, task.utype, task.taskdata );
}
else if ( task.type == eTaskType_Data )
{
parent->processor( parent->context,
thread->index, task.utype, (void *)(task.data) );
}
}
return nprocess;
}
int32_t msgqueue_push( struct msgqueue * self, struct task * task, uint8_t isnotify )
{
int32_t rc = -1;
uint32_t isbc = 0;
pthread_mutex_lock( &self->lock );
rc = QUEUE_PUSH(taskqueue)(&self->queue, task);
if ( isnotify != 0 )
{
isbc = QUEUE_COUNT(taskqueue)(&self->queue);
}
pthread_mutex_unlock( &self->lock );
if ( rc == 0 && isbc == 1 )
{
char buf[1] = {0};
if ( write( self->pushfd, buf, 1 ) != 1 )
{
//
}
}
return rc;
}
uint32_t _process( struct iothreads * parent, struct iothread * thread, struct taskqueue * doqueue )
{
uint32_t nprocess = 0;
// 交换任务队列
msgqueue_swap( thread->queue, doqueue );
// 获取最大任务数
nprocess = QUEUE_COUNT(taskqueue)(doqueue);
// 处理任务
while ( QUEUE_COUNT(taskqueue)(doqueue) > 0 )
{
struct task task;
void * data = NULL;
QUEUE_POP(taskqueue)( doqueue, &task );
switch ( task.type )
{
case eTaskType_Null :
{
// 空命令
continue;
}
break;
case eTaskType_User :
{
// 用户命令
data = task.taskdata;
}
break;
case eTaskType_Data :
{
// 数据命令
data = (void *)(task.data);
}
break;
}
// 回调
parent->method( parent->context, thread->index, task.utype, data );
}
return nprocess;
}
void runloop_idle(void *globals)
{
globals_t *g = (globals_t*)globals;
if (QUEUE_COUNT(&(g->packets_to_forward)) > 0)
dequeue_packet(g);
if (!g->option.hide_captured_packets_statistics)
print_stats(g);
}
uint32_t msgqueue_count( struct msgqueue * self )
{
uint32_t rc = 0;
pthread_mutex_lock( &self->lock );
rc = QUEUE_COUNT(taskqueue)(&self->queue);
pthread_mutex_unlock( &self->lock );
return rc;
}
/**
* hp3a_update_framework- execute tasks between frames.
*
* No return value.
**/
void hp3a_update_stats_readout_done(void)
{
int i;
bool allow_exp_update = true;
bool allow_gain_update = true;
struct hp3a_internal_buffer *ibuffer;
struct hp3a_sensor_param_internal sensor_param;
if (unlikely(g_tc.v4l2_streaming == 0)) {
hp3a_disable_histogram();
hp3a_disable_af();
return;
}
/* Reuse stats buffers. */
if (g_tc.histogram_buffer != NULL) {
g_tc.hist_done = 0;
hp3a_enqueue(&g_tc.hist_stat_queue,
&g_tc.histogram_buffer);
g_tc.histogram_buffer = NULL;
}
if (g_tc.af_buffer != NULL) {
hp3a_enqueue(&g_tc.af_stat_queue,
&g_tc.af_buffer);
g_tc.af_buffer = NULL;
}
if (g_tc.raw_buffer != NULL) {
hp3a_enqueue(&g_tc.raw_frame_queue,
&g_tc.raw_buffer);
g_tc.raw_buffer = NULL;
}
/* Process ready stats. */
for (i = MAX_STAT_BUFFERS_PER_FRAME; i--;) {
ibuffer = NULL;
if (hp3a_dequeue(&g_tc.ready_stats_queue, &ibuffer) == 0) {
if (ibuffer->type == HISTOGRAM &&
g_tc.histogram_buffer == NULL)
g_tc.histogram_buffer = ibuffer;
else if (ibuffer->type == PAXEL &&
g_tc.af_buffer == NULL)
g_tc.af_buffer = ibuffer;
else if (ibuffer->type == BAYER &&
g_tc.raw_buffer == NULL)
g_tc.raw_buffer = ibuffer;
else {
printk(KERN_ERR "hp3a: Error unknown "
"buffer type(%d)\n", ibuffer->type);
}
} else {
break;
}
}
for (i = QUEUE_COUNT(g_tc.sensor_read_queue); i--;) {
if (hp3a_dequeue(&g_tc.sensor_read_queue, &sensor_param) == 0) {
if (sensor_param.frame_id == g_tc.frame_count) {
if (sensor_param.exposure == (u32)-1) {
g_tc.sensor_stats.exposure = 0;
allow_exp_update = false;
} else if (sensor_param.exposure && allow_exp_update) {
g_tc.sensor_stats.exposure = sensor_param.exposure;
}
if (sensor_param.gain == (u16)-1) {
g_tc.sensor_stats.gain = 0;
allow_gain_update = false;
} else if (sensor_param.gain && allow_gain_update) {
g_tc.sensor_stats.gain = sensor_param.gain;
}
if (sensor_param.fps) {
g_tc.sensor_stats.fps = \
sensor_param.fps;
}
} else if (sensor_param.frame_id > g_tc.frame_count) {
hp3a_enqueue(&g_tc.sensor_read_queue,
&sensor_param);
}
} else {
break;
}
}
/* Histogram buffer processing and HW configuration. */
hp3a_enable_histogram();
/* AF stat buffer processing and HW configuration. */
hp3a_enable_af();
/* Notify threads waiting for stats. */
complete(&g_tc.frame_done);
}
/**
* hp3a_set_sensor_param - Set sensor specific params.
* @param: Pointer the structure containing sensor parameters.
* @fh: Pointer to a hp3a_fh stucture.
*
* Return 0 on success, less than 0 otherwise.
**/
int hp3a_set_sensor_param(struct hp3a_sensor_param *param, struct hp3a_fh *fh)
{
int ret = -1;
struct hp3a_sensor_param_internal sensor_param = {
.exposure = 0,
.gain = 0,
.fps = 0};
unsigned long irqflags = 0;
if (likely(fh->v4l2_dev > -1)) {
if (likely(g_tc.v4l2_streaming == 1)) {
sensor_param.v4l2_dev = fh->v4l2_dev;
ret = 0;
spin_lock_irqsave(&g_tc.stats_lock, irqflags);
if (!(g_tc.sensor_stats.exposure &&
g_tc.sensor_stats.gain) &&
!QUEUE_COUNT(g_tc.sensor_write_queue)) {
memset(&g_tc.sensor_current, 0, \
sizeof(g_tc.sensor_current));
memset(&g_tc.sensor_requested, 0, \
sizeof(g_tc.sensor_requested));
}
if (param->fps &&
g_tc.sensor_requested.fps != \
param->fps) {
sensor_param.fps = param->fps;
sensor_param.exposure = param->exposure;
sensor_param.gain = param->gain;
ret = hp3a_enqueue( \
&g_tc.sensor_write_queue,
&sensor_param);
sensor_param.fps = 0;
sensor_param.exposure = 0;
sensor_param.gain = 0;
if (!ret) {
g_tc.sensor_requested.fps = \
param->fps;
g_tc.sensor_requested.exposure =
param->exposure;
g_tc.sensor_requested.gain = \
param->gain;
}
}
if (param->exposure &&
(g_tc.sensor_requested.exposure != \
param->exposure)) {
sensor_param.exposure = param->exposure;
ret = hp3a_enqueue( \
&g_tc.sensor_write_queue,
&sensor_param);
sensor_param.exposure = 0;
if (!ret) {
g_tc.sensor_requested.exposure = \
param->exposure;
}
}
if (param->gain &&
(g_tc.sensor_requested.gain != \
param->gain)) {
sensor_param.gain = param->gain;
ret = hp3a_enqueue( \
&g_tc.sensor_write_queue,
&sensor_param);
if (!ret) {
g_tc.sensor_requested.gain = \
param->gain;
}
}
spin_unlock_irqrestore(&g_tc.stats_lock, irqflags);
} else {
struct cam_sensor_settings sensor_settings = {
.flags = 0,
.exposure = 0,
.gain = 0,
.fps = 0,
.regs = 0,
.reg_data = 0};
sensor_settings.exposure = param->exposure;
sensor_settings.gain = param->gain;
sensor_settings.fps = param->fps;
sensor_settings.flags = (OMAP34XXCAM_SET_GAIN | \
OMAP34XXCAM_SET_EXPOSURE);
/**
* Write and read sensor settings.
*/
ret = omap34xxcam_sensor_settings(fh->v4l2_dev,
&sensor_settings);
}
} else {
dev_err(fh->device->dev,
"hp3a: Invalid sensor id(%d)\n",
fh->v4l2_dev);
}
return ret;
}
/**
* hp3a_set_hardpipe_param - Set hard pipe specific params to be programmed.
* @param: Pointer the structure containing hard pipe parameters.
* @fh: Pointer to a hp3a_fh stucture.
*
* Return 0 on success, less than 0 otherwise.
**/
int hp3a_set_hardpipe_param(struct hp3a_hardpipe_param *param,
struct hp3a_fh *fh)
{
unsigned long irqflags = 0;
spin_lock_irqsave(&g_tc.hardpipe_lock, irqflags);
memcpy(&g_tc.hpipe_param, param, sizeof(struct hp3a_hardpipe_param));
g_tc.update_hardpipe = 1;
spin_unlock_irqrestore(&g_tc.hardpipe_lock, irqflags);
if (g_tc.v4l2_streaming == 0)
hp3a_update_hardpipe();
return 0;
}
