static int check_touch_env(struct pixcir_data *pixcir)
{
//int ret = 0;
int len = 96;
int Enable;
char retval[96] = {0};
char *p=NULL;
// Get u-boot parameter
if(wmt_getsyspara("wmt.io.touch", retval, &len)) return -EIO;
sscanf(retval,"%d:",&Enable);
//check touch enable
if(Enable == 0) return -ENODEV;
p = strchr(retval,':');
p++;
if(strncmp(p,"tangoc",6)) return -ENODEV;
pixcir->name = DEV_PIXCIR;
pixcir->addr = PIXCIR_ADDR;
p = strchr(p,':');
p++;
sscanf(p,"%d:%d:%d:%d:%d:%d",
&pixcir->xresl, &pixcir->yresl,&pixcir->igp_idx,&pixcir->igp_bit,&pixcir->rgp_idx, &pixcir->rgp_bit);
pixcir->irq = IRQ_GPIO;
printk("%s reslx=%d, resly=%d, Interrupt GP%d, bit%d, Reset GP%d, bit%d\n", pixcir->name,
pixcir->xresl, pixcir->yresl, pixcir->igp_idx,pixcir->igp_bit,pixcir->rgp_idx,pixcir->rgp_bit);
pixcir->swap = 1;
#if 0
memset(retval,0x00,sizeof(retval));
if(wmt_getsyspara("wmt.io.tangoc", retval, &len)){
pixcir->swap = 1;
}else{
sscanf(p,"%d:%d:%d",&pixcir->swap,&pixcir->xch, &pixcir->ych);
}
memset(retval,0x00,sizeof(retval));
ret = wmt_getsyspara("wmt.io.tskey", retval, &len);
if(!ret){
sscanf(retval,"%d:", &pixcir->nkeys);
p = strchr(retval,':');
p++;
for(i=0; i < pixcir->nkeys; i++ ){
sscanf(p,"%d:%d", &pixcir->tkey.ypos[i].y_lower, &pixcir->tkey.ypos[i].y_upper);
p = strchr(p,':');
p++;
p = strchr(p,':');
p++;
}
sscanf(p,"%d:%d:%d", &pixcir->tkey.axis, &pixcir->tkey.x_lower, &pixcir->tkey.x_upper);
pixcir->tskey_used = 1;
}
#endif
return 0;
}
static int vt1603_bat_uboot_env_check(struct vt1603_bat_drvdata *bat_drv)
{
int ret = 0;
int len = 96;
char buf[96] = { 0 };
ret = wmt_getsyspara("wmt.io.bat", buf, &len);
if(ret ||strncmp(buf,"3",1)){
dbg_err(" VT1603A/VT1609 Battery Disabled.\n");
return -EIO;
}
len = sizeof(buf);
memset(buf, 0, sizeof(buf));
ret = wmt_getsyspara("wmt.audio.i2s", buf, &len);
if(ret ||strncmp(buf,"vt1603",6)){
dbg_err("Vt1603 battery invalid, for VT1603 codec disabled.\n");
return -EINVAL;
}
bat_drv->tch_enabled = 0;
len = sizeof(buf);
memset(buf, 0, sizeof(buf));
ret = wmt_getsyspara("wmt.io.touch", buf, &len);
if(!strncmp(buf,"1:vt1603",8) ||!strncmp(buf,"1:vt1609",8) )
bat_drv->tch_enabled = 1;
return 0;
}
int cs8556_init(struct vout_s *vo)
{
char buf[100];
int varlen = 100;
cs8556_not_ready = 1;
if(cs8556_isEnable())
{
cs8556_reinitialize_table();
cs8556_not_ready = 0;
DPRINT("[CS8556] DVI ext device\n");
if( wmt_getsyspara("apc.model",buf,&varlen) != 0){
setenv("apc.model", "Rock");
saveenv();
}
return 0;
} else {
DPRINT("[CS8556] not exist\n");
if( wmt_getsyspara("apc.model",buf,&varlen) != 0){
setenv("apc.model", "Paper");
saveenv();
}
return -1;
}
}
static int parse_backlight_param(void)
{
static char env[] = "wmt.backlight.param";
struct platform_pwm_backlight_data *pdata = &wm8880_pwmbl_data;
uint8_t buf[64];
size_t l = sizeof(buf);
int pwm_freq = DFT_PWM0_FREQ;
int rc;
if (wmt_getsyspara(env, buf, &l)) {
pr_err("please set %s\n", env);
return -EINVAL;
}
/* wmt.backlight.param
* <pwmid>:<invert>:<gpio>:<active>:
* <lth_brightness>:<hth_brightness>:<pwm0freq>:<dft_brightness>
*/
rc = sscanf(buf, "%d:%d:%d:%d:%d:%d:%d:%d",
&pdata->pwm_id,
&pdata->invert,
&power.gpio, &power.active,
&pdata->lth_brightness,
&pdata->hth_brightness,
&pwm_freq,
&pdata->dft_brightness);
if ((rc < 4)) {
pr_err("bad env %s %s\n", env, buf);
return -EINVAL;
}
if ((pdata->hth_brightness > pdata->max_brightness) ||
(pdata->lth_brightness > pdata->hth_brightness))
pdata->hth_brightness = pdata->max_brightness;
pdata->pwm_period_ns = KHZ2PICOS(pwm_freq * 1000);
pr_info("backlight param: pwm%d(%dkHz), invert %d, brightness %d(%d~%d) ",
pdata->pwm_id, pwm_freq, pdata->invert, pdata->dft_brightness,
pdata->lth_brightness, pdata->hth_brightness);
if (gpio_is_valid(power.gpio)) {
if (gpio_request(power.gpio, "pwm_bl switch")) {
pr_warning("gpio request %d failed\n", power.gpio);
power.gpio = -1;
}
pr_info("gpio%d (active %d)\n", power.gpio, power.active);
} else
pr_info("no gpio control\n");
/* parse wmt.backlight.delay */
l = sizeof(buf);
if (wmt_getsyspara("wmt.backlight.delay", buf, &l) == 0) {
sscanf(buf, "%d", &backlight_delay);
}
pr_info("backlight delay: %dms\n", backlight_delay);
return 0;
}
static int wmt_pdm_probe(struct platform_device *pdev)
{
int ret = 0;
char buf[64];
int varlen = 64;
ret = wmt_getsyspara("wmt.audio.pdm", buf, &varlen);
if (ret == 0) {
sscanf(buf, "%d", &wmt_pdm_module_enable);
}
ret = wmt_pdm_init();
if (ret) {
pr_err("Failed to init pcm module: %d\n", ret);
return ret;
}
/* register with the ASoC layers */
ret = snd_soc_register_dai(&pdev->dev, &wmt_pdm_dai);
if (ret) {
pr_err("Failed to register DAI: %d\n", ret);
return ret;
}
wmt_pdm_data[0].dma_cfg = dma_device_cfg_table[PCM_TX_DMA_REQ];
wmt_pdm_data[1].dma_cfg = dma_device_cfg_table[PCM_RX_DMA_REQ];
spin_lock_init(&wmt_pdm_data[0].dma_lock);
spin_lock_init(&wmt_pdm_data[1].dma_lock);
return 0;
}
static int __init wmt_cpuidle_check_env(void)
{
int ret = 0;
int varlen = 128;
unsigned int drv_en = 0;
unsigned char buf[128] = {0};
/* uboot env name is: wmt.cpuidle.param/wmt.dvfs.param */
ret = wmt_getsyspara("wmt.cpuidle.param", buf, &varlen);
if (ret) {
printk(KERN_INFO "Can not find uboot env wmt.cpuidle.param\n");
ret = -ENODATA;
goto out;
}
id_dbg("wmt.cpuidle.param:%s\n", buf);
sscanf(buf, "%d", &drv_en);
if (!drv_en) {
printk(KERN_INFO "wmt cpuidle driver disaled\n");
ret = -ENODEV;
goto out;
}
out:
return ret;
}
static void parse_arg(void)
{
int retval;
unsigned char buf[80];
unsigned char tmp_buf[80];
int varlen = 80;
char *varname = "wmt.bc.param";
int i = 0;
int j = 0;
retval = wmt_getsyspara(varname, buf, &varlen);
if (retval == 0) {
for (i = 0; i < 80; ++i) {
if (buf[i] == ':')
break;
g_battery_charging_en = (buf[i] - '0' == 1)?1:0;
if (g_battery_charging_en == 0)/*disable*/
return;
}
++i;
for (; i < 80; ++i) {
if (buf[i] == ':')
break;
tmp_buf[j] = buf[i];
++j;
}
if (!strncmp(tmp_buf,"smb358",6))
g_battery_charging_en = 1;
else
g_battery_charging_en = 0;
++i;
g_i2cbus_id = buf[i] - '0';
} else
g_battery_charging_en = 0;
}
static int __init vt1603_bat_uboot_env_check(void)
{
int len = 128;
char buf[128] = { 0 };
int ret = 0;
int bat_op = 0;
int bat_update_interval = 0;
/* TODO uboot env should be like
* 2:1000:b78:972:b29:b11:afe:aca:aab:a94:a80:a64:a40:a1b:972 */
ret = wmt_getsyspara("wmt.io.bat", buf, &len);
if (ret) {
bat_dbg("can not find parameter: wmt.io.bat\n");
ret = -ENODATA;
goto out;
}
bat_dbg("%s", buf);
sscanf(buf,"%x:%x", &bat_op, &bat_update_interval);
bat_dbg("bat_op:%d, bat_update_interval:%d\n", bat_op, bat_update_interval);
if (bat_op != 2) {
bat_dbg("VT1603 Battery disabled now\n");
ret = -ENODEV;
goto out;
}
/* battery update interval 1sec ~ 30sec */
if ((bat_update_interval > 1000) && (bat_update_interval < 30000))
vt1603_bat_pdata.interval = bat_update_interval;
out:
return ret;
}
static int __init wmt_ebm_init(void)
{
int ret;
unsigned char buf[80];
int varlen = 80;
int param_num = 0;
char *varname = "wmt.ebm.param";
ret = wmt_getsyspara(varname, buf, &varlen);
if (ret == 0) {
param_num = sscanf(buf, "%d:%x:%x", &ebm_enable, &firmware_base_addr, &firmware_len);
if (param_num != 3) {
printk("EBM: parameter's format incorrect\n");
return 0;
}
if (ebm_enable == 0) {
printk("EBM disable\n");
return 0;
}
} else
return 0;
ret = platform_device_register(&wmt_ebm_device);
if (ret)
printk("wmt-ebm:register device failed\n");
return platform_driver_register(&ebm_platform_driver);
}
void pwm_get_env(void)
{
unsigned char buf[100];
int varlen = 100;
g_pwm_invert = 0;
if( wmt_getsyspara(ENV_DISPLAY_PWM,buf,&varlen) == 0) {
//printk(" pwm_get_env : %s = %s \n",ENV_DISPLAY_PWM,buf);
sscanf(buf,"%d",&g_pwm_invert);
g_pwm_invert = g_pwm_invert >> 4;
}
static int __init wifi_proc_init(void)
{
int retval = 0;
int varlen = 127;
char buf[200]={0};
Our_Proc_File = create_proc_entry(procfs_name, 0644, NULL);
if (Our_Proc_File == NULL) {
remove_proc_entry(procfs_name, NULL);
printk(KERN_ALERT "Error: Could not initialize /proc/%s\n",
procfs_name);
return -ENOMEM;
}
/*
* wmt.gpo.printer format as follows:
* power_on:lid_stat
* for example: setenv wmt.gpo.printer 153:3
* gpio8 for power on; gpio9 for lid status
*/
retval = wmt_getsyspara("wmt.gpo.printer", buf, &varlen);
if(!retval)
{
sscanf(buf, "%d:%d",&power_on,&lid_stat);
printk("power_on:%d,lid_stat:%d\n", power_on,lid_stat);
//request gpio for printer power control
retval = gpio_request(power_on, "printer power pin");
if(retval < 0) {
printk("reques gpio:%x failed!!! for printer power pin\n",power_on);
return -1;
}else{
printk("request gpio:%d for printer power pin success!!!\n", power_on);
}
//request gpio for printer lid status
retval = gpio_request(lid_stat, "printer lid status");
if(retval < 0) {
printk("reques gpio:%x failed!!! for printer lid status\n",lid_stat);
return -1;
}else{
printk("request gpio:%d for printer lid status success!!!\n", lid_stat);
}
}else{
printk("have not set wmt.gpo.printer");
}
Our_Proc_File->read_proc = procfile_read;
Our_Proc_File->write_proc = procfile_write;
Our_Proc_File->mode = S_IFREG | S_IRUGO;
Our_Proc_File->uid = 0;
Our_Proc_File->gid = 0;
Our_Proc_File->size = 37;
return 0; /* everything is ok */
}
static int __init kpad_init(void)
{
int ret;
int retval;
unsigned char buf[80];
int varlen = 80;
char *varname = "wmt.io.keypad";
int timeout_value;
DPRINTK(KERN_ALERT "Start\n");
/*read back&menu button integration enable >1 enable & the value is the timeout value*/
/*read keypad enable*/
retval = wmt_getsyspara(varname, buf, &varlen);
if (retval == 0) {
sscanf(buf,"%d:%d", &enable_keypad, &timeout_value);
printk(KERN_ALERT "wmt.io.keypad = %d:%d\n",enable_keypad,timeout_value);
if (enable_keypad <= 0)
return -ENODEV;
if (timeout_value >= 0) {
back_menu_timeout = timeout_value;
}
printk(KERN_ALERT "back_menu_timeout = %d \n",back_menu_timeout);
} else {
printk("##Warning: \"wmt.io.keypad\" not find\n");
printk(KERN_ALERT "Default wmt.io.keypad = %d:%d\n",enable_keypad,back_menu_timeout);
}
#ifdef CONFIG_CPU_FREQ
ret = cpufreq_register_notifier(&kpad_clock_nblock, \
CPUFREQ_TRANSITION_NOTIFIER);
if (ret) {
printk(KERN_ERR "Unable to register CPU frequency " \
"change notifier (%d)\n", ret);
}
#endif
ret = platform_device_register(&wmt_kpad_device);
if (ret != 0) {
DPRINTK("End1 ret = %x\n",ret);
return -ENODEV;
}
ret = platform_driver_register(&wmt_kpad_driver);
DPRINTK("End2 ret = %x\n",ret);
return ret;
}
static int __init hwdac_modinit(void)
{
char buf[80];
int varlen = 80;
int ret = 0;
char codec_name[5];
ret = wmt_getsyspara("wmt.audio.i2s", buf, &varlen);
if (ret == 0) {
sscanf(buf, "%5s", codec_name);
if (strcmp(codec_name, "hwdac")) {
info("hwdac string not found");
return -EINVAL;
}
}
return snd_soc_register_dai(&hwdac_dai);
}
static int get_vibratorset(void* param)
{
char buf[128];
unsigned int ubootval[6];
int ret = 0;
int varlen = 127;
/* read the paraqm from */
memset(buf ,0, sizeof(buf));
memset(ubootval, 0, sizeof(ubootval));
if (wmt_getsyspara("wmt.gpo.vibrator", buf, &varlen)) {
printk(KERN_WARNING "wmt.gpo.vibrator isn't set in u-boot env! -> Use default\n");
return -1;
}
ret = sscanf(buf, "%x:%x:%x:%x:%x:%x",
&ubootval[0],
&ubootval[1],
&ubootval[2],
&ubootval[3],
&ubootval[4],
&ubootval[5]);
if (ret != 6) {
printk(KERN_ERR "wmt.gpo.vibrator format is incorrect in u-boot\n");
return -2;
}
vibrate_dbg("wmt.gpo.vibrator = %x:%x:%x:%x:%x:%x\n",
ubootval[0],
ubootval[1],
ubootval[2],
ubootval[3],
ubootval[4],
ubootval[5]);
l_vibratedev.name = ubootval[0];
l_vibratedev.active = ubootval[1];
l_vibratedev.bmp = ubootval[2];
l_vibratedev.ctraddr = ubootval[3] + WMT_MMAP_OFFSET;
l_vibratedev.ocaddr = ubootval[4] + WMT_MMAP_OFFSET;
l_vibratedev.odaddr = ubootval[5] + WMT_MMAP_OFFSET;
return 0;
}
static int __init wmt_hwdac_platform_init(void)
{
char buf[80];
int varlen = 80;
char codec_name[5];
int ret = 0;
DBG_DETAIL();
ret = wmt_getsyspara("wmt.audio.i2s", buf, &varlen);
if (ret == 0) {
sscanf(buf, "%5s", codec_name);
if (strcmp(codec_name, "hwdac")) {
info("hwdac string not found");
return -EINVAL;
}
}
return platform_driver_register(&wmt_hwdac_driver);
}
union cs8556_TvEncoderParam getcs8556_TvEncoderParam(void)
{
char buf[100] = { 0 };
int varlen = sizeof(buf);
union cs8556_TvEncoderParam param;
if( wmt_getsyspara("wmt.display.tvencoder.param",buf,&varlen) == 0)
{
DBG_DETAIL("wmt.display.tvencoder.param: %s\n", buf);
vpp_parse_param(buf,(unsigned int *)param.buf,sizeof(union cs8556_TvEncoderParam)/sizeof(int),0);
DBG_DETAIL("%d:%d:%d:%d\n", param.use_pal, param.uboot_use_source_720p, param.kernel_use_source_720p, param.use_progressive_edid_table);
}
else
{
DBG_DETAIL("wmt.display.tvencoder not exist, use default setting\n");
// set default values
param.use_pal = 1;
param.uboot_use_source_720p = 1;
param.kernel_use_source_720p = 0;
param.use_progressive_edid_table = 1;
}
return param;
}
static int __init wmt_check_secure_env(void)
{
int ret = 0;
int varlen = 128;
unsigned int sec_en = 0;
unsigned char buf[128] = {0};
/* uboot env name is: wmt.secure.param */
ret = wmt_getsyspara("wmt.secure.param", buf, &varlen);
if (ret) {
ret = -ENODATA;
goto out;
}
sscanf(buf, "%d", &sec_en);
if (sec_en != 1) {
printk(KERN_INFO "wmt security extension disaled\n");
ret = -ENODEV;
goto out;
}
out:
return ret;
}
static int get_mali_param(struct mali_param_s *param)
{
unsigned char buf[32];
int varlen = 32;
/* wmt.mali.param 1:-1:-1:-1 */
if (wmt_getsyspara("wmt.mali.param", buf, &varlen) == 0) {
sscanf(buf, "%d:%d:%d:%d", ¶m->enabled,
¶m->buflen1, ¶m->buflen2, ¶m->buflen3);
} else {
param->enabled = 1;
param->buflen1 = -1; /* auto */
param->buflen2 = -1; /* auto */
param->buflen3 = -1; /* auto */
}
printk(KERN_INFO "wmt.mali.param = %d:%d:%d:%d\n", param->enabled,
param->buflen1, param->buflen2, param->buflen3);
if (param->enabled) {
/* MBytes -> Bytes */
if (param->buflen1 > 0)
param->buflen1 <<= 20;
if (param->buflen2 > 0)
param->buflen2 <<= 20;
if (param->buflen3 > 0)
param->buflen3 <<= 20;
} else {
param->buflen1 = 0;
param->buflen2 = 0;
param->buflen3 = 0;
}
return 0;
}
static int __init wmt_cec_init(void)
{
int ret;
char buf[100];
int varlen = 100;
unsigned int cec_enable = 0;
if( wmt_getsyspara("wmt.display.cec",buf,&varlen) == 0){
vpp_parse_param(buf,&cec_enable,1,0);
}
if( cec_enable == 0 )
return 0;
DBGMSG(KERN_ALERT "Enter wmt_cec_init\n");
ret = platform_driver_register(&wmt_cec_driver);
if (!ret) {
ret = platform_device_register(&wmt_cec_device);
if (ret)
platform_driver_unregister(&wmt_cec_driver);
}
return ret;
}
static int parse_pmic_param(void)
{
int retval;
unsigned char buf[par_len];
unsigned char tmp_buf[par_len];
int varlen = par_len;
int i = 0;
int j = 0;
int k = 0;
int t = 0;
int vol = 0;
int idx = 0;
char *varname = "wmt.pmic.param";
retval = wmt_getsyspara(varname, buf, &varlen);
if (retval != 0)
return -1;
if (buf[0] == 0) /*disable*/
return -1;
i += 2;
j = 0;
for (; i < par_len; ++i) {
if (buf[i] != ':')
tmp_buf[j] = buf[i];
else
break;
++j;
}
if (strncmp(tmp_buf, "gpio", 4))
return -1;
++i;
/*parse pin_num, map_num, up_time and down_time*/
j = sscanf((buf+i), "%d,%d,%d,%d,",
&g_pmic_param.pin_num,
&g_pmic_param.map_num,
&g_pmic_param.up_time,
&g_pmic_param.down_time);
k = 0;
for (j = i; j < par_len; ++j) {
if (buf[j] == ',')
++k;
if (k > 3) {
++j;
break;
}
}
i = j;
g_pmic_param.pmic_gpio = kzalloc(g_pmic_param.pin_num * sizeof(struct wmt_pmic_param_s), GFP_KERNEL);
g_pmic_param.voltage_map = kzalloc(g_pmic_param.map_num * sizeof(struct wmt_voltage_map), GFP_KERNEL);
for (j = 0; j < g_pmic_param.pin_num; ++j) {
k = sscanf((buf +i), "[%x:%x:%x:%x:%x:%x:%x:%x]",
&(g_pmic_param.pmic_gpio + j)->name_id,
&(g_pmic_param.pmic_gpio + j)->active,
&(g_pmic_param.pmic_gpio + j)->bitmap,
&(g_pmic_param.pmic_gpio + j)->ctraddr,
&(g_pmic_param.pmic_gpio + j)->ocaddr,
&(g_pmic_param.pmic_gpio + j)->odaddr,
&(g_pmic_param.pmic_gpio + j)->opcaddr,
&(g_pmic_param.pmic_gpio + j)->opdaddr);
g_pmic_param.pmic_gpio[j].ctraddr += WMT_MMAP_OFFSET;
g_pmic_param.pmic_gpio[j].ocaddr += WMT_MMAP_OFFSET;
g_pmic_param.pmic_gpio[j].odaddr += WMT_MMAP_OFFSET;
g_pmic_param.pmic_gpio[j].opcaddr += WMT_MMAP_OFFSET;
g_pmic_param.pmic_gpio[j].opdaddr += WMT_MMAP_OFFSET;
for (k = i; k < par_len; ++k) {
if (buf[k] == ']') {
++k;
break;
}
}
i = k;
}
++i;/*','*/
for (j = 0; j < g_pmic_param.map_num; ++j) {
k = sscanf((buf + i), "[%d,%d]",
&idx, &vol);
t = 0;
for (k = i; k < par_len; ++k) {
if (buf[k] == ']') {
++k;
break;
}
}
i = k;
(g_pmic_param.voltage_map + idx)->voltage = vol * 1000;
}
return 0;
}
