static ssize_t tethering_switch_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
{
int usbstatus;
usbstatus = FSA9480_Get_USB_Status();
dmsg("usbstatus = 0x%x, currentusbstatus = 0x%x\n", usbstatus, currentusbstatus);
if (strncmp(buf, "1", 1) == 0)
{
dmsg("tethering On\n");
g_tethering = 1;
usb_switch_select(USBSTATUS_VTP);
UsbIndicator(0);
}
else if (strncmp(buf, "0", 1) == 0)
{
dmsg("tethering Off\n");
g_tethering = 0;
usb_switch_select(oldusbstatus);
if(usbstatus)
UsbIndicator(1);
}
return size;
}
static ssize_t KiesStatus_switch_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
{
dmsg("buf=%s\n", buf);
if (strncmp(buf, "START", 5) == 0)
{
kies_status = 1;
}
else if (strncmp(buf, "STOP", 4) == 0)
{
kies_status = 2;
UsbIndicator(2);
}
else if (strncmp(buf, "INIT", 4) == 0 )
{
kies_status = 0;
}
return size;
}
static void fsa9480_detect_dev(struct fsa9480_usbsw *usbsw)
{
int device_type, ret;
unsigned char val1, val2;
struct fsa9480_platform_data *pdata = usbsw->pdata;
struct i2c_client *client = usbsw->client;
device_type = i2c_smbus_read_word_data(client, FSA9480_REG_DEV_T1);
if (device_type < 0)
dev_err(&client->dev, "%s: err %d\n", __func__, device_type);
val1 = device_type & 0xff;
val2 = device_type >> 8;
dev_info(&client->dev, "dev1: 0x%x, dev2: 0x%x\n", val1, val2);
/* Attached */
if (val1 || val2) {
/* USB */
if (val1 & DEV_T1_USB_MASK || val2 & DEV_T2_USB_MASK) {
if (pdata->usb_cb)
pdata->usb_cb(FSA9480_ATTACHED);
micro_usb_status = 1;
#ifdef _SUPPORT_SAMSUNG_AUTOINSTALLER_
askon_gadget_disconnect();
if (!askon_status)
UsbIndicator(1);
#else
UsbIndicator(1);
#endif
if (usbsw->mansw) {
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_MANSW1, usbsw->mansw);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
}
/* UART */
} else if (val1 & DEV_T1_UART_MASK || val2 & DEV_T2_UART_MASK) {
if(val2 & DEV_T2_UART_MASK)
MicroJigUARTOffStatus = 1;
if (pdata->uart_cb)
pdata->uart_cb(FSA9480_ATTACHED);
if (usbsw->mansw) {
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_MANSW1, SW_UART);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
}
if (val2 & DEV_T2_JIG_MASK) {
if (pdata->jig_cb)
pdata->jig_cb(FSA9480_ATTACHED);
}
/* CHARGER */
} else if (val1 & DEV_T1_CHARGER_MASK) {
if (pdata->charger_cb)
pdata->charger_cb(FSA9480_ATTACHED);
/* JIG */
} else if (val2 & DEV_T2_JIG_MASK) {
if (pdata->jig_cb)
pdata->jig_cb(FSA9480_ATTACHED);
/* Desk Dock */
} else if (val2 & DEV_AV) {
if (pdata->deskdock_cb)
pdata->deskdock_cb(FSA9480_ATTACHED);
dock_status = 1;
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_MANSW1, SW_DHOST);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
ret = i2c_smbus_read_byte_data(client,
FSA9480_REG_CTRL);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_CTRL, ret & ~CON_MANUAL_SW);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
/* Car Dock */
} else if (val2 & DEV_JIG_UART_ON) {
if (pdata->cardock_cb)
pdata->cardock_cb(FSA9480_ATTACHED);
dock_status = 1;
}
/* Detached */
} else {
/* USB */
if (usbsw->dev1 & DEV_T1_USB_MASK ||
usbsw->dev2 & DEV_T2_USB_MASK) {
micro_usb_status = 0;
UsbIndicator(0);
if (pdata->usb_cb)
pdata->usb_cb(FSA9480_DETACHED);
/* UART */
} else if (usbsw->dev1 & DEV_T1_UART_MASK ||
usbsw->dev2 & DEV_T2_UART_MASK) {
if(usbsw->dev2 & DEV_T2_UART_MASK)
MicroJigUARTOffStatus = 0;
if (pdata->uart_cb)
pdata->uart_cb(FSA9480_DETACHED);
if (usbsw->dev2 & DEV_T2_JIG_MASK) {
if (pdata->jig_cb)
pdata->jig_cb(FSA9480_DETACHED);
}
/* CHARGER */
} else if (usbsw->dev1 & DEV_T1_CHARGER_MASK) {
if (pdata->charger_cb)
pdata->charger_cb(FSA9480_DETACHED);
/* JIG */
} else if (usbsw->dev2 & DEV_T2_JIG_MASK) {
if (pdata->jig_cb)
pdata->jig_cb(FSA9480_DETACHED);
/* Desk Dock */
} else if (usbsw->dev2 & DEV_AV) {
if (pdata->deskdock_cb)
pdata->deskdock_cb(FSA9480_DETACHED);
dock_status = 0;
ret = i2c_smbus_read_byte_data(client,FSA9480_REG_CTRL);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_CTRL, ret | CON_MANUAL_SW);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
/* Car Dock */
} else if (usbsw->dev2 & DEV_JIG_UART_ON) {
if (pdata->cardock_cb)
pdata->cardock_cb(FSA9480_DETACHED);
dock_status = 0;
}
}
usbsw->dev1 = val1;
usbsw->dev2 = val2;
}
static void fsa9480_detect_dev(struct fsa9480_usbsw *usbsw)
{
int device_type, ret;
unsigned char val1, val2;
struct fsa9480_platform_data *pdata = usbsw->pdata;
struct i2c_client *client = usbsw->client;
#ifdef CONFIG_MACH_VICTORY
adc_fsa = i2c_smbus_read_word_data(client, FSA9480_REG_ADC);
if (adc_fsa < 0)
dev_err(&client->dev, "%s: err %d\n", __func__, adc_fsa);
if ( adc_fsa == WIMAX_CABLE_50K){
switch_set_state(&wimax_cable, USB_CABLE_50K);
} else if (adc_fsa == WIMAX_CABLE_50K_DIS) {
fsa9480_manual_switching(SWITCH_PORT_AUTO);
switch_set_state(&wimax_cable, CABLE_DISCONNECT);
}
#endif
device_type = i2c_smbus_read_word_data(client, FSA9480_REG_DEV_T1);
if (device_type < 0)
dev_err(&client->dev, "%s: err %d\n", __func__, device_type);
val1 = device_type & 0xff;
val2 = device_type >> 8;
dev_info(&client->dev, "dev1: 0x%x, dev2: 0x%x\n", val1, val2);
/* Attached */
if (val1 || val2) {
/* USB */
#ifdef CONFIG_MACH_VICTORY
if (val1 & DEV_T1_USB_MASK){
#else
if (val1 & DEV_T1_USB_MASK || val2 & DEV_T2_USB_MASK ) {
#endif
if (pdata->usb_cb)
pdata->usb_cb(FSA9480_ATTACHED);
micro_usb_status = 1;
#ifdef _SUPPORT_SAMSUNG_AUTOINSTALLER_
askon_gadget_disconnect();
if (!askon_status)
UsbIndicator(1);
#else
UsbIndicator(1);
#endif
if (usbsw->mansw) {
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_MANSW1, usbsw->mansw);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
}
#ifdef CONFIG_MACH_VICTORY
} else if ( val2 & DEV_T2_USB_MASK ) {
if (pdata->wimax_cb)
pdata->wimax_cb(FSA9480_ATTACHED);
switch_set_state(&wimax_cable, USB_CABLE_255K);
#endif
/* UART */
} else if (val1 & DEV_T1_UART_MASK || val2 & DEV_T2_UART_MASK) {
if(val2 & DEV_T2_UART_MASK)
MicroJigUARTOffStatus = 1;
if (pdata->uart_cb)
pdata->uart_cb(FSA9480_ATTACHED);
if (usbsw->mansw) {
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_MANSW1, SW_UART);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
}
if (val2 & DEV_T2_JIG_MASK) {
if (pdata->jig_cb)
pdata->jig_cb(FSA9480_ATTACHED);
}
/* CHARGER */
} else if (val1 & DEV_T1_CHARGER_MASK) {
if (pdata->charger_cb)
pdata->charger_cb(FSA9480_ATTACHED);
/* JIG */
} else if (val2 & DEV_T2_JIG_MASK) {
if (pdata->jig_cb)
pdata->jig_cb(FSA9480_ATTACHED);
/* Desk Dock */
} else if (val2 & DEV_AV) {
if (pdata->deskdock_cb)
pdata->deskdock_cb(FSA9480_ATTACHED);
dock_status = 1;
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_MANSW1, SW_VAUDIO);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
ret = i2c_smbus_read_byte_data(client,
FSA9480_REG_CTRL);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_CTRL, ret & ~CON_MANUAL_SW);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
/* Car Dock */
} else if (val2 & DEV_JIG_UART_ON) {
if (pdata->cardock_cb)
pdata->cardock_cb(FSA9480_ATTACHED);
dock_status = 1;
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_MANSW1, SW_VAUDIO);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
ret = i2c_smbus_read_byte_data(client,
FSA9480_REG_CTRL);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_CTRL, ret & ~CON_MANUAL_SW);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
}
/* Detached */
} else {
/* USB */
#ifdef CONFIG_MACH_VICTORY
if (usbsw->dev1 & DEV_T1_USB_MASK){
#else
if (usbsw->dev1 & DEV_T1_USB_MASK ||
usbsw->dev2 & DEV_T2_USB_MASK) {
#endif
micro_usb_status = 0;
UsbIndicator(0);
if (pdata->usb_cb)
pdata->usb_cb(FSA9480_DETACHED);
#ifdef CONFIG_MACH_VICTORY
/* USB JIG */
} else if (usbsw->dev2 & DEV_T2_USB_MASK) {
if (pdata->wimax_cb)
pdata->wimax_cb(FSA9480_DETACHED);
switch_set_state(&wimax_cable, CABLE_DISCONNECT);
#endif
/* UART */
} else if (usbsw->dev1 & DEV_T1_UART_MASK ||
usbsw->dev2 & DEV_T2_UART_MASK) {
if(usbsw->dev2 & DEV_T2_UART_MASK)
MicroJigUARTOffStatus = 0;
if (pdata->uart_cb)
pdata->uart_cb(FSA9480_DETACHED);
if (usbsw->dev2 & DEV_T2_JIG_MASK) {
if (pdata->jig_cb)
pdata->jig_cb(FSA9480_DETACHED);
}
/* CHARGER */
} else if (usbsw->dev1 & DEV_T1_CHARGER_MASK) {
if (pdata->charger_cb)
pdata->charger_cb(FSA9480_DETACHED);
/* JIG */
} else if (usbsw->dev2 & DEV_T2_JIG_MASK) {
if (pdata->jig_cb)
pdata->jig_cb(FSA9480_DETACHED);
/* Desk Dock */
} else if (usbsw->dev2 & DEV_AV) {
if (pdata->deskdock_cb)
pdata->deskdock_cb(FSA9480_DETACHED);
dock_status = 0;
ret = i2c_smbus_read_byte_data(client,FSA9480_REG_CTRL);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_CTRL, ret | CON_MANUAL_SW);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
/* Car Dock */
} else if (usbsw->dev2 & DEV_JIG_UART_ON) {
if (pdata->cardock_cb)
pdata->cardock_cb(FSA9480_DETACHED);
dock_status = 0;
ret = i2c_smbus_read_byte_data(client,
FSA9480_REG_CTRL);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_CTRL, ret | CON_MANUAL_SW);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
}
}
usbsw->dev1 = val1;
usbsw->dev2 = val2;
}
static void fsa9480_reg_init(struct fsa9480_usbsw *usbsw)
{
struct i2c_client *client = usbsw->client;
unsigned int ctrl = CON_MASK;
int ret;
#if defined (CONFIG_MACH_ATLAS) || defined (CONFIG_MACH_FORTE)
/* mask interrupts (unmask attach/detach only) */
ret = i2c_smbus_write_word_data(client, FSA9480_REG_INT1_MASK, 0x1ffc);
if (ret < 0)
dev_err(&client->dev, "%s: err %d\n", __func__, ret);
#elif CONFIG_MACH_VICTORY
/* mask interrupts (unmask attach/detach only reserved attach only) */
ret = i2c_smbus_write_word_data(client, FSA9480_REG_INT1_MASK, 0x1dfc);
if (ret < 0)
dev_err(&client->dev, "%s: err %d\n", __func__, ret);
#endif
/* mask all car kit interrupts */
ret = i2c_smbus_write_word_data(client, FSA9480_REG_CK_INTMASK1, 0x07ff);
if (ret < 0)
dev_err(&client->dev, "%s: err %d\n", __func__, ret);
/* ADC Detect Time: 500ms */
ret = i2c_smbus_write_byte_data(client, FSA9480_REG_TIMING1, 0x6);
if (ret < 0)
dev_err(&client->dev, "%s: err %d\n", __func__, ret);
usbsw->mansw = i2c_smbus_read_byte_data(client, FSA9480_REG_MANSW1);
if (usbsw->mansw < 0)
dev_err(&client->dev, "%s: err %d\n", __func__, usbsw->mansw);
if (usbsw->mansw)
ctrl &= ~CON_MANUAL_SW; /* Manual Switching Mode */
ret = i2c_smbus_write_byte_data(client, FSA9480_REG_CTRL, ctrl);
if (ret < 0)
dev_err(&client->dev, "%s: err %d\n", __func__, ret);
}
static irqreturn_t fsa9480_irq_thread(int irq, void *data)
{
struct fsa9480_usbsw *usbsw = data;
struct i2c_client *client = usbsw->client;
int intr;
/* read and clear interrupt status bits */
intr = i2c_smbus_read_word_data(client, FSA9480_REG_INT1);
if (intr < 0) {
dev_err(&client->dev, "%s: err %d\n", __func__, intr);
} else if (intr == 0) {
/* interrupt was fired, but no status bits were set,
so device was reset. In this case, the registers were
reset to defaults so they need to be reinitialised. */
fsa9480_reg_init(usbsw);
}
/* device detection */
fsa9480_detect_dev(usbsw);
return IRQ_HANDLED;
}
static int fsa9480_irq_init(struct fsa9480_usbsw *usbsw)
{
struct i2c_client *client = usbsw->client;
int ret;
if (client->irq) {
ret = request_threaded_irq(client->irq, NULL,
fsa9480_irq_thread, IRQF_TRIGGER_FALLING,
"fsa9480 micro USB", usbsw);
if (ret) {
dev_err(&client->dev, "failed to reqeust IRQ\n");
return ret;
}
ret = enable_irq_wake(client->irq);
if (ret < 0)
dev_err(&client->dev,
"failed to enable wakeup src %d\n", ret);
}
return 0;
}
static int __devinit fsa9480_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct fsa9480_usbsw *usbsw;
int ret = 0;
#ifdef CONFIG_MACH_FORTE
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);
#endif
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
return -EIO;
usbsw = kzalloc(sizeof(struct fsa9480_usbsw), GFP_KERNEL);
if (!usbsw) {
dev_err(&client->dev, "failed to allocate driver data\n");
return -ENOMEM;
}
usbsw->client = client;
usbsw->pdata = client->dev.platform_data;
if (!usbsw->pdata)
goto fail1;
i2c_set_clientdata(client, usbsw);
local_usbsw = usbsw; // temp
if (usbsw->pdata->cfg_gpio)
usbsw->pdata->cfg_gpio();
fsa9480_reg_init(usbsw);
ret = fsa9480_irq_init(usbsw);
if (ret)
goto fail1;
ret = sysfs_create_group(&client->dev.kobj, &fsa9480_group);
if (ret) {
dev_err(&client->dev,
"failed to create fsa9480 attribute group\n");
goto fail2;
}
if (usbsw->pdata->reset_cb)
usbsw->pdata->reset_cb();
indicator_dev.name = DRIVER_NAME;
#if 1
indicator_dev.print_name = print_switch_name;
indicator_dev.print_state = print_switch_state;
#endif
switch_dev_register(&indicator_dev);
#if defined(CONFIG_MACH_VICTORY)
ret = switch_dev_register(&wimax_cable);
wimax_cable.print_state = wimax_cable_type;
#endif
/* device detection */
fsa9480_detect_dev(usbsw);
// set fsa9480 init flag.
if (usbsw->pdata->set_init_flag)
usbsw->pdata->set_init_flag();
return 0;
fail2:
if (client->irq)
free_irq(client->irq, usbsw);
fail1:
i2c_set_clientdata(client, NULL);
kfree(usbsw);
return ret;
}
static int __devexit fsa9480_remove(struct i2c_client *client)
{
struct fsa9480_usbsw *usbsw = i2c_get_clientdata(client);
if (client->irq) {
disable_irq_wake(client->irq);
free_irq(client->irq, usbsw);
}
i2c_set_clientdata(client, NULL);
sysfs_remove_group(&client->dev.kobj, &fsa9480_group);
kfree(usbsw);
return 0;
}
#ifdef CONFIG_PM
static int fsa9480_suspend(struct i2c_client *client, pm_message_t mesg)
{
#ifdef CONFIG_MACH_VICTORY
disable_irq(client->irq );
#endif
return 0;
}
static int fsa9480_resume(struct i2c_client *client)
{
struct fsa9480_usbsw *usbsw = i2c_get_clientdata(client);
#ifdef CONFIG_MACH_VICTORY
enable_irq(client->irq);
#endif
/* device detection */
fsa9480_detect_dev(usbsw);
return 0;
}
#else
#define fsa9480_suspend NULL
#define fsa9480_resume NULL
#endif /* CONFIG_PM */
static const struct i2c_device_id fsa9480_id[] = {
{"fsa9480", 0},
{}
};
MODULE_DEVICE_TABLE(i2c, fsa9480_id);
static struct i2c_driver fsa9480_i2c_driver = {
.driver = {
.name = "fsa9480",
},
.probe = fsa9480_probe,
.remove = __devexit_p(fsa9480_remove),
.suspend = fsa9480_suspend,
.resume = fsa9480_resume,
.id_table = fsa9480_id,
};
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_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;
}
}
}
