static int usif_switch_probe(struct platform_device *pdev)
{
struct usif_switch_platform_data *pdata = pdev->dev.platform_data;
struct usif_switch *usif;
int ret = 0;
usif = kzalloc(sizeof(struct usif_switch), GFP_KERNEL);
if (!usif) {
pr_err("usif: %s: no memory\n", __func__);
return -ENOMEM;
}
usif->pdev = pdev;
muic_client_dev_register(pdev->name, usif, &usif_ops);
usif->ctrl_gpio = pdata->ctrl_gpio;
ret = gpio_request(usif->ctrl_gpio, "USIF switch control GPIO");
if (ret < 0) {
pr_err("usif: GPIO 165 USIF1_SW is already occupied by other driver!\n");
/*
* We know board_cosmo.c:ifx_n721_configure_gpio() performs a gpio_request on this pin first.
* Because the prior gpio_request is also for the analog switch control, this is not a confliction.
*/
kfree(usif);
return -ENOSYS;
}
/* USIF can't switch */
usif_ctrl = USIF_CTRL_OK;
#if defined(CONFIG_MACH_LGE_P2_LU5400)
ret = gpio_direction_output(usif->ctrl_gpio, 1);
#else
ret = gpio_direction_output(usif->ctrl_gpio, 0);
#endif
if (ret < 0) {
pr_err("usif: gpio_16 USIF_IN_1_GPIO direction initialization failed!\n");
gpio_free(usif->ctrl_gpio);
kfree(usif);
return -ENOSYS;
}
usif_mode = USIF_AP;
platform_set_drvdata(pdev, usif);
return 0;
}
// [email protected] section mismatch error fix //static s32 __init muic_probe(struct i2c_client *client, const struct i2c_device_id *id){ static s32 muic_probe(struct i2c_client *client, const struct i2c_device_id *id){ s32 ret = 0; u32 retry_no = 0; /* B-Prj Power off charging [[email protected]] 2010-12-15 */ int err = 0; /* B-Prj Power off charging [[email protected]] 2010-12-15 */ // [email protected] 20120502 MUIC re-work struct hub_muic_device *dev = NULL; struct muic_platform_data *pdata = client->dev.platform_data; dev_info(&client->dev, "muic: %s()\n", __func__); if (!pdata) { dev_err(&client->dev, "muic: %s: no platform data\n", __func__); return -EINVAL; } dev = kzalloc(sizeof(struct hub_muic_device), GFP_KERNEL); if (!dev) { dev_err(&client->dev, "muic: %s: no memory\n", __func__); return -ENOMEM; } dev->client = client; // [email protected] 20120502 MUIC re-work muic_client = client; /* wake lock for usb connection */ wake_lock_init(&the_wlock.wake_lock, WAKE_LOCK_SUSPEND, "usb_connection"); the_wlock.wake_lock_on=0; /* GPIO initialization */ omap_mux_init_gpio(MUIC_INT_GPIO, OMAP_PIN_INPUT_PULLUP | OMAP_PIN_OFF_WAKEUPENABLE); omap_mux_init_gpio(GPIO_DP3T_IN_1, OMAP_PIN_OUTPUT); omap_mux_init_gpio(GPIO_DP3T_IN_2, OMAP_PIN_OUTPUT); omap_mux_init_gpio(GPIO_USIF_IN_1, OMAP_PIN_OUTPUT); // USIF_IN_1_GPIO -> GPIO_USIF_IN_1 omap_mux_init_gpio(GPIO_IFX_USB_VBUS_EN, OMAP_PIN_OUTPUT); //[email protected] 20120502 MUIC re-work start ret = muic_device_register(&muic_dev, NULL); if (ret < 0) { dev_err(&client->dev, "muic: %s: muic_device_register failed\n", __func__); goto err_gpio_request; } i2c_set_clientdata(client, dev); printk("%s, registering ops\n", __func__); muic_client_dev_register(dev->client->name, dev, &hub_muic_ops); //[email protected] 20120502 MUIC re-work end /* Initialize GPIO direction before use. * Check if other driver already occupied it. */ //[email protected] 20120502 MUIC re-work start //if (gpio_request(GPIO_USIF_IN_1, "USIF switch control GPIO") < 0) { // printk(KERN_INFO "[MUIC] GPIO %d USIF1_SW is already occupied by other driver!\n", GPIO_USIF_IN_1); // /* We know board_hub.c:ifx_n721_configure_gpio() performs a gpio_request on this pin first. // * Because the prior gpio_request is also for the analog switch control, this is not a confliction.*/ // ret = -ENOSYS; // goto err_gpio_request; //} //if (gpio_request(GPIO_DP3T_IN_1, "DP3T switch control 1 GPIO") < 0) { // printk(KERN_INFO "[MUIC] GPIO %d GPIO_DP3T_IN_1 is already occupied by other driver!\n", GPIO_DP3T_IN_1); // ret = -ENOSYS; // goto err_gpio_request; //} //if (gpio_request(GPIO_DP3T_IN_2, "DP3T switch control 2 GPIO") < 0) { // printk(KERN_INFO "[MUIC] GPIO %d GPIO_DP3T_IN_2 is already occupied by other driver!\n", GPIO_DP3T_IN_2); // ret = -ENOSYS; // goto err_gpio_request; //} //if (gpio_request(GPIO_IFX_USB_VBUS_EN, "IFX VBUS EN") < 0) { // printk(KERN_INFO "[MUIC] GPIO %d GPIO_IFX_USB_VBUS_EN is already occupied by other driver!\n", GPIO_IFX_USB_VBUS_EN); // ret = -ENOSYS; // goto err_gpio_request; //} //[email protected] 20120502 MUIC re-work end /* Initialize GPIO 40 (MUIC_INT_N). * Check if other driver already occupied it. */ if (gpio_request(MUIC_INT_GPIO, "MUIC IRQ GPIO") < 0) { printk(KERN_INFO "[MUIC] GPIO %d MUIC_INT_N is already occupied by other driver!\n", MUIC_INT_GPIO); ret = -ENOSYS; goto err_gpio_request; } /* Initialize GPIO direction before use or IRQ setting */ if (gpio_direction_input(MUIC_INT_GPIO) < 0) { printk(KERN_INFO "[MUIC] GPIO %d MUIC_INT_N direction initialization failed!\n", MUIC_INT_GPIO); ret = -ENOSYS; goto err_gpio_request; } //[[UBIQUIX_CHANGE_START, 0120419, [email protected], For AP/CP switching //gpio_direction_output(GPIO_DP3T_IN_1, 0); //gpio_direction_output(GPIO_DP3T_IN_2, 0); //gpio_direction_output(GPIO_USIF_IN_1, 0); //gpio_direction_output(GPIO_IFX_USB_VBUS_EN, 0); //UBIQUIX_CHANGE_START, 0120419, [email protected], For AP/CP switching]] /* Register MUIC work queue function */ INIT_DELAYED_WORK(&muic_wq, muic_wq_func); /* Set up an IRQ line and enable the involved interrupt handler. * From this point, a MUIC_INT_N can invoke muic_interrupt_handler(). * muic_interrupt_handler merely calls schedule_work() with muic_wq_func(). * muic_wq_func() actually performs the accessory detection. */ if (request_irq(gpio_to_irq(MUIC_INT_GPIO), muic_interrupt_handler, IRQF_TRIGGER_FALLING, "muic_irq", &client->dev) < 0) { printk(KERN_INFO "[MUIC] GPIO %d MUIC_INT_N IRQ line set up failed!\n", MUIC_INT_GPIO); free_irq(gpio_to_irq(MUIC_INT_GPIO), &client->dev); ret = -ENOSYS; goto err_gpio_request; } /* Make the interrupt on MUIC INT wake up OMAP which is in suspend mode */ if (enable_irq_wake(gpio_to_irq(MUIC_INT_GPIO)) < 0) { printk(KERN_INFO "[MUIC] GPIO %d MUIC_INT_N wake up source setting failed!\n", MUIC_INT_GPIO); disable_irq_wake(gpio_to_irq(MUIC_INT_GPIO)); ret = -ENOSYS; goto err_gpio_request; } /* Prepare a human accessible method to control MUIC */ create_hub_muic_proc_file(); /* B-Prj Power off charging [[email protected]] 2010-12-15 */ err = device_create_file(&client->dev, &dev_attr_wake_lock); err = device_create_file(&client->dev, &dev_attr_charging_mode); /* B-Prj Power off charging [[email protected]] 2010-12-15 */ /* Initialize MUIC - Finally MUIC INT becomes enabled */ /* LGE_CHANGE_START 2011-03-16 [email protected] patch for Adb offline set and Mass Storage Driver detecting fail */ muic_init_done = 1; //20110113 [email protected] check muic driver init. state /* LGE_CHANGE_END 2011-03-16 [email protected] */ muic_initialize(RESET); muic_set_mode(MUIC_NONE); mdelay(70); ret = muic_device_detection(NOT_UPON_IRQ); /* If an erronous situation occurs, try again */ while(ret < 0 && retry_no < 3){ printk(KERN_INFO "[MUIC] muic_probe(): muic_device_detection() failed %d times\n", ++retry_no); ret = muic_device_detection(NOT_UPON_IRQ); } printk(KERN_INFO "[MUIC] muic_probe(): done!\n"); return ret; err_muic_device_register: free_irq(gpio_to_irq(MUIC_INT_GPIO), dev); err_gpio_request: kfree(dev); return ret; }
static int __devinit max14526_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
TYPE_MUIC_MODE muic_mode;
struct ts5usb_device *dev = NULL;
struct muic_platform_data *pdata = client->dev.platform_data;
dev_info(&client->dev, "muic: %s()\n", __func__);
if (!pdata) {
dev_err(&client->dev, "muic: %s: no platform data\n", __func__);
return -EINVAL;
}
dev = kzalloc(sizeof(struct ts5usb_device), GFP_KERNEL);
if (!dev) {
dev_err(&client->dev, "muic: %s: no memory\n", __func__);
return -ENOMEM;
}
dev->client = client;
dev->gpio_int = pdata->gpio_int;
#if defined(CONFIG_MHL)
dev->gpio_mhl = pdata->gpio_mhl;
dev->gpio_ifx_vbus = pdata->gpio_ifx_vbus;
#endif
dev->irq = client->irq;
max14526 = client;
/* Initializes gpio_165 (USIF1_SW). */
ret = gpio_request(USIF_IN_1_GPIO, "USIF switch control GPIO");
if (ret < 0) {
printk(KERN_INFO "[MUIC] GPIO 165 USIF1_SW is already occupied by other driver!\n");
/*
* We know board_cosmo.c:ifx_n721_configure_gpio() performs a gpio_request on this pin first.
* Because the prior gpio_request is also for the analog switch control, this is not a confliction.
*/
return -ENOSYS;
}
ret = gpio_direction_output(USIF_IN_1_GPIO, 0);
if (ret < 0) {
printk(KERN_INFO "[MUIC] gpio_16 USIF_IN_1_GPIO direction initialization failed!\n");
return -ENOSYS;
}
/* Initializes gpio_11 (OMAP_UART_SW) and gpio_12 (IFX_UART_SW) */
ret = gpio_request(DP3T_IN_1_GPIO, "DP3T switch control 1 GPIO");
if (ret < 0) {
printk(KERN_INFO "[MUIC] GPIO 11 DP3T_IN_1_GPIO is already occupied by other driver!\n");
return -ENOSYS;
}
ret = gpio_direction_output(DP3T_IN_1_GPIO, 0);
if (ret < 0) {
printk(KERN_INFO "[MUIC] gpio_11 DP3T_IN_1_GPIO direction initialization failed!\n");
return -ENOSYS;
}
ret = gpio_request(DP3T_IN_2_GPIO, "DP3T switch control 2 GPIO");
if (ret < 0) {
printk(KERN_INFO "[MUIC] gpio_12 DP3T_IN_2_GPIO is already occupied by other driver!\n");
return -ENOSYS;
}
ret = gpio_direction_output(DP3T_IN_2_GPIO, 0);
if (ret < 0) {
printk(KERN_INFO "[MUIC] gpio_12 DP3T_IN_2_GPIO direction initialization failed!\n");
return -ENOSYS;
}
ret = gpio_request(IFX_USB_VBUS_EN_GPIO, "DP3T switch control 2 GPIO");
if (ret < 0) {
printk(KERN_INFO "[MUIC] gpio_55 IFX_USB_VBUS_EN_GPIO is already occupied by other driver!\n");
return -ENOSYS;
}
ret = gpio_direction_output(IFX_USB_VBUS_EN_GPIO, 0);
if (ret < 0) {
printk(KERN_INFO "[MUIC] gpio_55 IFX_USB_VBUS_EN_GPIO direction initialization failed!\n");
return -ENOSYS;
}
/*
* Initializes gpio_wk8 (MUIC_INT_N).
* Checks if other driver already occupied it.
*/
ret = gpio_request(dev->gpio_int, "MUIC IRQ GPIO");
if (ret < 0) {
dev_err(&client->dev, "muic: GPIO %d is already used\n", dev->gpio_int);
ret = -ENOSYS;
goto err_gpio_request;
}
/* Initializes GPIO direction before use or IRQ setting */
gpio_direction_input(dev->gpio_int);
/* Registers MUIC work queue function */
INIT_WORK(&dev->muic_wq, max14526_wq_func);
/*
* Set up an IRQ line and enable the involved interrupt handler.
* From this point, a MUIC_INT_N can invoke muic_interrupt_handler().
* muic_interrupt_handler merely calls schedule_work() with muic_wq_func().
* muic_wq_func() actually performs the accessory detection.
*/
ret = request_irq(dev->irq, max14526_interrupt_handler,IRQF_TRIGGER_FALLING, "muic_irq", dev);
if (ret < 0)
{
dev_err(&client->dev, "muic: %s: request_irq failed!\n",__func__);
goto err_request_irq;
}
//disable_irq_wake(gpio_to_irq(MUIC_INT));
/* Prepares a human accessible method to control MUIC */
//create_cosmo_muic_proc_file();
/* Selects one of the possible muic chips */
//muic_detect_device();
wake_lock_init(&dev->muic_wake_lock, WAKE_LOCK_SUSPEND,"muic_wake_lock");
ret = muic_device_register(&muic_dev, NULL);
if (ret < 0) {
dev_err(&client->dev, "muic: %s: muic_device_register failed\n",__func__);
goto err_muic_device_register;
}
i2c_set_clientdata(client, dev);
// hunsoo.lee
printk("%s, registering ops\n", __func__);
muic_client_dev_register(dev->client->name, dev, &max14526_ops);
/* Initializes MUIC - Finally MUIC INT becomes enabled */
if (BOOT_RECOVERY == muic_retain_mode)
{ /* Recovery mode */
muic_mode = MUIC_CP_UART;
muic_init_max14526(client, BOOTUP);
dev_info(&client->dev, "muic: %s: first boot\n", __func__);
}
else
{
muic_init_max14526(client, RESET);
muic_max14526_detect_accessory(client, NOT_UPON_IRQ);
muic_mode = muic_get_mode();
}
muic_set_mode(muic_mode);
/* Makes the interrupt on MUIC INT wake up OMAP which is in suspend mode */
ret = enable_irq_wake(dev->irq);
if (ret < 0) {
dev_err(&client->dev, "muic: GPIO %d wake up source setting failed!\n", dev->gpio_int);
disable_irq_wake(dev->irq);
goto err_irq_wake;
}
dev_info(&client->dev, "muic: muic_probe()\n");
return ret;
err_irq_wake:
muic_device_unregister(&muic_dev);
err_muic_device_register:
wake_lock_destroy(&dev->muic_wake_lock);
free_irq(dev->irq, dev);
err_request_irq:
gpio_free(dev->gpio_int);
err_gpio_request:
kfree(dev);
return ret;
}
static int __devinit sii9244_mhl_tx_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct sii9244_data *sii9244;
int ret;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
return -EIO;
sii9244 = kzalloc(sizeof(struct sii9244_data), GFP_KERNEL);
if (!sii9244) {
dev_err(&client->dev, "failed to allocate driver data\n");
return -ENOMEM;
}
sii9244->pdata = client->dev.platform_data;
sii9244->pdata->mhl_tx_client = client;
if (!sii9244->pdata) {
ret = -EINVAL;
goto err_exit1;
}
i2c_set_clientdata(client, sii9244);
sii9244->irq = client->irq;
init_waitqueue_head(&sii9244->wq);
mutex_init(&sii9244->lock);
#if !defined(CONFIG_MACH_LGE_CX2) //nthyunjin.yang 120526 MHL_1V8 is different with CX2.
if (sii9244->mhl_reg == NULL) {
struct regulator *mhl_reg;
mhl_reg = regulator_get(&client->dev, "mhl_1v8");
if (IS_ERR(mhl_reg)) {
dev_err(&client->dev, "can't get MHL 1.8V regulator\n");
return PTR_ERR(mhl_reg);
}
sii9244->mhl_reg = mhl_reg;
}
#endif
ret = request_threaded_irq(client->irq, NULL, sii9244_irq_thread,
IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
"sii9244", sii9244);
if (ret < 0)
goto err_exit2;
disable_irq(client->irq);
/* GPIO configuration */
sii9244_gpio_config(sii9244);
#if defined(CONFIG_MUIC)
/* Register detection/cancel func to MUIC driver */
ret = muic_client_dev_register(client->name, sii9244, &mhl_ops);
if (ret < 0) {
dev_err(&client->dev, "Unable to register mhl_ops\n");
goto err_exit2;
}
#else
sii9244->otg_id_nb.detect = sii9244_detection_callback;
sii9244->otg_id_nb.cancel = sii9244_cancel_callback;
sii9244->otg_id_nb.priority = sii9244->pdata->prio;
plist_node_init(&sii9244->otg_id_nb.p, sii9244->pdata->prio);
ret = otg_id_register_notifier(&sii9244->otg_id_nb);
if (ret < 0) {
dev_err(&client->dev, "Unable to register notifier\n");
goto err_exit2;
}
#endif
return 0;
err_exit2:
err_exit1:
kfree(sii9244);
return ret;
}
static int dp3t_switch_probe(struct platform_device *pdev)
{
struct dp3t_switch_platform_data *pdata = pdev->dev.platform_data;
struct dp3t_switch *dp3t;
int ret = 0;
pr_info("dp3t: dp3t_switch_probe\n");
dp3t = kzalloc(sizeof(struct dp3t_switch), GFP_KERNEL);
dp3t->pdev = pdev;
muic_client_dev_register(pdev->name, dp3t, &dp3t_ops);
dp3t->ctrl_gpio1 = pdata->ctrl_gpio1;
dp3t->ctrl_gpio2 = pdata->ctrl_gpio2;
dp3t->ctrl_ifx_vbus_gpio = pdata->ctrl_ifx_vbus_gpio;
/*
* Initializes gpio_11 (OMAP_UART_SW) and gpio_12 (IFX_UART_SW).
* Checks if other driver already occupied them.
*/
ret = gpio_request(dp3t->ctrl_gpio1, "DP3T switch control 1 GPIO");
if (ret < 0) {
pr_err("dp3t: GPIO %d is already used!\n", dp3t->ctrl_gpio1);
return -ENOSYS;
}
ret = gpio_direction_output(dp3t->ctrl_gpio1, 0);
if (ret < 0) {
pr_err("dp3t: GPIO %d direction initialization failed!\n",
dp3t->ctrl_gpio1);
return -ENOSYS;
}
ret = gpio_request(dp3t->ctrl_gpio2, "DP3T switch control 2 GPIO");
if (ret < 0) {
pr_err("dp3t: GPIO %d is already used\n", dp3t->ctrl_gpio2);
return -ENOSYS;
}
ret = gpio_direction_output(dp3t->ctrl_gpio2, 0);
if (ret < 0) {
pr_err("dp3t: GPIO %d direction initialization failed!\n",
dp3t->ctrl_gpio2);
return -ENOSYS;
}
ret = gpio_request(dp3t->ctrl_ifx_vbus_gpio, "DP3T switch control 2 GPIO");
if (ret < 0) {
pr_err("dp3t: GPIO %d is already used\n",
dp3t->ctrl_ifx_vbus_gpio);
return -ENOSYS;
}
ret = gpio_direction_output(dp3t->ctrl_ifx_vbus_gpio, 0);
if (ret < 0) {
pr_err("dp3t: GPIO %d direction initialization failed!\n",
dp3t->ctrl_ifx_vbus_gpio);
return -ENOSYS;
}
platform_set_drvdata(pdev, dp3t);
//[email protected] for FOTA START
/* gpio output mode setting */
ret = gpio_direction_output(GPIO_IFX_USB_VBUS_EN, 0);
if (ret < 0) {
pr_err("dp3t: GPIO %d direction initialization failed!\n",
GPIO_IFX_USB_VBUS_EN);
return -ENOSYS;
}
ret = gpio_direction_output(GPIO_DP3T_IN_1, 0);
if (ret < 0) {
pr_err("dp3t: GPIO %d direction initialization failed!\n",
GPIO_DP3T_IN_1);
return -ENOSYS;
}
ret = gpio_direction_output(GPIO_DP3T_IN_2, 0);
if (ret < 0) {
pr_err("dp3t: GPIO %d direction initialization failed!\n",
GPIO_DP3T_IN_2);
return -ENOSYS;
}
//[email protected] for FOTA END
pr_info("dp3t: dp3t_switch_probe done!\n");
return 0;
}
