int sanremo_tsi_enable_headset(int headset_en)
{
u8 tmp;
if (sanremo_version < 0x48) {
if (headset_en) {
sanremo_read(SANREMO_AUDIO_REG_BASE + SANREMO_AUDIO_HEADSET_DETECTION, &tmp);
tmp |= 0x01;
sanremo_write(SANREMO_AUDIO_REG_BASE + SANREMO_AUDIO_HEADSET_DETECTION, tmp);
} else {
sanremo_read(SANREMO_AUDIO_REG_BASE + SANREMO_AUDIO_HEADSET_DETECTION, &tmp);
tmp &= ~0x01;
sanremo_write(SANREMO_AUDIO_REG_BASE + SANREMO_AUDIO_HEADSET_DETECTION, tmp);
}
} else {
if (headset_en) {
sanremo_read(SANREMO_AUDIO_HEADSET_DETECTION_BO, &tmp);
tmp |= 0x01;
sanremo_write(SANREMO_AUDIO_HEADSET_DETECTION_BO, tmp);
} else {
sanremo_read(SANREMO_AUDIO_HEADSET_DETECTION_BO, &tmp);
tmp &= ~0x01;
sanremo_write(SANREMO_AUDIO_HEADSET_DETECTION_BO, tmp);
}
}
return 0;
}
int sanremo_tsi_enable_mic(int mic_en)
{
u8 tmp;
if (sanremo_version < 0x48) {
if (mic_en) {
sanremo_read(SANREMO_AUDIO_REG_BASE + SANREMO_AUDIO_MIC_BUTTON_DETECTION, &tmp);
tmp |= 0x27;
sanremo_write(SANREMO_AUDIO_REG_BASE + SANREMO_AUDIO_MIC_BUTTON_DETECTION, tmp);
} else {
sanremo_read(SANREMO_AUDIO_REG_BASE + SANREMO_AUDIO_MIC_BUTTON_DETECTION, &tmp);
tmp &= ~0x27;
sanremo_write(SANREMO_AUDIO_REG_BASE + SANREMO_AUDIO_MIC_BUTTON_DETECTION, tmp);
}
} else {
if (mic_en) {
sanremo_read(SANREMO_AUDIO_MIC_BUTTON_DETECTION_B0, &tmp);
tmp |= 0x27;
sanremo_write(SANREMO_AUDIO_MIC_BUTTON_DETECTION_B0, tmp);
} else {
sanremo_read(SANREMO_AUDIO_MIC_BUTTON_DETECTION_B0, &tmp);
tmp &= ~0x27;
sanremo_write(SANREMO_AUDIO_MIC_BUTTON_DETECTION_B0, tmp);
}
}
return 0;
}
int sanremo_get_headset_state(void)
{
u8 tmp;
if (sanremo_version < 0x48) {
sanremo_read(SANREMO_STATUS, &tmp);
return (tmp & SANREMO_MICIN_STATUS) ? 1 : 0;
} else {
sanremo_read(SANREMO_STATUS_B0, &tmp);
return (tmp & SANREMO_HEADSET_STATUS) ? 0 : 1;
}
}
int sanremo_get_vbat(void)
{
u8 tmp;
unsigned int val;
sanremo_read(SANREMO_VBAT_MEAS2, &tmp);
val = tmp&0xf;
sanremo_read(SANREMO_VBAT_MEAS1, &tmp);
val += tmp<<4;
return val*131836/100000;
}
int sanremo_tsi_enable_tsi(int tsi_en)
{
u8 tmp;
if(tsi_en) {
sanremo_read(SANREMO_MEAS_ENABLE3, &tmp);
tmp |= 0x30;
sanremo_write(SANREMO_MEAS_ENABLE3, tmp);
} else {
sanremo_read(SANREMO_MEAS_ENABLE3, &tmp);
tmp &= ~0x30;
sanremo_write(SANREMO_MEAS_ENABLE3, tmp);
}
return 0;
}
int sanremo_tsi_enable_pen(int pen_en)
{
u8 tmp;
if(pen_en) {
sanremo_read(SANREMO_MEAS_ENABLE3, &tmp);
tmp |= 0x08;
sanremo_write(SANREMO_MEAS_ENABLE3, tmp);
} else {
sanremo_read(SANREMO_MEAS_ENABLE3, &tmp);
tmp &= ~0x08;
sanremo_write(SANREMO_MEAS_ENABLE3, tmp);
}
return 0;
}
int sanremo_tsi_readxy(u16 *x, u16 *y, int *pen_state)
{
u8 meas1, meas2;
sanremo_read(SANREMO_TSIX_MEAS1, &meas1);
sanremo_read(SANREMO_TSIX_MEAS2, &meas2);
*pen_state = (meas2 & (1<<6))? 1 : 0;
if(*pen_state) {
*x = (meas1 << 4) + (meas2 & 0xf);
sanremo_read(SANREMO_TSIY_MEAS1, &meas1);
sanremo_read(SANREMO_TSIY_MEAS2, &meas2);
*y = (meas1 << 4) + (meas2 & 0xf);
}
return 0;
}
int sanremo_enable_headset_irq(int enable)
{
u8 tmp;
if (enable) {
sanremo_read(SANREMO_INTERRUPT_ENABLE3, &tmp);
if (!(tmp & SANREMO_HEADSET_MASK)) {
tmp |= SANREMO_HEADSET_MASK;
sanremo_write(SANREMO_INTERRUPT_ENABLE3, tmp);
}
} else {
sanremo_read(SANREMO_INTERRUPT_ENABLE3, &tmp);
if (tmp & SANREMO_HEADSET_MASK) {
tmp &= ~SANREMO_HEADSET_MASK;
sanremo_write(SANREMO_INTERRUPT_ENABLE3, tmp);
}
}
return 0;
}
void sanremo_turn_off_power(void)
{
u8 tmp;
printk("turning off power....\n");
sanremo_read(SANREMO_RESET_OUT, &tmp);
sanremo_write(SANREMO_RESET_OUT, tmp | 0x80);
return;
}
static void sanremo_stop_charging(void)
{
u8 tmp;
printk("sanremo stop charging\n");
/*disable TIT and IBAT measurement*/
sanremo_read(SANREMO_MEAS_ENABLE1, &tmp);
sanremo_write(SANREMO_MEAS_ENABLE1, tmp&(~SANREMO_MEAS_EN1_TINT));
sanremo_read(SANREMO_MEAS_ENABLE3, &tmp);
sanremo_write(SANREMO_MEAS_ENABLE3, tmp&(~SANREMO_MEAS_EN3_IBAT));
/*disable GPADC FSM */
sanremo_read(SANREMO_GPADC_MISC1, &tmp);
sanremo_write(SANREMO_GPADC_MISC1, tmp&(~SANREMO_GPADC_MISC1_GPFSM_EN));
/*enable interrupts*/
sanremo_read(SANREMO_INTERRUPT_ENABLE3, &tmp);
sanremo_write(SANREMO_INTERRUPT_ENABLE3,
tmp&(~(SANREMO_CHG_FAIL_MASK|SANREMO_CHG_DONE_MASK|
SANREMO_CHG_IOVER_MASK)));
charging_status = 0;
}
static void sanremo_on_key_event(void)
{
u8 tmp;
unsigned int val;
/*check for battery*/
sanremo_read(SANREMO_STATUS, &tmp);
if(tmp & SANREMO_ONKEY_STATUS) {
printk(KERN_INFO "On key pressed\n");
sanremo_turn_off_booster();
sanremo_turn_off_power();
return;
}else {
printk(KERN_INFO "On key released\n");
}
}
static void sanremo_charger_init(void)
{
u8 tmp;
int val;
/*enable interrupt*/
sanremo_read(SANREMO_INTERRUPT_ENABLE1, &tmp);
sanremo_write(SANREMO_INTERRUPT_ENABLE1,
tmp|SANREMO_CHG_MASK);
sanremo_read(SANREMO_INTERRUPT_ENABLE1, &tmp);
/*detection*/
sanremo_read(SANREMO_MEAS_OFF_TIME1, &tmp);
sanremo_write(SANREMO_MEAS_OFF_TIME1, tmp|0x1);
if (sanremo_version < 0x48) {
sanremo_read(SANREMO_GPADC_MISC2, &tmp);
sanremo_write(SANREMO_GPADC_MISC2, tmp|0x40);
} else {
sanremo_read(SANREMO_CHG_CTRL6, &tmp);
sanremo_write(SANREMO_CHG_CTRL6, tmp|0x01);
}
sanremo_write(SANREMO_VBAT_LOW_TH, 0xaa);
sanremo_read(SANREMO_MEAS_ENABLE1, &tmp);
sanremo_write(SANREMO_MEAS_ENABLE1, tmp|SANREMO_MEAS_EN1_VBAT);
/*
sanremo_read(SANREMO_INTERRUPT_ENABLE2, &tmp);
sanremo_write(SANREMO_INTERRUPT_ENABLE2,
tmp|SANREMO_VBAT_MASK);
*/
kthread_run(sanremo_charging_display, NULL, "cdisplay");
// sanremo_start_charging();
}
static int sanremo_ts_probe(struct platform_device *pdev)
{
int ret;
u8 tmp;
if(sanremo_read(SANREMO_ID, &tmp) < 0)
return -ENODEV;
sanremo_td = kzalloc(sizeof(struct sanremo_ts_data), GFP_KERNEL);
if (!sanremo_td) {
ret = -ENOMEM;
goto sanremo_ts_out;
}
sanremo_td->use_count = 0;
sanremo_td->ts_timer =
(struct timer_list *)kmalloc(sizeof(struct timer_list), GFP_KERNEL);
init_timer(sanremo_td->ts_timer);
sanremo_td->ts_timer->function = sanremo_ts_timer_handler;
// sanremo_td->ts_timer->data = sanremo_td;
/* register input device */
sanremo_ts_input_dev = input_allocate_device();
if (sanremo_ts_input_dev == NULL) {
printk(KERN_ERR "%s: failed to allocate input dev\n",
__FUNCTION__);
return -ENOMEM;
}
sanremo_ts_input_dev->name = "sanremo-ts";
sanremo_ts_input_dev->phys = "sanremo-ts/input0";
sanremo_ts_input_dev->dev.parent = &pdev->dev;
sanremo_ts_input_dev->open = sanremo_ts_open;
sanremo_ts_input_dev->close = sanremo_ts_close;
__set_bit(EV_ABS, sanremo_ts_input_dev->evbit);
__set_bit(ABS_X, sanremo_ts_input_dev->absbit);
__set_bit(ABS_Y, sanremo_ts_input_dev->absbit);
__set_bit(ABS_PRESSURE, sanremo_ts_input_dev->absbit);
__set_bit(EV_SYN, sanremo_ts_input_dev->evbit);
__set_bit(EV_KEY, sanremo_ts_input_dev->evbit);
__set_bit(BTN_TOUCH, sanremo_ts_input_dev->keybit);
input_set_abs_params(sanremo_ts_input_dev, ABS_X, 0, 3600, 0, 0);
input_set_abs_params(sanremo_ts_input_dev, ABS_Y, 0, 3800, 0, 0);
input_set_abs_params(sanremo_ts_input_dev, ABS_PRESSURE, 0, 255, 0, 0);
input_set_abs_params(sanremo_ts_input_dev, ABS_TOOL_WIDTH, 0, 15, 0, 0);
ret = input_register_device(sanremo_ts_input_dev);
if (ret) {
printk(KERN_ERR
"%s: unabled to register input device, ret = %d\n",
__FUNCTION__, ret);
return ret;
}
/* The Littleton IRQ come from Sanremo. So we just implemate
* a callback IRQ function for Sanremo.
*/
ret = pmic_callback_register(PMIC_EVENT_TOUCH, sanremo_ts_interrupt);
if (ret < 0)
goto pmic_cb_out;
return 0;
pmic_cb_out:
input_unregister_device(sanremo_ts_input_dev);
sanremo_ts_out:
kfree(sanremo_td);
return ret;
}
static int get_sanremo_voltage(int cmd, int *pmv)
{
int power_module, status = 0, data;
u8 val;
*pmv = -1;
power_module = get_power_supply_module(cmd);
start_calc_time();
switch (power_module) {
case SAN_BUCK1:
case SAN_BUCK1_SLEEP:
status = sanremo_read(SANREMO_REG(power_module), &val);
if (!status) {
data = val & 0x3f;
*pmv = SANREMO_VBUCK1_MV(data);
}
break;
case SAN_BUCK2:
case SAN_BUCK2_SLEEP:
status = sanremo_read(SANREMO_REG(power_module), &val);
if (!status) {
data = val & 0x3f;
*pmv = SANREMO_VBUCK2_MV(data);
}
break;
case SAN_BUCK3:
case SAN_BUCK3_SLEEP:
status = sanremo_read(SANREMO_REG(power_module), &val);
if (!status) {
data = val & 0x3f;
*pmv = SANREMO_VBUCK3_MV(data);
}
break;
case SAN_LDO1:
status = sanremo_read(SANREMO_LDO1, &val);
if (!status) {
data = val & 0x3f;
*pmv = SANREMO_LDO1_MV(data);
}
break;
case SAN_LDO1_SLEEP:
status = sanremo_read(SANREMO_LDO1, &val);
if (!status) {
data = (val >> 2) & 0x03;
*pmv = SANREMO_LDO1_SLEEP_MV(data);
}
break;
case SAN_LDO2:
case SAN_LDO3:
case SAN_LDO4:
case SAN_LDO7:
case SAN_LDO8:
case SAN_LDO9:
case SAN_LDO14:
status = sanremo_read(SANREMO_REG(power_module), &val);
if (!status) {
data = val & 0x07;
*pmv = SANREMO_LDO2_MV(data);
}
break;
case SAN_LDO2_SLEEP:
case SAN_LDO3_SLEEP:
case SAN_LDO4_SLEEP:
case SAN_LDO7_SLEEP:
case SAN_LDO8_SLEEP:
case SAN_LDO9_SLEEP:
case SAN_LDO14_SLEEP:
status = sanremo_read(SANREMO_REG(power_module), &val);
if (!status) {
data = (val >> 3) & 0x07;
*pmv = SANREMO_LDO2_MV(data);
}
static unsigned int sanremo_event_change(void)
{
unsigned int ret = 0;
u8 status1, status2, status3;
u8 e1, e2, e3;
u8 tmp;
sanremo_read(SANREMO_INTERRUPT_STATUS1, &status1);
sanremo_read(SANREMO_INTERRUPT_STATUS2, &status2);
sanremo_read(SANREMO_INTERRUPT_STATUS3, &status3);
sanremo_write(SANREMO_INTERRUPT_STATUS1, status1);
sanremo_write(SANREMO_INTERRUPT_STATUS2, status2);
sanremo_write(SANREMO_INTERRUPT_STATUS3, status3);
sanremo_read(SANREMO_INTERRUPT_ENABLE1, &e1);
sanremo_read(SANREMO_INTERRUPT_ENABLE2, &e2);
sanremo_read(SANREMO_INTERRUPT_ENABLE3, &e3);
if (status1 & SANREMO_EXTON_INT)
ret |= PMIC_EVENT_EXTON;
if (status1 & SANREMO_CHG_INT) {
ret |= PMIC_EVENT_CHARGER | PMIC_EVENT_VBUS;
sanremo_read(SANREMO_STATUS, &tmp);
usb_connect = !!(tmp & SANREMO_CHG_STATUS);
sanremo_start_charging();
}
if (status1 & SANREMO_ONKEY_INT) {
ret |= PMIC_EVENT_ON_KEY;
if (mod_timer(&on_key_timer, jiffies + ONKEY_TIMER_TIMEOUT)) {
/* timer is active already */
}
}
/*
if (status2 & SANREMO_VBAT_MASK) {
printk(KERN_INFO "Battery is low.\n");
sanremo_start_charging();
}
*/
if (status2 & SANREMO_VCHG_INT) {
ret |= PMIC_EVENT_VBUS;
}
if (status2 & SANREMO_GPADC1_INT)
ret |= PMIC_EVENT_TBAT;
if(status3 & SANREMO_PEN_INT)
ret |= PMIC_EVENT_TOUCH;
if (status3 & SANREMO_HEADSET_INT)
ret |= PMIC_EVENT_HSDETECT;
if (status3 & SANREMO_MICIN_INT)
ret |= PMIC_EVENT_MICDETECT;
if (status3 & SANREMO_HOOK_INT)
ret |= PMIC_EVENT_HOOKSWITCH;
if (status3 & SANREMO_CHG_FAIL_INT) {
ret |= PMIC_EVENT_CHARGER;
if(charging_status) {
printk("charging failed.\n");
sanremo_stop_charging();
}
}
if (status3 & SANREMO_CHG_DONE_INT) {
ret |= PMIC_EVENT_CHARGER;
if(charging_status) {
printk("charging done\n");
sanremo_stop_charging();
}
}
if (status3 & SANREMO_CHG_IOVER_INT) {
ret |= PMIC_EVENT_REV_IOVER;
if(charging_status) {
printk("over charging.\n");
sanremo_stop_charging();
}
}
return ret;
}
static void sanremo_start_charging(void)
{
u8 tmp;
unsigned int val;
/*check for battery*/
sanremo_read(SANREMO_STATUS, &tmp);
if(!(tmp & SANREMO_BAT_STATUS)) {
printk(KERN_INFO "Battery is NOT detected, ignore charging\n");
return;
}else {
printk(KERN_INFO "Battery is detected\n");
}
/*check charging*/
sanremo_read(SANREMO_STATUS, &tmp);
if(!(tmp & SANREMO_CHG_STATUS)) {
printk(KERN_INFO "Charger cable is NOT detected\n");
return;
}else {
printk(KERN_INFO "Charger cable is detected\n");
}
val = sanremo_get_vbat();
if(val < 3850) {
printk(KERN_INFO "Voltage is about %dmv, start charging\n", val);
/*enable TIT and IBAT measurement*/
sanremo_read(SANREMO_MEAS_ENABLE1, &tmp);
sanremo_write(SANREMO_MEAS_ENABLE1, tmp|SANREMO_MEAS_EN1_TINT);
sanremo_read(SANREMO_MEAS_ENABLE3, &tmp);
sanremo_write(SANREMO_MEAS_ENABLE3, tmp|SANREMO_MEAS_EN3_IBAT);
/*set a off time*/
if (sanremo_version < 0x48) {
sanremo_write(SANREMO_MEAS_OFF_TIME1, 0x41);
sanremo_read(SANREMO_MEAS_OFF_TIME2, &tmp);
sanremo_write(SANREMO_MEAS_OFF_TIME2, (tmp&0x3f)|0x6c);
} else {
sanremo_read(SANREMO_MEAS_ENABLE3, &tmp);
sanremo_write(SANREMO_MEAS_ENABLE3, tmp|SANREMO_MEASOFFTIME1_BAT_DET_EN_B0);
sanremo_write(SANREMO_MEAS_OFF_TIME1, 0x80);
sanremo_write(SANREMO_MEAS_OFF_TIME2, (tmp&0x7f)|0xd8);
}
/* enable GPADC FSM */
sanremo_read(SANREMO_GPADC_MISC1, &tmp);
sanremo_write(SANREMO_GPADC_MISC1, tmp|SANREMO_GPADC_MISC1_GPFSM_EN);
/*enable interrupts*/
sanremo_read(SANREMO_INTERRUPT_ENABLE3, &tmp);
sanremo_write(SANREMO_INTERRUPT_ENABLE3,
tmp|SANREMO_CHG_FAIL_MASK|SANREMO_CHG_DONE_MASK|
SANREMO_CHG_IOVER_MASK);
/* set pre-regulator to 1000mA & Vsys to 4.5v*/
portofino_write(PORTOFINO_PREREG1,0x09);
/*set the end of charge value and enable s ILIM FSM*/
sanremo_write(SANREMO_CHG_CTRL1, 0x30);
/*set current limit at 550 mA*/
sanremo_write(SANREMO_CHG_CTRL2, 0x2a);
/*set the max charging time to 90 min*/
sanremo_write(SANREMO_CHG_CTRL3, 0x30);
/*enable monitoring*/
sanremo_write(SANREMO_CHG_CTRL4, 0x40);
sanremo_write(SANREMO_GPADC0_MEAS1, 0x82);
charging_status = 1;
wake_up(&charging_display_wait);
/*enable fast charing*/
sanremo_write(SANREMO_CHG_CTRL1, 0x32);
/*set the temperature threshold */
sanremo_write(SANREMO_TINT_MEAS1, 0xc0);
sanremo_write(SANREMO_TINT_MEAS2, 0x82);
sanremo_write(SANREMO_GPADC0_MEAS1, 0x7d);
}
}
