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;
}
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;
}
void microusb_init(void)
{
#define I2C_READ_RETRY_MAX 2
int ret = 0;
int read_retry;
u8 device1;
u8 device2;
u8 interrupt1;
u8 interrupt2;
u8 attach = FSA9480_INT1_ATTACH;
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;
}
}
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
{
if(device1 && (device1 != FSA9480_DEV_TY1_DED_CHG)) {
attach = FSA9480_INT1_ATTACH;
}
if(device1 == 0 && device2 == 0) {
device1 = FSA9480_DEV_TY1_USB;
attach = FSA9480_INT1_DETACH;
}
fsa9480_device1 = device1;
fsa9480_device2 = device2;
fsa9480_process_device(fsa9480_device1, fsa9480_device2, attach);
fsa9480_init();
}
// clear interrupt
fsa9480_read(fsa9480_i2c_client, REGISTER_INTERRUPT1, &interrupt1);
msleep(5);
fsa9480_read(fsa9480_i2c_client, REGISTER_INTERRUPT2, &interrupt2);
msleep(5);
fsa9480_interrupt_init(fsa9480_i2c_client->irq, fsa9480_i2c_device_id);
}
