/**********************************************************************
* Name : fsa9480_SetManualSW()
* Description : Control FSA9480's Manual SW1 and SW2
*
* Parameter :
* @ valManualSw1 : the value to set SW1
* @ valManualSw2 : the value to set SW2
* Return : None
*
***********************************************************************/
void fsa9480_SetManualSW(unsigned char valManualSw1, unsigned char valManualSw2)
{
unsigned char cont_reg, man_sw1, man_sw2;
DEBUG_FSA9480("[FSA9480]%s \n", __func__);
/*Set Manual switch*/
fsa9480_write(fsa9480_i2c_client, REGISTER_MANUALSW1, valManualSw1);
mdelay(20);
fsa9480_write(fsa9480_i2c_client, REGISTER_MANUALSW2, valManualSw2);
mdelay(20);
/*when detached the cable, Control register automatically be restored.*/
fsa9480_read(fsa9480_i2c_client, REGISTER_CONTROL, &cont_reg);
mdelay(20);
DEBUG_FSA9480("[FSA9480] fsa9480_SetManualSW : [Before]Control Register's value is %s\n",&cont_reg);
/*set switching mode to MANUAL*/
fsa9480_write(fsa9480_i2c_client, REGISTER_CONTROL, 0x1A);
/* Read current setting value , manual sw1, manual sw2, control register.*/
fsa9480_read(fsa9480_i2c_client, REGISTER_MANUALSW1, &man_sw1);
mdelay(20);
DEBUG_FSA9480("[FSA9480] fsa9480_SetManualSW : Manual SW1 Register's value is %s\n",&man_sw1);
fsa9480_read(fsa9480_i2c_client, REGISTER_MANUALSW2, &man_sw2);
mdelay(20);
DEBUG_FSA9480("[FSA9480] fsa9480_SetManualSW : Manual SW2 Register's value is %s\n",&man_sw2);
fsa9480_read(fsa9480_i2c_client, REGISTER_CONTROL, &cont_reg);
DEBUG_FSA9480("[FSA9480] fsa9480_SetManualSW : [After]Control Register's value is %s\n",&cont_reg);
}
void usb_switch_mode(int sel)
{
if (sel == SWITCH_PDA)
{
DEBUG_FSA9480("[FSA9480] %s: Path = PDA\n", __func__);
Ap_Cp_Switch_Config(AP_USB_MODE);
}
else if (sel == SWITCH_MODEM)
{
DEBUG_FSA9480("[FSA9480] %s: Path = MODEM\n", __func__);
Ap_Cp_Switch_Config(CP_USB_MODE);
}
else
DEBUG_FSA9480("[FSA9480] Invalid mode...\n");
}
/**********************************************************************
* Name : fsa9480_SetAutoSWMode()
* Description : Set FSA9480 with Auto Switching Mode.
*
* Parameter : None
* @
* @
* Return : None
*
***********************************************************************/
void fsa9480_SetAutoSWMode(void)
{
DEBUG_FSA9480("[FSA9480]%s\n ", __func__);
/*set Auto Swithing mode */
fsa9480_write(fsa9480_i2c_client, REGISTER_CONTROL, 0x1E);
}
void FSA9480_Enable_SPK(u8 enable)
{
struct i2c_client *client = fsa9480_i2c_client;
u8 data = 0;
byte reg_value=0;
byte reg_address=0x0D;
if(enable)
{
DEBUG_FSA9480("FSA9480_Enable_SPK --- enable\n");
msleep(10);
Get_MAX8998_PM_ADDR(reg_address, ®_value, 1); // read 0x0D register
check_reg = reg_value;
reg_value = ((0x2<<5)|reg_value);
check_reg = reg_value;
Set_MAX8998_PM_ADDR(reg_address,®_value,1);
check_reg = reg_value;
msleep(10);
fsa9480_write(client, REGISTER_MANUALSW1, 0x90); // D+/- switching by V_Audio_L/R in HW03
msleep(10);
fsa9480_write(client, REGISTER_CONTROL, 0x1A); //manual switching
}
}
static ssize_t usb_sel_store(
struct device *dev, struct device_attribute *attr,
const char *buf, size_t size)
{
DEBUG_FSA9480("[FSA9480]%s\n ", __func__);
if (sec_get_param_value)
sec_get_param_value(__SWITCH_SEL, &switch_sel);
if(strncmp(buf, "PDA", 3) == 0 || strncmp(buf, "pda", 3) == 0)
{
usb_switch_mode(SWITCH_PDA);
usb_switching_value_update(SWITCH_PDA);
switch_sel |= USB_SEL_MASK;
}
if(strncmp(buf, "MODEM", 5) == 0 || strncmp(buf, "modem", 5) == 0)
{
usb_switch_mode(SWITCH_MODEM);
usb_switching_value_update(SWITCH_MODEM);
switch_sel &= ~USB_SEL_MASK;
}
switching_value_update();
if (sec_set_param_value)
sec_set_param_value(__SWITCH_SEL, &switch_sel);
microusb_uart_status(0);
return size;
}
/**********************************************************************
* Name : usb_state_store()
* Description : for sysfs control (/sys/class/sec/switch/usb_state)
* noting to do.
* Parameter :
*
*
* Return : None
*
***********************************************************************/
static ssize_t usb_state_store(
struct device *dev, struct device_attribute *attr,
const char *buf, size_t size)
{
DEBUG_FSA9480("[FSA9480]%s\n ", __func__);
return 0;
}
void fsa9480_interrupt_init(void)
{
s3c_gpio_cfgpin(GPIO_JACK_nINT, S3C_GPIO_SFN(GPIO_JACK_nINT_AF));
s3c_gpio_setpull(GPIO_JACK_nINT, S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_FSA9480_INTB, IRQ_TYPE_EDGE_FALLING);
if (request_irq(IRQ_FSA9480_INTB, fsa9480_interrupt, IRQF_DISABLED, "FSA9480 Detected", NULL))
DEBUG_FSA9480("[FSA9480]fail to register IRQ[%d] for FSA9480 USB Switch \n", IRQ_FSA9480_INTB);
}
static void FSA9480_ReadIntRegister(struct work_struct * work)
{
u8 interrupt1 , device1, device2, temp;
DEBUG_FSA9480("[FSA9480] %s\n", __func__);
fsa9480_read( REGISTER_INTERRUPT1, &interrupt1);
msleep(5);
fsa9480_read( REGISTER_DEVICETYPE1, &device1);
msleep(5);
fsa9480_read( REGISTER_DEVICETYPE2, &device2);
usb_state = (device2 << 8) | (device1 << 0);
if((interrupt1 & FSA9480_INT1_ATTACH) ||
(FSA9480_Get_JIG_Status() && maxim_lpm_chg_status()))
{
fsa9480_device1 = device1;
fsa9480_device2 = device2;
if(fsa9480_device1 != FSA9480_DEV_TY1_DED_CHG) {
s3c_usb_cable(USB_CABLE_ATTACHED);
}
if(fsa9480_device1&FSA9480_DEV_TY1_CAR_KIT)
{
msleep(5);
fsa9480_write( REGISTER_CARKITSTATUS, 0x02);
msleep(5);
fsa9480_read( REGISTER_CARKITINT1, &temp);
}
}
msleep(5);
fsa9480_write( REGISTER_CONTROL, 0x1E);
fsa9480_write( REGISTER_INTERRUPTMASK1, 0xFC);
FSA9480_ProcessDevice(fsa9480_device1, fsa9480_device2, interrupt1);
if((interrupt1 & FSA9480_INT1_DETACH) ||
(FSA9480_Get_JIG_Status() && !maxim_lpm_chg_status()))
{
if(fsa9480_device1 != FSA9480_DEV_TY1_DED_CHG) {
s3c_usb_cable(USB_CABLE_DETACHED);
}
fsa9480_device1 = 0;
fsa9480_device2 = 0;
}
enable_irq(IRQ_FSA9480_INTB);
}
static int __init fsa9480_driver_init(void)
{
int ret;
DEBUG_FSA9480("%s\n", __func__);
if((ret = i2c_add_driver(&fsa9480_i2c_driver)))
pr_err("%s: Can't add fsa9480 i2c driver\n", __func__);
return ret;
}
static void dock_keys_input(dock_key_type key, int press)
{
if( key >= DOCK_KEY_MAX )
return;
input_report_key(dock_key_input_dev, dock_keys[key], press);
input_sync(dock_key_input_dev);
DEBUG_FSA9480("key pressed(%d) [%s] \n", press, dock_keys_string[key]);
}
/**********************************************************************
* Name : fsa9480_MakeRxdLow()
* Description : Make UART port to OPEN state.
*
* Parameter : None
* @
* @
* Return : None
*
***********************************************************************/
void fsa9480_MakeRxdLow(void)
{
unsigned char hidden_reg;
DEBUG_FSA9480("[FSA9480]%s\n ", __func__);
fsa9480_write(fsa9480_i2c_client, HIDDEN_REGISTER_MANUAL_OVERRDES1, 0x0a);
mdelay(20);
fsa9480_read(fsa9480_i2c_client, HIDDEN_REGISTER_MANUAL_OVERRDES1, &hidden_reg);
fsa9480_SetManualSW(0x00, 0x00);
}
static int fsa9480_modify(struct i2c_client *client, u8 reg, u8 data, u8 mask)
{
u8 original_value, modified_value;
fsa9480_read(client, reg, &original_value);
mdelay(10);
DEBUG_FSA9480("[FSA9480] %s Original value is 0x%02x\n ",__func__, original_value);
modified_value = ((original_value&~mask) | data);
DEBUG_FSA9480("[FSA9480] %s modified value is 0x%02x\n ",__func__, modified_value);
fsa9480_write(client, reg, modified_value);
mdelay(10);
return 0;
}
static void fsa9480_interrupt_init(int irq, void *dev_id)
{
#define FSA9480_IRQ_FLAGS (IRQF_SHARED)
set_irq_type(irq, IRQ_TYPE_LEVEL_LOW/*IRQ_TYPE_EDGE_FALLING*/);
if (request_irq(irq, fsa9480_interrupt, FSA9480_IRQ_FLAGS, "FSA9480 Detected", dev_id))
{
DEBUG_FSA9480("[FSA9480]fail to register IRQ[%d] for FSA9480 USB Switch \n", irq);
}
enable_irq_wake(irq); // keep wakeup attr in sleep state
}
static int fsa9480_codec_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct fsa9480_state *state;
struct device *dev = &client->dev;
u8 pData;
DEBUG_FSA9480("[FSA9480] %s\n", __func__);
s3c_gpio_cfgpin(GPIO_USB_SW_SCL, S3C_GPIO_OUTPUT);
s3c_gpio_setpull(GPIO_USB_SW_SCL, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(GPIO_USB_SW_SDA, S3C_GPIO_OUTPUT);
s3c_gpio_setpull(GPIO_USB_SW_SDA, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(GPIO_UART_SEL, S3C_GPIO_OUTPUT );
s3c_gpio_setpull(GPIO_UART_SEL, S3C_GPIO_PULL_NONE);
user_switch_init();
init_waitqueue_head(&usb_detect_waitq);
INIT_WORK(&fsa9480_work, FSA9480_ReadIntRegister);
fsa9480_workqueue = create_singlethread_workqueue("fsa9480_workqueue");
state = kzalloc(sizeof(struct fsa9480_state), GFP_KERNEL);
if(!state) {
dev_err(dev, "%s: failed to create fsa9480_state\n", __func__);
return -ENOMEM;
}
state->client = client;
fsa9480_i2c_client = client;
i2c_set_clientdata(client, state);
if(!fsa9480_i2c_client)
{
dev_err(dev, "%s: failed to create fsa9480_i2c_client\n", __func__);
return -ENODEV;
}
/*clear interrupt mask register*/
fsa9480_read( REGISTER_CONTROL, &pData);
fsa9480_write( REGISTER_CONTROL, pData & ~INT_MASK);
fsa9480_interrupt_init();
fsa9480_chip_init();
return 0;
}
void fsa9480_enable_interrupt(int enable)
{
DEBUG_FSA9480("[FSA9480] enable_interrupt(%d)\n", enable);
if(enable)
{
enable_irq(IRQ_FSA9480_INTB);
enable_irq(PMIC_IRQ);
}
else
{
disable_irq_nosync(PMIC_IRQ);
disable_irq_nosync(IRQ_FSA9480_INTB);
}
}
static void FSA9480_ProcessDevice(u8 dev1, u8 dev2, u8 attach)
{
DEBUG_FSA9480("[FSA9480] %s (dev1 : 0x%x, dev2 : 0x%x)\n", __func__, dev1, dev2);
if(dev1)
{
switch(dev1)
{
case FSA9480_DEV_TY1_AUD_TY1:
// DEBUG_FSA9480("Audio Type1 ");
if(attach & FSA9480_INT1_ATTACH)
DEBUG_FSA9480("FSA9480_DEV_TY1_AUD_TY1 --- ATTACH\n");
else
DEBUG_FSA9480("FSA9480_DEV_TY1_AUD_TY1 --- DETACH\n");
break;
case FSA9480_DEV_TY1_AUD_TY2:
DEBUG_FSA9480("Audio Type2 ");
break;
case FSA9480_DEV_TY1_USB:
// DEBUG_FSA9480("USB attach or detach: %d\n",attach);
if(attach & FSA9480_INT1_ATTACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY1_USB --- ATTACH\n");
MicroUSBStatus = 1;
usb_switch_state();
if(!askonstatus)
UsbIndicator(1);
else
inaskonstatus = 0;
uUSB_check_finished = 1; // finished
}
else if(attach & FSA9480_INT1_DETACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY1_USB --- DETACH\n");
MicroUSBStatus = 0;
UsbIndicator(0);
askon_gadget_disconnect();
uUSB_check_finished = 0; // finished
}
break;
case FSA9480_DEV_TY1_UART:
DEBUG_FSA9480("UART\n");
break;
case FSA9480_DEV_TY1_CAR_KIT:
DEBUG_FSA9480("Carkit\n");
break;
case FSA9480_DEV_TY1_USB_CHG:
DEBUG_FSA9480("USB\n");
break;
case FSA9480_DEV_TY1_DED_CHG:
{
if(attach & FSA9480_INT1_ATTACH)
{
DEBUG_FSA9480("Dedicated Charger ATTACH\n");
uUSB_check_finished = 1; // finished
//A9480_ChangePathToAudio(TRUE);
}
else if(attach & FSA9480_INT1_DETACH)
{
DEBUG_FSA9480("Dedicated Charger DETACH\n");
uUSB_check_finished = 0; // finished
//A9480_ChangePathToAudio(FALSE);
}
}
break;
case FSA9480_DEV_TY1_USB_OTG:
DEBUG_FSA9480("USB OTG\n");
break;
default:
DEBUG_FSA9480("Unknown device\n");
break;
}
}
if(dev2)
{
switch(dev2)
{
case FSA9480_DEV_TY2_JIG_USB_ON:
// DEBUG_FSA9480("JIG USB ON attach or detach: %d\n",attach);
if(HWREV >= 13) { // To support JIG_USB_ON (Above Rev0.7)
if(maxim_lpm_chg_status())
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_USB_ON --- ATTACH (VBUS)\n");
MicroJigUSBOnStatus = 1;
usb_switch_state();
if(!askonstatus)
UsbIndicator(1);
else
inaskonstatus = 0;
uUSB_check_finished = 1; // finished
}
else
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_USB_ON --- DETACH (VBUS)\n");
MicroJigUSBOnStatus = 0;
inaskonstatus = 0;
UsbIndicator(0);
askon_gadget_disconnect();
uUSB_check_finished = 0; // finished
}
}
else {
if(attach & FSA9480_INT1_ATTACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_USB_ON --- ATTACH\n");
MicroJigUSBOnStatus = 1;
usb_switch_state();
if(!askonstatus)
UsbIndicator(1);
else
inaskonstatus = 0;
}
else if(attach & FSA9480_INT1_DETACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_USB_ON --- DETACH\n");
MicroJigUSBOnStatus = 0;
inaskonstatus = 0;
UsbIndicator(0);
askon_gadget_disconnect();
}
}
break;
case FSA9480_DEV_TY2_JIG_USB_OFF:
// DEBUG_FSA9480("JIG USB OFF attach or detach: %d\n",attach);
if(HWREV >= 13) { // To support JIG_USB_OFF (Above Rev0.7)
if(maxim_lpm_chg_status())
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_USB_OFF --- ATTACH (VBUS)\n");
MicroJigUSBOnStatus = 1;
usb_switch_state();
if(!askonstatus)
UsbIndicator(1);
else
inaskonstatus = 0;
uUSB_check_finished = 1; // finished
}
else
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_USB_OFF --- DETACH (VBUS)\n");
MicroJigUSBOnStatus = 0;
inaskonstatus = 0;
UsbIndicator(0);
askon_gadget_disconnect();
uUSB_check_finished = 0; // finished
}
}
else {
if(attach & FSA9480_INT1_ATTACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_USB_OFF --- ATTACH\n");
MicroJigUSBOffStatus = 1;
usb_switch_state();
if(!askonstatus)
UsbIndicator(1);
else
inaskonstatus = 0;
}
else if(attach & FSA9480_INT1_DETACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_USB_OFF --- DETACH\n");
MicroJigUSBOffStatus = 0;
inaskonstatus = 0;
UsbIndicator(0);
askon_gadget_disconnect();
}
}
break;
case FSA9480_DEV_TY2_JIG_UART_ON:
if(attach & FSA9480_INT1_ATTACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_UART_ON --- ATTACH\n");
// car_vps_status_change(1);
}
else
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_UART_ON --- DETACH\n");
// car_vps_status_change(0);
}
// DEBUG_FSA9480("JIG UART ON\n");
break;
case FSA9480_DEV_TY2_JIG_UART_OFF:
if(attach & FSA9480_INT1_ATTACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_UART_OFF --- ATTACH\n");
MicroJigUARTOffStatus = 1;
uart_insert_switch_state();
}
else
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_UART_OFF --- DETACH\n");
MicroJigUARTOffStatus = 0;
uart_remove_switch_state();
}
// DEBUG_FSA9480("JIT UART OFF\n");
break;
case FSA9480_DEV_TY2_PDD:
DEBUG_FSA9480("PPD \n");
break;
case FSA9480_DEV_TY2_TTY:
DEBUG_FSA9480("TTY\n");
break;
case FSA9480_DEV_TY2_AV:
// DEBUG_FSA9480("AudioVideo\n");
if(attach & FSA9480_INT1_ATTACH)
DEBUG_FSA9480("FSA9480_DEV_TY2_AV --- ATTACH\n");
else
DEBUG_FSA9480("FSA9480_DEV_TY2_AV --- DETACH\n");
break;
default:
DEBUG_FSA9480("Unknown device\n");
break;
}
}
}
static void __exit fsa9480_driver_exit(void)
{
DEBUG_FSA9480("%s\n", __func__);
i2c_del_driver(&fsa9480_i2c_driver);
}
static int fsa9480_codec_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct fsa9480_state *state;
struct device *dev = &client->dev;
u8 pData;
DEBUG_FSA9480("[FSA9480] %s\n", __func__);
s3c_gpio_cfgpin(GPIO_USB_SCL_28V, S3C_GPIO_OUTPUT);
s3c_gpio_setpull(GPIO_USB_SCL_28V, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(GPIO_USB_SDA_28V, S3C_GPIO_OUTPUT);
s3c_gpio_setpull(GPIO_USB_SDA_28V, S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(GPIO_UART_SEL, S3C_GPIO_OUTPUT );
s3c_gpio_setpull(GPIO_UART_SEL, S3C_GPIO_PULL_NONE);
if (device_create_file(switch_dev, &dev_attr_uart_sel) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_uart_sel.attr.name);
if (device_create_file(switch_dev, &dev_attr_usb_sel) < 0)
DEBUG_FSA9480("[FSA9480]Failed to create device file(%s)!\n", dev_attr_usb_sel.attr.name);
if (device_create_file(switch_dev, &dev_attr_usb_state) < 0)
DEBUG_FSA9480("[FSA9480]Failed to create device file(%s)!\n", dev_attr_usb_state.attr.name);
#if 1
if (device_create_file(switch_dev, &dev_attr_DMport) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_DMport.attr.name);
if (device_create_file(switch_dev, &dev_attr_DMlog) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_DMlog.attr.name);
#endif
if (device_create_file(switch_dev, &dev_attr_UsbMenuSel) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_UsbMenuSel.attr.name);
if (device_create_file(switch_dev, &dev_attr_AskOnMenuSel) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_AskOnMenuSel.attr.name);
if (device_create_file(switch_dev, &dev_attr_Mtp) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_Mtp.attr.name);
if (device_create_file(switch_dev, &dev_attr_SwitchingInitValue) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_SwitchingInitValue.attr.name);
if (device_create_file(switch_dev, &dev_attr_FactoryResetValue) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_FactoryResetValue.attr.name);
if (device_create_file(switch_dev, &dev_attr_AskOnStatus) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_AskOnStatus.attr.name);
if (device_create_file(switch_dev, &dev_attr_MtpInitStatusSel) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_MtpInitStatusSel.attr.name);
if (device_create_file(switch_dev, &dev_attr_AskInitStatusSel) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_AskInitStatusSel.attr.name);
if (device_create_file(switch_dev, &dev_attr_tethering) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_tethering.attr.name);
if (device_create_file(switch_dev, &dev_attr_dock) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_dock.attr.name);
init_waitqueue_head(&usb_detect_waitq);
INIT_WORK(&fsa9480_work, FSA9480_ReadIntRegister);
fsa9480_workqueue = create_singlethread_workqueue("fsa9480_workqueue");
state = kzalloc(sizeof(struct fsa9480_state), GFP_KERNEL);
if(!state) {
dev_err(dev, "%s: failed to create fsa9480_state\n", __func__);
return -ENOMEM;
}
indicator_dev.name = DRIVER_NAME;
indicator_dev.print_name = print_switch_name;
indicator_dev.print_state = print_switch_state;
switch_dev_register(&indicator_dev);
state->client = client;
fsa9480_i2c_client = client;
i2c_set_clientdata(client, state);
if(!fsa9480_i2c_client)
{
dev_err(dev, "%s: failed to create fsa9480_i2c_client\n", __func__);
return -ENODEV;
}
/*clear interrupt mask register*/
fsa9480_read(fsa9480_i2c_client, REGISTER_CONTROL, &pData);
fsa9480_write(fsa9480_i2c_client, REGISTER_CONTROL, pData & ~INT_MASK);
fsa9480_interrupt_init();
fsa9480_chip_init();
INIT_DELAYED_WORK(&micorusb_init_work, connectivity_switching_init);
schedule_delayed_work(&micorusb_init_work, msecs_to_jiffies(200));
return 0;
}
static void fsa9480_process_device(u8 dev1, u8 dev2, u8 attach)
{
DEBUG_FSA9480("fsa9480_process_device function!!!!\n");
if(dev1)
{
switch(dev1)
{
case FSA9480_DEV_TY1_AUD_TY1:
DEBUG_FSA9480("Audio Type1 ");
if(attach & FSA9480_INT1_ATTACH)
DEBUG_FSA9480("FSA9480_DEV_TY1_AUD_TY1 --- ATTACH\n");
else
DEBUG_FSA9480("FSA9480_DEV_TY1_AUD_TY1 --- DETACH\n");
break;
case FSA9480_DEV_TY1_AUD_TY2:
DEBUG_FSA9480("Audio Type2 ");
DEBUG_FSA9480("\n");
break;
case FSA9480_DEV_TY1_USB:
{
DEBUG_FSA9480("USB attach or detach: %d ",attach);
if(attach & FSA9480_INT1_ATTACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY1_USB --- ATTACH\n");
MicroUSBStatus = _ATTACH;
}
else if(attach & FSA9480_INT1_DETACH)
{
MicroUSBStatus = _DETACH;
DEBUG_FSA9480("FSA9480_DEV_TY1_USB --- DETACH\n");
interruptible_sleep_on_timeout(&usb_disconnect_waitq, USB_DISCONNECT_WAIT_TIMEOUT);
}
wake_up_interruptible(&usb_detect_waitq);
microusb_usbjig_detect();
}
break;
case FSA9480_DEV_TY1_UART:
DEBUG_FSA9480("UART ");
DEBUG_FSA9480("\n");
break;
case FSA9480_DEV_TY1_CAR_KIT:
DEBUG_FSA9480("Carkit ");
DEBUG_FSA9480("\n");
break;
case FSA9480_DEV_TY1_USB_CHG:
DEBUG_FSA9480("USB ");
DEBUG_FSA9480("\n");
if (attach & FSA9480_INT1_ATTACH) {
USBCHGStatus = _ATTACH;
}
else if(attach & FSA9480_INT1_DETACH) {
USBCHGStatus = _DETACH;
}
break;
case FSA9480_DEV_TY1_DED_CHG:
DEBUG_FSA9480("Dedicated Charger ");
DEBUG_FSA9480("\n");
if (attach & FSA9480_INT1_ATTACH) {
DedicatedCHGStatus = _ATTACH;
}
else if(attach & FSA9480_INT1_DETACH) {
DedicatedCHGStatus = _DETACH;
}
break;
case FSA9480_DEV_TY1_USB_OTG:
DEBUG_FSA9480("USB OTG ");
DEBUG_FSA9480("\n");
break;
default:
DEBUG_FSA9480("Unknown device ");
DEBUG_FSA9480("\n");
break;
}
}
if(dev2)
{
switch(dev2)
{
case FSA9480_DEV_TY2_JIG_USB_ON:
DEBUG_FSA9480("JIG USB ON attach or detach: %d ",attach);
if(attach & FSA9480_INT1_ATTACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_USB_ON --- ATTACH\n");
MicroJigUSBOnStatus = _ATTACH;
}
else if(attach & FSA9480_INT1_DETACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_USB_ON --- DETACH\n");
MicroJigUSBOnStatus = DETACH;
interruptible_sleep_on_timeout(&usb_disconnect_waitq, USB_DISCONNECT_WAIT_TIMEOUT);
}
wake_up_interruptible(&usb_detect_waitq);
microusb_usbjig_detect();
break;
case FSA9480_DEV_TY2_JIG_USB_OFF:
DEBUG_FSA9480("JIG USB OFF ");
if(attach & FSA9480_INT1_ATTACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_USB_OFF --- ATTACH\n");
MicroJigUSBOffStatus = _ATTACH;
}
else if(attach & FSA9480_INT1_DETACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_USB_OFF --- DETACH\n");
MicroJigUSBOffStatus = DETACH;
interruptible_sleep_on_timeout(&usb_disconnect_waitq, USB_DISCONNECT_WAIT_TIMEOUT);
}
wake_up_interruptible(&usb_detect_waitq);
microusb_usbjig_detect();
break;
case FSA9480_DEV_TY2_JIG_UART_ON:
DEBUG_FSA9480("JIG UART ON ");
if(attach & FSA9480_INT1_ATTACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_UART_ON --- ATTACH\n");
MicroJigUARTOnStatus = _ATTACH;
}
else
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_UART_ON --- DETACH\n");
MicroJigUARTOnStatus = DETACH;
}
break;
case FSA9480_DEV_TY2_JIG_UART_OFF:
DEBUG_FSA9480("JIT UART OFF ");
if(attach & FSA9480_INT1_ATTACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_UART_OFF --- ATTACH\n");
MicroJigUARTOffStatus = _ATTACH;
}
else
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_UART_OFF --- DETACH\n");
MicroJigUARTOffStatus = DETACH;
}
break;
case FSA9480_DEV_TY2_PDD:
DEBUG_FSA9480("PPD ");
DEBUG_FSA9480("\n");
break;
case FSA9480_DEV_TY2_TTY:
DEBUG_FSA9480("TTY ");
DEBUG_FSA9480("\n");
break;
case FSA9480_DEV_TY2_AV:
{
DEBUG_FSA9480("AudioVideo ");
if(attach & FSA9480_INT1_ATTACH)
DEBUG_FSA9480("FSA9480_DEV_TY2_AV --- ATTACH\n");
else
DEBUG_FSA9480("FSA9480_DEV_TY2_AV --- DETACH\n");
}
break;
default:
DEBUG_FSA9480("Unknown device ");
DEBUG_FSA9480("\n");
break;
}
}
}
void FSA9480_ReadIntRegister(struct work_struct *work)
{
struct i2c_client *client = fsa9480_i2c_client;
u8 interrupt1 ,interrupt2 ,device1, device2, temp;
DEBUG_FSA9480("[FSA9480] %s\n", __func__);
fsa9480_read(client, REGISTER_INTERRUPT1, &interrupt1);
msleep(5);
fsa9480_read(client, REGISTER_INTERRUPT2, &interrupt2);
msleep(5);
fsa9480_read(client, REGISTER_DEVICETYPE1, &device1);
msleep(5);
fsa9480_read(client, REGISTER_DEVICETYPE2, &device2);
usb_state = (device2 << 8) | (device1 << 0);
if(interrupt1 & FSA9480_INT1_ATTACH)
{
fsa9480_device1 = device1;
fsa9480_device2 = device2;
if(fsa9480_device1 != FSA9480_DEV_TY1_DED_CHG) {
//DEBUG_FSA9480("FSA9480_enable LDO8\n");
s3c_usb_cable(1);
}
if(fsa9480_device1&FSA9480_DEV_TY1_CAR_KIT)
{
msleep(5);
fsa9480_write(client, REGISTER_CARKITSTATUS, 0x02);
msleep(5);
fsa9480_read(client, REGISTER_CARKITINT1, &temp);
}
}
msleep(5);
fsa9480_write(client, REGISTER_CONTROL, 0x1E);
fsa9480_write(client, REGISTER_INTERRUPTMASK1, 0xFC);
#if defined(CONFIG_ARIES_NTT) // Modify NTTS1
//syyoon 20100724 fix for SC - Ad_10_2nd - 0006. When USB is removed, sometimes attatch value gets 0x00
if((fsa9480_device1 == FSA9480_DEV_TY1_USB) && (!interrupt1)) {
printk("[FSA9480] dev1=usb, attach change is from 0 to 2\n");
interrupt1 = FSA9480_INT1_DETACH;
}
#endif
FSA9480_ProcessDevice(fsa9480_device1, fsa9480_device2, interrupt1);
if(interrupt1 & FSA9480_INT1_DETACH)
{
if(fsa9480_device1 != FSA9480_DEV_TY1_DED_CHG) {
//DEBUG_FSA9480("FSA9480_disable LDO8\n");
s3c_usb_cable(0);
}
fsa9480_device1 = 0;
fsa9480_device2 = 0;
}
enable_irq(IRQ_FSA9480_INTB);
}
void FSA9480_ProcessDevice(u8 dev1, u8 dev2, u8 attach)
{
DEBUG_FSA9480("[FSA9480] %s (dev1 : 0x%x, dev2 : 0x%x)\n", __func__, dev1, dev2);
if(!attach && !chip_error && (mtp_mode_on == 1))
chip_error = 0xAE;
if(dev1)
{
switch(dev1)
{
case FSA9480_DEV_TY1_AUD_TY1:
DEBUG_FSA9480("Audio Type1 ");
if(attach & FSA9480_INT1_ATTACH)
DEBUG_FSA9480("FSA9480_DEV_TY1_AUD_TY1 --- ATTACH\n");
else
DEBUG_FSA9480("FSA9480_DEV_TY1_AUD_TY1 --- DETACH\n");
break;
case FSA9480_DEV_TY1_AUD_TY2:
DEBUG_FSA9480("Audio Type2 ");
break;
case FSA9480_DEV_TY1_USB:
DEBUG_FSA9480("USB attach or detach: %d\n",attach);
if(attach & FSA9480_INT1_ATTACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY1_USB --- ATTACH\n");
MicroUSBStatus = 1;
log_via_usb = log_usb_enable;
#if 0
if(connectivity_switching_init_state)
s3c_usb_cable(1);
#endif
usb_switch_state();
if(!askonstatus)
UsbIndicator(1);
else
inaskonstatus = 0;
uUSB_check_finished = 1; // finished
}
else if(attach & FSA9480_INT1_DETACH)
{
MicroUSBStatus = 0;
inaskonstatus = 0;
chip_error = 0;
#if 0
if(connectivity_switching_init_state)
s3c_usb_cable(0);
#endif
UsbIndicator(0);
askon_gadget_disconnect();
DEBUG_FSA9480("FSA9480_DEV_TY1_USB --- DETACH\n");
uUSB_check_finished = 0; // finished
}
break;
case FSA9480_DEV_TY1_UART:
DEBUG_FSA9480("UART\n");
break;
case FSA9480_DEV_TY1_CAR_KIT:
DEBUG_FSA9480("Carkit\n");
break;
case FSA9480_DEV_TY1_USB_CHG:
DEBUG_FSA9480("USB\n");
break;
case FSA9480_DEV_TY1_DED_CHG:
{
if(attach & FSA9480_INT1_ATTACH)
{
DEBUG_FSA9480("Dedicated Charger ATTACH\n");
uUSB_check_finished = 1; // finished
//A9480_ChangePathToAudio(TRUE);
}
else if(attach & FSA9480_INT1_DETACH)
{
DEBUG_FSA9480("Dedicated Charger DETACH\n");
uUSB_check_finished = 0; // finished
//A9480_ChangePathToAudio(FALSE);
}
}
break;
case FSA9480_DEV_TY1_USB_OTG:
DEBUG_FSA9480("USB OTG\n");
break;
default:
DEBUG_FSA9480("Unknown device\n");
break;
}
}
if(dev2)
{
switch(dev2)
{
case FSA9480_DEV_TY2_JIG_USB_ON:
DEBUG_FSA9480("JIG USB ON attach or detach: %d",attach);
if(attach & FSA9480_INT1_ATTACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_USB_ON --- ATTACH\n");
MicroJigUSBOnStatus = 1;
#if 0
if(connectivity_switching_init_state)
s3c_usb_cable(1);
#endif
usb_switch_state();
if(!askonstatus)
UsbIndicator(1);
else
inaskonstatus = 0;
}
else if(attach & FSA9480_INT1_DETACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_USB_ON --- DETACH\n");
chip_error = 0;
MicroJigUSBOnStatus = 0;
inaskonstatus = 0;
#if 0
if(connectivity_switching_init_state)
s3c_usb_cable(0);
#endif
UsbIndicator(0);
askon_gadget_disconnect();
}
break;
case FSA9480_DEV_TY2_JIG_USB_OFF:
if(attach & FSA9480_INT1_ATTACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_USB_OFF --- ATTACH\n");
MicroJigUSBOffStatus = 1;
#if 0
if(connectivity_switching_init_state)
s3c_usb_cable(1);
#endif
usb_switch_state();
if(!askonstatus)
UsbIndicator(1);
else
inaskonstatus = 0;
}
else if(attach & FSA9480_INT1_DETACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_USB_OFF --- DETACH\n");
chip_error = 0;
MicroJigUSBOffStatus = 0;
inaskonstatus = 0;
#if 0
if(connectivity_switching_init_state)
s3c_usb_cable(0);
#endif
UsbIndicator(0);
askon_gadget_disconnect();
}
DEBUG_FSA9480("JIG USB OFF \n");
break;
case FSA9480_DEV_TY2_JIG_UART_ON:
if(attach & FSA9480_INT1_ATTACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_UART_ON --- ATTACH\n");
set_dock_state((int)CAR_DOCK_INSERTED);
g_dock = CAR_DOCK_INSERTED;
}
else
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_UART_ON --- DETACH\n");
set_dock_state((int)DOCK_REMOVED);
g_dock = DOCK_REMOVED;
}
DEBUG_FSA9480("JIG UART ON\n");
break;
case FSA9480_DEV_TY2_JIG_UART_OFF:
if(attach & FSA9480_INT1_ATTACH)
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_UART_OFF --- ATTACH\n");
MicroJigUARTOffStatus = 1;
uart_insert_switch_state();
}
else
{
DEBUG_FSA9480("FSA9480_DEV_TY2_JIG_UART_OFF --- DETACH\n");
MicroJigUARTOffStatus = 0;
uart_remove_switch_state();
}
DEBUG_FSA9480("JIT UART OFF\n");
break;
case FSA9480_DEV_TY2_PDD:
DEBUG_FSA9480("PPD \n");
break;
case FSA9480_DEV_TY2_TTY:
DEBUG_FSA9480("TTY\n");
break;
case FSA9480_DEV_TY2_AV:
DEBUG_FSA9480("AudioVideo\n");
if (attach & FSA9480_INT1_DETACH) {
DEBUG_FSA9480("FSA9480_disable_spk\n");
set_dock_state((int)DOCK_REMOVED);
g_dock = DOCK_REMOVED;
}
else {
DEBUG_FSA9480("FSA9480_enable_spk\n");
set_dock_state((int)HOME_DOCK_INSERTED);
FSA9480_Enable_SPK(1);
g_dock = HOME_DOCK_INSERTED;
}
break;
default:
DEBUG_FSA9480("Unknown device\n");
break;
}
}
if((attach == FSA9480_INT1_ATTACH) && (chip_error == 0xAE) && (mtp_mode_on == 1)) {
ap_usb_power_on(1);
chip_error = 0;
}
}
static void fsa9480_read_int_register(struct work_struct *work)
{
u8 interrupt1 , interrupt2, device1, device2, temp;
DEBUG_FSA9480("fsa9480_read_int_register function!!!!\n");
fsa9480_read(fsa9480_i2c_client, REGISTER_INTERRUPT1, &interrupt1);
mdelay(10);
fsa9480_read(fsa9480_i2c_client, REGISTER_INTERRUPT2, &interrupt2);
mdelay(10);
fsa9480_read(fsa9480_i2c_client, REGISTER_DEVICETYPE1, &device1);
mdelay(10);
fsa9480_read(fsa9480_i2c_client, REGISTER_DEVICETYPE2, &device2);
if(interrupt1 & FSA9480_INT1_ATTACH)
{
fsa9480_device1 = device1;
fsa9480_device2 = device2;
if(fsa9480_device1 & FSA9480_DEV_TY1_CAR_KIT)
{
mdelay(10);
fsa9480_write(fsa9480_i2c_client, REGISTER_CARKITSTATUS, 0x02);
mdelay(10);
fsa9480_read(fsa9480_i2c_client, REGISTER_CARKITINT1, &temp);
}
}
mdelay(10);
if(microusb_usbpath > 0) // if CP USB
{
fsa9480_write(fsa9480_i2c_client, REGISTER_CONTROL, 0x1A);
mdelay(10);
fsa9480_write(fsa9480_i2c_client, REGISTER_MANUALSW1, 0x90);
mdelay(10);
fsa9480_write(fsa9480_i2c_client, REGISTER_MANUALSW2, 0x10);
mdelay(10);
}
else
{
fsa9480_write(fsa9480_i2c_client, REGISTER_CONTROL, 0x1E);
wake_up_interruptible(&usb_detect_waitq);
fsa9480_process_device(fsa9480_device1, fsa9480_device2, interrupt1);
}
fsa9480_write(fsa9480_i2c_client, REGISTER_INTERRUPTMASK1, 0xFC);
if(interrupt1 & FSA9480_INT1_DETACH)
{
fsa9480_device1 = 0;
fsa9480_device2 = 0;
}
enable_irq(fsa9480_i2c_client->irq);
wake_lock_timeout(&fsa9480_wake_lock, 3*HZ);
}
int get_real_usbic_state(void)
{
#define I2C_READ_RETRY_MAX 2
int ret = 0;
int read_retry;
u8 device1;
u8 device2;
interruptible_sleep_on_timeout(&usb_detect_waitq, HZ);
for(read_retry = 0; read_retry < I2C_READ_RETRY_MAX; read_retry++)
{
device1 = 0;
if(fsa9480_read(fsa9480_i2c_client, REGISTER_DEVICETYPE1, &device1) == 0)
{
break;
}
}
for(read_retry = 0; read_retry < I2C_READ_RETRY_MAX; read_retry++)
{
device2 = 0;
if(fsa9480_read(fsa9480_i2c_client, REGISTER_DEVICETYPE2, &device2) == 0)
{
break;
}
}
DEBUG_FSA9480("real usbic state : %d, %d\n", device1, device2);
switch(device1)
{
case FSA9480_DEV_TY1_USB:
ret = MICROUSBIC_USB_CABLE;
break;
case FSA9480_DEV_TY1_USB_CHG:
ret = MICROUSBIC_USB_CHARGER;
break;
case FSA9480_DEV_TY1_CAR_KIT:
ret = MICROUSBIC_5W_CHARGER;
break;
case FSA9480_DEV_TY1_DED_CHG:
ret = MICROUSBIC_TA_CHARGER;
break;
default:
break;
}
if(!ret)
{
switch(device2)
{
case FSA9480_DEV_TY2_JIG_USB_ON:
case FSA9480_DEV_TY2_JIG_USB_OFF:
ret = MICROUSBIC_USB_CABLE;
break;
default:
break;
}
}
if(microusb_usbpath > 0) // if CP USB
{
if(ret == MICROUSBIC_USB_CABLE)
{
ret = MICROUSBIC_USB_CHARGER;
}
}
return ret;
}
