static ssize_t muic_set_reg_sel(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
muic_data_t *pmuic = dev_get_drvdata(dev);
int len = strlen(buf);
unsigned int reg_base = 0, reg_num = 0;
int ret = -EINVAL, i = 0;
#if 0 /* For the compatibility in 64 bit */
pr_info("%s:%s -> %s(%d, %d)\n", MUIC_DEV_NAME, __func__,
buf, count, len);
#endif
if (len < 6) {
ret = kstrtoint(buf, 0, ®_base);
if (ret) {
pr_err("%s: Undefined Regs\n", __func__);
goto err;
}
reg_num = 1;
} else if (len < 10) {
char *ptr;
char reg_buf[8];
strcpy(reg_buf, buf);
ptr = strstr(reg_buf, "++");
*ptr = 0x00;
ret = kstrtoint(reg_buf, 0, ®_base);
if (ret) {
pr_err("%s: Undefined Regs\n", __func__);
goto err;
}
ret = kstrtoint(ptr + 2, 0, ®_num);
if (ret) {
pr_err("%s: Undefined Regs\n", __func__);
goto err;
}
} else {
pr_err("%s: Undefined Regs\n", __func__);
goto err;
}
pr_info(" (reg_base,reg_num) = (0x%02x,%d)\n", reg_base, reg_num);
memset(reg_dump_buf, 0x00, sizeof(reg_dump_buf));
while (reg_num--) {
mutex_lock(&pmuic->muic_mutex);
ret = muic_i2c_read_byte(pmuic->i2c, reg_base + i);
mutex_unlock(&pmuic->muic_mutex);
if (ret < 0) {
pr_err("%s:%s err read %d\n", MUIC_DEV_NAME, __func__,
reg_base);
goto err;
}
pr_info(" [%02x] : %02x\n", reg_base, ret);
sprintf(reg_dump_buf + strlen(reg_dump_buf),
" [%02x] : %02x\n", reg_base + i++, ret);
}
err:
return count;
}
int muic_set_device_none_detect(struct i2c_client *client,
unsigned char int_stat_value)
{
// s32 loop = 0;
unsigned char charger_value = 0;
unsigned char stat_value = 0;
// unsigned char Accessory_value = 0;
// unsigned char orginal_value = 0;
unsigned char id_register_value = 0;
// int i;
id_register_value = 0x0f & int_stat_value;
dev_info(&client->dev, "muic: %s, muic_retain_mode:%d, Int_Status:%d, INT_STATUS:0x%2x\n",
__func__,muic_retain_mode, Int_Status, int_stat_value);
if(int_stat_value & VBUS) {// VBUS = High
dev_info(&client->dev, "muic: %s: VBUS is High....\n", __func__);
if(muic_process_retention_mode(client))
return 0;
if(Second_Int == tsu5611_process_reset_muic(client))
return 0;
if( (int_stat_value & CHGDET) || (charger_value & CHPORT))
{
dev_info(&client->dev, "muic: Charger detection....\n");
muic_i2c_write_byte(client, CONTROL_2, 0x02);
mdelay(250); // if charger type then waiting 250ms
muic_i2c_read_byte(client, STATUS, &charger_value); // 06H register read
muic_i2c_read_byte(client, INT_STATUS1, &stat_value);
dev_info(&client->dev, "muic: STATUS register:0x%x, INT_STATUS1 register:0x%x\n",
charger_value, stat_value);
muic_set_charger_mode(client, charger_value);
// Int_Status = First_Int;
}else if((id_register_value == IDNO_0010) // 56k + VBUS
|| (id_register_value == IDNO_1010) // 910k + VBUS
|| (id_register_value == IDNO_1001)) // 620k + VBUS
{
muic_set_mode(MUIC_CP_USB);
}else if(id_register_value == IDNO_0100){
muic_set_mode(MUIC_CP_UART);
}else if(IDNO_0000 ==id_register_value){
muic_set_mode(MUIC_MHL);
#if 0
}else if(0){
muic_set_mode(MUIC_AP_UART);
#endif
}else{
muic_set_mode(MUIC_AP_USB);
#if 0
}else{
int muic_set_device_none_detect(struct i2c_client *client,unsigned char int_stat_value)
{
// s32 loop = 0;
unsigned char charger_value = 0;
// unsigned char stat_value = 0;
// unsigned char Accessory_value = 0;
// unsigned char orginal_value = 0;
unsigned char id_register_value = 0;
// int i;
id_register_value = 0x0f & int_stat_value;
dev_info(&client->dev, "muic: %s, muic_retain_mode:%d, Int_Status:%d, INT_STATUS:0x%2x\n",
__func__,muic_retain_mode, Int_Status, int_stat_value);
if(int_stat_value & VBUS)
{// VBUS = High
dev_info(&client->dev, "muic: %s: VBUS is High.... id_register_value:%d\n", __func__,id_register_value);
if(muic_process_retention_mode(client))
return 0;
//if(Second_Int == max14526_process_reset_muic(client))
//return 0;
if(id_register_value == IDNO_0010 /*56k + VBUS*/)
{
muic_set_mode(MUIC_CP_USB);
}
else if(id_register_value == IDNO_1010 /*910k + VBUS*/)
{
muic_set_mode(MUIC_CP_USB);
}
else if(id_register_value == IDNO_1001 /*620k + VBUS*/)
{
muic_set_mode(MUIC_CP_USB);
}
else if(id_register_value == IDNO_0100)/*130k + VBUS*/
{
muic_set_mode(MUIC_CP_UART);
}
#if defined(CONFIG_MHL)
else if(id_register_value==IDNO_0000)
{
muic_set_mode(MUIC_MHL);
}
#endif
else if(id_register_value == IDNO_0101)/*180k + VBUS LG proprietary TA Detected*/
{
//muic_set_mode(MUIC_LG_TA);
muic_set_mode(MUIC_AP_USB);//lg usb calble\C0\C7 int_stat_value =0x15 \B7\CE \B5\BF\C0۵Ǿ\EE, \C0Ϲ\DD usb cable\B7\CE \BC\F6\C1\A4 \C7\D4.
}
else// if(charger_value & CHPORT)
{
dev_info(&client->dev, "muic: Charger detection....\n");
muic_i2c_write_byte(client,SW_CONTROL, COMP2_TO_HZ | COMN1_TO_C1COMP);
//muic_mdelay(2);//mdelay(250); // if charger type then waiting 250ms
//muic_i2c_read_byte(client, INT_STAT, &stat_value);
muic_i2c_read_byte(client,STATUS, &charger_value);
dev_info(&client->dev, "muic: charger_value :0x%x\n",charger_value);
//muic_set_charger_mode(client, charger_value);
//else if( (stat_value & CHGDET)&&((id_register_value & IDNO) == IDNO_1011))//stat_value==0x9B \C0Ϲ\DD \C3\E6\C0\FC\B1\E2
#ifdef CONFIG_FORCE_FAST_CHARGE
if((int_stat_value & CHGDET) || (force_fast_charge != 0))
{
muic_i2c_write_byte(client,SW_CONTROL, COMP2_TO_HZ | COMN1_TO_HZ);
muic_set_mode(MUIC_LG_TA);
}
#else
if(int_stat_value & CHGDET)
{
muic_i2c_write_byte(client,SW_CONTROL, COMP2_TO_HZ | COMN1_TO_HZ);
muic_set_mode(MUIC_LG_TA);
}
#endif
else if (charger_value & DCPORT)
{
/* Not used actually. Special TA for North America.*/
muic_i2c_write_byte(client,SW_CONTROL, COMP2_TO_HZ | COMN1_TO_HZ);
muic_set_mode(MUIC_NA_TA);
}
else if (charger_value & CHPORT)
{
//muic_i2c_write_byte(client,SW_CONTROL, COMP2_TO_HZ | COMN1_TO_HZ);
muic_set_mode(MUIC_AP_USB);
}
else if (charger_value & C1COMP)
{//MUIC_LG_TA , CHARGING_LG_TA
muic_i2c_write_byte(client,SW_CONTROL, COMP2_TO_HZ | COMN1_TO_HZ);
muic_set_mode(MUIC_LG_TA);
//muic_path = MUIC_LG_TA;
//charging_mode = CHARGING_LG_TA;
}
else //stat_value==0x1B \C0Ϲ\DD UBS\C4\C9\C0̺\ED
{
//set_max14526_ap_usb_mode();
muic_set_mode(MUIC_AP_USB);
//muic_path = MUIC_AP_USB;
//charging_mode = CHARGING_USB;
}
}
}
else
{
muic_set_mode(MUIC_NONE);
}
return 0;
}
s32 muic_max14526_detect_accessory(struct i2c_client *client, s32 upon_irq)
{
s32 ret = 0;
s32 loop = 0;
u8 int_stat_value=0;
TYPE_MUIC_MODE muic_mode = muic_get_mode();
struct ts5usb_device *dev = i2c_get_clientdata(client);
/*
* Upon an MUIC IRQ (MUIC_INT_N falls),
* wait 70ms before reading INT_STATUS1 and STATUS.
* After the reads, MUIC_INT_N returns to high
* (but the INT_STATUS1 and STATUS contents will be held).
*
* Do this only if muic_max14526_detect_accessory() was called upon IRQ.
*/
if (upon_irq) {
mdelay(70);
}
/* Read INT_STATUS1 */
ret = muic_i2c_read_byte(client, INT_STAT, &int_stat_value);
dev_info(&client->dev, "muic: %s: int_stat_value:0x%x :%d\n", __func__, int_stat_value, muic_mode);
if (ret < 0) {
dev_info(&client->dev, "muic: INT_STATUS1 reading failed\n");
muic_set_mode(MUIC_UNKNOWN);
return ret;
}
switch (muic_mode)
{/* Branch according to the previous muic_mode */
case MUIC_UNKNOWN :
case MUIC_NONE :
muic_set_device_none_detect(client, int_stat_value);
break;
case MUIC_AP_UART :
case MUIC_CP_UART :
dev_info(&client->dev, "muic: MUIC_AP_UART || MUIC_CP_UART\n");
if(!(int_stat_value & VBUS)&&(IDNO_0010 == (int_stat_value & 0x0f)))
{
muic_set_mode(MUIC_CP_USB);
}
else if (!(int_stat_value & VBUS))
{
muic_i2c_write_byte(client, SW_CONTROL, DP_UART | DM_UART);
muic_set_mode(MUIC_NONE);
}
else
{
dev_info(&client->dev, "UART is not removed\n");
}
break;
case MUIC_NA_TA :
case MUIC_LG_TA :
case MUIC_TA_1A :
case MUIC_INVALID_CHG :
dev_info(&client->dev, "muic: Detect step2\n");
if (((int_stat_value & VBUS) == 0) ||((int_stat_value & CHGDET) == 0))
{
muic_set_mode(MUIC_NONE);
}
else
{
dev_info(&client->dev, "TA is not removed\n");
}
break;
case MUIC_AP_USB :
/* USB Host Removed */
if((int_stat_value & VBUS) == 0)
{
android_USB_disconnect();// for usb disconnect event
muic_set_mode(MUIC_NONE);
}
else
{
dev_info(&client->dev, "AP USB is not removed\n");
}
break;
case MUIC_CP_USB :
if((int_stat_value & VBUS) == 0)
{
muic_set_mode(MUIC_NONE);
}
else
{
dev_info(&client->dev, "CP USB is not removed\n");
}
break;
#if defined(CONFIG_MHL_TX_SII9244) || defined(CONFIG_MHL_TX_SII9244_LEGACY)
case MUIC_MHL :
dev_info(&client->dev, "muic: Detect step3 mhl \n");
if ((int_stat_value & VBUS) == 0) {
//MHL_On(0);
muic_set_mode(MUIC_NONE);
}
break;
#endif
default:
dev_info(&client->dev, "muic: Failed to detect an accessory. Try again!");
muic_set_mode(MUIC_UNKNOWN);
ret = -1;
break;
}
muic_mode = muic_get_mode();
dev_info(&client->dev, "muic: muic_detection_mode=%d \n", muic_mode);
if (muic_mode == MUIC_UNKNOWN || muic_mode == MUIC_NONE) {
#if defined(CONFIG_MHL) && defined(CONFIG_MHL_TX_MUIC_BUG_FIX)
/* SJIT 2012-01-27 [[email protected]] P940 GB
* max14526 300ms delay side effect bug fixed test code
*/
if (Int_Status == Second_Int) {
if (!gpio_get_value(dev->gpio_mhl)) {
dev_info(&client->dev, "muic: wait for mhl switch completed\n");
muic_init_max14526(client, DEFAULT);
gpio_set_value(dev->gpio_ifx_vbus, 0);
}
else {
dev_info(&client->dev, "muic: mhl switch not completed\n");
while (!gpio_get_value(dev->gpio_mhl)) {
udelay(500);
muic_set_mode(MUIC_MHL);
// MHL_On(0);
}
dev_info(&client->dev, "muic: mhl switch completed\n");
muic_init_max14526(client, DEFAULT);
gpio_set_value(dev->gpio_ifx_vbus, 0);
}
}
else {
muic_init_max14526(client, DEFAULT);
gpio_set_value(dev->gpio_ifx_vbus, 0);
}
#else
muic_init_max14526(client, RESET);
gpio_set_value(IFX_USB_VBUS_EN_GPIO, 0);
//charging_ic_deactive();
dev_info(&client->dev, "muic: charging_ic_deactive()\n");
#endif
}
// LGE_CHANGES_S [[email protected]] 2012-03-19
#if defined(CONFIG_MAX8971_CHARGER)
if(muic_mode == MUIC_NA_TA || muic_mode == MUIC_LG_TA || muic_mode == MUIC_TA_1A)
{
printk("[MUIC] max8971_start_charging TA\n");
max8971_start_charging(900);
}
else if(muic_mode == MUIC_AP_USB)
{
printk("[MUIC]max8971_start_charging USB\n");
max8971_start_charging(500);
}
/* else if( muic_mode == MUIC_CP_USB || muic_mode == MUIC_CP_UART)
{
printk("[MUIC] max8971_start_charging Factory\n");
max8971_start_charging(1550);
}
*/
else if( muic_mode == MUIC_CP_USB )
{
//printk("[MUIC] max8971_stop due to MUIC_CP_USB mode \n");
printk("[MUIC] max8971_start_charging Factory MUIC_CP_USB \n");
// max8971_start_charging(1550);
// max8971_stop_charging();
max8971_start_Factory_charging();
}
else if( muic_mode == MUIC_CP_UART)
{
printk("[MUIC] max8971_start_charging Factory MUIC_CP_UART \n");
//printk("[MUIC] max8971_stop due to MUIC_CP_UART mode \n");
// max8971_stop_charging();
// max8971_start_charging(1550);
max8971_start_Factory_charging();
}
else if( muic_mode == MUIC_MHL)
{
printk("[MUIC] max8971_start_charging MHL\n");
max8971_start_charging(400);
}
else if( muic_mode == MUIC_NONE)
{
printk("[MUIC] max8971_stop_charging\n");
max8971_stop_charging();
}
else
printk("[MUIC] can not open muic mode\n");
// LGE_CHANGES_E [[email protected]] 2012-03-19
#endif
return ret;
}
s32 muic_max14526_detect_accessory(s32 upon_irq)
{
s32 ret = 0;
int loop = 0;
u8 int_stat_value;
/* Upon an MUIC IRQ (MUIC_INT_N falls),
* wait 70ms before reading INT_STAT and STATUS.
* After the reads, MUIC_INT_N returns to high
* (but the INT_STAT and STATUS contents will be held).
*
* Do this only if muic_max14526_detect_accessory() was called upon IRQ. */
if (upon_irq) {
for (; loop < 250; loop++)
muic_udelay(1000);
}
/* Reads INT_STAT */
ret = muic_i2c_read_byte(INT_STAT, &int_stat_value);
if (ret < 0) {
printk(KERN_INFO "[chahee.kim] INT_STAT reading failed\n");
muic_mode = MUIC_UNKNOWN;
return ret;
}
printk(KERN_INFO "[chahee.kim] IDNO = %d\n", (int_stat_value & IDNO));
muic_mode = int_stat_value & IDNO;
/* Branches according to the previous muic_mode */
switch (muic_mode) {
/* MUIC_UNKNOWN is reached in two cases both do not have nothing to do with IRQ.
* First, at the initialization time where the muic_mode is not available yet.
* Second, whenever the current muic_mode detection is failed.
*/
case MUIC_UNKNOWN :
/* If the previous muic_mode was MUIC_NONE,
* the only possible condition for a MUIC IRQ is plugging in an accessory.
*/
case MUIC_NONE :
set_max14526_muic_mode(int_stat_value);
break;
/* If the previous muic_mode was MUIC_NA_TA, MUIC_LG_TA, MUIC_TA_1A, MUIC_INVALID_CHG,
* MUIC_AP_UART, MUIC_CP_UART, MUIC_AP_USB, MUIC_OTG, or MUIC_CP_USB,
* the only possible condition for a MUIC IRQ is plugging out the accessory.
*
* In this case, initialize MUIC and wait an IRQ.
* We don't need to wait 250msec because this is not an erronous case
* (we need to reset the facility to set STATUS for an erronous case and
* have to wait 250msec) and, if this is not an erronous case, the facility
* was already initialized at the system booting.
*/
case MUIC_NA_TA:
case MUIC_TA_1A:
case MUIC_INVALID_CHG :
if ((int_stat_value & VBUS) == 0) {
// Exit Charger Mode
muic_mode = MUIC_NONE;
}else{
set_max14526_muic_mode(int_stat_value);
}
break;
case MUIC_LG_TA :
printk(KERN_WARNING "[chahee.kim] LG_TA");
if ((int_stat_value & CHGDET) == 0) {
muic_mode = MUIC_NONE;
}
else {
set_max14526_muic_mode(int_stat_value);
}
break;
case MUIC_AP_UART :
if ((int_stat_value & IDNO) == IDNO_1011) {
/* Exit Factory Mode */
muic_mode = MUIC_NONE;
}
else {
set_max14526_muic_mode(int_stat_value);
}
break;
case MUIC_AP_USB :
if ((int_stat_value & VBUS) == 0) {
/* USB Host Removed */
muic_mode = MUIC_NONE;
}else{
set_max14526_muic_mode(int_stat_value);
}
break;
default:
printk(KERN_WARNING "[chahee.kim] Failed to detect an accessory. Try again!\n");
#ifndef CHARGER_TEST
lge_charger_disable();
#endif
muic_mode = MUIC_UNKNOWN;
ret = -1;
break;
}
printk(KERN_WARNING "[chahee.kim] muic_max14526_detect_accessory, muic_mode = %d \n", muic_mode );
//if (muic_mode == MUIC_UNKNOWN || muic_mode == MUIC_NONE) {
// muic_init_max14526(DEFAULT);
// printk(KERN_INFO "[chahee.kim] charging_ic_deactive()\n");
//}
return ret;
}
s32 muic_max14526_detect_accessory(s32 upon_irq)
{
s32 ret = 0;
u8 int_stat_value;
/* For detecting time */
muic_mdelay(250);
/* Reads INT_STAT */
ret = muic_i2c_read_byte(muic_client,INT_STAT, &int_stat_value);
printk(KERN_WARNING "[MUIC] muic_max14526_detect_accessory, int_stat_value = 0x%02x \n", int_stat_value);
if (ret < 0) {
printk(KERN_INFO "[MUIC] INT_STAT reading failed\n");
muic_path = MUIC_UNKNOWN;
charging_mode = CHARGING_UNKNOWN;
//LGE_CHANGE_S [[email protected]] let charger know muic detected charger type..
//set_muic_charger_detected();
return ret;
}
/* Branches according to the previous muic_path */
switch (muic_path) {
/* MUIC_UNKNOWN is reached in two cases both do not have nothing to do with IRQ.
* First, at the initialization time where the muic_path is not available yet.
* Second, whenever the current muic_path detection is failed.
*/
case MUIC_UNKNOWN :
/* If the previous muic_path was MUIC_NONE,
* the only possible condition for a MUIC IRQ is plugging in an accessory.
*/
case MUIC_NONE :
set_max14526_muic_path(int_stat_value);
break;
/* If the previous muic_path was MUIC_NA_TA, MUIC_LG_TA, MUIC_TA_1A, MUIC_INVALID_CHG,
* MUIC_AP_UART, MUIC_CP_UART, MUIC_AP_USB, MUIC_OTG, or MUIC_CP_USB,
* the only possible condition for a MUIC IRQ is plugging out the accessory.
*
* In this case, initialize MUIC and wait an IRQ.
* We don't need to wait 250msec because this is not an erronous case
* (we need to reset the facility to set STATUS for an erronous case and
* have to wait 250msec) and, if this is not an erronous case, the facility
* was already initialized at the system booting.
*/
case MUIC_NA_TA:
case MUIC_TA_1A:
case MUIC_INVALID_CHG :
case MUIC_LG_TA :
case MUIC_AP_UART :
case MUIC_CP_UART :
case MUIC_AP_USB :
case MUIC_CP_USB :
if ((int_stat_value & VBUS) != 0) {
set_max14526_muic_path(int_stat_value);
} else if ((int_stat_value & IDNO) == IDNO_1011) {
charging_mode = CHARGING_NONE;
muic_path = MUIC_NONE;
} else
set_max14526_muic_path(int_stat_value);
break;
default :
printk(KERN_WARNING "[MUIC] Failed to detect an accessory. Try again!");
muic_path = MUIC_UNKNOWN;
charging_mode = CHARGING_UNKNOWN;
ret = -1;
}
printk(KERN_WARNING "[MUIC] muic_max14526_detect_accessory, muic_path = %s, charing = %s\n",
muic_path_str[muic_path], charging_mode_str[charging_mode]);
if (muic_path == MUIC_UNKNOWN || muic_path == MUIC_NONE) {
muic_init_max14526(RESET);
gpio_set_value(IFX_USB_VBUS_EN_GPIO, 0);
printk(KERN_INFO "[MUIC] charging_ic_deactive()\n");
}
//LGE_CHANGE_S [[email protected]] let charger know muic detected charger type..
//set_muic_charger_detected();
return ret;
}
s32 muic_max14526_detect_accessory(s32 upon_irq)
{
s32 ret = 0;
u8 int_stat_value;
/* Upon an MUIC IRQ (MUIC_INT_N falls),
* wait 70ms before reading INT_STAT and STATUS.
* After the reads, MUIC_INT_N returns to high
* (but the INT_STAT and STATUS contents will be held).
*
* Do this only if muic_max14526_detect_accessory() was called upon IRQ. */
muic_mdelay(250);
/* Reads INT_STAT */
ret = muic_i2c_read_byte(INT_STAT, &int_stat_value);
printk(KERN_WARNING "[MUIC] muic_max14526_detect_accessory, int_stat_value = 0x%02x \n", int_stat_value);
if (ret < 0) {
printk(KERN_INFO "[MUIC] INT_STAT reading failed\n");
muic_mode = MUIC_UNKNOWN;
charging_mode = CHARGING_UNKNOWN;
return ret;
}
//ret = muic_i2c_write_byte(CONTROL_2, 0x00); //interrupt masked by [email protected] for debugging
//muic_mode = int_stat_value & IDNO;
//set_max14526_device_none_detect(int_stat_value);
/* Branches according to the previous muic_mode */
switch (muic_mode) {
/* MUIC_UNKNOWN is reached in two cases both do not have nothing to do with IRQ.
* First, at the initialization time where the muic_mode is not available yet.
* Second, whenever the current muic_mode detection is failed.
*/
case MUIC_UNKNOWN :
/* If the previous muic_mode was MUIC_NONE,
* the only possible condition for a MUIC IRQ is plugging in an accessory.
*/
case MUIC_NONE :
set_max14526_muic_mode(int_stat_value);
break;
/* If the previous muic_mode was MUIC_NA_TA, MUIC_LG_TA, MUIC_TA_1A, MUIC_INVALID_CHG,
* MUIC_AP_UART, MUIC_CP_UART, MUIC_AP_USB, MUIC_OTG, or MUIC_CP_USB,
* the only possible condition for a MUIC IRQ is plugging out the accessory.
*
* In this case, initialize MUIC and wait an IRQ.
* We don't need to wait 250msec because this is not an erronous case
* (we need to reset the facility to set STATUS for an erronous case and
* have to wait 250msec) and, if this is not an erronous case, the facility
* was already initialized at the system booting.
*/
case MUIC_NA_TA:
case MUIC_TA_1A:
case MUIC_INVALID_CHG :
case MUIC_LG_TA :
case MUIC_AP_UART :
case MUIC_CP_UART :
case MUIC_AP_USB :
case MUIC_CP_USB :
if ((int_stat_value & V_VBUS) != 0) { // V_VBUS == 1
set_max14526_muic_mode(int_stat_value);
} else if ((int_stat_value & IDNO) == IDNO_1011) { // V_VBUS == 0
charging_mode = CHARGING_NONE;
muic_mode = MUIC_NONE;
#ifdef COFIG_MACH_STAR_SU660
printk(KERN_INFO "[******MUIC*********] VBUS NONE UNPLUG\n");
#endif
} else
set_max14526_muic_mode(int_stat_value);
break;
#if defined(CONFIG_MHL_TX_SII9244)
case MUIC_MHL :
printk(KERN_WARNING "[MUIC] Detect step3 MHL \n");
if ((int_stat_value & V_VBUS) == 0) {
MHL_On(0);
muic_mode = MUIC_NONE;
charging_mode = CHARGING_NONE;
}
break;
#endif
default:
printk(KERN_WARNING "[MUIC] Failed to detect an accessory. Try again!");
muic_mode = MUIC_UNKNOWN;
charging_mode = CHARGING_UNKNOWN;
ret = -1;
break;
}
printk(KERN_WARNING "[MUIC] muic_max14526_detect_accessory, muic_mode = %s (%d) \n", muic_mode_str[muic_mode], muic_mode );
if (muic_mode == MUIC_UNKNOWN || muic_mode == MUIC_NONE) {
muic_init_max14526(RESET);
gpio_set_value(IFX_USB_VBUS_EN_GPIO, 0);
printk(KERN_INFO "[MUIC] charging_ic_deactive()\n");
}
// LGE_UPDATE [email protected] [[ 4 charger
//muic_send_cable_type(muic_mode); //[[email protected]] - charger type is now sent by muic.c part.
return ret;
}
void set_max14526_muic_mode(unsigned char int_stat_value)
{
unsigned char reg_value;
printk(KERN_WARNING "[chahee.kim] set_max14526_muic_mode, "
"int_stat_value = %x \n", int_stat_value);
if (int_stat_value & CHGDET) {
set_max14526_charger_mode(int_stat_value);
#ifndef CHARGER_TEST
lge_charger_ta_mode_enable();
#endif
}
else if (int_stat_value & VBUS) {
if ((int_stat_value & IDNO) == IDNO_0101) {
set_max14526_ap_usb_mode();
#ifndef CHARGER_TEST
lge_charger_usb_mode_enable();
#endif
}
else {
/* Standard USB Host Detected (0x03=0x23) */
muic_i2c_write_byte(SW_CONTROL, COMP2_TO_HZ | COMN1_TO_C1COMP);
muic_udelay(1000);
/* Read Status Reigster(0x05) */
muic_i2c_read_byte(STATUS, ®_value);
if (reg_value & C1COMP) {
/* Charger Detected COMP2/COMN1 to H-Z (0x03=0x24) */
muic_i2c_write_byte(SW_CONTROL, COMP2_TO_HZ | COMN1_TO_HZ);
/* Dedicated Charger(TA) Detected */
muic_mode = MUIC_NA_TA;
}
else {
/* Turn on USB switches */
set_max14526_ap_usb_mode();
#ifndef CHARGER_TEST
lge_charger_usb_mode_enable();
#endif
}
}
}
else if ((int_stat_value & IDNO) == IDNO_0010) {
//set_max14526_cp_usb_mode();
set_max14526_ap_uart_mode();
#ifndef CHARGER_TEST
lge_charger_disable();
#endif
}
else if ((int_stat_value & IDNO) == IDNO_0101) {
set_max14526_ap_uart_mode();
#ifndef CHARGER_TEST
lge_charger_disable();
#endif
}
else {
/* Accessory Not Supported */
muic_mode = MUIC_NONE;
muic_init_max14526(DEFAULT);
#ifndef CHARGER_TEST
lge_charger_disable();
#endif
}
}
s32 muic_ts5usba33402_detect_accessory(s32 upon_irq)
{
s32 ret = 0;
u8 int_stat_value;
/*
* Upon an MUIC IRQ (MUIC_INT_N falls),
* wait 70ms before reading INT_STAT and STATUS.
* After the reads, MUIC_INT_N returns to high
* (but the INT_STAT and STATUS contents will be held).
*
* Do this only if muic_ts5usba33402_detect_accessory() was called upon IRQ.
*/
//if (upon_irq) {
muic_mdelay(70);
//}
/* Read INT_STAT */
ret = muic_i2c_read_byte(INT_STAT, &int_stat_value);
printk("[MUIC] muic_ts5usba33402_detect_accessory, int_stat_value:0x%02x \n", int_stat_value);
if (ret < 0) {
printk(KERN_INFO "[MUIC] INT_STAT reading failed\n");
muic_mode = MUIC_UNKNOWN;
charging_mode = CHARGING_UNKNOWN;
//
//set_muic_charger_detected();
return ret;
}
// muic_set_device_none_detect(int_stat_value);
/* Branch according to the previous muic_mode */
switch (muic_mode) {
/*
* MUIC_UNKNOWN is reached in two cases both do not have nothing to do with IRQ.
* First, at the initialization time where the muic_mode is not available yet.
* Second, whenever the current muic_mode detection is failed.
*/
case MUIC_UNKNOWN :
/*
* If the previous muic_mode was MUIC_NONE,
* the only possible condition for a MUIC IRQ is plugging in an accessory.
*/
case MUIC_NONE :
set_ts5usba33402_muic_mode(int_stat_value);
break;
/*
* If the previous muic_mode was MUIC_NA_TA, MUIC_LG_TA, MUIC_TA_1A, MUIC_INVALID_CHG,
* MUIC_AP_UART, MUIC_CP_UART, MUIC_AP_USB, MUIC_OTG, or MUIC_CP_USB,
* the only possible condition for a MUIC IRQ is plugging out the accessory.
*
* In this case, initialize MUIC and wait an IRQ.
* We don't need to wait 250msec because this is not an erronous case
* (we need to reset the facility to set STATUS for an erronous case and
* have to wait 250msec) and, if this is not an erronous case, the facility
* was already initialized at the system booting.
*/
case MUIC_AP_UART :
case MUIC_CP_UART :
if ((int_stat_value & IDNO) == IDNO_1011) {
muic_i2c_write_byte(SW_CONTROL, COMP2_TO_HZ | COMN1_TO_HZ);
muic_mode = MUIC_NONE;
charging_mode = CHARGING_NONE;
}
break;
case MUIC_NA_TA :
case MUIC_LG_TA :
case MUIC_TA_1A :
case MUIC_INVALID_CHG :
if (((int_stat_value & V_VBUS) == 0) || ((int_stat_value & CHGDET) == 0)) {
muic_mode = MUIC_NONE;
charging_mode = CHARGING_NONE;
}
break;
case MUIC_AP_USB :
case MUIC_CP_USB :
/*
* Check if V_VBUS == 0 && IDNO == 0x1011 (open).
* If so, it's MUIC_NONE.
* Otherwise, it's an erronous situation. MUIC_UNKNOWN.
*/
if((int_stat_value & IDNO) == IDNO_0010)
{
muic_mode = MUIC_CP_USB;
}
else if ((int_stat_value & IDNO) == IDNO_0100)
{
muic_mode = MUIC_CP_UART;
}
else if ((int_stat_value & V_VBUS) == 0) {
/* USB Host Removed */
muic_mode = MUIC_NONE;
charging_mode = CHARGING_NONE;
}
break;
#if defined(CONFIG_MHL_TX_SII9244)
case MUIC_MHL :
printk(KERN_WARNING "[MUIC] Detect step3 MHL \n");
if ((int_stat_value & V_VBUS) == 0) {
MHL_On(0);
muic_mode = MUIC_NONE;
charging_mode = CHARGING_NONE;
}
break;
#endif
default:
printk(KERN_WARNING "[MUIC] Failed to detect an accessory. Try again!");
muic_mode = MUIC_UNKNOWN;
charging_mode = CHARGING_NONE;
ret = -1;
break;
}
if(muic_mode == MUIC_UNKNOWN || muic_mode == MUIC_NONE){
muic_init_ts5usba33402(RESET);
gpio_set_value(IFX_USB_VBUS_EN_GPIO, 0);
printk(KERN_INFO "[MUIC] charging_ic_deactive()\n");
}
//
//
printk( "[MUIC] muic_ts5usba33402_detect_accessory, muic_mode = %s (%d) \n", muic_mode_str[muic_mode], muic_mode);
return ret;
}
void set_max14526_muic_mode(unsigned char int_stat_value)
{
unsigned char reg_value;
printk(KERN_WARNING "[MUIC] set_max14526_muic_mode, int_stat_value = 0x%02x \n", int_stat_value);
//[[email protected]] - Cosmo MUIC detection code
if (int_stat_value & V_VBUS) {
#if 0
if ((int_stat_value & IDNO) == IDNO_0010 ||
(int_stat_value & IDNO) == IDNO_1001 ||
(int_stat_value & IDNO) == IDNO_1010) {
set_max14526_cp_usb_mode();
muic_mode = MUIC_CP_USB;
charging_mode = CHARGING_FACTORY;
}
#else
if ((int_stat_value & IDNO) == IDNO_1001 ||
(int_stat_value & IDNO) == IDNO_1010) {
set_max14526_cp_usb_mode();
muic_mode = MUIC_CP_USB;
charging_mode = CHARGING_FACTORY;
} else if ((int_stat_value & IDNO) == IDNO_0010) {
#ifdef V56K_CONVERT_CP_USB_TO_AP_UART
set_max14526_ap_uart_mode();
muic_mode = MUIC_AP_UART;
#else
set_max14526_cp_usb_mode();
muic_mode = MUIC_CP_USB;
#endif
charging_mode = CHARGING_FACTORY;
}
#endif
else if ((int_stat_value & IDNO) == IDNO_0100) {
set_max14526_cp_uart_mode();
muic_mode = MUIC_CP_UART;
charging_mode = CHARGING_FACTORY;
#if defined(CONFIG_MHL_TX_SII9244)
} else if ((int_stat_value & IDNO) == IDNO_0000) { //[[email protected]] - added MHL to Cosmo base
muic_set_mhl_mode_detect();
muic_mode = MUIC_MHL;
charging_mode = CHARGING_USB;
#endif
} else if (int_stat_value & CHGDET) {
#ifdef CONFIG_MACH_STAR_SU660
printk("[****MUIC****] Detect Charger CHGDET!!!!");
muic_i2c_write_byte(SW_CONTROL, COMP2_TO_HZ | COMN1_TO_HZ);
muic_i2c_write_byte(CONTROL_1,ID_200 | ADC_EN | CP_EN );
#else
muic_i2c_write_byte(SW_CONTROL, COMP2_TO_HZ | COMN1_TO_HZ);
#endif
muic_mode = MUIC_LG_TA;
charging_mode = CHARGING_LG_TA;
} else {
muic_i2c_write_byte(SW_CONTROL, COMP2_TO_HZ | COMN1_TO_C1COMP);
muic_mdelay(2);
muic_i2c_read_byte(STATUS, ®_value);
if (reg_value & C1COMP) {
#ifdef CONFIG_MACH_STAR_SU660
printk("[****MUIC****] Detect Charger C1COMP!!!!");
muic_i2c_write_byte(SW_CONTROL, COMP2_TO_HZ | COMN1_TO_HZ);
muic_i2c_write_byte(CONTROL_1,ID_200 | ADC_EN | CP_EN );
muic_i2c_write_byte(CONTROL_2, INT_EN);
#else
muic_i2c_write_byte(SW_CONTROL, COMP2_TO_HZ | COMN1_TO_HZ);
#endif
muic_mode = MUIC_LG_TA;
charging_mode = CHARGING_LG_TA;
} else {
set_max14526_ap_usb_mode();
muic_mode = MUIC_AP_USB;
charging_mode = CHARGING_USB;
}
}
} else {
if ((int_stat_value & IDNO) == IDNO_0010) {
set_max14526_ap_uart_mode();
muic_mode = MUIC_AP_UART;
charging_mode = CHARGING_NONE;
} else if ((int_stat_value & IDNO) == IDNO_0100) {
set_max14526_cp_uart_mode();
muic_mode = MUIC_CP_UART;
charging_mode = CHARGING_NONE;
} else {
muic_mode = MUIC_UNKNOWN;
charging_mode = CHARGING_NONE;
}
}
#if 0 //[[email protected]] - X3 original code
if(retain_mode == BOOT_CP_USB){
set_max14526_cp_usb_mode_detect();
}if ((int_stat_value & IDNO) == IDNO_0100 || (int_stat_value == 0x11)) { /* 0x11 for Special Test with MIC */
/* IDNO=0100? 130Kohm :: UART_MODE */
set_max14526_cp_uart_mode_detect();
} else if ((int_stat_value & IDNO ) == IDNO_0010) {
/* IDNO=0010? 56Kohm :: USB_MODE */
set_max14526_ap_uart_mode_detect();
#if defined(CONFIG_MHL_TX_SII9244)
} else if (int_stat_value == 0x10) {
/* IDNO=0000? 0Kohm :: MHL_MODE */
muic_set_mhl_mode_detect();
#else
} else if ((int_stat_value == 0x11) || (int_stat_value == 0x10)) {
//Set_MAX14526_SpecialTest_Mode_Detect();
#endif//
} else if ((int_stat_value & IDNO) == IDNO_1010) {
set_max14526_cp_usb_mode_detect();
} else if (int_stat_value & CHGDET) {
/* CHGDET=1? */
set_max14526_charger_detect(int_stat_value);
} else if (int_stat_value & V_VBUS) {
/* V_VBUS=1? */
/* Standard USB Host Detected (0x03=0x23) */
muic_i2c_write_byte(SW_CONTROL, COMP2_TO_HZ | COMN1_TO_C1COMP);
muic_udelay(1000);
/* Read Status Reigster(0x05) */
muic_i2c_read_byte(STATUS, ®_value);
if (reg_value & C1COMP) {
/* Charger Detected COMP2/COMN1 to H-Z (0x03=0x24) */
muic_i2c_write_byte(SW_CONTROL, COMP2_TO_HZ | COMN1_TO_HZ);
/* Dedicated Charger(TA) Detected */
muic_mode = MUIC_NA_TA;
} else {
/* Turn on USB switches */
#if defined(CONFIG_MHL_TX_SII9244)
if ((int_stat_value & IDNO ) == IDNO_0000) {
muic_set_mhl_mode_detect();
} else {
///* Standard USB Host Detected (0x03=0x23) */
set_max14526_ap_usb_mode_detect();
muic_mode = MUIC_AP_USB;
}
#else
set_max14526_ap_usb_mode_detect();
muic_mode = MUIC_AP_USB;
#endif//
}
} else if ((int_stat_value & IDNO) == IDNO_0001) {
/* Vidoe Cable 24k registor Detected - No TV Attached */
//muic_mode = DEVICE_VIDEO_CABLE_NO_LOAD;
} else if ((int_stat_value & IDNO) == IDNO_0000 ) {
muic_mode = MUIC_NONE;
} else {
/* Accessory Not Supported */
muic_mode = MUIC_NONE;
}
#endif
}
void set_ts5usba33402_muic_mode(unsigned char int_stat_value)
{
gpio_set_value(GPIO_CP_UART_SW, 0);
gpio_set_value(GPIO_CP_USB_VBUS_EN, 0);
#if defined(CONFIG_LU6500)
muic_i2c_write_byte(SW_CONTROL, DP_OPEN | DM_OPEN);
#else
muic_i2c_write_byte(SW_CONTROL, COMP2_TO_HZ | COMN1_TO_HZ);
#endif
muic_i2c_write_byte(CONTROL_1, ID_200 | SEMREN | CP_EN);
muic_mdelay(10);
if (int_stat_value & V_VBUS) {
if ((int_stat_value & IDNO) == IDNO_0010 ||
(int_stat_value & IDNO) == IDNO_1001 ||
(int_stat_value & IDNO) == IDNO_1010) {
set_ts5usba33402_cp_usb_mode();
muic_mode = MUIC_CP_USB;
charging_mode = CHARGING_FACTORY;
} else if ((int_stat_value & IDNO) == IDNO_0100) {
set_ts5usba33402_cp_uart_mode();
muic_mode = MUIC_CP_UART;
charging_mode = CHARGING_FACTORY;
#if defined(CONFIG_MHL_TX_SII9244)
} else if ((int_stat_value & IDNO) == IDNO_0000) { //
muic_set_mhl_mode_detect();
muic_mode = MUIC_MHL;
charging_mode = CHARGING_USB;
#endif
} else if (int_stat_value & CHGDET) {
muic_i2c_write_byte(SW_CONTROL, COMP2_TO_HZ | COMN1_TO_HZ);
muic_mode = MUIC_LG_TA;
charging_mode = CHARGING_LG_TA;
} else {
set_ts5usba33402_ap_usb_mode();
muic_mode = MUIC_AP_USB;
charging_mode = CHARGING_USB;
}
} else {
if ((int_stat_value & IDNO) == IDNO_0010) {
set_ts5usba33402_ap_uart_mode();
muic_mode = MUIC_AP_UART;
charging_mode = CHARGING_NONE;
} else if ((int_stat_value & IDNO) == IDNO_0100) {
set_ts5usba33402_cp_uart_mode();
muic_mode = MUIC_CP_UART;
charging_mode = CHARGING_NONE;
} else {
muic_mode = MUIC_UNKNOWN;
charging_mode = CHARGING_NONE;
}
}
#if 0 //
unsigned char reg_value;
s32 ret = 0;
printk(KERN_INFO "[MUIC] %s : int_stat_value = 0x%x \n" ,__func__ ,int_stat_value);
/*if(retain_mode == BOOT_CP_USB){
muic_set_develop_mode_detect();
}else */if (int_stat_value & CHGDET) {
printk(KERN_INFO "[MUIC] %s : muic_mode is CHGDET (%d) \n" ,__func__ ,muic_mode);
muic_set_charger_detect(int_stat_value);
} else if((int_stat_value & IDNO) == IDNO_0100 ) {
printk(KERN_INFO "[MUIC] %s : muic_mode is 130Kohm CP_UART (%d) \n" ,__func__ ,muic_mode);
/* IDNO=0100? 130Kohm :: CP_UART */
muic_set_factory_mode_detect(IDNO_0100);
} else if((int_stat_value & IDNO) == IDNO_1010) {
printk(KERN_INFO "[MUIC] %s : muic_mode is 910KOhm AP_USB (%d) \n" ,__func__ ,muic_mode);
/* IDNO=0100? 910KOhm :: CP_USB */
muic_set_factory_mode_detect(IDNO_1010);
} else if ((int_stat_value & IDNO) == IDNO_0010) {
/* IDNO=0010? 56Kohm :: USB_MODE */
muic_set_develop_mode_detect();
#if defined(CONFIG_MHL_TX_SII9244)
} else if (int_stat_value == 0x10) {
/* IDNO=0000? 0Kohm :: MHL_MODE */
muic_set_mhl_mode_detect();
#else
} else if ((int_stat_value == 0x30) || (int_stat_value == 0x11) || (int_stat_value == 0x10)) {
muic_set_special_test_mode_detect();
#endif//
} else if (int_stat_value & V_VBUS) {
/* Standard USB Host Detected (0x03=0x23) */
/* Read a status reigster(0x05) */
ret = muic_i2c_read_byte(STATUS, ®_value);
if (reg_value & DCPORT || reg_value & CHPORT) {
/* Charger Detected*/
/* COMP2/COMN1 to H-Z (0x03=0x24) */
muic_i2c_write_byte(SW_CONTROL, COMP2_TO_HZ | COMN1_TO_HZ);
muic_mode = MUIC_NA_TA;
} else {
#if defined(CONFIG_MHL_TX_SII9244)
if ((int_stat_value & IDNO ) == IDNO_0000) {
muic_set_mhl_mode_detect();
} else {
///* Standard USB Host Detected (0x03=0x23) */
muic_set_usb_mode_detect(); // Turn on USB switches
muic_mode = MUIC_AP_USB;
}
#else
///* Standard USB Host Detected (0x03=0x23) */
muic_set_usb_mode_detect(); // Turn on USB switches
muic_mode = MUIC_AP_USB;
#endif
}
} else if ((int_stat_value & IDNO ) == IDNO_0001) {
/* Vidoe Cable 24k registor Detected - No TV Attached */
//current_device = DEVICE_VIDEO_CABLE_NO_LOAD;
} else if ((int_stat_value & IDNO) == IDNO_0000 ) {
//Set_MUIC_Other_Mode_Detect();
} else {
/* Accessory Not Supported */
muic_mode = MUIC_NONE;
}
#endif
}
s32 muic_ts5usba33402_detect_accessory(s32 upon_irq)
{
s32 ret = 0;
u8 int_stat_value;
muic_mdelay(70);
/* Read INT_STAT */
ret = muic_i2c_read_byte(INT_STAT, &int_stat_value);
printk("[MUIC] muic_ts5usba33402_detect_accessory, int_stat_value:0x%02x \n", int_stat_value);
if (ret < 0) {
printk(KERN_INFO "[MUIC] INT_STAT reading failed\n");
muic_path = MUIC_UNKNOWN;
charging_mode = muic_path;
//set_muic_charger_detected();
return ret;
}
/* Branch according to the previous muic_path */
switch (muic_path) {
/*
* MUIC_UNKNOWN is reached in two cases both do not have nothing to do with IRQ.
* First, at the initialization time where the muic_path is not available yet.
* Second, whenever the current muic_path detection is failed.
*/
case MUIC_UNKNOWN :
/*
* If the previous muic_path was MUIC_NONE,
* the only possible condition for a MUIC IRQ is plugging in an accessory.
*/
case MUIC_NONE :
set_ts5usba33402_muic_path(int_stat_value);
break;
/*
* If the previous muic_path was MUIC_NA_TA, MUIC_LG_TA, MUIC_TA_1A, MUIC_INVALID_CHG,
* MUIC_AP_UART, MUIC_CP_UART, MUIC_AP_USB, MUIC_OTG, or MUIC_CP_USB,
* the only possible condition for a MUIC IRQ is plugging out the accessory.
*
* In this case, initialize MUIC and wait an IRQ.
* We don't need to wait 250msec because this is not an erronous case
* (we need to reset the facility to set STATUS for an erronous case and
* have to wait 250msec) and, if this is not an erronous case, the facility
* was already initialized at the system booting.
*/
case MUIC_AP_UART :
case MUIC_CP_UART :
if ((int_stat_value & IDNO) == IDNO_1011) {
muic_i2c_write_byte(SW_CONTROL, COMP2_TO_HZ | COMN1_TO_HZ);
muic_path = MUIC_NONE;
charging_mode = CHARGING_NONE;
}
break;
case MUIC_NA_TA :
case MUIC_LG_TA :
case MUIC_TA_1A :
case MUIC_INVALID_CHG :
if (((int_stat_value & VBUS) == 0) || ((int_stat_value & CHGDET) == 0)) {
muic_path = MUIC_NONE;
charging_mode = CHARGING_NONE;
}
break;
case MUIC_AP_USB :
case MUIC_CP_USB :
if ((int_stat_value & VBUS) == 0) {
/* USB host removed */
muic_path = MUIC_NONE;
charging_mode = CHARGING_NONE;
}
break;
default :
printk(KERN_WARNING "[MUIC] Failed to detect an accessory. Try again!");
muic_path = MUIC_UNKNOWN;
charging_mode = CHARGING_NONE;
ret = -1;
}
printk(KERN_WARNING "[MUIC] muic_ts5usba33402_detect_accessory, muic_path = %s\n", muic_path_str[muic_path]);
if (muic_path == MUIC_UNKNOWN || muic_path == MUIC_NONE){
muic_init_ts5usba33402(RESET);
gpio_set_value(IFX_USB_VBUS_EN_GPIO, 0);
printk(KERN_INFO "[MUIC] charging_ic_deactive()\n");
}
//set_muic_charger_detected();
return ret;
}
int muic_init(int isFactoryReset)
{
unsigned int retain_mode = NO_RETAIN;
unsigned char i2c_ret;
unsigned char reg_val;
unsigned char muic_device;
MUIC_MODE_TYPE muic_mode = MUIC_OPEN;
char cmd_line[256];
strcpy(cmd_line, getenv("bootargs"));
#if defined(CONFIG_COSMO_EVB_B) || defined(CONFIG_COSMO_EVB_C)
printf("muic chip : I2C4\n");
select_bus(I2C4 , OMAP_I2C_STANDARD);
#else
printf("muic chip : I2C3\n");
select_bus(I2C3 , OMAP_I2C_STANDARD);
#endif
i2c_init(OMAP_I2C_STANDARD, MUIC_SLAVE_ADDR);
i2c_ret = muic_i2c_read_byte(DEVICE_ID, ®_val);
if ((reg_val & 0xf0) == 0x10)
muic_device = TS5USBA33402;
else if ((reg_val & 0xf0) == 0x20)
muic_device = MAX14526;
else if ((reg_val & 0xf0) == ANY_VANDOR_ID)
muic_device = ANY_VANDOR;
if (downloadkey()){
write_muic_retain_mode(NO_RETAIN);
printf("[MUIC] No retain\n");
}
retain_mode = read_muic_retain_mode();
printf("muic_init muic vendor : %d, reg_val:0x%x, retain_mode = %d\n", muic_device, reg_val, retain_mode);
if (muic_device == TS5USBA33402) {
printf("muic chip : TS5USBA33402\n");
if (retain_mode == RETAIN_AP_USB) {
muic_i2c_write_byte(CONTROL_1, ID_200 | SEMREN | CP_EN);
muic_i2c_write_byte(SW_CONTROL, USB);
muic_mode = MUIC_USB;
check_charging_mode(&muic_mode);
printf("[MUIC] retain AP_USB\n");
printf("\n###[MUIC] USB charger may not have enough power to boot up depends on your board condition..... ###\n");
printf("\n###[MUIC] You'd better to use TA or PIF for power supply. ###\n");
strcat(cmd_line, " muic=2");
setenv("bootargs", cmd_line);
} else if (retain_mode == RETAIN_CP_USB) {
muic_i2c_write_byte(SW_CONTROL, OPEN);
dp3t_switch_ctrl(DP3T_NC);
muic_mode = MUIC_USB;
check_charging_mode(&muic_mode);
printf("[MUIC] retain CP_USB\n");
strcat(cmd_line, " muic=3");
setenv("bootargs", cmd_line);
} else
muic_mode = muic_device_ts5usba33402(isFactoryReset, cmd_line);
} else if (muic_device == MAX14526) {
printf("muic chip : MAX14526\n");
if (retain_mode == RETAIN_AP_USB) {
muic_i2c_write_byte(CONTROL_1, ID_200 | ADC_EN | CP_EN);
muic_i2c_write_byte(SW_CONTROL, USB);
muic_mode = MUIC_USB;
check_charging_mode(&muic_mode);
printf("[MUIC] retain AP_USB\n");
printf("\n###[MUIC] USB charger may not have enough power to boot up depends on your board condition..... ###\n");
printf("\n###[MUIC] You'd better to use TA or PIF for power supply. ###\n");
strcat(cmd_line, " muic=2");
setenv("bootargs", cmd_line);
} else if (retain_mode == RETAIN_CP_USB) {
muic_i2c_write_byte(SW_CONTROL, OPEN);
dp3t_switch_ctrl(DP3T_NC);
muic_mode = MUIC_USB;
check_charging_mode(&muic_mode);
printf("[MUIC] retain CP_USB\n");
strcat(cmd_line, " muic=3");
setenv("bootargs", cmd_line);
} else
muic_mode = muic_device_max14526(isFactoryReset, cmd_line);
} else
printf("[MUIC] ANY VENDOR, Not supported\n");
select_bus(I2C1, OMAP_I2C_STANDARD);
return muic_mode;
}
static MUIC_MODE_TYPE muic_device_max14526(int _isFactoryRest, char *cmd)
{
unsigned char i2c_ret;
unsigned char status_val;
unsigned char int_status_val;
MUIC_MODE_TYPE muic_mode = MUIC_OPEN;
i2c_ret = muic_i2c_write_byte(CONTROL_1, ID_200 | ADC_EN);
i2c_ret = muic_i2c_write_byte(CONTROL_2, 0x00);
usif1_switch_ctrl(USIF1_UART);
udelay(70000);
i2c_ret = muic_i2c_read_byte(INT_STATUS, &int_status_val);
printf("INT_STAT = 0x%x\n", int_status_val);
if ((int_status_val & VBUS) != 0) {
if ((int_status_val & IDNO) == 0x02) {
#ifdef CONFIG_COSMO_SU760
cable_56K_detect = 1;
#endif
if (_isFactoryRest) {
muic_i2c_write_byte(SW_CONTROL, UART);
dp3t_switch_ctrl(DP3T_S2_CP_UART);
muic_mode = MUIC_FACTORY_MODE;
strcat(cmd, " muic=1");
setenv("bootargs", cmd);
printf("[MUIC] first boot, path = CP UART\n");
} else {
muic_i2c_write_byte(SW_CONTROL, OPEN);
dp3t_switch_ctrl(DP3T_NC);
muic_mode = MUIC_FACTORY_MODE;
printf("CP_USB\n");
}
} else if ((int_status_val & IDNO) == 0x04) {
muic_i2c_write_byte(SW_CONTROL, UART);
dp3t_switch_ctrl(DP3T_S2_CP_UART);
muic_mode = MUIC_FACTORY_MODE;
printf("CP_UART\n");
} else if ((int_status_val & IDNO) == 0x0a || (int_status_val & IDNO) == 0x09) {
mmc_init(1);
cable_910K_detect = 1;
dload_mode = read_muic_mode_of_dload();
if (dload_mode == NORMAL_MODE) {
muic_i2c_write_byte(CONTROL_1, ID_200 | ADC_EN | CP_EN);
muic_i2c_write_byte(SW_CONTROL, USB);
muic_mode = MUIC_FACTORY_MODE;
printf("AP_USB is set(910Kohm)\n");
} else {
muic_i2c_write_byte(SW_CONTROL, OPEN);
dp3t_switch_ctrl(DP3T_NC);
write_muic_mode_of_dload(NORMAL_MODE);
muic_mode = MUIC_FACTORY_MODE;
printf("CP_USB is set(910Kohm)\n");
}
}else {
muic_i2c_write_byte(SW_CONTROL, COMP2_TO_HZ | COMN1_TO_C1COMP);
udelay(2000);
i2c_ret = muic_i2c_read_byte(STATUS, &status_val);
printf("STATUS = 0x%x\n", status_val);
if (status_val & C1COMP) {
muic_i2c_write_byte(SW_CONTROL, OPEN);
dp3t_switch_ctrl(DP3T_NC);
muic_mode = MUIC_CHRGER;
printf("Charger Detected\n");
} else {
muic_i2c_write_byte(CONTROL_1, ID_200 | ADC_EN | CP_EN);
muic_i2c_write_byte(SW_CONTROL, USB);
dp3t_switch_ctrl(DP3T_NC);
#ifdef CONFIG_COSMO_SU760
cable_open_usb_detect = 1;
#endif
muic_mode = MUIC_USB;
printf("\n### USB charger may not have enough power to boot up depends on your board condition..... ###\n");
printf("\n### You'd better to use TA or PIF for power supply. ###\n");
printf("[MUIC] AP USB\n");
}
}
} else {
if ((int_status_val & IDNO) == 0x02) {
muic_i2c_write_byte(CONTROL_1, ID_200 | ADC_EN | CP_EN);
muic_i2c_write_byte(SW_CONTROL, UART);
dp3t_switch_ctrl(DP3T_S1_AP_UART);
printf("AP_UART\n");
} else if ((int_status_val & IDNO) == 0x04) {
muic_i2c_write_byte(CONTROL_1, ID_200 | ADC_EN);
muic_i2c_write_byte(SW_CONTROL, UART);
dp3t_switch_ctrl(DP3T_S2_CP_UART);
printf("CP_UART\n");
} else {
muic_i2c_write_byte(SW_CONTROL, OPEN);
dp3t_switch_ctrl(DP3T_NC);
muic_mode = MUIC_OPEN;
printf("MUIC opened\n");
}
}
printf("INT_STAT = 0x%x\n", int_status_val);
return muic_mode;
}
s32 muic_max14526_detect_accessory(s32 upon_irq)
{
s32 ret = 0;
int loop = 0;
u8 int_stat_value;
if (upon_irq) {
for (; loop < 250; loop++)
muic_udelay(1000);
}
/* Reads INT_STAT */
ret = muic_i2c_read_byte(INT_STAT, &int_stat_value);
if (ret < 0) {
printk(KERN_INFO "[chahee.kim] INT_STAT reading failed\n");
muic_mode = MUIC_UNKNOWN;
return ret;
}
printk(KERN_INFO "[chahee.kim] IDNO = %d\n", (int_stat_value & IDNO));
muic_mode = int_stat_value & IDNO;
/* Branches according to the previous muic_mode */
switch (muic_mode) {
/* MUIC_UNKNOWN is reached in two cases both do not have nothing to do with IRQ.
* First, at the initialization time where the muic_mode is not available yet.
* Second, whenever the current muic_mode detection is failed.
*/
case MUIC_UNKNOWN :
/* If the previous muic_mode was MUIC_NONE,
* the only possible condition for a MUIC IRQ is plugging in an accessory.
*/
case MUIC_NONE :
set_max14526_muic_mode(int_stat_value);
break;
case MUIC_NA_TA:
case MUIC_TA_1A:
case MUIC_INVALID_CHG :
if ((int_stat_value & VBUS) == 0) {
muic_mode = MUIC_NONE;
}else{
set_max14526_muic_mode(int_stat_value);
}
break;
case MUIC_LG_TA :
printk(KERN_WARNING "[chahee.kim] LG_TA");
if ((int_stat_value & CHGDET) == 0) {
muic_mode = MUIC_NONE;
}
else {
set_max14526_muic_mode(int_stat_value);
}
break;
case MUIC_AP_UART :
if ((int_stat_value & IDNO) == IDNO_1011) {
/* Exit Factory Mode */
muic_mode = MUIC_NONE;
}
else {
set_max14526_muic_mode(int_stat_value);
}
break;
case MUIC_AP_USB :
if ((int_stat_value & VBUS) == 0) {
/* USB Host Removed */
muic_mode = MUIC_NONE;
}else{
set_max14526_muic_mode(int_stat_value);
}
break;
default:
printk(KERN_WARNING "[chahee.kim] Failed to detect an accessory. Try again!\n");
#ifndef CHARGER_TEST
lge_charger_disable();
#endif
muic_mode = MUIC_UNKNOWN;
ret = -1;
break;
}
printk(KERN_WARNING "[chahee.kim] muic_max14526_detect_accessory, muic_mode = %d \n", muic_mode );
return ret;
}
