static int curcial_oj_poweron(int on)
{
uint8_t data[2];
#ifdef CONFIG_MACH_BRAVO
struct vreg *oj_power = vreg_get(0, "gp2");
if (IS_ERR(oj_power)) {
pr_err("%s: Error power domain\n", __func__);
return 0;
}
if (on) {
vreg_set_level(oj_power, 2750);
vreg_enable(oj_power);
} else {
/* for microp firmware(v04) setting*/
microp_i2c_read(MICROP_I2C_RCMD_VERSION, data, 2);
if (data[0] < 4) {
printk("Microp firmware version: %d\n", data[0]);
return 1;
}
vreg_disable(oj_power);
}
pr_err("%s: OJ power enable(%d)\n", __func__, on);
#else
/* for microp firmware(v04) setting*/
if (on == 0) {
microp_i2c_read(MICROP_I2C_RCMD_VERSION, data, 2);
if (data[0] < 4) {
printk("Microp firmware version:%d\n",data[0]);
return 1;
}
}
gpio_set_value(CURCIAL_OJ_POWER, on);
if (gpio_get_value(CURCIAL_OJ_POWER) != on) {
printk(KERN_ERR "%s:OJ:power status fail \n", __func__);
return 0;
}
printk(KERN_ERR "%s:OJ:power status ok \n", __func__);
#endif
return 1;
}
/*static*/ int ts_set_vreg(unsigned char onoff) //for touch download
{
int rc = 0;
struct vreg *vreg_l1 = NULL;
vreg_l1 = vreg_get(NULL, "rfrx1");
if (IS_ERR(vreg_l1)) {
pr_err("%s: vreg_get failed (%ld)\n", __func__, PTR_ERR(vreg_l1));
return PTR_ERR(vreg_l1);
}
printk(KERN_INFO "ts_set_veg : %d\n", onoff);
if(onoff){
/* LGE_CHANGE_S: E0 [email protected] [2011-12-19]
: Changed the touchscreen operating power 3V into 3.05V*/
rc = vreg_set_level(vreg_l1, 3050);
/* LGE_CHANGE_E: E0 [email protected] [2011-12-19]
: Changed the touchscreen operating power 3V into 3.05V*/
if (rc < 0) {
pr_err("%s: vreg_set_level failed (%d)\n", __func__, rc);
goto vreg_touch_fail;
}
rc = vreg_enable(vreg_l1);
if (rc < 0) {
pr_err("%s: vreg_enable failed (%d)\n", __func__, rc);
goto vreg_touch_fail;
}
} else {
rc = vreg_disable(vreg_l1);
if (rc < 0) {
pr_err("%s: vreg_disable failed (%d)\n", __func__, rc);
goto vreg_touch_fail;
}
}
return rc;
vreg_touch_fail:
vreg_put(vreg_l1);
return rc;
}
static uint32_t htcleo_sdslot_switchvdd(struct device *dev, unsigned int vdd)
{
// We have to find the right vreg Interface on Leo
int i;
int ret = 0;
if (vdd == sdslot_vdd)
return 0;
sdslot_vdd = vdd;
printk("@@@ SD power %d @@@\n", vdd);
if (vdd == 0)
{
config_gpio_table(sdcard_off_gpio_table,ARRAY_SIZE(sdcard_off_gpio_table));
vreg_disable(sdslot_vreg);
sdslot_vreg_enabled = 0;
return 0;
}
if (!sdslot_vreg_enabled)
{
ret = vreg_enable(sdslot_vreg);
if (ret)
pr_err("%s: Error enabling vreg (%d)\n", __func__, ret);
config_gpio_table(sdcard_on_gpio_table, ARRAY_SIZE(sdcard_on_gpio_table));
sdslot_vreg_enabled = 1;
}
for (i = 0; i < ARRAY_SIZE(mmc_vdd_table); i++) {
if (mmc_vdd_table[i].mask != (1 << vdd))
continue;
ret = vreg_set_level(sdslot_vreg, mmc_vdd_table[i].level);
if (ret)
pr_err("%s: Error setting level (%d)\n", __func__, ret);
return 0;
}
pr_err("%s: Invalid VDD (%d) specified\n", __func__, vdd);
return 0;
}
static uint32_t vision_sdslot_switchvdd(struct device *dev, unsigned int vdd)
{
int i;
BUG_ON(!vreg_sdslot);
if (vdd == sdslot_vdd)
return 0;
sdslot_vdd = vdd;
if (vdd == 0) {
printk(KERN_INFO "%s: Disabling SD slot power\n", __func__);
config_gpio_table(sdcard_off_gpio_table,
ARRAY_SIZE(sdcard_off_gpio_table));
vreg_disable(vreg_sdslot);
sdslot_vreg_enabled = 0;
return 0;
}
if (!sdslot_vreg_enabled) {
mdelay(5);
vreg_enable(vreg_sdslot);
udelay(500);
config_gpio_table(sdcard_on_gpio_table,
ARRAY_SIZE(sdcard_on_gpio_table));
sdslot_vreg_enabled = 1;
}
for (i = 0; i < ARRAY_SIZE(mmc_vdd_table); i++) {
if (mmc_vdd_table[i].mask == (1 << vdd)) {
printk(KERN_INFO "%s: Setting level to %u\n",
__func__, mmc_vdd_table[i].level);
vreg_set_level(vreg_sdslot, mmc_vdd_table[i].level);
return 0;
}
}
printk(KERN_ERR "%s: Invalid VDD %d specified\n", __func__, vdd);
return 0;
}
static int __init ts_init(void)
{
u8 buf[8];
int ret,rc;
struct vreg *vreg_gp4 = NULL;
u32 x_st,y_st;
printk("[Bing]set gp4=2.6v\r\n");
vreg_gp4 = vreg_get(0, "gp4");
rc = vreg_set_level(vreg_gp4, 2600);
if (rc)
{
printk("[Bing]%s: vreg set gp4 level failed (%d)\n", __func__, rc);
}
rc = vreg_enable(vreg_gp4);
if (rc)
{
printk("[Bing]%s: vreg enable gp4 failed (%d)\n", __func__, rc);
}
ret = i2c_add_driver(&st1232_ts_driver);
ts_early.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
ts_early.suspend = st1232_early_suspend;
ts_early.resume = st1232_later_resume;
register_early_suspend(&ts_early);
printk("[Bing][%s]K4H/CAP6 project, ret = %d\r\n", __func__, ret);
//ret = gpio_request(TOUCH_GPIO,"touch_int");
//if(ret < 0)
// printk("fail to request gpio for touch_int! error = %d\n",ret);
// printk("[Bing] %s: TOUCH_GPIO = %d\n",__func__,gpio_get_value(TOUCH_GPIO) );
//gpio_direction_output(TOUCH_GPIO, 1);
printk("[Bing] %s: TOUCH_GPIO = %d\n",__func__,gpio_get_value(TOUCH_GPIO) );
ret = i2c_master_recv(st1232_ts->client, buf, 8);
y_st = ((buf[2]&0x70)<<4)|buf[3];
x_st = 289 - (((buf[2]&0x07)<<8)|buf[4]);
printk("[Bing]init x_st=%d, y_st=%d\r\n", x_st, y_st);
return ret;
}
/** accelerometer **/
int accel_power(unsigned char onoff)
{
int ret = 0;
struct vreg *usim2_vreg = vreg_get(0, "usim2");
if (onoff) {
printk(KERN_INFO "accel_power_on\n");
ret = vreg_set_level(usim2_vreg, 3000);
if (ret != 0) {
printk(KERN_INFO "[Accel] vreg_set_level failed\n");
return ret;
}
vreg_enable(usim2_vreg);
} else {
printk(KERN_INFO "accel_power_off\n");
vreg_disable(usim2_vreg);
}
return ret;
}
static uint32_t mahimahi_sdslot_switchvdd(struct device *dev, unsigned int vdd)
{
int i;
int ret;
if (vdd == sdslot_vdd)
return 0;
sdslot_vdd = vdd;
if (vdd == 0) {
config_gpio_table(sdcard_off_gpio_table,
ARRAY_SIZE(sdcard_off_gpio_table));
vreg_disable(sdslot_vreg);
sdslot_vreg_enabled = 0;
return 0;
}
if (!sdslot_vreg_enabled) {
ret = vreg_enable(sdslot_vreg);
if (ret)
pr_err("%s: Error enabling vreg (%d)\n", __func__, ret);
config_gpio_table(sdcard_on_gpio_table,
ARRAY_SIZE(sdcard_on_gpio_table));
sdslot_vreg_enabled = 1;
}
for (i = 0; i < ARRAY_SIZE(mmc_vdd_table); i++) {
if (mmc_vdd_table[i].mask != (1 << vdd))
continue;
ret = vreg_set_level(sdslot_vreg, mmc_vdd_table[i].level);
if (ret)
pr_err("%s: Error setting level (%d)\n", __func__, ret);
return 0;
}
pr_err("%s: Invalid VDD (%d) specified\n", __func__, vdd);
return 0;
}
static unsigned int ft5306_power_up(void)
{
int rc = 0;
struct vreg *vreg = NULL;
vreg = vreg_get(NULL, "gp2");
if (IS_ERR(vreg)) {
pr_err("%s: vreg get failed (%ld)\n",
__func__, PTR_ERR(vreg));
return PTR_ERR(vreg);
}
rc = vreg_set_level(vreg, 2850);
if (rc < 0) {
pr_err("%s: vreg set level failed (%d)\n",
__func__, rc);
}
rc = vreg_enable(vreg);
if (rc < 0) {
pr_err("%s: vreg enable failed (%d)\n",
__func__, rc);
}
return rc;
}
int key_led_power_control(uint8_t LED_ON_OFF)
{
struct vreg *vreg_keyled;
int ret=0;
printk(KERN_ERR "%s: key_led_power_control ON/OFF [%d]\n",__func__, LED_ON_OFF);
vreg_keyled = vreg_get(NULL, "maxldo04");
if (LED_ON_OFF == TRUE) {
ret = vreg_set_level(vreg_keyled, OUT3000mV);
ret = vreg_enable(vreg_keyled);
mod_timer(&g_led_timer, jiffies + (HZ*KEY_LED_ON_TIME));
if (ret) {
return -EIO;
}
} else {
ret = vreg_disable(vreg_keyled);
if (ret) {
return -EIO;
}
}
return ret;
}
static void htckovsky_oj_power(bool enable) {
char buffer[2];
if (enable) {
vreg_set_level(htckovsky_oj.vreg_pwr, 2800);
vreg_enable(htckovsky_oj.vreg_pwr);
vreg_enable(htckovsky_oj.vreg_28v);
buffer[0] = MICROP_OJ_POWER_KOVS;
buffer[1] = MICROP_CMD_OJ_PWR_ON;
microp_ng_write(htckovsky_oj.client, buffer, ARRAY_SIZE(buffer));
htckovsky_oj_reset();
}
else {
buffer[0] = MICROP_OJ_POWER_KOVS;
buffer[1] = MICROP_CMD_OJ_PWR_OFF;
microp_ng_write(htckovsky_oj.client, buffer, ARRAY_SIZE(buffer));
vreg_disable(htckovsky_oj.vreg_28v);
vreg_disable(htckovsky_oj.vreg_pwr);
}
}
static int ts_set_vreg(unsigned char onoff)
#endif
{
struct vreg *vreg_touch;
int rc;
// LGE_CHANGE [[email protected]] 2010-07-26, onoff stat
static int old_onoff = 0;
printk("[Touch] %s() onoff:%d\n",__FUNCTION__, onoff);
// LGE_CHANGE [[email protected]] 2010-07-26, onoff stat
if (old_onoff == onoff)
return 0;
vreg_touch = vreg_get(0, "synt");
if(IS_ERR(vreg_touch)) {
printk("[Touch] vreg_get fail : touch\n");
return -1;
}
if (onoff) {
rc = vreg_set_level(vreg_touch, 3050);
if (rc != 0) {
printk("[Touch] vreg_set_level failed\n");
return -1;
}
vreg_enable(vreg_touch);
// LGE_CHANGE [[email protected]] 2010-07-26, onoff stat
old_onoff = onoff;
} else {
vreg_disable(vreg_touch);
// LGE_CHANGE [[email protected]] 2010-07-26, onoff stat
old_onoff = onoff;
}
return 0;
}
/* proximity */
static int prox_power_set(unsigned char onoff)
{
static bool init_done = 0;
int ret = 0;
struct vreg *gp6_vreg = vreg_get(0, "gp6");
printk("[Proximity] %s() : Power %s\n",__FUNCTION__, onoff ? "On" : "Off");
if (init_done == 0 && onoff)
{
if (onoff) {
vreg_set_level(gp6_vreg, 2800);
vreg_enable(gp6_vreg);
init_done = 1;
} else {
vreg_disable(gp6_vreg);
}
}
return ret;
}
static int pp2106_vreg_set(unsigned char onoff)
{
int rc = 0;
struct vreg *vreg_l12 = NULL;
vreg_l12 = vreg_get(NULL, "gp2");
if (IS_ERR(vreg_l12)) {
pr_err("%s: vreg_get failed (%ld)\n", __func__, PTR_ERR(vreg_l12));
return PTR_ERR(vreg_l12);
}
if (onoff) {
rc = vreg_set_level(vreg_l12, 2850);
if (rc < 0) {
pr_err("%s: vreg_set_level failed (%d)\n", __func__, rc);
goto vreg_fail;
}
rc = vreg_enable(vreg_l12);
if (rc < 0) {
pr_err("%s: vreg_enable failed (%d)\n", __func__, rc);
goto vreg_fail;
}
} else {
rc = vreg_disable(vreg_l12);
if (rc < 0) {
pr_err("%s: vreg_disable failed (%d)\n", __func__, rc);
goto vreg_fail;
}
}
return rc;
vreg_fail:
vreg_put(vreg_l12);
return rc;
}
static int32_t sensor_vreg_enable
(
struct msm_camera_sensor_vreg *sensor_vreg,
uint8_t vreg_num
)
{
struct vreg *vreg_handle;
uint8_t temp_vreg_sum;
int32_t rc;
if(sensor_vreg == NULL)
{
return 0;
}
for(temp_vreg_sum = 0; temp_vreg_sum < vreg_num;temp_vreg_sum++)
{
vreg_handle = vreg_get(0, sensor_vreg[temp_vreg_sum].vreg_name);
if (!vreg_handle) {
printk(KERN_ERR "vreg_handle get failed\n");
return -EIO;
}
rc = vreg_set_level(vreg_handle, sensor_vreg[temp_vreg_sum].mv);
if (rc) {
printk(KERN_ERR "vreg_handle set level failed\n");
return -EIO;
}
rc = vreg_enable(vreg_handle);
if (rc) {
printk(KERN_ERR "vreg_handle enable failed\n");
return -EIO;
}
}
return 0;
}
static int ts_set_vreg(unsigned char onoff)
{
struct vreg *vreg_touch;
int rc;
unsigned on_off, id;
printk("[Touch] %s() onoff:%d\n",__FUNCTION__, onoff);
vreg_touch = vreg_get(0, "synt");
if(IS_ERR(vreg_touch)) {
printk("[Touch] vreg_get fail : touch\n");
return -1;
}
if (onoff) {
on_off = 0;
id = PM_VREG_PDOWN_SYNT_ID;
msm_proc_comm(PCOM_VREG_PULLDOWN, &on_off, &id);
vreg_disable(vreg_touch);
rc = vreg_set_level(vreg_touch, 3050);
if (rc != 0) {
printk("[Touch] vreg_set_level failed\n");
return -1;
}
vreg_enable(vreg_touch);
} else {
vreg_disable(vreg_touch);
on_off = 1;
id = PM_VREG_PDOWN_SYNT_ID;
msm_proc_comm(PCOM_VREG_PULLDOWN, &on_off, &id);
}
return 0;
}
/* Proximity Sensor (Capella_CM3602)*/
static int __capella_cm3602_power(int on)
{
int ret;
struct vreg *vreg = vreg_get(0, "gp1");
if (!vreg) {
printk(KERN_ERR "%s: vreg error\n", __func__);
return -EIO;
}
ret = vreg_set_level(vreg, 2800);
printk(KERN_DEBUG "%s: Turn the capella_cm3602 power %s\n",
__func__, (on) ? "on" : "off");
if (on) {
gpio_direction_output(SUPERSONIC_GPIO_PROXIMITY_EN_N, 1);
ret = vreg_enable(vreg);
if (ret < 0)
printk(KERN_ERR "%s: vreg enable failed\n", __func__);
} else {
vreg_disable(vreg);
gpio_direction_output(SUPERSONIC_GPIO_PROXIMITY_EN_N, 0);
}
return ret;
}
/* proximity */
static int apds_power_set(unsigned char enable)
{
int err = 0;
int hw_rev_num = lge_get_hw_rev();
struct vreg *vreg_power_1;
printk("### apds_power_set enable : %d\n", enable);
if(hw_rev_num < LGE_REV_11)
vreg_power_1 = vreg_get(0, VREG_PROXI_VDD_26V);
else if(hw_rev_num >= LGE_REV_11)
vreg_power_1 = vreg_get(0, VREG_PERI_26V);
if (enable) {
vreg_enable(vreg_power_1);
// LGE_UPDATE_S... [email protected] 13-Apr-2011
// Change Vreg_power value for Proximtiy Sensor Tunning.(2.6V --> 2.8V)
// [email protected] 30-JUN-2011 Change Vreg_power value for Proximtiy Sensor Tunning.(2.8V --> 3.0V)
err = vreg_set_level(vreg_power_1, 3000/*2800*/);
// LGE_UPDATE_E...
if (err != 0) {
printk("### vreg_power_1 failed.\n");
return -1;
}
printk("### adps sensor power OK\n");
}
else {
vreg_disable(vreg_power_1);
}
return err;
}
int vreg_set_level(struct vreg *vreg, unsigned mv)
{
unsigned id = vreg->id;
#if defined(CONFIG_MSM_AMSS_VERSION_WINCE)
struct msm_dex_command dex = {
.cmd = PCOM_PMIC_REG_VOLTAGE,
.has_data = 1,
.data = (1U << id) };
// This reg appears to only be used by vreg_set_level()
writel(mv, MSM_SHARED_RAM_BASE + 0xfc130);
vreg->status = msm_proc_comm_wince(&dex, 0);
#else
vreg->status = msm_proc_comm(PCOM_VREG_SET_LEVEL, &id, &mv);
#endif
if (debug_mask & VREG_DEBUG_LEVEL)
printk(KERN_DEBUG "%s: n=%s id=%u s=%d ref=%u -> %umv\n", __func__,
vreg->name, vreg->id, vreg->status, vreg->refcnt, mv);
return vreg->status;
}
#if defined(CONFIG_DEBUG_FS)
static int vreg_debug_set(void *data, u64 val)
{
struct vreg *vreg = data;
switch (val) {
case 0:
vreg_disable(vreg);
break;
case 1:
vreg_enable(vreg);
break;
default:
vreg_set_level(vreg, val);
break;
}
return 0;
}
static int vreg_debug_get(void *data, u64 *val)
{
struct vreg *vreg = data;
if (!vreg->status)
*val = 0;
else
*val = 1;
return 0;
}
static int vreg_debug_count_set(void *data, u64 val)
{
struct vreg *vreg = data;
if (val > UINT_MAX)
val = UINT_MAX;
vreg->refcnt = val;
return 0;
}
static int vreg_debug_count_get(void *data, u64 *val)
{
struct vreg *vreg = data;
*val = vreg->refcnt;
return 0;
}
DEFINE_SIMPLE_ATTRIBUTE(vreg_fops, vreg_debug_get, vreg_debug_set, "%llu\n");
DEFINE_SIMPLE_ATTRIBUTE(vreg_count_fops, vreg_debug_count_get,
vreg_debug_count_set, "%llu\n");
static int __init vreg_debug_init(void)
{
struct dentry *dent;
int n;
char name[32];
const char *refcnt_name = "_refcnt";
dent = debugfs_create_dir("vreg", 0);
if (IS_ERR(dent))
return 0;
for (n = 0; n < ARRAY_SIZE(vregs); n++) {
(void) debugfs_create_file(vregs[n].name, 0644,
dent, vregs + n, &vreg_fops);
strlcpy(name, vregs[n].name, sizeof(name));
strlcat(name, refcnt_name, sizeof(name));
(void) debugfs_create_file(name, 0644,
dent, vregs + n, &vreg_count_fops);
}
return 0;
}
device_initcall(vreg_debug_init);
static uint32_t chacha_sdslot_switchvdd(struct device *dev, unsigned int vdd)
{
int i;
BUG_ON(!vreg_sdslot);
if (vdd == sdslot_vdd)
return 0;
sdslot_vdd = vdd;
if (vdd == 0) {
printk(KERN_INFO "%s: Disabling SD slot power\n", __func__);
writel(MCI_PWR_OFF, MSM_SDC2_BASE + MMCIPOWER);
mdelay(1);
config_gpio_table(sdcard_off_gpio_table,
ARRAY_SIZE(sdcard_off_gpio_table));
vreg_disable(vreg_sdslot);
sdslot_vreg_enabled = 0;
return 0;
}
if (!sdslot_vreg_enabled) {
mdelay(5);
vreg_enable(vreg_sdslot);
}
for (i = 0; i < ARRAY_SIZE(mmc_vdd_table); i++) {
if (mmc_vdd_table[i].mask == (1 << vdd)) {
printk(KERN_INFO "%s: Setting level to %u\n",
__func__, mmc_vdd_table[i].level);
vreg_set_level(vreg_sdslot, mmc_vdd_table[i].level);
if (!sdslot_vreg_enabled)
break;
else
return 0;
}
}
/* All vdd match failed */
if (i == ARRAY_SIZE(mmc_vdd_table))
goto out;
if (!sdslot_vreg_enabled) {
u32 pwr = 0;
/* Power on MCI controller */
mdelay(5);
pwr = readl(MSM_SDC2_BASE + MMCIPOWER);
writel(pwr | MCI_PWR_UP, MSM_SDC2_BASE + MMCIPOWER);
mdelay(5);
pwr = readl(MSM_SDC2_BASE + MMCIPOWER);
writel(pwr | MCI_PWR_ON, MSM_SDC2_BASE + MMCIPOWER);
mdelay(5);
/* ..then, config GPIO */
config_gpio_table(sdcard_on_gpio_table,
ARRAY_SIZE(sdcard_on_gpio_table));
sdslot_vreg_enabled = 1;
return 0;
}
out:
printk(KERN_ERR "%s: Invalid VDD %d specified\n", __func__, vdd);
return 0;
}
static int sr130pc10_set_power(int onoff)
{
int rc = 0;
struct vreg *vreg_ldo20, *vreg_ldo11;
/* test1*/
vreg_ldo20 = vreg_get(NULL, "gp13");
if(!vreg_ldo20){
printk("[S5K4ECGX]%s: VREG L20 get failed\n", __func__);
}
if(vreg_set_level(vreg_ldo20, 1800)){
printk("[S5K4ECGX]%s: vreg_set_level failed\n", __func__);
}
vreg_ldo11 = vreg_get(NULL, "gp2");
if (!vreg_ldo11) {
printk("[S5K4ECGX]%s: VREG L11 get failed\n", __func__);
}
if (vreg_set_level(vreg_ldo11, 2800)) {
printk("[S5K4ECGX]%s: vreg_set_level failed\n", __func__);
}
/* end of test1 */
if(onoff)
{
printk("<=PCAM=> ++++++++++++++++++++++++++sr130pc10 test driver++++++++++++++++++++++++++++++++++++ \n");
gpio_tlmm_config(GPIO_CFG(CAM_RESET, 0,GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_16MA), GPIO_CFG_ENABLE); //CAM_RESET
gpio_tlmm_config(GPIO_CFG(CAM_STANDBY, 0,GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_16MA), GPIO_CFG_ENABLE); //CAM_STANDBY
gpio_tlmm_config(GPIO_CFG(CAM_EN, 0,GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_16MA), GPIO_CFG_ENABLE); //CAM_EN
gpio_tlmm_config(GPIO_CFG(CAM_VT_RST, 0,GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_16MA), GPIO_CFG_ENABLE); //CAM_VT_RST
gpio_tlmm_config(GPIO_CFG(CAM_VT_nSTBY, 0,GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_16MA), GPIO_CFG_ENABLE); //CAM_VT_nSTBY
#if 0
vreg_ldo20 = vreg_get(NULL, "gp13");
vreg_ldo11 = vreg_get(NULL, "gp2");
vreg_set_level(vreg_ldo20, 1800);
vreg_set_level(vreg_ldo11, 2800);
vreg_disable(vreg_ldo20);
vreg_disable(vreg_ldo11);
#endif
gpio_set_value(CAM_RESET, 0);
gpio_set_value(CAM_STANDBY, 0);
gpio_set_value(CAM_EN, 0);
gpio_set_value(CAM_VT_RST, 0);
gpio_set_value(CAM_VT_nSTBY, 0);
mdelay(1);
gpio_set_value(CAM_EN, 1); //CAM_EN->UP
#if 1
if (vreg_enable(vreg_ldo20)) {
printk("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!![S5K4ECGX]%s: reg_enable failed\n", __func__);
}
if (vreg_enable(vreg_ldo11)) {
printk("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!![S5K4ECGX]%s: reg_enable failed\n", __func__);
}
#else
vreg_enable(vreg_ldo20);
mdelay(1);
vreg_enable(vreg_ldo11);
#endif
gpio_set_value(CAM_VT_nSTBY, 1); //VGA_STBY UP
udelay(5);
gpio_tlmm_config(GPIO_CFG(CAM_MCLK, 1,GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_16MA), GPIO_CFG_ENABLE);
mdelay(10);
//CAM_MCLK
// msm_camio_clk_rate_set(24000000); //MCLK
// msm_camio_camif_pad_reg_reset();
gpio_set_value(CAM_VT_RST, 1); //VGA_RESET UP
mdelay(2);
printk("I2C Enable \n");
gpio_tlmm_config(GPIO_CFG(0, 2, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_16MA) , GPIO_CFG_ENABLE);
gpio_tlmm_config(GPIO_CFG(1, 2, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_16MA) , GPIO_CFG_ENABLE);
}
else
{
gpio_set_value(CAM_RESET, 0); //REST -> DOWN
gpio_set_value(CAM_STANDBY,0);
mdelay(1);
gpio_set_value(CAM_EN, 0); //CAM_EN->UP
printk("I2C Disable \n");
gpio_tlmm_config(GPIO_CFG(0, 2, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_16MA) , GPIO_CFG_DISABLE);
gpio_tlmm_config(GPIO_CFG(1, 2, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_16MA) , GPIO_CFG_DISABLE);
mdelay(7/*2*/);
gpio_set_value(CAM_VT_RST, 0); //REST -> DOWN
mdelay(2);
gpio_tlmm_config(GPIO_CFG(CAM_MCLK, 1,GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_DISABLE);
udelay(5);
gpio_set_value(CAM_VT_nSTBY, 0); //STBY -> DOWN
udelay(5);
#if 1
//Entering shutdown mode
if (vreg_disable(vreg_ldo11)) { //Power down VDDIO 1.8V and 1.3Mcore 1.8V
printk("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!![S5K4ECGX]%s: reg_disable failed\n", __func__);
}
mdelay(1);
if (vreg_disable(vreg_ldo20)) { //Power down AVDD 2.8V
printk("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!![S5K4ECGX]%s: reg_disable failed\n", __func__);
}
#else
vreg_disable(vreg_get(NULL, "gp2"));
mdelay(1);
vreg_disable(vreg_get(NULL, "gp13"));
mdelay(1);
#endif
// gpio_set_value(CAM_EN, 0); //EN -> DOWN
// mdelay(1);
}
}
/*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
Driver Description
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
static int bwpm_driver_probe( struct platform_device *pdev )
{
int pin;
int ret;
struct vreg *vreg_bt;
struct vreg *vreg_wl;
bwpm_data_t *p_priv;
int ini;
/* Port Configuration */
for (pin = 0; pin < ARRAY_SIZE(bwpm_gpio_config); pin++) {
ret = gpio_tlmm_config( bwpm_gpio_config[pin], GPIO_CFG_ENABLE );
if (ret) {
disp_err( "gpio_tlmm_config(%d)<-%#x : %d\n", pin,bwpm_gpio_config[pin], ret);
return -EIO;
}
}
/* Regurator Configuration for BT */
vreg_bt = vreg_get(NULL, "wlan");
if (IS_ERR(vreg_bt)) {
disp_err( "vreg get failed (%ld)\n", PTR_ERR(vreg_bt) );
return PTR_ERR(vreg_bt);
}
ret = vreg_set_level( vreg_bt, BWPM_VREG_L13_LEVEL );
if ( ret ) {
disp_err( "vreg set level failed (%d)\n", ret) ;
return -EIO;
}
/* Regurator Configration for wlan */
vreg_wl = vreg_get(NULL, "wlan2");
if (IS_ERR(vreg_wl)) {
disp_err( "vreg get for wlan failed (%ld)\n", PTR_ERR(vreg_wl) );
return PTR_ERR(vreg_wl);
}
ret = vreg_set_level( vreg_wl, BWPM_VREG_L19_LEVEL );
if ( ret ) {
disp_err( "vreg set level for wlan failed (%d)\n", ret) ;
return -EIO;
}
/* Initialize private data */
p_priv = kmalloc( sizeof(*p_priv) , GFP_KERNEL );
if ( p_priv == NULL ){
disp_err( "memory allocation for private data failed\n" );
return -ENOMEM;
}
p_priv->vreg_bt = vreg_bt;
p_priv->vreg_wl = vreg_wl;
platform_set_drvdata( pdev , p_priv );
/* power on reset */
bwpm_reset( &(pdev->dev) );
/* power on */
ini = BWPM_INI_FM;
if ( ini ){
bwpm_fm_on( &(pdev->dev) , 1 );
}
ini = BWPM_INI_BT;
if ( ini ){
bwpm_bluetooth_on( &(pdev->dev) , 1 );
}
ini = BWPM_INI_WL;
if ( ini ){
bwpm_wifi_on( &(pdev->dev) , 1 );
}
/* create sysfs interface */
ret = sysfs_create_group( &(pdev->dev.kobj), &bwpm_device_attributes_gourp);
if ( ret ){
disp_err( "Sysfs attribute export failed with error %d.\n" , ret );
}
return ret;
}
static int aps_12d_probe(
struct i2c_client *client, const struct i2c_device_id *id)
{
/* define and initialization the value */
int value_lsb = 0;
int value_msb = 0;
int ret;
struct aps_data *aps;
/*the aps_12d sensors ispower on*/
int i;
#ifdef CONFIG_ARCH_MSM7X30
struct vreg *vreg_gp4=NULL;
int rc;
/*delete this line,27A don't have to match the power supply*/
vreg_gp4 = vreg_get(NULL, VREG_GP4_NAME);
if (IS_ERR(vreg_gp4))
{
pr_err("%s:gp4 power init get failed\n", __func__);
}
/* set gp4 voltage as 2700mV for all */
rc = vreg_set_level(vreg_gp4,VREG_GP4_VOLTAGE_VALUE_2700);
if (rc) {
pr_err("%s: vreg_gp4 vreg_set_level failed (%d)\n", __func__, rc);
return rc;
}
rc = vreg_enable(vreg_gp4);
if (rc) {
pr_err("%s: vreg_gp4 vreg_enable failed (%d)\n", __func__, rc);
return rc;
}
#endif
mdelay(5);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
printk(KERN_ERR "aps_12d_probe: need I2C_FUNC_I2C\n");
ret = -ENODEV;
goto err_check_functionality_failed;
}
/* if querry the board is T1 or T2 turn off the proximity */
/* This modification for version A&B of U8800,only */
if((machine_is_msm7x30_u8800())&&((get_hw_sub_board_id() == HW_VER_SUB_VA) || ((get_hw_sub_board_id() == HW_VER_SUB_VB))))
{
printk(KERN_ERR "aps_12d_probe: aps is not supported in U8800 and U8800 T1 board!\n");
ret = -ENODEV;
goto err_check_functionality_failed;
}
aps = kzalloc(sizeof(*aps), GFP_KERNEL);
if (aps == NULL) {
ret = -ENOMEM;
goto err_alloc_data_failed;
}
mutex_init(&aps->mlock);
INIT_WORK(&aps->work, aps_12d_work_func);
aps->client = client;
i2c_set_clientdata(client, aps);
PROXIMITY_DEBUG(KERN_INFO "ghj aps_12d_probe send command 2\n ");
/* Command 2 register: 25mA,DC,12bit,Range1 */
/*power_down to avoid the iic read error */
aps_i2c_reg_write(aps, APS_12D_REG_CMD1, APS_12D_POWER_DOWN);
/*init the flag,because everlight's 0x06,0x07's register's value low 4 bit is 0*/
value_lsb = aps_i2c_reg_read(aps, APS_INT_HT_LSB);
value_msb = aps_i2c_reg_read(aps, APS_INT_HT_MSB);
old_lsb = value_lsb;
old_msb = value_msb;
/* debug--- stare at the value of lsb & msb */
APS_DBG("value_lsb=%d,value_msb=%d\n",value_lsb,value_msb);
/* judge the device type */
/* when 06 07 registers don't equal 0x00, we think it's a intersil hardware */
if((0x00 == value_lsb) && (0x00 == value_msb))
{
intersil_flag = EVERLIGHT;
}
else
{
intersil_flag = INTERSIL;
}
/* write reg value for the two device */
if(EVERLIGHT == intersil_flag)
{
ret = aps_i2c_reg_write(aps, APS_12D_REG_CMD2, \
(uint8_t)(APS_12D_IRDR_SEL_50MA << 6 | \
APS_12D_FREQ_SEL_DC << 4 | \
APS_12D_RES_SEL_12 << 2 | \
APS_12D_RANGE_SEL_ALS_1000));
}
else
{
/*because Power-up and Power Supply Considerations is not good enough for intersil's datasheet,so avoid it via software*/
ret = aps_i2c_reg_write(aps, APS_TEST, APS_12D_POWER_DOWN);
if (ret < 0)
{
PROXIMITY_DEBUG("APS_TEST error!\n");
}
msleep(10);
ret = aps_i2c_reg_write(aps, APS_12D_REG_CMD1, APS_12D_POWER_DOWN);
if (ret < 0)
{
PROXIMITY_DEBUG("APS_12D_POWER_DOWN error!\n");
}
msleep(10);
ret = aps_i2c_reg_write(aps, APS_12D_REG_CMD2, \
(uint8_t)(APS_12D_IRDR_SEL_INTERSIL_50MA << 4 | \
APS_FREQ_INTERSIL_DC << 6 | \
APS_ADC_12 << 2 | \
APS_INTERSIL_SCHEME_OFF| \
APS_12D_RANGE_SEL_ALS_1000));
}
err_threshold_value[1] = 50;
if (ret < 0) {
goto err_detect_failed;
}
range_index = 0;
#ifdef CONFIG_HUAWEI_HW_DEV_DCT
/* detect current device successful, set the flag as present */
set_hw_dev_flag(DEV_I2C_APS);
#endif
for(i = 0; i < TOTAL_RANGE_NUM; i++)
{
/* NOTE: do NOT use the last one */
/* get the down_range_value */
if(EVERLIGHT == intersil_flag)
{
up_range_value[i] = MAX_ADC_OUTPUT - high_threshold_value_U8661[i] - RANGE_FIX + 500;
}
else
{
up_range_value[i] = MAX_ADC_OUTPUT - high_threshold_value_U8661_I[i] - RANGE_FIX + 500;
}
}
down_range_value[0] = 0;
for(i = 1; i < TOTAL_RANGE_NUM; i++)
{
/* NOTE: do not use the first one */
/* get the down_range_value */
if(EVERLIGHT == intersil_flag)
{
down_range_value[i] = (MAX_ADC_OUTPUT - high_threshold_value_U8661[i-1] - (MAX_ADC_OUTPUT / ADJUST_GATE)) / 4 - 650;
}
else
{
down_range_value[i] = (MAX_ADC_OUTPUT - high_threshold_value_U8661_I[i-1] - (MAX_ADC_OUTPUT / ADJUST_GATE)) / 4 - 650;
}
}
/*we don't use the input device sensors again */
aps->input_dev = input_allocate_device();
if (aps->input_dev == NULL) {
ret = -ENOMEM;
PROXIMITY_DEBUG(KERN_ERR "aps_12d_probe: Failed to allocate input device\n");
goto err_input_dev_alloc_failed;
}
aps->input_dev->name = "sensors_aps";
aps->input_dev->id.bustype = BUS_I2C;
input_set_drvdata(aps->input_dev, aps);
ret = input_register_device(aps->input_dev);
if (ret) {
printk(KERN_ERR "aps_probe: Unable to register %s input device\n", aps->input_dev->name);
goto err_input_register_device_failed;
}
set_bit(EV_ABS, aps->input_dev->evbit);
input_set_abs_params(aps->input_dev, ABS_LIGHT, 0, 10240, 0, 0);
input_set_abs_params(aps->input_dev, ABS_DISTANCE, 0, 1, 0, 0);
ret = misc_register(&light_device);
if (ret) {
printk(KERN_ERR "aps_12d_probe: light_device register failed\n");
goto err_light_misc_device_register_failed;
}
ret = misc_register(&proximity_device);
if (ret) {
printk(KERN_ERR "aps_12d_probe: proximity_device register failed\n");
goto err_proximity_misc_device_register_failed;
}
if( light_device.minor != MISC_DYNAMIC_MINOR ){
light_device_minor = light_device.minor;
}
if( proximity_device.minor != MISC_DYNAMIC_MINOR ){
proximity_device_minor = proximity_device.minor ;
}
wake_lock_init(&proximity_wake_lock, WAKE_LOCK_SUSPEND, "proximity");
hrtimer_init(&aps->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
aps->timer.function = aps_timer_func;
aps_wq = create_singlethread_workqueue("aps_wq");
if (!aps_wq)
{
ret = -ENOMEM;
goto err_create_workqueue_failed;
}
this_aps_data =aps;
ret = set_sensor_input(PS, aps->input_dev->dev.kobj.name);
if (ret) {
dev_err(&client->dev, "%s set_sensor_input failed\n", __func__);
goto err_create_workqueue_failed;
}
ret = set_sensor_input(ALS, aps->input_dev->dev.kobj.name);
if (ret) {
dev_err(&client->dev, "%s set_sensor_input failed\n", __func__);
goto err_create_workqueue_failed;
}
/* delete the redundant code */
printk(KERN_INFO "aps_12d_probe: Start Proximity Sensor APS-12D\n");
set_sensors_list(L_SENSOR + P_SENSOR);
return 0;
err_create_workqueue_failed:
misc_deregister(&proximity_device);
err_proximity_misc_device_register_failed:
misc_deregister(&light_device);
err_light_misc_device_register_failed:
err_input_register_device_failed:
input_free_device(aps->input_dev);
err_input_dev_alloc_failed:
err_detect_failed:
kfree(aps);
err_alloc_data_failed:
err_check_functionality_failed:
#ifdef CONFIG_ARCH_MSM7X30
if(NULL != vreg_gp4)
{
/* can't use the flag ret here, it will change the return value of probe function */
vreg_disable(vreg_gp4);
/* delete a line */
}
#endif
return ret;
}
static int gp2a_opt_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int err = 0;
int i;
#if USE_INTERRUPT
int irq;
#endif
int config;
struct gp2a_data *gp2a;
#ifdef STM_DEBUG
printk(KERN_INFO "%s\n",__FUNCTION__);
#endif
#if defined(CONFIG_MACH_TOTORO_CTC) && (CONFIG_BOARD_REVISION >= 0x02) //twkim add proximity sensor driver to totoro_ctc
{
vreg_proximity = vreg_get(0, "ldo9"); //twkim fixed pmic set
if (IS_ERR(vreg_proximity))
{
printk("===== [PROXIMITY] proximity IS_ERR TEST =====\n");
return PTR_ERR(vreg_proximity);
}
#if defined(CONFIG_MACH_TOTORO_CTC) && (CONFIG_BOARD_REVISION >= 0x02) //twkim add proximity sensor driver to totoro_ctc
vreg_set_level(vreg_proximity, OUT2800mV); // set to 3.0V voltage twkim 12 -> 10 to set 2.85V -> 2.6v
gp2a_gpio_set(ENABLE);
#else
vreg_set_level(vreg_proximity, OUT2850mV); // set to 3.0V voltage twkim 12 -> 10 to set 2.85V
#endif
vreg_enable(vreg_proximity); // voltage
}
#else
if( board_hw_revision < 3 )
{
vreg_proximity = vreg_get(0, "ldo19");
if (IS_ERR(vreg_proximity))
{
printk("===== [PROXIMITY] proximity IS_ERR TEST =====\n");
return PTR_ERR(vreg_proximity);
}
vreg_set_level(vreg_proximity, 12); // set to 3.0V voltage
vreg_enable(vreg_proximity); // voltage
}
else
{
gpio_set_value(VIR_LED_EN, 1);
}
#endif
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
{
printk(KERN_INFO "[GP2A] i2c_check_functionality error\n");
err = -ENODEV;
goto exit;
}
if ( !i2c_check_functionality(client->adapter,I2C_FUNC_SMBUS_BYTE_DATA) ) {
printk(KERN_INFO "[GP2A] byte op is not permited.\n");
goto exit;
}
/* OK. For now, we presume we have a valid client. We now create the
client structure, even though we cannot fill it completely yet. */
if (!(gp2a = kzalloc(sizeof(struct gp2a_data), GFP_KERNEL)))
{
err = -ENOMEM;
goto exit;
}
memset(gp2a, 0, sizeof(struct gp2a_data));
gp2a->client = client;
i2c_set_clientdata(client, gp2a);
opt_i2c_client = client;
if (i2c_smbus_read_byte(client) < 0)
{
printk(KERN_ERR "[GP2A] i2c_smbus_read_byte error!!\n");
goto exit_kfree;
}
else
{
printk("GP2A Device detected!\n");
}
printk("[%s] slave addr = %x\n", __func__, client->addr);
/* Input device Settings */
if(USE_INPUT_DEVICE)
{
gp2a->input_dev = input_allocate_device();
if (gp2a->input_dev == NULL)
{
pr_err("Failed to allocate input device\n");
return -ENOMEM;
}
gp2a->input_dev->name = "proximity_sensor";
set_bit(EV_SYN,gp2a->input_dev->evbit);
set_bit(EV_ABS,gp2a->input_dev->evbit);
input_set_abs_params(gp2a->input_dev, ABS_DISTANCE, 0, 1, 0, 0);
err = input_register_device(gp2a->input_dev);
if (err)
{
pr_err("Unable to register %s input device\n", gp2a->input_dev->name);
input_free_device(gp2a->input_dev);
kfree(gp2a);
return -1;
}
}
#if USE_INTERRUPT
/* WORK QUEUE Settings */
gp2a_wq = create_singlethread_workqueue("gp2a_wq");
if (!gp2a_wq)
return -ENOMEM;
INIT_WORK(&gp2a->work_prox, gp2a_work_func_prox);
gprintk("Workqueue Settings complete\n");
#endif
/* misc device Settings */
err = misc_register(&proximity_device);
if(err) {
pr_err(KERN_ERR "misc_register failed - prox \n");
}
/* wake lock init */
wake_lock_init(&prx_wake_lock, WAKE_LOCK_SUSPEND, "prx_wake_lock");
/* set sysfs for light sensor */
proxsensor_class = class_create(THIS_MODULE, "proxsensor");
if (IS_ERR(proxsensor_class))
pr_err("Failed to create class(proxsensor)!\n");
switch_cmd_dev = device_create(proxsensor_class, NULL, 0, NULL, "switch_cmd");
if (device_create_file(switch_cmd_dev, &dev_attr_proxsensor_file_state) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_proxsensor_file_state.attr.name);
dev_set_drvdata(switch_cmd_dev,gp2a);
/* ktime init */
timeA = ktime_set(0,0);
timeB = ktime_set(0,0);
/* gpio config */
config = GPIO_CFG(GPIO_SENSE_OUT, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA);
err = gpio_tlmm_config(config, GPIO_CFG_ENABLE);
if (err)
printk(KERN_ERR "%s: gpio_tlmm_config(%#x)=%d\n", __func__, GPIO_SENSE_OUT, err);
/* GP2A Regs INIT SETTINGS */
for(i=1;i<5;i++)
{
opt_i2c_write((u8)(i),&gp2a_original_image[i]);
}
mdelay(2);
#if USE_INTERRUPT
/* INT Settings */
irq = gpio_to_irq(GPIO_SENSE_OUT);
gp2a->irq = -1;
set_irq_type(irq, IRQ_TYPE_EDGE_BOTH);
err = request_irq(irq, gp2a_irq_handler, IRQF_DISABLED, "gp2a_int", gp2a);
if (err)
{
printk("[GP2A] request_irq failed for gp2a\n");
goto exit_kfree;
}
printk("[GP2A] register irq = %d\n",irq);
err = set_irq_wake(irq, 1);
printk("[GP2A] register wakeup source = %d\n",err);
if (err)
printk("[GP2A] register wakeup source failed\n");
gp2a->irq = irq;
gprintk("INT Settings complete\n");
#endif
// maintain power-down mode before using sensor
gp2a_off(gp2a,ALL);
//++ // test for sensor
/*
printk("[GP2A] curr prox value = %d\n", gpio_get_value(GPIO_SENSE_OUT));
gp2a_on(gp2a,PROXIMITY);
printk("[GP2A] curr prox value = %d\n", gpio_get_value(GPIO_SENSE_OUT));
//--
// maintain power-down mode before using sensor
//ESD test sleep
gp2a_off(gp2a,ALL);
*/
printk("gp2a_opt_probe is OK!!\n");
return 0;
exit_kfree:
kfree(gp2a);
exit:
return err;
}
int ts_set_vreg(unsigned char onoff)
{
if (lge_bd_rev == LGE_REV_A) {
struct vreg *vreg_touch;
int rc;
printk(KERN_INFO "[Touch] %s() onoff:%d\n", __func__, onoff);
vreg_touch = vreg_get(0, "bt");
if (IS_ERR(vreg_touch)) {
printk(KERN_INFO"[Touch] vreg_get fail : touch\n");
return -EBUSY;
}
if (onoff) {
rc = vreg_set_level(vreg_touch, 2850);
if (rc != 0) {
printk(KERN_INFO "[Touch] vreg_set_level failed\n");
return -EBUSY;
}
vreg_enable(vreg_touch);
} else {
vreg_disable(vreg_touch);
}
} else if (lge_bd_rev >= LGE_REV_B) {
static struct regulator *ldo1 = NULL;
int rc;
static int init = 0;
ldo1 = regulator_get(NULL, "RT8053_LDO1");
if (ldo1 == NULL)
pr_err("%s: regulator_get(ldo1) failed\n", __func__);
if (onoff) {
rc = regulator_set_voltage(ldo1, 3000000, 3000000);
if (rc < 0)
pr_err(
"%s: regulator_set_voltage(ldo1) failed\n",
__func__);
rc = regulator_enable(ldo1);
if (rc < 0)
pr_err(
"%s: regulator_enable(ldo1) failed\n",
__func__);
init = 1;
} else {
if (init > 0) {
rc = regulator_disable(ldo1);
if (rc < 0)
pr_err(
"%s: regulator_disble(ldo1) failed\n",
__func__);
regulator_put(ldo1);
}
}
}
return 0;
}
static ssize_t misc_helper_write(struct file *fp, const char __user *buf, size_t count, loff_t *pos)
{
unsigned char cmd[64];
int len;
int i, r;
unsigned int id, val;
unsigned char *uchar;
char *soc_baseband_id, *args[10]={0};
static char bp_version[32]={0};
static int bp_taken=0;
static smem_mot_vendor1_type *vendor1;
if (count < 1)
return 0;
len = count > 63 ? 63 : count;
if (copy_from_user(cmd, buf, len))
return -EFAULT;
cmd[len] = 0;
/* lazy */
if (cmd[len-1] == '\n') {
cmd[len-1] = 0;
len--;
}
if ((r = misc_helper_args (args, cmd, len)) > 0) {
for (i=0; i < r; i++)
D(KERN_ERR "ARG[%d] %s\n", i, args[i]);
}
if (r == 0)
return count;
switch (misc_helper_get_cmd (args[0], r))
{
case CMD_BP_VER :
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
if (! bp_taken) {
soc_baseband_id = socinfo_get_baseband_id();
if (soc_baseband_id) {
strncpy (bp_version, soc_baseband_id, sizeof (bp_version)-1);
bp_version[31] = 0;
}else
strcpy (bp_version, "undefined");
bp_taken = 1;
}
D("%s(): %s\n", misc_helper_cmd_name[CMD_BP_VER], bp_version);
sprintf (misc_helper_info.data.buffer, "%s", bp_version);
break;
case CMD_AP_FLASH :
if(!0) {
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
id = PROCCOMM_MODEM_SET_AP_FLASH_REASON;
val = 0;
r = meta_proc(id, &val);
D("%s()=%08x,%08x rc=%d\n", misc_helper_cmd_name[CMD_AP_FLASH], id, val, r);
sprintf (misc_helper_info.data.buffer, "%u %u", id, val);
} else
sprintf (misc_helper_info.data.buffer, "Permissions denied");
break;
case CMD_UUID_HIGH :
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
id = 0;
val = 0;
r = msm_proc_comm (PCOM_GET_UUID_HIGH, &id, &val);
D("%s()=%08x,%08x rc=%d\n", misc_helper_cmd_name[CMD_UUID_HIGH], id, val, r);
uchar = (unsigned char *)&id;
sprintf (misc_helper_info.data.buffer, "%02x %02x %02x %02x ", *uchar, *uchar+1, *uchar+2, *uchar+3);
uchar = (unsigned char *)&val;
sprintf (misc_helper_info.data.buffer+strlen(misc_helper_info.data.buffer),
"%02x %02x %02x %02x", *uchar, *uchar+1, *uchar+2, *uchar+3);
break;
case CMD_UUID_LOW :
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
id = 0;
val = 0;
r = msm_proc_comm (PCOM_GET_UUID_LOW, &id, &val);
D("%s()=%08x,%08x rc=%d\n", misc_helper_cmd_name[CMD_UUID_LOW], id, val, r);
uchar = (unsigned char *)&id;
sprintf (misc_helper_info.data.buffer, "%02x %02x %02x %02x ", *uchar, *uchar+1, *uchar+2, *uchar+3);
uchar = (unsigned char *)&val;
sprintf (misc_helper_info.data.buffer+strlen(misc_helper_info.data.buffer),
"%02x %02x %02x %02x", *uchar, *uchar+1, *uchar+2, *uchar+3);
break;
case CMD_HELP :
if (!is_secure_hw()) {
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
misc_helper_usage (args, r);
} else
sprintf (misc_helper_info.data.buffer, "Permissions denied");
break;
case CMD_GPIO_GET :
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
id = (unsigned)simple_strtoul (args[1], NULL, 10);
val = gpio_get_value (id);
D("%s(%u)=%u\n", misc_helper_cmd_name[CMD_GPIO_GET], id, val);
sprintf (misc_helper_info.data.buffer, "%u", val);
break;
case CMD_BATTERY :
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
id = 0;
val = 0;
r = msm_proc_comm (PCOM_GET_BATT_LEVEL, &id, &val);
D("%s()=%u,%u rc=%d\n", misc_helper_cmd_name[CMD_BATTERY], id, val, r);
sprintf (misc_helper_info.data.buffer, "%u %u", id, val);
break;
case CMD_CHARGING :
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
id = 0;
val = 0;
r = msm_proc_comm (PCOM_CHG_IS_CHARGING, &id, &val);
D("%s()=%u,%u rc=%d\n", misc_helper_cmd_name[CMD_CHARGING], id, val, r);
sprintf (misc_helper_info.data.buffer, "%u %u", id, val);
break;
case CMD_RESET :
if(!0) { //if (!is_secure_hw()) {
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
id = 0;
val = 0;
r = msm_proc_comm (PCOM_RESET_MODEM, &id, &val);
D("%s()=%u,%u rc=%d\n", misc_helper_cmd_name[CMD_RESET], id, val, r);
sprintf (misc_helper_info.data.buffer, "%u %u", id, val);
} else
sprintf (misc_helper_info.data.buffer, "Permissions denied");
break;
case CMD_CHIP_PWRDN :
if(!0) { //if (!is_secure_hw()) {
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
id = 0;
val = 0;
r = msm_proc_comm (PCOM_POWER_DOWN, &id, &val);
D("%s()=%u,%u rc=%d\n", misc_helper_cmd_name[CMD_CHIP_PWRDN], id, val, r);
sprintf (misc_helper_info.data.buffer, "%u %u", id, val);
} else
sprintf (misc_helper_info.data.buffer, "Permissions denied");
break;
case CMD_NVREAD :
if (!0) { //if (!is_secure_hw()) {
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
id = (unsigned)simple_strtoul (args[1], NULL, 10);
id = (id << 8) | PROCCOMM_NV_READ;
val = 0;
r = msm_proc_comm (PCOM_CUSTOMER_CMD3, &id, &val);
D("%s(0x%08x)=%u rc=%d\n", misc_helper_cmd_name[CMD_NVREAD], id, val, r);
sprintf (misc_helper_info.data.buffer, "%u %u", id, val);
} else
sprintf (misc_helper_info.data.buffer, "Permissions denied");
break;
case CMD_NVWRITE :
if (!0) { //if (!is_secure_hw()) {
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
id = (unsigned)simple_strtoul (args[1], NULL, 10);
id = (id << 8) | PROCCOMM_NV_WRITE;
val = (unsigned)simple_strtoul (args[2], NULL, 10);
r = msm_proc_comm (PCOM_CUSTOMER_CMD3, &id, &val);
D("%s(0x%08x, %u) rc=%d\n", misc_helper_cmd_name[CMD_NVWRITE], id, val, r);
sprintf (misc_helper_info.data.buffer, "%d", r);
} else
sprintf (misc_helper_info.data.buffer, "Permissions denied");
break;
#if 0
case CMD_NVR :
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
id = (unsigned)simple_strtoul (args[1], NULL, 10);
val = 0;
r = msm_proc_comm (PCOM_NV_READ, &id, &val);
D("%s(%u)=%u rc=%d\n", misc_helper_cmd_name[CMD_NVR], id, val, r);
sprintf (misc_helper_info.data.buffer, "%u %u", id, val);
break;
case CMD_NVW :
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
id = (unsigned)simple_strtoul (args[1], NULL, 10);
val = (unsigned)simple_strtoul (args[2], NULL, 10);
r = msm_proc_comm (PCOM_NV_WRITE, &id, &val);
D("%s(%u, %u) rc=%d\n", misc_helper_cmd_name[CMD_NVW], id, val, r);
sprintf (misc_helper_info.data.buffer, "%d", r);
break;
#endif
case CMD_GPIO_SET :
if (!is_secure_hw()) {
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
id = (unsigned)simple_strtoul (args[1], NULL, 10);
val = (unsigned)simple_strtoul (args[2], NULL, 10);
r = gpio_set_value (id, val);
val = gpio_get_value (id);
D("%s(%u, %u) rc=%d\n", misc_helper_cmd_name[CMD_GPIO_SET], id, val, r);
sprintf (misc_helper_info.data.buffer, "%u", val);
} else
sprintf (misc_helper_info.data.buffer, "Permissions denied");
break;
case CMD_VREG :
if (!is_secure_hw()) {
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
{
unsigned int mv = (unsigned)simple_strtoul (args[2], NULL, 10);
int rc;
struct vreg *vreg;
vreg = vreg_get(0,args[1]);
if (IS_ERR(vreg)) {
sprintf(misc_helper_info.data.buffer, "* bad name (%s)", args[1]);
break;
}
if (mv > 0) {
if ((rc = vreg_set_level(vreg, mv))) {
sprintf(misc_helper_info.data.buffer, "* failed to set level (%d mV) [%d]", mv, rc);
break;
}
if ((rc = vreg_enable(vreg))) {
sprintf(misc_helper_info.data.buffer, "* failed to enable [%d]", rc);
break;
}
}
else {
if ((rc = vreg_disable(vreg))) {
sprintf(misc_helper_info.data.buffer, "* failed to disable [%d]", rc);
break;
}
}
D("%s(%s,%d) rc=%d\n", misc_helper_cmd_name[CMD_VREG],args[1],mv,rc);
}
sprintf(misc_helper_info.data.buffer, "OK");
} else
sprintf (misc_helper_info.data.buffer, "Permissions denied");
break;
case CMD_CLK :
if (!is_secure_hw()) {
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
{
unsigned int rate = (unsigned)simple_strtoul (args[2], NULL, 10);
int rc = 0;
struct clk *clk;
clk = clk_get(NULL, args[1]);
if (IS_ERR(clk)) {
sprintf(misc_helper_info.data.buffer, "* bad name (%s)", args[1]);
break;
}
if (rate > 0) {
if ((rc = clk_enable(clk))) {
sprintf(misc_helper_info.data.buffer, "* failed to enable clk [%d]", rc);
break;
}
if ((rc = clk_set_rate(clk,rate))) {
sprintf(misc_helper_info.data.buffer, "* failed to set rate [%d]", rc);
break;
}
}
else {
clk_disable(clk);
}
D("%s(%s,%d) rc=%d\n", misc_helper_cmd_name[CMD_CLK],args[1],rate,rc);
}
sprintf(misc_helper_info.data.buffer, "OK");
} else
sprintf (misc_helper_info.data.buffer, "Permissions denied");
break;
case CMD_FB_SET :
if (!is_secure_hw()) {
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
id = (1 << 8) | PROCCOMM_FACTORY_BYTE;
val = (unsigned)simple_strtoul (args[1], NULL, 10);
r = msm_proc_comm (PCOM_CUSTOMER_CMD3, &id, &val);
D("%s(%u)=%u\n", misc_helper_cmd_name[CMD_FB_SET], id, val);
sprintf (misc_helper_info.data.buffer, "%u", val);
} else
sprintf (misc_helper_info.data.buffer, "Permissions denied");
break;
case CMD_TRUSTED_BOOT :
if (! vendor1) {
vendor1 = smem_alloc(SMEM_ID_VENDOR1, sizeof(smem_mot_vendor1_type));
}
if (vendor1) {
r = 0;
val = (unsigned int)vendor1->trusted_boot;
} else {
r = -1;
val = -1;
}
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
D("%s(is_boot_trusted)=%u, rc=%d\n", misc_helper_cmd_name[CMD_TRUSTED_BOOT], val, r);
sprintf (misc_helper_info.data.buffer, "%u", val);
break;
case CMD_SECURE :
r = 0;
val = (unsigned int)is_secure_hw();
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
D("%s(is_security_on)=%u, rc=%d\n", misc_helper_cmd_name[CMD_SECURE], val, r);
sprintf (misc_helper_info.data.buffer, "%u", val);
break;
case CMD_FB_GET :
if (! vendor1) {
vendor1 = smem_alloc(SMEM_ID_VENDOR1, sizeof(smem_mot_vendor1_type));
}
if (vendor1) {
r = 0;
val = (unsigned int)vendor1->fact_byte;
} else {
r = -1;
val = -1;
}
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
D("%s(10024)=%u, rc=%d\n", misc_helper_cmd_name[CMD_FB_GET], val, r);
sprintf (misc_helper_info.data.buffer, "%u", val);
break;
case CMD_MAX :
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
sprintf (misc_helper_info.data.buffer, "missing parameters for command: %s", args[0]);
break;
default :
misc_helper_info.response |= MH_RESP_REQUIRED | MH_RESP_READY | MH_RESP_FMT_BUFF;
sprintf (misc_helper_info.data.buffer, "command: %s is not supported", cmd);
}
return count;
}
static int cypress_cpt_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int ret = 0;
int j = 0;
#ifdef CONFIG_CYPRESS_1044_UPDATE_TS_FIRMWARE
static char version[10];
int firmware_id;
#endif
int gpio_config;
if(machine_is_msm7x27_c8800())
{
lcd_x = LCD_X_WVGA;
lcd_y = LCD_Y_WVGA;
v_key_h = VIRTUAL_KEYS_H_WVGA;
}
else
{
lcd_x = LCD_X_HVGA;
lcd_y = LCD_Y_HVGA;
v_key_h = VIRTUAL_KEYS_H_HVGA;
}
gpio_config = GPIO_CFG(29, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_2MA);
ret = gpio_tlmm_config(gpio_config, GPIO_CFG_ENABLE);
if(ret)
{
printk(KERN_ERR "GPIO_CFG failed\n");
}
/* power on touchscreen */
struct vreg *v_gp5 = NULL;
v_gp5 = vreg_get(NULL,"gp5");
ret = IS_ERR(v_gp5);
if(ret)
{
goto err_power_failed;
}
ret = vreg_set_level(v_gp5,2700);
ret = vreg_enable(v_gp5);
msleep(200);
struct cypress_cpt_ts_data *ts = NULL;
#if defined (CONFIG_CYPRESS_TOUCHSCREEN_GESTURE) || defined (CONFIG_CYPRESS_TOUCHSCREEN_1044_EXTRA_KEY)
int i;
#endif
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
{
printk(KERN_ERR "cypress_cpt_ts_probe: need I2C_FUNC_I2C\n");
ret = -ENODEV;
goto err_check_functionality_failed;
}
cypress_ts_power_on_reset(client);
/* detect make sure the client really exists */
for( j = 5; j > 0; j-- )
{
ret = i2c_smbus_read_byte_data(client, 0x00);
if ( ret >= 0 )
{
break;
}
msleep(10);
}
if( j <= 0 )
{
goto err_i2c_read_failed;
}
#ifdef CONFIG_CYPRESS_1044_UPDATE_TS_FIRMWARE
g_client = client;
for (i = 0 ; i < 3; i++)
{
ret= ts_firmware_file();
if (!ret)
break;
}
#endif
cypress_cpt_wq = create_singlethread_workqueue("cypress_cpt_wq");
if (!cypress_cpt_wq)
{
printk(KERN_ERR "%s: create_singlethread_workqueue failed\n", __FUNCTION__);
goto err_work_init_failed;
}
ts = kzalloc(sizeof(*ts), GFP_KERNEL);
if (ts == NULL)
{
ret = -ENOMEM;
goto err_alloc_data_failed;
}
INIT_WORK(&ts->work, cypress_cpt_ts_work_func);
ts->client = client;
i2c_set_clientdata(client, ts);
ts->input_dev = input_allocate_device();
if (ts->input_dev == NULL)
{
ret = -ENOMEM;
printk(KERN_ERR "cypress_cpt_ts_probe: Failed to allocate input device\n");
goto err_input_dev_alloc_failed;
}
if(client->flags)
{
muti_touch = TRUE;
i2c_read_len = I2C_MUTI_READ_LEN;
}
else
{
muti_touch = FALSE;
i2c_read_len = I2C_SNGL_READ_LEN;
}
#ifdef CONFIG_CYPRESS_TOUCHSCREEN_1044_EXTRA_KEY
ts->input_extra_dev = input_allocate_device();
if(ts->input_extra_dev == NULL)
{
ret = -ENOMEM;
printk(KERN_ERR"%s: Failed to allocate input extra device \n", __FUNCTION__ );
goto err_input_dev_alloc_failed;
}
#endif
ts->input_dev->name = "cypress_cpt";
set_bit(EV_SYN, ts->input_dev->evbit);
set_bit(EV_ABS, ts->input_dev->evbit);
set_bit(EV_KEY, ts->input_dev->evbit);
set_bit(BTN_TOUCH, ts->input_dev->keybit);
set_bit(ABS_X, ts->input_dev->absbit);
set_bit(ABS_Y, ts->input_dev->absbit);
set_bit(KEY_NUMLOCK, ts->input_dev->keybit);
/* single or mutil touch both set as this */
input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X,0,lcd_x, 0, 0);
input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, lcd_y-v_key_h, 0, 0);
input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
#ifdef CONFIG_CYPRESS_TOUCHSCREEN_GESTURE
set_bit(EV_GESTURE, ts->input_dev->evbit);
for (i = GESTURE_NO_GESTURE; i < GESTURE_MAX; i++)
set_bit(i, ts->input_dev->gesturebit);
#endif /*CONFIG_CYPRESS_TOUCHSCREEN_GESTURE*/
/* query version number */
#ifdef CONFIG_CYPRESS_1044_UPDATE_TS_FIRMWARE
ts->input_dev->uniq = version;
firmware_id = i2c_smbus_read_byte_data(g_client, 0x0c);
version[0] = (firmware_id / 16) + '0';
version[1] = '.';
version[2] = (firmware_id % 16) + '0';
version[3] = '\0';
#endif
ret = input_register_device(ts->input_dev);
if (ret)
{
printk(KERN_ERR "cypress_cpt_ts_probe: Unable to register %s input device\n", ts->input_dev->name);
goto err_input_register_device_failed;
}
#ifdef CONFIG_CYPRESS_TOUCHSCREEN_1044_EXTRA_KEY
ts->input_extra_dev->name ="cypress extra key";
set_bit(EV_KEY, ts->input_extra_dev->evbit);
for(i =0; i < MAX_EXTRA_TOUCH_KEY; i++)
{
set_bit(touch_extra_key_region.touch_extra_key[i].keycode&KEY_MAX, ts->input_extra_dev->keybit);
}
ret = input_register_device(ts->input_extra_dev);
if(ret)
{
printk(KERN_ERR"%s: Unable to register input device %s", __FUNCTION__, ts->input_extra_dev->name);
goto err_input_register_extra_device_failed;
}
#endif
ret = gpio_request(29, "gpio 29 for touch");
if(ret)
printk("%s: request gpio %d failed!\n", __FUNCTION__, client->irq);
ret = gpio_direction_input(29);
if (ret)
printk("touchscreen gpio 45 direction input error!\n");
if (client->irq)
{
printk(KERN_ERR "%s@%d: cypress_cpt_ts_probe\n", __FILE__,__LINE__);
ret = request_irq(client->irq, cypress_cpt_ts_irq_handler, IRQF_TRIGGER_FALLING, client->name, ts);
if (ret == 0)
ts->use_irq = 1;
else
printk("cypress_cpt_ts_probe: request_irq %d failed\n", client->irq);
}
if (!ts->use_irq)
{
printk("cypress use timer-based polling\n ");
hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
ts->timer.function = cypress_cpt_ts_timer_func;
hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
}
#ifdef CONFIG_HAS_EARLYSUSPEND
ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
ts->early_suspend.suspend = cypress_cpt_ts_early_suspend;
ts->early_suspend.resume = cypress_cpt_ts_late_resume;
register_early_suspend(&ts->early_suspend);
#endif
CYPRESS_DEBUG(KERN_INFO "cpt_ts_probe: Start touchscreen %s in %s mode\n", ts->input_dev->name, ts->use_irq ? "interrupt" : "polling");
return 0;
#ifdef CONFIG_CYPRESS_TOUCHSCREEN_1044_EXTRA_KEY
err_input_register_extra_device_failed:
input_free_device(ts->input_extra_dev);
#endif
err_input_register_device_failed:
input_free_device(ts->input_dev);
err_input_dev_alloc_failed:
kfree(ts);
err_alloc_data_failed:
err_work_init_failed:
err_i2c_read_failed:
if(NULL != v_gp5)
{
ret = vreg_disable(v_gp5);
}
err_power_failed:
err_check_functionality_failed:
return ret;
}
static void msm_camera_vreg_enable(struct platform_device *pdev)
{
vreg_gp2 = vreg_get(NULL, "gp2");
if (IS_ERR(vreg_gp2)) {
pr_err("%s: VREG GP2 get failed %ld\n", __func__,
PTR_ERR(vreg_gp2));
vreg_gp2 = NULL;
return;
}
if (vreg_set_level(vreg_gp2, 2600)) {
pr_err("%s: VREG GP2 set failed\n", __func__);
goto gp2_put;
}
if (vreg_enable(vreg_gp2)) {
pr_err("%s: VREG GP2 enable failed\n", __func__);
goto gp2_put;
}
vreg_lvsw1 = vreg_get(NULL, "lvsw1");
if (IS_ERR(vreg_lvsw1)) {
pr_err("%s: VREG LVSW1 get failed %ld\n", __func__,
PTR_ERR(vreg_lvsw1));
vreg_lvsw1 = NULL;
goto gp2_disable;
}
if (vreg_set_level(vreg_lvsw1, 1800)) {
pr_err("%s: VREG LVSW1 set failed\n", __func__);
goto lvsw1_put;
}
if (vreg_enable(vreg_lvsw1)) {
pr_err("%s: VREG LVSW1 enable failed\n", __func__);
goto lvsw1_put;
}
if (!strcmp(pdev->name, "msm_camera_sn12m0pz")) {
vreg_gp6 = vreg_get(NULL, "gp6");
if (IS_ERR(vreg_gp6)) {
pr_err("%s: VREG GP6 get failed %ld\n", __func__,
PTR_ERR(vreg_gp6));
vreg_gp6 = NULL;
goto lvsw1_disable;
}
if (vreg_set_level(vreg_gp6, 3050)) {
pr_err("%s: VREG GP6 set failed\n", __func__);
goto gp6_put;
}
if (vreg_enable(vreg_gp6)) {
pr_err("%s: VREG GP6 enable failed\n", __func__);
goto gp6_put;
}
vreg_gp16 = vreg_get(NULL, "gp16");
if (IS_ERR(vreg_gp16)) {
pr_err("%s: VREG GP16 get failed %ld\n", __func__,
PTR_ERR(vreg_gp16));
vreg_gp16 = NULL;
goto gp6_disable;
}
if (vreg_set_level(vreg_gp16, 1200)) {
pr_err("%s: VREG GP16 set failed\n", __func__);
goto gp16_put;
}
if (vreg_enable(vreg_gp16)) {
pr_err("%s: VREG GP16 enable failed\n", __func__);
goto gp16_put;
}
}
return;
gp16_put:
vreg_put(vreg_gp16);
vreg_gp16 = NULL;
gp6_disable:
vreg_disable(vreg_gp6);
gp6_put:
vreg_put(vreg_gp6);
vreg_gp6 = NULL;
lvsw1_disable:
vreg_disable(vreg_lvsw1);
lvsw1_put:
vreg_put(vreg_lvsw1);
vreg_lvsw1 = NULL;
gp2_disable:
vreg_disable(vreg_gp2);
gp2_put:
vreg_put(vreg_gp2);
vreg_gp2 = NULL;
}
static int synaptics_ts_probe(
struct i2c_client *client, const struct i2c_device_id *id)
{
struct synaptics_ts_data *ts;
int ret = 0;
struct vreg *vreg_touch;
uint8_t i2c_addr = 0x1B;
uint8_t buf_tmp[3]={0,};
HW_ver = 0;
SW_ver = 0;
printk("[TSP] %s, %d\n", __func__, __LINE__ );
vreg_touch = vreg_get(NULL, "ldo6");
ret = vreg_set_level(vreg_touch, OUT3000mV);
if (ret) {
printk(KERN_ERR "%s: vreg set level failed (%d)\n",
__func__, ret);
return -EIO;
}
ret = vreg_enable(vreg_touch);
if (ret) {
printk(KERN_ERR "%s: vreg enable failed (%d)\n",
__func__, ret);
return -EIO;
}
msleep(700);
ts = kzalloc(sizeof(*ts), GFP_KERNEL);
if (ts == NULL) {
ret = -ENOMEM;
goto err_alloc_data_failed;
}
INIT_WORK(&ts->work, synaptics_ts_work_func);
INIT_DELAYED_WORK(&ts->work_check_ic, check_ic_work_func );
schedule_delayed_work(&ts->work_check_ic, CHECK_TIME );
ts->client = client;
i2c_set_clientdata(client, ts);
ts_global = ts;
ts->input_dev = input_allocate_device();
if (ts->input_dev == NULL) {
ret = -ENOMEM;
touch_present = 0;
printk(KERN_ERR "synaptics_ts_probe: Failed to allocate input device\n");
goto err_input_dev_alloc_failed;
}
ts->input_dev->name = "sec_touchscreen";
set_bit(EV_SYN, ts->input_dev->evbit);
set_bit(EV_KEY, ts->input_dev->evbit);
set_bit(BTN_TOUCH, ts->input_dev->keybit);
set_bit(EV_ABS, ts->input_dev->evbit);
printk(KERN_INFO "synaptics_ts_probe: max_x: 240, max_y: 320\n");
input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, MAX_X, 0, 0); //0, MAX_X, 0, 0
input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, MAX_Y, 0, 0); //0, MAX_Y, 0, 0
input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
/* ts->input_dev->name = ts->keypad_info->name; */
ret = input_register_device(ts->input_dev);
if (ret) {
touch_present = 0;
printk(KERN_ERR "synaptics_ts_probe: Unable to register %s input device\n", ts->input_dev->name);
goto err_input_register_device_failed;
}
printk("[TSP] %s, irq=%d\n", __func__, client->irq );
if (client->irq) {
ret = request_irq(client->irq, synaptics_ts_irq_handler,/* IRQF_TRIGGER_RISING |*/ IRQF_TRIGGER_FALLING , client->name, ts);
if (ret == 0)
ts->use_irq = 1;
else
dev_err(&client->dev, "request_irq failed\n");
}
#ifdef CONFIG_HAS_EARLYSUSPEND
ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
ts->early_suspend.suspend = synaptics_ts_early_suspend;
ts->early_suspend.resume = synaptics_ts_late_resume;
register_early_suspend(&ts->early_suspend);
#endif
printk(KERN_INFO "synaptics_ts_probe: Start touchscreen %s in %s mode\n", ts->input_dev->name, ts->use_irq ? "interrupt" : "polling");
/* sys fs */
touch_class = class_create(THIS_MODULE, "touch");
if (IS_ERR(touch_class))
pr_err("Failed to create class(touch)!\n");
firmware_dev = device_create(touch_class, NULL, 0, NULL, "firmware");
if (IS_ERR(firmware_dev))
pr_err("Failed to create device(firmware)!\n");
if (device_create_file(firmware_dev, &dev_attr_firmware) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_firmware.attr.name);
if (device_create_file(firmware_dev, &dev_attr_firmware_ret) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_firmware_ret.attr.name);
/* sys fs */
/* Check point - i2c check - start */
ret = tsp_i2c_read( i2c_addr, buf_tmp, sizeof(buf_tmp));
HW_ver = buf_tmp[1];
SW_ver = buf_tmp[2];
if (ret <= 0) {
printk(KERN_ERR "i2c_transfer failed\n");
ret = tsp_i2c_read( i2c_addr, buf_tmp, sizeof(buf_tmp));
if (ret <= 0)
{
disable_irq(ts_global->client->irq);
cancel_delayed_work_sync(&ts_global->work_check_ic);
touch_present = 0;
printk("[TSP] %s, ln:%d, Failed to register TSP!!!\n\tcheck the i2c line!!!, ret=%d\n", __func__,__LINE__, ret);
goto err_check_functionality_failed;
}
}
/* Check point - i2c check - end */
printk("[TSP] %s, ver CY=%x\n", __func__ , buf_tmp[0] );
printk("[TSP] %s, ver HW=%x\n", __func__ , buf_tmp[1] );
printk("[TSP] %s, ver SW=%x\n", __func__ , buf_tmp[2] );
touch_present = 1;
/* Check point - Firmware */
printk("[TSP] %s:%d, ver SW=%x, HW=%x\n", __func__, __LINE__, SW_ver, HW_ver);
printk("[TSP] Here - Deleted Firmware Check Routine \n");
#if 0
switch( (HW_ver+1)/10 ){
case 0: //Degitech
if(HW_ver < Digi_HEX_HW_VER){ //Firmware Update
firm_update();
}else if((SW_ver<Digi_HEX_SW_VER)||((SW_ver&0xF0)==0xF0)||(SW_ver==0)){
printk("[TSP] firm_update START!!, ln=%d\n",__LINE__);
firm_update();
}else{
printk("[TSP] Firmware Version(Digitech) is Up-to-date.\n");
}break;
case 1: //SMAC
if(HW_ver < SMAC_HEX_HW_VER){ //Firmware Update
firm_update();
}else if((SW_ver<SMAC_HEX_SW_VER)||((SW_ver&0xF0)==0xF0)||(SW_ver==0)){
printk("[TSP] firm_update START!!, ln=%d\n",__LINE__);
firm_update();
}else{
printk("[TSP] Firmware Version(SMAC) is Up-to-date.\n");
}break;
case 2: ; //
}
#endif
printk(KERN_INFO "synaptics_ts_probe: Manufacturer ID: %x, HW ver=%x, SW ver=%x\n", buf_tmp[0], buf_tmp[1], buf_tmp[2]);
/* Check point - Firmware */
return 0;
err_input_register_device_failed:
input_free_device(ts->input_dev);
err_input_dev_alloc_failed:
kfree(ts);
err_alloc_data_failed:
err_check_functionality_failed:
return ret;
}
static int fm_radio_setup(struct marimba_fm_platform_data *pdata)
{
int rc = 0;
const char *id = "FMPW";
uint32_t irqcfg;
struct marimba config = { .mod_id = SLAVE_ID_BAHAMA};
u8 value;
/* Voting for 1.8V Regulator */
fm_regulator = vreg_get(NULL , "msme1");
if (IS_ERR(fm_regulator)) {
pr_err("%s: vreg get failed with : (%ld)\n",
__func__, PTR_ERR(fm_regulator));
return -EINVAL;
}
/* Set the voltage level to 1.8V */
rc = vreg_set_level(fm_regulator, 1800);
if (rc < 0) {
pr_err("%s: set regulator level failed with :(%d)\n",
__func__, rc);
goto fm_vreg_fail;
}
/* Enabling the 1.8V regulator */
rc = vreg_enable(fm_regulator);
if (rc) {
pr_err("%s: enable regulator failed with :(%d)\n",
__func__, rc);
goto fm_vreg_fail;
}
/* Voting for 19.2MHz clock */
rc = pmapp_clock_vote(id, PMAPP_CLOCK_ID_D1,
PMAPP_CLOCK_VOTE_ON);
if (rc < 0) {
pr_err("%s: clock vote failed with :(%d)\n",
__func__, rc);
goto fm_clock_vote_fail;
}
rc = bt_set_gpio(1);
if (rc) {
pr_err("%s: bt_set_gpio = %d", __func__, rc);
goto fm_gpio_config_fail;
}
/*re-write FM Slave Id, after reset*/
value = BAHAMA_SLAVE_ID_FM_ADDR;
rc = marimba_write_bit_mask(&config,
BAHAMA_SLAVE_ID_FM_REG, &value, 1, 0xFF);
if (rc < 0) {
pr_err("%s: FM Slave ID rewrite Failed = %d", __func__, rc);
goto fm_gpio_config_fail;
}
/* Configuring the FM GPIO */
irqcfg = GPIO_CFG(FM_GPIO, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL,
GPIO_CFG_2MA);
rc = gpio_tlmm_config(irqcfg, GPIO_CFG_ENABLE);
if (rc) {
pr_err("%s: gpio_tlmm_config(%#x)=%d\n",
__func__, irqcfg, rc);
goto fm_gpio_config_fail;
}
return 0;
fm_gpio_config_fail:
pmapp_clock_vote(id, PMAPP_CLOCK_ID_D1,
PMAPP_CLOCK_VOTE_OFF);
bt_set_gpio(0);
fm_clock_vote_fail:
vreg_disable(fm_regulator);
fm_vreg_fail:
vreg_put(fm_regulator);
return rc;
};
static int proximity_sensor_probe(struct platform_device *pdev)
{
#if 1
vreg_proximity = vreg_get(0, "ruim");
vreg_set_level(vreg_proximity, 2800);
vreg_enable(vreg_proximity);
#endif
struct proximity_platform_data *proximity = pdev->dev.platform_data;
printk(KERN_ERR"%s: enter, irq=%d\n", __func__, gpio_to_irq(proximity->intr));
int err = 0;
if (err < 0)
printk(KERN_ERR"%s: gpio_direction_input failed\n", __func__);
err = gpio_request(proximity->enable, "proximity_sensor");
if (err < 0)
printk(KERN_ERR"%s: gpio_request failed\n", __func__);
err = gpio_direction_output(proximity->enable, 1);
if (err < 0)
printk(KERN_ERR"%s: gpio_direction_input failed\n", __func__);
err = gpio_request(proximity->intr, "proximity_sensor");
if (err < 0)
printk(KERN_ERR"%s: gpio_request failed\n", __func__);
err = gpio_direction_input(proximity->intr);
if (err < 0)
printk(KERN_ERR"%s: gpio_direction_input failed\n", __func__);
proximity->input_dev = input_allocate_device();
if (!proximity->input_dev) {
err = -ENOMEM;
printk(KERN_ERR"%s: Failed to allocate input device\n", __func__);
}
set_bit(EV_ABS, proximity->input_dev->evbit);
input_set_abs_params(proximity->input_dev, ABS_DISTANCE, 0, 1, 0, 0);
proximity->input_dev->name = "proximity";
err = input_register_device(proximity->input_dev);
err = request_irq(gpio_to_irq(proximity->intr), proximity_interrupt, IRQF_TRIGGER_LOW|IRQF_TRIGGER_HIGH,
"proximity", proximity);
if (err < 0)
printk(KERN_ERR"%s: request irq failed, proximity: %p\n", __func__, proximity);
err = misc_register(&proximity_device);
if (err)
printk(KERN_ERR "%s: misc register failed\n", __func__);
#if 0
vreg_proximity = vreg_get(0, "ruim");
vreg_set_level(vreg_proximity, 2800);
vreg_enable(vreg_proximity);
#endif
proximity->early_suspend_proximity.suspend = proximity_early_suspend;
proximity->early_suspend_proximity.resume = proximity_early_resume;
register_early_suspend(&proximity->early_suspend_proximity);
err = device_create_file(&pdev->dev, &dev_attr_proximity);
if (err)
printk(KERN_ERR"%s: device_create_file failed\n", __func__);
this_proximity = proximity;
return 0;
}