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);
}
#if defined CONFIG_USB_S3C_OTG_HOST || defined CONFIG_USB_DWC_OTG
// sztupy: handle automatic otg switching
if (val1 & DEV_USB_OTG) {
// otg cable detected
set_otghost_mode(2);
} else {
// client cable detected
set_otghost_mode(1);
}
#endif
#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);
#if defined CONFIG_USB_S3C_OTG_HOST || defined CONFIG_USB_DWC_OTG
// sztupy: also switch off otg host mode
set_otghost_mode(0);
#endif
#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;
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);
/* device detection */
fsa9480_detect_dev(usbsw);
// set fsa9480 init flag.
if (usbsw->pdata->set_init_flag)
usbsw->pdata->set_init_flag();
#if defined(CONFIG_MACH_VICTORY)
ret = switch_dev_register(&wimax_cable);
wimax_cable.print_state = wimax_cable_type;
#endif
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,
};
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);
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);
}
#if defined CONFIG_USB_S3C_OTG_HOST || defined CONFIG_USB_DWC_OTG
// sztupy: handle automatic otg switching
if (val1 & DEV_USB_OTG) {
// otg cable detected
set_otghost_mode(2);
} else {
// client cable detected
set_otghost_mode(1);
}
#endif
/* UART */
} else if (val1 & DEV_T1_UART_MASK || val2 & DEV_T2_UART_MASK) {
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);
}
/* 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);
#if defined(CONFIG_MACH_ARIES)
#if defined(CONFIG_SAMSUNG_CAPTIVATE) || defined(CONFIG_SAMSUNG_FASCINATE)
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_MANSW1, SW_AUDIO);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
#else
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);
#endif
#else
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);
#endif
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;
#if defined(CONFIG_MACH_ARIES)
#if defined(CONFIG_SAMSUNG_CAPTIVATE) || defined(CONFIG_SAMSUNG_FASCINATE)
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_MANSW1, SW_AUDIO);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
#else
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);
#endif
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);
#endif
}
/* Detached */
} else {
/* USB */
if (usbsw->dev1 & DEV_T1_USB_MASK ||
usbsw->dev2 & DEV_T2_USB_MASK) {
if (pdata->usb_cb) {
pdata->usb_cb(FSA9480_DETACHED);
#if defined CONFIG_USB_S3C_OTG_HOST || defined CONFIG_USB_DWC_OTG
// sztupy: also switch off otg host mode
set_otghost_mode(0);
#endif
}
/* UART */
} else if (usbsw->dev1 & DEV_T1_UART_MASK ||
usbsw->dev2 & DEV_T2_UART_MASK) {
if (pdata->uart_cb)
pdata->uart_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);
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;
#if defined(CONFIG_MACH_ARIES)
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);
#endif
}
}
usbsw->dev1 = val1;
usbsw->dev2 = val2;
}
