// [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; }