int proc_avs_0_colorformat_read(char *page, char **start, off_t off, int count,
int *eof, void *data_unused)
{
struct stmfb_info *info = stmfb_get_fbinfo_ptr();
struct stmfbio_output_configuration outputConfig;
int len = 0;
#ifdef VERY_VERBOSE
printk("%s %d\n", __FUNCTION__, count);
#endif
outputConfig.outputid = 1;
stmfb_get_output_configuration(&outputConfig, info);
if (outputConfig.hdmi_config & STMFBIO_OUTPUT_HDMI_422)
len = sprintf(page, "hdmi_422\n");
else if (outputConfig.hdmi_config & STMFBIO_OUTPUT_HDMI_YUV)
len = sprintf(page, "hdmi_yuv\n");
else
len = sprintf(page, "hdmi_rgb\n");
if (outputConfig.analogue_config & STMFBIO_OUTPUT_ANALOGUE_RGB)
len += sprintf(page + len, "rgb\n");
else if (outputConfig.analogue_config & STMFBIO_OUTPUT_ANALOGUE_CVBS)
len += sprintf(page + len, "cvbs\n");
else if (outputConfig.analogue_config & STMFBIO_OUTPUT_ANALOGUE_YC)
len += sprintf(page + len, "svideo\n");
else if (outputConfig.analogue_config & STMFBIO_OUTPUT_ANALOGUE_YPrPb)
len += sprintf(page + len, "yuv\n");
else
len += sprintf(page + len, "not defined\n");
return len;
}
int proc_hdmi_output_read (char *page, char **start, off_t off, int count, int *eof, void *data_unused)
{
int len = 0;
unsigned int disabled = 0;
struct stmfbio_output_configuration outputConfig = {0};
struct stmfb_info *info = NULL;
mutex_lock (&(ProcDeviceContext->DvbContext->Lock));
outputConfig.outputid = 1;
info = stmfb_get_fbinfo_ptr();
stmfb_get_output_configuration(&outputConfig, info);
disabled = (outputConfig.hdmi_config & STMFBIO_OUTPUT_HDMI_DISABLED)?1:0;
printk("%s - %u\n", __FUNCTION__, disabled);
switch (disabled)
{
case 0:
len = sprintf(page, "on\n");
break;
case 1:
default:
len = sprintf(page, "off\n");
break;
}
mutex_unlock (&(ProcDeviceContext->DvbContext->Lock));
return len;
}
int proc_hdmi_output_write(struct file *file, const char __user *buf,
unsigned long count, void *data)
{
char *page;
ssize_t ret = -ENOMEM;
struct stmfbio_output_configuration outputConfig = {0};
struct stmfb_info *info = NULL;
char* myString = kmalloc(count + 1, GFP_KERNEL);
printk("%s %ld - ", __FUNCTION__, count);
mutex_lock (&(ProcDeviceContext->DvbContext->Lock));
page = (char *)__get_free_page(GFP_KERNEL);
if (page)
{
ret = -EFAULT;
if (copy_from_user(page, buf, count))
goto out;
strncpy(myString, page, count);
myString[count] = '\0';
printk("%s\n", myString);
outputConfig.outputid = 1;
info = stmfb_get_fbinfo_ptr();
stmfb_get_output_configuration(&outputConfig, info);
outputConfig.caps = 0;
outputConfig.activate = STMFBIO_ACTIVATE_IMMEDIATE;
outputConfig.analogue_config = 0;
outputConfig.caps |= STMFBIO_OUTPUT_CAPS_HDMI_CONFIG;
if (!strncmp("off", myString, count))
{
outputConfig.hdmi_config |= STMFBIO_OUTPUT_HDMI_DISABLED;
}
else if (!strncmp("on", myString, count))
{
outputConfig.hdmi_config &= ~STMFBIO_OUTPUT_HDMI_DISABLED;
}
stmfb_set_output_configuration(&outputConfig, info);
/* always return count to avoid endless loop */
ret = count;
}
out:
free_page((unsigned long)page);
kfree(myString);
mutex_unlock (&(ProcDeviceContext->DvbContext->Lock));
return ret;
}
int proc_video_hdmi_colorspace_read(char *page, char **start, off_t off, int count, int *eof, void *data_unused)
{
struct stmfb_info *info = stmfb_get_fbinfo_ptr();
struct stmfbio_output_configuration outputConfig;
int len = 0;
printk("%s %d\n", __FUNCTION__, count);
outputConfig.outputid = 1;
stmfb_get_output_configuration(&outputConfig, info);
if (outputConfig.hdmi_config & STMFBIO_OUTPUT_HDMI_422)
len = sprintf(page, "hdmi_422\n");
else if (outputConfig.hdmi_config & STMFBIO_OUTPUT_HDMI_YUV)
len = sprintf(page, "hdmi_yuv\n");
else
len = sprintf(page, "hdmi_rgb\n");
return len;
}
int stmfb_ioctl(struct fb_info* fb, u_int cmd, u_long arg)
{
struct stmfb_info* i = (struct stmfb_info* )fb;
switch (cmd)
{
case STMFBIO_GET_OUTPUTSTANDARDS:
{
struct stmfbio_outputstandards standards, *user = (void *) arg;
DPRINTK("STMFBIO_GET_OUTPUTSTANDARDS\n");
if (get_user(standards.outputid, &user->outputid))
return -EFAULT;
if (standards.outputid != STMFBIO_OUTPUTID_MAIN)
return -EINVAL;
if (down_interruptible(&i->framebufferLock))
return -ERESTARTSYS;
stmfb_get_outputstandards(i, &standards);
up(&i->framebufferLock);
if (put_user (standards.all_standards, &user->all_standards))
return -EFAULT;
return 0;
}
break;
case STMFBIO_GET_OUTPUTINFO:
{
struct stmfbio_outputinfo info, *user = (void *) arg;
int ret;
DPRINTK("STMFBIO_GET_OUTPUTINFO\n");
if (get_user(info.outputid, &user->outputid))
return -EFAULT;
if (info.outputid != STMFBIO_OUTPUTID_MAIN)
return -EINVAL;
if(down_interruptible(&i->framebufferLock))
return -ERESTARTSYS;
if (!i->current_videomode_valid) {
up(&i->framebufferLock);
return -EAGAIN;
}
ret = stmfb_videomode_to_outputinfo(&i->current_videomode, &info);
up(&i->framebufferLock);
if (!ret && copy_to_user ((void *) arg, &info, sizeof (info)))
return -EFAULT;
return ret;
}
break;
case STMFBIO_SET_OUTPUTINFO:
{
struct stmfbio_outputinfo info;
struct stmfb_videomode vm;
int ret;
DPRINTK("STMFBIO_SET_OUTPUTINFO\n");
if (copy_from_user (&info, (void *) arg, sizeof (info)))
return -EFAULT;
if (info.outputid != STMFBIO_OUTPUTID_MAIN)
return -EINVAL;
if (down_interruptible (&i->framebufferLock))
return -ERESTARTSYS;
/* prevent the framebuffer kernel API from messing around w/ the
config in the future, until all apps have exited */
i->fbdev_api_suspended = 1;
ret = stmfb_outputinfo_to_videomode (i, &info, &vm);
up (&i->framebufferLock);
if (!ret) {
/*
* Re-create the VAR from the exact hardware description, this gives a
* completely clean var, which is why we have to save and restore the
* activate flags. Without this we get spurious mode changes when they
* should have been just tests.
*/
enum _stmfbio_activate activate = info.activate;
ret = stmfb_videomode_to_outputinfo (&vm, &info);
info.activate = activate;
if (!ret && ((activate & STMFBIO_ACTIVATE_MASK) == STMFBIO_ACTIVATE_IMMEDIATE))
ret = stmfb_set_videomode (info.outputid, &vm, i);
if (!ret && copy_to_user ((void *) arg, &info, sizeof (info)))
return -EFAULT;
}
return ret;
}
break;
case STMFBIO_GET_PLANEMODE:
{
struct stmfbio_planeinfo plane, *user = (void *) arg;
DPRINTK("STMFBIO_GET_PLANEMODE\n");
if (get_user (plane.layerid, &user->layerid))
return -EFAULT;
if (plane.layerid != 0)
return -EINVAL;
if (down_interruptible (&i->framebufferLock))
return -ERESTARTSYS;
if (!i->current_planeconfig_valid) {
up (&i->framebufferLock);
return -EAGAIN;
}
plane.config = i->current_planeconfig;
plane.activate = STMFBIO_ACTIVATE_IMMEDIATE;
up (&i->framebufferLock);
if (copy_to_user ((void *) arg, &plane, sizeof (plane)))
return -EFAULT;
return 0;
}
break;
case STMFBIO_SET_PLANEMODE:
{
struct stmfbio_planeinfo plane;
int ret;
DPRINTK("STMFBIO_SET_PLANEMODE\n");
if (copy_from_user (&plane, (void *) arg, sizeof (plane)))
return -EFAULT;
if (plane.layerid != 0)
return -EINVAL;
plane.config.bitdepth = stmfb_bitdepth_for_pixelformat (plane.config.format);
if(down_interruptible(&i->framebufferLock))
return -ERESTARTSYS;
ret = stmfb_verify_planeinfo (i, &plane);
up(&i->framebufferLock);
if (!ret && ((plane.activate & STMFBIO_ACTIVATE_MASK) == STMFBIO_ACTIVATE_IMMEDIATE))
ret = stmfb_set_planemode (&plane, i);
return ret;
}
break;
case STMFBIO_PAN_PLANE:
{
struct stmfbio_plane_pan pan;
int ret;
DPRINTK("STMFBIO_PAN_PLANE\n");
if (copy_from_user (&pan, (void *) arg, sizeof (pan)))
return -EFAULT;
if (pan.layerid != 0)
return -EINVAL;
if (down_interruptible (&i->framebufferLock))
return -ERESTARTSYS;
/* prevent the framebuffer kernel API from messing around w/ the
config in the future, until all apps have exited */
i->fbdev_api_suspended = 1;
ret = stmfb_set_plane_pan (&pan, i);
up (&i->framebufferLock);
return ret;
}
break;
case STMFBIO_GET_VAR_SCREENINFO_EX:
{
DPRINTK("STMFBIO_GET_VAR_SCREENINFO_EX\n");
if(down_interruptible(&i->framebufferLock))
return -ERESTARTSYS;
if(copy_to_user((void*)arg,&i->current_var_ex,sizeof(struct stmfbio_var_screeninfo_ex)))
{
up(&i->framebufferLock);
return -EFAULT;
}
up(&i->framebufferLock);
break;
}
case STMFBIO_SET_VAR_SCREENINFO_EX:
{
struct stmfbio_var_screeninfo_ex tmp;
int ret;
DPRINTK("STMFBIO_SET_VAR_SCREENINFO_EX\n");
if(copy_from_user(&tmp, (void*)arg, sizeof(tmp)))
return -EFAULT;
if(down_interruptible(&i->framebufferLock))
return -ERESTARTSYS;
/*
* If we don't have a valid videomode, change an immediate activation to
* a deferred one; the settings will take effect when the next valid video
* mode is set.
*/
if(!i->current_planeconfig_valid
&& tmp.activate == STMFBIO_ACTIVATE_IMMEDIATE)
tmp.activate = STMFBIO_ACTIVATE_ON_NEXT_CHANGE;
ret = stmfb_set_var_ex(&tmp, i);
up(&i->framebufferLock);
if(ret != 0)
{
/*
* Copy back the var to set the failed entry
*/
if(copy_to_user((void*)arg,&tmp, sizeof(tmp)))
return -EFAULT;
return ret;
}
break;
}
case STMFBIO_GET_OUTPUT_CONFIG:
{
struct stmfbio_output_configuration tmp;
int ret;
DPRINTK("STMFBIO_GET_OUTPUT_CONFIG\n");
if(copy_from_user(&tmp, (void*)arg, sizeof(tmp)))
return -EFAULT;
if(down_interruptible(&i->framebufferLock))
return -ERESTARTSYS;
ret = stmfb_get_output_configuration(&tmp,i);
up(&i->framebufferLock);
if(ret == 0)
{
if(copy_to_user((void*)arg,&tmp,sizeof(tmp)))
ret = -EFAULT;
}
return ret;
}
case STMFBIO_SET_OUTPUT_CONFIG:
{
struct stmfbio_output_configuration tmp;
int ret;
DPRINTK("STMFBIO_SET_OUTPUT_CONFIG\n");
if(copy_from_user(&tmp, (void*)arg, sizeof(tmp)))
return -EFAULT;
if(down_interruptible(&i->framebufferLock))
return -ERESTARTSYS;
ret = stmfb_set_output_configuration(&tmp, i);
up(&i->framebufferLock);
if(ret != 0)
{
/*
* Copy back the var to set the failed entry
*/
copy_to_user((void*)arg,&tmp, sizeof(tmp));
return ret;
}
break;
}
case STMFBIO_SET_PICTURE_CONFIG:
{
struct stmfbio_picture_configuration tmp;
int ret;
DPRINTK("STMFBIO_SET_PICTURE_CONFIG\n");
if(copy_from_user(&tmp, (void*)arg, sizeof(tmp)))
return -EFAULT;
if(down_interruptible(&i->framebufferLock))
return -ERESTARTSYS;
ret = stmfb_set_picture_configuration(&tmp, i);
up(&i->framebufferLock);
return ret;
}
case STMFBIO_GET_AUXMEMORY2:
{
struct stmfbio_auxmem2 auxmem;
if (copy_from_user (&auxmem, (void *) arg, sizeof (auxmem)))
return -EFAULT;
if (auxmem.index >= ARRAY_SIZE (i->AuxBase))
return -EINVAL;
auxmem.physical = i->AuxBase[auxmem.index];
auxmem.size = i->AuxSize[auxmem.index];
if (copy_to_user ((void *) arg, &auxmem, sizeof (auxmem)))
return -EFAULT;
break;
}
case STMFBIO_GET_SHARED_AREA:
{
struct stmfbio_shared shared;
shared.physical = i->ulPSharedAreaBase;
shared.size = i->ulSharedAreaSize;
if (copy_to_user ((void *) arg, &shared, sizeof (shared)))
return -EFAULT;
break;
}
case STMFBIO_BLT:
{
int ret;
if(down_interruptible(&i->framebufferLock))
return -ERESTARTSYS;
ret = stmfbio_blt(i, arg);
up(&i->framebufferLock);
if(ret<0)
{
if(signal_pending(current))
return -ERESTARTSYS;
else
return ret;
}
break;
}
case STMFBIO_SET_BLITTER_PALETTE:
return stmfbio_set_blitter_palette(i, arg);
case STMFBIO_SYNC_BLITTER:
{
int err;
if (!i->pBlitter)
return -ENODEV;
if(down_interruptible(&i->framebufferLock))
{
DPRINTK(" taking framebuffer lock interrupted\n");
return -ERESTARTSYS;
}
if((err = stm_display_blitter_sync(i->pBlitter)) != 0)
{
up(&i->framebufferLock);
if(signal_pending(current))
{
DPRINTK(" sync interrupted\n");
return -ERESTARTSYS;
}
else
{
DPRINTK(" sync error! code = %d\n",err);
return -EIO;
}
}
up(&i->framebufferLock);
break;
}
case STMFBIO_WAIT_NEXT:
{
int err;
if (!i->pBlitter)
return -ENODEV;
if(down_interruptible(&i->framebufferLock))
{
DPRINTK(" taking framebuffer lock interrupted\n");
return -ERESTARTSYS;
}
if((err = stm_display_blitter_waitnext(i->pBlitter)) != 0)
{
up(&i->framebufferLock);
if(signal_pending(current))
{
DPRINTK(" wait_next interrupted\n");
return -ERESTARTSYS;
}
else
{
DPRINTK(" wait_next error! code = %d\n",err);
return -EIO;
}
}
up(&i->framebufferLock);
break;
}
case STMFBIO_GET_BLTLOAD:
{
if (!i->pBlitter)
return -ENODEV;
return put_user (stm_display_blitter_get_bltload (i->pBlitter),
(unsigned long *) arg);
}
case STMFBIO_PRE_AUTH:
return stmfbio_pre_auth(i);
case STMFBIO_POST_AUTH:
return stmfbio_post_auth(i, arg);
case STMFBIO_WAIT_FOR_REAUTH:
return stmfbio_wait_for_reauth(i, arg);
case STMFBIO_SET_DAC_HD_POWER:
{
if(down_interruptible(&i->framebufferLock))
return -ERESTARTSYS;
stm_display_output_set_control(i->pFBMainOutput, STM_CTRL_DAC_HD_POWER, arg);
up(&i->framebufferLock);
return 0;
}
case STMFBIO_SET_DAC_HD_FILTER:
{
if(down_interruptible(&i->framebufferLock))
return -ERESTARTSYS;
stm_display_output_set_control(i->pFBMainOutput, STM_CTRL_DAC_HD_FILTER, arg);
up(&i->framebufferLock);
return 0;
}
case STMFBIO_SET_CGMS_ANALOG:
{
if(down_interruptible(&i->framebufferLock))
return -ERESTARTSYS;
stm_display_output_set_control(i->pFBMainOutput, STM_CTRL_CGMS_ANALOG, arg);
up(&i->framebufferLock);
return 0;
}
case FBIO_WAITFORVSYNC:
{
struct stmcore_display_pipeline_data *pd = *((struct stmcore_display_pipeline_data **)i->platformDevice->dev.platform_data);
DPRINTK("FBIO_WAITFORVSYNC\n");
if(down_interruptible(&i->framebufferLock))
return -ERESTARTSYS;
if(!i->current_videomode_valid)
{
up(&i->framebufferLock);
return -ENODEV;
}
up(&i->framebufferLock);
interruptible_sleep_on(&pd->display_runtime->vsync_wait_queue);
if(signal_pending(current))
return -ERESTARTSYS;
break;
}
case FBIOGET_VBLANK:
{
struct stmcore_display_pipeline_data *pd = *((struct stmcore_display_pipeline_data **)i->platformDevice->dev.platform_data);
struct fb_vblank vblank;
vblank.flags = FB_VBLANK_HAVE_COUNT;
vblank.count = atomic_read (&pd->display_runtime->vsync_count);
if (copy_to_user ((void *) arg, &vblank, sizeof (vblank)))
return -EFAULT;
break;
}
default:
{
DPRINTK(" Invalid IOCTL code 0x%08x\n",cmd);
return -ENOTTY;
}
}
return 0;
}
int proc_video_hdmi_colorspace_write(struct file *file, const char __user *buf, unsigned long count, void *data)
{
char *page;
char *myString;
ssize_t ret = -ENOMEM;
#ifdef VERY_VERBOSE
printk("%s %ld - ", __FUNCTION__, count);
#endif
page = (char *)__get_free_page(GFP_KERNEL);
if (page)
{
struct stmfb_info *info = stmfb_get_fbinfo_ptr();
struct stmfbio_output_configuration outputConfig;
int err = 0;
//int alpha = 0;
int hdmi_colour = 0;
ret = -EFAULT;
if (copy_from_user(page, buf, count))
goto out;
myString = (char *) kmalloc(count + 1, GFP_KERNEL);
strncpy(myString, page, count);
myString[count] = '\0';
#ifdef VERY_VERBOSE
printk("%s\n", myString);
#endif
//sscanf(myString, "%d", &alpha);
//0rgb 1yuv 2422
if (strncmp("hdmi_rgb", page, count - 1) == 0)
{
hdmi_colour = 0;
}
else if (strncmp("hdmi_yuv", page, count - 1) == 0)
{
hdmi_colour = 1;
}
else if (strncmp("hdmi_422", page, count - 1) == 0)
{
hdmi_colour = 2;
}
outputConfig.outputid = 1;
stmfb_get_output_configuration(&outputConfig, info);
outputConfig.caps = 0;
outputConfig.activate = 0; //STMFBIO_ACTIVATE_IMMEDIATE;
outputConfig.caps |= STMFBIO_OUTPUT_CAPS_HDMI_CONFIG;
outputConfig.hdmi_config &= ~(STMFBIO_OUTPUT_HDMI_YUV | STMFBIO_OUTPUT_HDMI_422);
switch (hdmi_colour)
{
case 1:
outputConfig.hdmi_config |= STMFBIO_OUTPUT_HDMI_YUV;
break;
case 2:
outputConfig.hdmi_config |= (STMFBIO_OUTPUT_HDMI_YUV | STMFBIO_OUTPUT_HDMI_422);
break;
default:
break;
}
err = stmfb_set_output_configuration(&outputConfig, info);
//if(ioctl(fbfd, STMFBIO_SET_OUTPUT_CONFIG, &outputConfig)<0)
//perror("setting output configuration failed");
kfree(myString);
}
ret = count;
out:
free_page((unsigned long)page);
return ret;
}
int proc_avs_0_colorformat_write(struct file *file, const char __user *buf,
unsigned long count, void *data)
{
char *page;
char *myString;
ssize_t ret = -ENOMEM;
#ifdef VERY_VERBOSE
printk("%s %ld - ", __FUNCTION__, count);
#endif
page = (char *)__get_free_page(GFP_KERNEL);
if (page)
{
struct stmfb_info *info = stmfb_get_fbinfo_ptr();
struct stmfbio_output_configuration outputConfig;
int err = 0;
int alpha = 0;
int hdmi_colour = 0;
int scart_colour = 0;
int hdmi0scart1yuv2 = 1;
ret = -EFAULT;
if (copy_from_user(page, buf, count))
goto out;
myString = (char *) kmalloc(count + 1, GFP_KERNEL);
strncpy(myString, page, count);
myString[count] = '\0';
#ifdef VERY_VERBOSE
printk("%s\n", myString);
#endif
sscanf(myString, "%d", &alpha);
//0rgb 1yuv 2422
if (strncmp("hdmi_rgb", page, count - 1) == 0)
{
hdmi_colour = 0;
hdmi0scart1yuv2 = 0;
}
else if (strncmp("hdmi_yuv", page, count - 1) == 0)
{
hdmi_colour = 1;
hdmi0scart1yuv2 = 0;
}
else if (strncmp("hdmi_422", page, count - 1) == 0)
{
hdmi_colour = 2;
hdmi0scart1yuv2 = 0;
}
else if (strncmp("rgb", page, count - 1) == 0)
{
scart_colour = SAA_MODE_RGB;
hdmi0scart1yuv2 = 1;
}
else if (strncmp("cvbs", page, count - 1) == 0)
{
scart_colour = SAA_MODE_FBAS;
hdmi0scart1yuv2 = 1;
}
else if (strncmp("svideo", page, count - 1) == 0)
{
scart_colour = SAA_MODE_SVIDEO;
hdmi0scart1yuv2 = 1;
}
else if (strncmp("yuv", page, count - 1) == 0)
{
hdmi0scart1yuv2 = 2;
}
if (hdmi0scart1yuv2 == 0)
{
outputConfig.outputid = 1;
stmfb_get_output_configuration(&outputConfig, info);
outputConfig.caps = 0;
outputConfig.activate = 0; //STMFBIO_ACTIVATE_IMMEDIATE;
outputConfig.caps |= STMFBIO_OUTPUT_CAPS_HDMI_CONFIG;
outputConfig.hdmi_config &= ~(STMFBIO_OUTPUT_HDMI_YUV | STMFBIO_OUTPUT_HDMI_422);
switch (hdmi_colour)
{
case 1:
outputConfig.hdmi_config |= STMFBIO_OUTPUT_HDMI_YUV;
break;
case 2:
outputConfig.hdmi_config |= (STMFBIO_OUTPUT_HDMI_YUV | STMFBIO_OUTPUT_HDMI_422);
break;
default:
break;
}
err = stmfb_set_output_configuration(&outputConfig, info);
}
else if (hdmi0scart1yuv2 == 1)
{
avs_command_kernel(SAAIOSMODE, (void *) scart_colour);
outputConfig.outputid = 1;
stmfb_get_output_configuration(&outputConfig, info);
outputConfig.caps = 0;
outputConfig.activate = 0; //STMFBIO_ACTIVATE_IMMEDIATE;
outputConfig.caps |= STMFBIO_OUTPUT_CAPS_ANALOGUE_CONFIG;
outputConfig.analogue_config = 0;
switch (scart_colour)
{
case SAA_MODE_RGB:
outputConfig.analogue_config |= (STMFBIO_OUTPUT_ANALOGUE_RGB | STMFBIO_OUTPUT_ANALOGUE_CVBS);
break;
case SAA_MODE_FBAS:
outputConfig.analogue_config |= STMFBIO_OUTPUT_ANALOGUE_CVBS;
break;
case SAA_MODE_SVIDEO:
outputConfig.analogue_config |= STMFBIO_OUTPUT_ANALOGUE_YC;
break;
default:
break;
}
err = stmfb_set_output_configuration(&outputConfig, info);
if (err != 0)
{
printk("SET SCART COLOR - %ld - ", count);
}
}
else
{
outputConfig.outputid = 1;
stmfb_get_output_configuration(&outputConfig, info);
outputConfig.caps = 0;
outputConfig.activate = 0; //STMFBIO_ACTIVATE_IMMEDIATE;
outputConfig.caps |= STMFBIO_OUTPUT_CAPS_ANALOGUE_CONFIG;
outputConfig.analogue_config = 0;
outputConfig.analogue_config |= STMFBIO_OUTPUT_ANALOGUE_YPrPb;
err = stmfb_set_output_configuration(&outputConfig, info);
if (err != 0)
{
printk("SET SCART COLOR - %ld - ", count);
}
}
//if(ioctl(fbfd, STMFBIO_SET_OUTPUT_CONFIG, &outputConfig)<0)
//perror("setting output configuration failed");
kfree(myString);
}
ret = count;
out:
free_page((unsigned long)page);
return ret;
}
int proc_avs_0_input_write(struct file *file, const char __user *buf,
unsigned long count, void *data)
{
char *page;
char *myString;
ssize_t ret = -ENOMEM;
/* int result; */
#if defined(ADB_BOX)
struct stmfbio_output_configuration outputConfig;
struct stmfb_info *info = stmfb_get_fbinfo_ptr();
int err;
outputConfig.outputid = 1;
stmfb_get_output_configuration(&outputConfig, info);
outputConfig.caps = 0;
outputConfig.activate = 0;//STMFBIO_ACTIVATE_IMMEDIATE;
outputConfig.analogue_config = 0;
outputConfig.caps |= STMFBIO_OUTPUT_CAPS_HDMI_CONFIG;
#endif
#ifdef VERY_VERBOSE
printk("%s %ld - ", __FUNCTION__, count);
#endif
page = (char *)__get_free_page(GFP_KERNEL);
if (page)
{
ret = -EFAULT;
if (copy_from_user(page, buf, count))
goto out;
myString = (char *) kmalloc(count + 1, GFP_KERNEL);
strncpy(myString, page, count);
myString[count] = '\0';
#ifdef VERY_VERBOSE
printk("%s\n", myString);
#endif
if (!strncmp("encoder", myString, count - 1))
{
avs_command_kernel(SAAIOSSRCSEL, SAA_SRC_ENC);
// Note: Volumne is not changed directly but by using the MIXER instead of the AVS.
// So this should always be set to the maximum
#if defined(UFS910) \
|| defined(ADB_BOX)
avs_command_kernel(AVSIOSVOL, (void *) 31);
#else
avs_command_kernel(AVSIOSVOL, (void *) 0);
#endif
#if defined(ADB_BOX)
avs_command_kernel(SAAIOSWSS, (void *) SAA_WSS_43F);
outputConfig.hdmi_config &= ~STMFBIO_OUTPUT_HDMI_DISABLED;
#endif
current_input = ENCODER;
}
if (!strncmp("scart", myString, count - 1))
{
avs_command_kernel(SAAIOSSRCSEL, (void *) SAA_SRC_SCART);
avs_command_kernel(AVSIOSVOL, (void *) current_volume);
#if defined(ADB_BOX)
avs_command_kernel(SAAIOSWSS, (void *) SAA_WSS_OFF);
outputConfig.hdmi_config |= STMFBIO_OUTPUT_HDMI_DISABLED;
#endif
current_input = SCART;
}
#if defined(ADB_BOX)
err = stmfb_set_output_configuration(&outputConfig, info);
if (err != 0)
{
printk("HDMI Config Disabled - Failed !!!!!!!!!!");
}
#endif
kfree(myString);
//result = sscanf(page, "%3s %3s %3s %3s %3s", s1, s2, s3, s4, s5);
}
ret = count;
out:
free_page((unsigned long)page);
return ret;
}
