static int cm3663_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = -ENODEV; struct input_dev *input_dev; struct cm3663_data *cm3663; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s: i2c functionality check failed!\n", __func__); return ret; } cm3663 = kzalloc(sizeof(struct cm3663_data), GFP_KERNEL); if (!cm3663) { pr_err("%s: failed to alloc memory for module data\n", __func__); return -ENOMEM; } cm3663->pdata = client->dev.platform_data; cm3663->i2c_client = client; i2c_set_clientdata(client, cm3663); /* wake lock init */ wake_lock_init(&cm3663->prx_wake_lock, WAKE_LOCK_SUSPEND, "prx_wake_lock"); mutex_init(&cm3663->power_lock); /* setup initial registers */ ret = cm3663_setup_reg(cm3663); if (ret < 0) { pr_err("%s: could not setup regs\n", __func__); goto err_setup_reg; } ret = cm3663_setup_irq(cm3663); if (ret) { pr_err("%s: could not setup irq\n", __func__); goto err_setup_irq; } /* allocate proximity input_device */ input_dev = input_allocate_device(); if (!input_dev) { pr_err("%s: could not allocate input device\n", __func__); goto err_input_allocate_device_proximity; } cm3663->proximity_input_dev = input_dev; input_set_drvdata(input_dev, cm3663); input_dev->name = "proximity_sensor"; input_set_capability(input_dev, EV_ABS, ABS_DISTANCE); input_set_abs_params(input_dev, ABS_DISTANCE, 0, 1, 0, 0); ret = input_register_device(input_dev); if (ret < 0) { pr_err("%s: could not register input device\n", __func__); input_free_device(input_dev); goto err_input_register_device_proximity; } ret = sysfs_create_group(&input_dev->dev.kobj, &proximity_attribute_group); if (ret) { pr_err("%s: could not create sysfs group\n", __func__); goto err_sysfs_create_group_proximity; } /* light_timer settings. we poll for light values using a timer. */ hrtimer_init(&cm3663->light_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); cm3663->light_poll_delay = ns_to_ktime(200 * NSEC_PER_MSEC); cm3663->light_timer.function = cm3663_light_timer_func; /* prox_timer settings. we poll for light values using a timer. */ hrtimer_init(&cm3663->prox_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); cm3663->prox_poll_delay = ns_to_ktime(2000 * NSEC_PER_MSEC); cm3663->prox_timer.function = cm3663_prox_timer_func; /* the timer just fires off a work queue request. we need a thread to read the i2c (can be slow and blocking). */ cm3663->light_wq = create_singlethread_workqueue("cm3663_light_wq"); if (!cm3663->light_wq) { ret = -ENOMEM; pr_err("%s: could not create light workqueue\n", __func__); goto err_create_light_workqueue; } cm3663->prox_wq = create_singlethread_workqueue("cm3663_prox_wq"); if (!cm3663->prox_wq) { ret = -ENOMEM; pr_err("%s: could not create prox workqueue\n", __func__); goto err_create_prox_workqueue; } /* this is the thread function we run on the work queue */ INIT_WORK(&cm3663->work_light, cm3663_work_func_light); INIT_WORK(&cm3663->work_prox, cm3663_work_func_prox); /* allocate lightsensor-level input_device */ input_dev = input_allocate_device(); if (!input_dev) { pr_err("%s: could not allocate input device\n", __func__); ret = -ENOMEM; goto err_input_allocate_device_light; } input_set_drvdata(input_dev, cm3663); input_dev->name = "light_sensor"; #if defined(CONFIG_MACH_S2PLUS) input_set_capability(input_dev, EV_REL, REL_MISC); #else input_set_capability(input_dev, EV_ABS, ABS_MISC); input_set_abs_params(input_dev, ABS_MISC, 0, 1, 0, 0); #endif ret = input_register_device(input_dev); if (ret < 0) { pr_err("%s: could not register input device\n", __func__); input_free_device(input_dev); goto err_input_register_device_light; } cm3663->light_input_dev = input_dev; ret = sysfs_create_group(&input_dev->dev.kobj, &light_attribute_group); if (ret) { pr_err("%s: could not create sysfs group\n", __func__); goto err_sysfs_create_group_light; } #if defined(CONFIG_MACH_S2PLUS) /* set sysfs for proximity sensor */ cm3663->proximity_dev = sensors_classdev_register("proximity_sensor"); if (IS_ERR(cm3663->proximity_dev)) { pr_err("%s: could not create proximity_dev\n", __func__); goto err_proximity_classdev_create; } if (device_create_file(cm3663->proximity_dev, &dev_attr_state) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_state.attr.name); goto err_proximity_device_create_file1; } if (device_create_file(cm3663->proximity_dev, &dev_attr_prox_avg) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_prox_avg.attr.name); goto err_proximity_device_create_file2; } dev_set_drvdata(cm3663->proximity_dev, cm3663); /* set sysfs for light sensor */ cm3663->switch_cmd_dev = sensors_classdev_register("light_sensor"); if (IS_ERR(cm3663->switch_cmd_dev)) { pr_err("%s: could not create switch_cmd_dev\n", __func__); goto err_light_classdev_create; } if (device_create_file(cm3663->switch_cmd_dev, &dev_attr_lux) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_lux.attr.name); goto err_light_device_create_file; } dev_set_drvdata(cm3663->switch_cmd_dev, cm3663); #else /* set sysfs for proximity sensor */ cm3663->proximity_class = class_create(THIS_MODULE, "proximity"); if (IS_ERR(cm3663->proximity_class)) { pr_err("%s: could not create proximity_class\n", __func__); goto err_proximity_class_create; } cm3663->proximity_dev = device_create(cm3663->proximity_class, NULL, 0, NULL, "proximity"); if (IS_ERR(cm3663->proximity_dev)) { pr_err("%s: could not create proximity_dev\n", __func__); goto err_proximity_device_create; } if (device_create_file(cm3663->proximity_dev, &dev_attr_proximity_state) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_proximity_state.attr.name); goto err_proximity_device_create_file1; } if (device_create_file(cm3663->proximity_dev, &dev_attr_proximity_avg) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_proximity_avg.attr.name); goto err_proximity_device_create_file2; } dev_set_drvdata(cm3663->proximity_dev, cm3663); /* set sysfs for light sensor */ cm3663->lightsensor_class = class_create(THIS_MODULE, "lightsensor"); if (IS_ERR(cm3663->lightsensor_class)) { pr_err("%s: could not create lightsensor_class\n", __func__); goto err_light_class_create; } cm3663->switch_cmd_dev = device_create(cm3663->lightsensor_class, NULL, 0, NULL, "switch_cmd"); if (IS_ERR(cm3663->switch_cmd_dev)) { pr_err("%s: could not create switch_cmd_dev\n", __func__); goto err_light_device_create; } if (device_create_file(cm3663->switch_cmd_dev, &dev_attr_lightsensor_file_state) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_lightsensor_file_state.attr.name); goto err_light_device_create_file; } dev_set_drvdata(cm3663->switch_cmd_dev, cm3663); #endif goto done; /* error, unwind it all */ #if defined(CONFIG_MACH_S2PLUS) err_light_device_create_file: sensors_classdev_unregister(cm3663->switch_cmd_dev); err_light_classdev_create: device_remove_file(cm3663->proximity_dev, &dev_attr_prox_avg); err_proximity_device_create_file2: device_remove_file(cm3663->proximity_dev, &dev_attr_state); err_proximity_device_create_file1: sensors_classdev_unregister(cm3663->proximity_dev); err_proximity_classdev_create: #else err_light_device_create_file: device_destroy(cm3663->lightsensor_class, 0); err_light_device_create: class_destroy(cm3663->lightsensor_class); err_light_class_create: device_remove_file(cm3663->proximity_dev, &dev_attr_proximity_avg); err_proximity_device_create_file2: device_remove_file(cm3663->proximity_dev, &dev_attr_proximity_state); err_proximity_device_create_file1: device_destroy(cm3663->proximity_class, 0); err_proximity_device_create: class_destroy(cm3663->proximity_class); err_proximity_class_create: #endif sysfs_remove_group(&input_dev->dev.kobj, &light_attribute_group); err_sysfs_create_group_light: input_unregister_device(cm3663->light_input_dev); err_input_register_device_light: err_input_allocate_device_light: destroy_workqueue(cm3663->prox_wq); err_create_prox_workqueue: destroy_workqueue(cm3663->light_wq); err_create_light_workqueue: sysfs_remove_group(&cm3663->proximity_input_dev->dev.kobj, &proximity_attribute_group); err_sysfs_create_group_proximity: input_unregister_device(cm3663->proximity_input_dev); err_input_register_device_proximity: err_input_allocate_device_proximity: free_irq(cm3663->irq, 0); err_setup_irq: err_setup_reg: mutex_destroy(&cm3663->power_lock); wake_lock_destroy(&cm3663->prx_wake_lock); kfree(cm3663); done: return ret; }
static inline void deinit_suspend(void) { wake_lock_destroy(&mt9t013_wake_lock); }
static int pn547_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; int err; int addr; char tmp[4] = {0x20, 0x00, 0x01, 0x01}; int addrcnt; struct pn547_i2c_platform_data *platform_data; struct pn547_dev *pn547_dev; #ifdef CONFIG_MACH_VICTORLTE_CTC pr_info("%s : start system_rev : %d\n", __func__,system_rev); if (system_rev < 3) { pr_info("%s : probe fail \n", __func__); return -ENODEV; } #endif if (client->dev.of_node) { platform_data = devm_kzalloc(&client->dev, sizeof(struct pn547_i2c_platform_data), GFP_KERNEL); if (!platform_data) { dev_err(&client->dev, "Failed to allocate memory\n"); return -ENOMEM; } err = pn547_parse_dt(&client->dev, platform_data); if (err) return err; } else { platform_data = client->dev.platform_data; } if (platform_data == NULL) { pr_err("%s : nfc probe fail\n", __func__); return -ENODEV; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s : need I2C_FUNC_I2C\n", __func__); return -ENODEV; } ret = gpio_request(platform_data->irq_gpio, "nfc_int"); if (ret) return -ENODEV; ret = gpio_request(platform_data->ven_gpio, "nfc_ven"); if (ret) goto err_ven; ret = gpio_request(platform_data->firm_gpio, "nfc_firm"); if (ret) goto err_firm; #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST ret = gpio_request(platform_data->clk_req_gpio, "nfc_clk_req"); if (ret) goto err_clk_req; #endif #ifdef CONFIG_NFC_PN547_8226_USE_BBCLK2 ret = gpio_request(platform_data->clk_req_gpio, "nfc_clk_req"); if (ret) goto err_clk_req; #endif pn547_dev = kzalloc(sizeof(*pn547_dev), GFP_KERNEL); if (pn547_dev == NULL) { dev_err(&client->dev, "failed to allocate memory for module data\n"); ret = -ENOMEM; goto err_exit; } #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST pn547_dev->nfc_clock = msm_xo_get(MSM_XO_TCXO_A1, "nfc"); if (IS_ERR(pn547_dev->nfc_clock)) { ret = PTR_ERR(pn547_dev->nfc_clock); printk(KERN_ERR "%s: Couldn't get TCXO_A1 vote for NFC (%d)\n", __func__, ret); ret = -ENODEV; goto err_get_clock; } pn547_dev->clock_state = false; #endif #ifdef CONFIG_NFC_PN547_8226_USE_BBCLK2 pn547_dev->nfc_clock = clk_get(NULL, "nfc_clock"); if (IS_ERR(pn547_dev->nfc_clock)) { ret = PTR_ERR(pn547_dev->nfc_clock); printk(KERN_ERR "%s: Couldn't get D1 (%d)\n", __func__, ret); } else { if (clk_prepare_enable(pn547_dev->nfc_clock)) printk(KERN_ERR "%s: Couldn't prepare D1\n", __func__); } #endif #ifdef CONFIG_NFC_PN547_PMC8974_CLK_REQ #ifdef CONFIG_NFC_I2C_OVERWRITE pn547_dev->nfc_clk = clk_get(NULL, "nfc_clk"); #else pn547_dev->nfc_clk = clk_get(&client->dev, "nfc_clk"); #endif if (IS_ERR(pn547_dev->nfc_clk)) { ret = PTR_ERR(pn547_dev->nfc_clk); printk(KERN_ERR "%s: Couldn't get D1 (%d)\n", __func__, ret); } else { if (clk_prepare_enable(pn547_dev->nfc_clk)) printk(KERN_ERR "%s: Couldn't prepare D1\n", __func__); } #endif pr_info("%s : IRQ num %d\n", __func__, client->irq); pn547_dev->irq_gpio = platform_data->irq_gpio; pn547_dev->ven_gpio = platform_data->ven_gpio; pn547_dev->firm_gpio = platform_data->firm_gpio; pn547_dev->conf_gpio = platform_data->conf_gpio; #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST pn547_dev->clk_req_gpio = platform_data->clk_req_gpio; pn547_dev->clk_req_irq = platform_data->clk_req_irq; #endif #ifdef CONFIG_NFC_PN547_8226_USE_BBCLK2 pn547_dev->clk_req_gpio = platform_data->clk_req_gpio; #endif pn547_dev->client = client; /* init mutex and queues */ init_waitqueue_head(&pn547_dev->read_wq); mutex_init(&pn547_dev->read_mutex); pn547_dev->pn547_device.minor = MISC_DYNAMIC_MINOR; #ifdef CONFIG_NFC_PN547 pn547_dev->pn547_device.name = "pn547"; #else pn547_dev->pn547_device.name = "pn544"; #endif pn547_dev->pn547_device.fops = &pn547_dev_fops; ret = misc_register(&pn547_dev->pn547_device); if (ret) { pr_err("%s : misc_register failed\n", __FILE__); goto err_misc_register; } /* request irq. the irq is set whenever the chip has data available * for reading. it is cleared when all data has been read. */ pr_info("%s : requesting IRQ %d\n", __func__, client->irq); gpio_direction_input(pn547_dev->irq_gpio); gpio_direction_output(pn547_dev->ven_gpio, 0); gpio_direction_output(pn547_dev->firm_gpio, 0); #if defined(CONFIG_NFC_PN547_CLOCK_REQUEST) || defined(CONFIG_NFC_PN547_8226_USE_BBCLK2) gpio_direction_input(pn547_dev->clk_req_gpio); #endif i2c_set_clientdata(client, pn547_dev); wake_lock_init(&pn547_dev->nfc_wake_lock, WAKE_LOCK_SUSPEND, "nfc_wake_lock"); #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST pn547_dev->wq_clock = create_singlethread_workqueue("nfc_wq"); if (!pn547_dev->wq_clock) { ret = -ENOMEM; pr_err("%s: could not create workqueue\n", __func__); goto err_create_workqueue; } INIT_WORK(&pn547_dev->work_nfc_clock, nfc_work_func_clock); #endif if(client->irq <=0) { pr_info("%s : [Before] requesting IRQ %d\n", __func__, client->irq); client->irq = gpio_to_irq(pn547_dev->irq_gpio); pr_info("%s : [After] requesting IRQ %d\n", __func__, client->irq); } ret = request_irq(client->irq, pn547_dev_irq_handler, IRQF_TRIGGER_RISING, "pn547", pn547_dev); if (ret) { dev_err(&client->dev, "request_irq failed\n"); goto err_request_irq_failed; } disable_irq_nosync(pn547_dev->client->irq); atomic_set(&pn547_dev->irq_enabled, 0); #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST ret = request_irq(pn547_dev->clk_req_irq, pn547_dev_clk_req_irq_handler, IRQF_SHARED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING , "pn547_clk_req", pn547_dev); if (ret) { dev_err(&client->dev, "request_irq(clk_req) failed\n"); goto err_request_irq_failed; } enable_irq_wake(pn547_dev->clk_req_irq); #endif gpio_set_value(pn547_dev->ven_gpio, 1); gpio_set_value(pn547_dev->firm_gpio, 1); /* add firmware pin */ usleep_range(4900, 5000); gpio_set_value(pn547_dev->ven_gpio, 0); usleep_range(4900, 5000); gpio_set_value(pn547_dev->ven_gpio, 1); usleep_range(4900, 5000); for (addr = 0x2B; addr > 0x27; addr--) { client->addr = addr; addrcnt = 2; do { ret = i2c_master_send(client, tmp, 4); if (ret > 0) { pr_info("%s : i2c addr=0x%X\n", __func__, client->addr); break; } } while (addrcnt--); if (ret > 0) break; } if(ret <= 0) client->addr = 0x2B; gpio_set_value(pn547_dev->ven_gpio, 0); gpio_set_value(pn547_dev->firm_gpio, 0); /* add */ if (ret < 0) pr_err("%s : fail to get i2c addr\n", __func__); /* goto err_request_irq_failed; */ else pr_info("%s : success\n", __func__); return 0; err_request_irq_failed: #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST err_create_workqueue: #endif misc_deregister(&pn547_dev->pn547_device); wake_lock_destroy(&pn547_dev->nfc_wake_lock); err_misc_register: mutex_destroy(&pn547_dev->read_mutex); #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST msm_xo_put(pn547_dev->nfc_clock); err_get_clock: #endif kfree(pn547_dev); err_exit: #if defined(CONFIG_NFC_PN547_CLOCK_REQUEST) || defined(CONFIG_NFC_PN547_8226_USE_BBCLK2) gpio_free(platform_data->clk_req_gpio); err_clk_req: #endif gpio_free(platform_data->firm_gpio); err_firm: gpio_free(platform_data->ven_gpio); err_ven: gpio_free(platform_data->irq_gpio); pr_err("[pn547] pn547_probe fail!\n"); return ret; }
static int ssp_probe(struct spi_device *spi_dev) { int iRet = 0; struct ssp_data *data; struct ssp_platform_data *pdata; if (poweroff_charging == 1 || recovery_mode == 1) { pr_err("[SSP] probe exit : lpm %d recovery %d \n", poweroff_charging, recovery_mode); return -ENODEV; } data = kzalloc(sizeof(*data), GFP_KERNEL); if (data == NULL) { pr_err("[SSP]: %s - failed to allocate memory for data\n", __func__); iRet = -ENOMEM; goto exit; } if (spi_dev->dev.of_node) { iRet = ssp_parse_dt(&spi_dev->dev, data); if (iRet) { pr_err("[SSP]: %s - Failed to parse DT\n", __func__); goto err_setup; } data->ssp_changes = SSP_MCU_L5; /* K330, MPU L5*/ } else { pdata = spi_dev->dev.platform_data; if (pdata == NULL) { pr_err("[SSP]: %s - platform_data is null\n", __func__); iRet = -ENOMEM; goto err_setup; } data->wakeup_mcu = pdata->wakeup_mcu; data->check_mcu_ready = pdata->check_mcu_ready; data->check_mcu_busy = pdata->check_mcu_busy; data->set_mcu_reset = pdata->set_mcu_reset; data->read_chg = pdata->read_chg; /* AP system_rev */ if (pdata->check_ap_rev) data->ap_rev = pdata->check_ap_rev(); else data->ap_rev = 0; /* For changed devices */ if (pdata->check_changes) data->ssp_changes = pdata->check_changes(); else data->ssp_changes = SSP_MCU_L5; /* K330, MPU L5*/ /* Get sensor positions */ if (pdata->get_positions) pdata->get_positions(&data->accel_position, &data->mag_position); else if (spi_dev->dev.of_node == NULL) { data->accel_position = 0; data->mag_position = 0; } } spi_dev->mode = SPI_MODE_1; if (spi_setup(spi_dev)) { pr_err("failed to setup spi for ssp_spi\n"); goto err_setup; } data->bProbeIsDone = false; data->fw_dl_state = FW_DL_STATE_NONE; data->spi = spi_dev; spi_set_drvdata(spi_dev, data); #ifdef CONFIG_SENSORS_SSP_SHTC1 mutex_init(&data->cp_temp_adc_lock); mutex_init(&data->bulk_temp_read_lock); #endif #ifdef CONFIG_SENSORS_SSP_STM mutex_init(&data->comm_mutex); mutex_init(&data->pending_mutex); #endif if (((data->wakeup_mcu == NULL) || (data->check_mcu_ready == NULL) || (data->check_mcu_busy == NULL) || (data->set_mcu_reset == NULL) || (data->read_chg == NULL)) && (spi_dev->dev.of_node == NULL)) { pr_err("[SSP]: %s - function callback is null\n", __func__); iRet = -EIO; goto err_reset_null; } pr_info("\n#####################################################\n"); INIT_DELAYED_WORK(&data->work_firmware, work_function_firmware_update); wake_lock_init(&data->ssp_wake_lock, WAKE_LOCK_SUSPEND, "ssp_wake_lock"); iRet = initialize_input_dev(data); if (iRet < 0) { pr_err("[SSP]: %s - could not create input device\n", __func__); goto err_input_register_device; } iRet = initialize_debug_timer(data); if (iRet < 0) { pr_err("[SSP]: %s - could not create workqueue\n", __func__); goto err_create_workqueue; } iRet = initialize_irq(data); if (iRet < 0) { pr_err("[SSP]: %s - could not create irq\n", __func__); goto err_setup_irq; } iRet = initialize_sysfs(data); if (iRet < 0) { pr_err("[SSP]: %s - could not create sysfs\n", __func__); goto err_sysfs_create; } iRet = initialize_event_symlink(data); if (iRet < 0) { pr_err("[SSP]: %s - could not create symlink\n", __func__); goto err_symlink_create; } initialize_variable(data); ssp_enable(data, true); /* check boot loader binary */ data->fw_dl_state = check_fwbl(data); if (data->fw_dl_state == FW_DL_STATE_NONE) { iRet = initialize_mcu(data); if (iRet == ERROR) { data->uResetCnt++; toggle_mcu_reset(data); msleep(SSP_SW_RESET_TIME); initialize_mcu(data); } else if (iRet < ERROR) { pr_err("[SSP]: %s - initialize_mcu failed\n", __func__); goto err_read_reg; } } #ifdef CONFIG_HAS_EARLYSUSPEND data->early_suspend.suspend = ssp_early_suspend; data->early_suspend.resume = ssp_late_resume; register_early_suspend(&data->early_suspend); #endif #ifdef CONFIG_SENSORS_SSP_SENSORHUB /* init sensorhub device */ iRet = ssp_sensorhub_initialize(data); if (iRet < 0) { pr_err("%s: ssp_sensorhub_initialize err(%d)", __func__, iRet); ssp_sensorhub_remove(data); } #endif data->bMcuDumpMode = sec_debug_is_enabled(); iRet = ssp_send_cmd(data, MSG2SSP_AP_MCU_SET_DUMPMODE,data->bMcuDumpMode); if (iRet < 0) { pr_err("[SSP]: %s - MSG2SSP_AP_MCU_SET_DUMPMODE failed\n", __func__); } pr_info("[SSP]: %s - setup debuglevel %d!\n", __func__,data->bMcuDumpMode); pr_info("[SSP]: %s - probe success!\n", __func__); enable_debug_timer(data); iRet = 0; if (data->fw_dl_state == FW_DL_STATE_NEED_TO_SCHEDULE) { pr_info("[SSP]: Firmware update is scheduled\n"); schedule_delayed_work(&data->work_firmware, msecs_to_jiffies(1000)); data->fw_dl_state = FW_DL_STATE_SCHEDULED; } else if (data->fw_dl_state == FW_DL_STATE_FAIL) data->bSspShutdown = true; data->bProbeIsDone = true; goto exit; err_read_reg: err_symlink_create: remove_sysfs(data); err_sysfs_create: free_irq(data->iIrq, data); gpio_free(data->mcu_int1); err_setup_irq: destroy_workqueue(data->debug_wq); err_create_workqueue: remove_input_dev(data); err_input_register_device: wake_lock_destroy(&data->ssp_wake_lock); err_reset_null: #ifdef CONFIG_SENSORS_SSP_SHTC1 mutex_destroy(&data->cp_temp_adc_lock); mutex_destroy(&data->bulk_temp_read_lock); #endif #ifdef CONFIG_SENSORS_SSP_STM mutex_destroy(&data->comm_mutex); mutex_destroy(&data->pending_mutex); #endif err_setup: kfree(data); pr_err("[SSP]: %s - probe failed!\n", __func__); exit: pr_info("#####################################################\n\n"); return iRet; }
static int gp2a_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct gp2a_data *gp2a; struct gp2a_platform_data *pdata = client->dev.platform_data; u8 value = 0; int err = 0; pr_info("%s : probe start!\n", __func__); if (!pdata) { pr_err("%s: missing pdata!\n", __func__); err = -EINVAL; goto done; } if (!pdata->power_on) { pr_err("%s: incomplete pdata!\n", __func__); err = -EINVAL; goto done; } /* allocate driver_data */ gp2a = kzalloc(sizeof(struct gp2a_data), GFP_KERNEL); if (!gp2a) { pr_err("kzalloc error\n"); err = -ENOMEM; goto done; } gp2a->pdata = pdata; gp2a->client = client; gp2a->proximity_enabled = 0; gp2a->light_enabled = 0; gp2a->light_delay = SENSOR_DEFAULT_DELAY; gp2a->light_zero_count = 0; gp2a->light_reset_count = 0; i2c_set_clientdata(client, gp2a); if (pdata->power_on) pdata->power_on(true); if (pdata->version) { /* GP2AP030 */ gp2a_reg[1][1] = 0x1A; if (pdata->thresh[0]) gp2a_reg[3][1] = pdata->thresh[0]; else gp2a_reg[3][1] = 0x08; if (pdata->thresh[1]) gp2a_reg[5][1] = pdata->thresh[1]; else gp2a_reg[5][1] = 0x0A; } INIT_DELAYED_WORK(&gp2a->light_work, gp2a_work_func_light); INIT_WORK(&gp2a->proximity_work, gp2a_work_func_prox); err = proximity_input_init(gp2a); if (err < 0) goto error_setup_reg_prox; err = light_input_init(gp2a); if (err < 0) goto error_setup_reg_light; err = sysfs_create_group(&gp2a->proximity_input_dev->dev.kobj, &proximity_attribute_group); if (err < 0) goto err_sysfs_create_group_proximity; err = sysfs_create_group(&gp2a->light_input_dev->dev.kobj, &lightsensor_attribute_group); if (err) goto err_sysfs_create_group_light; mutex_init(&gp2a->light_mutex); mutex_init(&gp2a->data_mutex); /* wake lock init */ wake_lock_init(&gp2a->prx_wake_lock, WAKE_LOCK_SUSPEND, "prx_wake_lock"); /* GP2A Regs INIT SETTINGS and Check I2C communication */ /* shutdown mode op[3]=0 */ value = 0x00; err = gp2a_i2c_write(gp2a, (u8) (COMMAND1), &value); if (err < 0) { pr_err("%s failed : threre is no such device.\n", __func__); goto err_no_device; } /* Setup irq */ err = gp2a_setup_irq(gp2a); if (err) { pr_err("%s: could not setup irq\n", __func__); goto err_setup_irq; } err = sensors_register(&(gp2a->light_sensor_device), gp2a, additional_light_attrs, "light_sensor"); if (err) { pr_err("%s: cound not register sensor device\n", __func__); goto err_sysfs_create_factory_light; } err = sensors_register(&(gp2a->proximity_sensor_device), gp2a, additional_proximity_attrs, "proximity_sensor"); if (err) { pr_err("%s: cound not register sensor device\n", __func__); goto err_sysfs_create_factory_proximity; } pr_info("%s : probe success!\n", __func__); return 0; err_sysfs_create_factory_proximity: err_sysfs_create_factory_light: free_irq(gp2a->irq, gp2a); gpio_free(gp2a->pdata->p_out); err_setup_irq: err_no_device: wake_lock_destroy(&gp2a->prx_wake_lock); mutex_destroy(&gp2a->light_mutex); mutex_destroy(&gp2a->data_mutex); sysfs_remove_group(&gp2a->light_input_dev->dev.kobj, &lightsensor_attribute_group); err_sysfs_create_group_light: sysfs_remove_group(&gp2a->proximity_input_dev->dev.kobj, &proximity_attribute_group); err_sysfs_create_group_proximity: input_unregister_device(gp2a->light_input_dev); error_setup_reg_light: input_unregister_device(gp2a->proximity_input_dev); error_setup_reg_prox: if (pdata->power_on) pdata->power_on(false); kfree(gp2a); done: return err; }
static int __devinit sec_fuelgauge_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); struct sec_fuelgauge_info *fuelgauge; sec_battery_platform_data_t *pdata = NULL; struct battery_data_t *battery_data = NULL; int ret = 0; union power_supply_propval raw_soc_val; dev_info(&client->dev, "%s: SEC Fuelgauge Driver Loading\n", __func__); if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE)) return -EIO; fuelgauge = kzalloc(sizeof(*fuelgauge), GFP_KERNEL); if (!fuelgauge) return -ENOMEM; mutex_init(&fuelgauge->fg_lock); fuelgauge->client = client; if (client->dev.of_node) { int error; pdata = devm_kzalloc(&client->dev, sizeof(sec_battery_platform_data_t), GFP_KERNEL); if (!pdata) { dev_err(&client->dev, "Failed to allocate memory\n"); ret = -ENOMEM; goto err_free; } battery_data = devm_kzalloc(&client->dev, sizeof(struct battery_data_t), GFP_KERNEL); if (!battery_data) { dev_err(&client->dev, "Failed to allocate memory\n"); devm_kfree(&client->dev, pdata); ret = -ENOMEM; goto err_free; } pdata->battery_data = (void *)battery_data; fuelgauge->pdata = pdata; error = fuelgauge_parse_dt(&client->dev, fuelgauge); if (error) { dev_err(&client->dev, "%s: Failed to get fuel_int\n", __func__); } } else { dev_err(&client->dev, "%s: Failed to get of_node\n", __func__); fuelgauge->pdata = client->dev.platform_data; } i2c_set_clientdata(client, fuelgauge); if (!sec_hal_fg_init(fuelgauge->client)) { dev_err(&client->dev, "%s: Failed to Initialize Fuelgauge\n", __func__); goto err_free; } fuelgauge->psy_fg.name = "sec-fuelgauge"; fuelgauge->psy_fg.type = POWER_SUPPLY_TYPE_UNKNOWN; fuelgauge->psy_fg.get_property = sec_fg_get_property; fuelgauge->psy_fg.set_property = sec_fg_set_property; fuelgauge->psy_fg.properties = sec_fuelgauge_props; fuelgauge->psy_fg.num_properties = ARRAY_SIZE(sec_fuelgauge_props); fuelgauge->capacity_max = fuelgauge->pdata->capacity_max; raw_soc_val.intval = SEC_FUELGAUGE_CAPACITY_TYPE_RAW; sec_hal_fg_get_property(fuelgauge->client, POWER_SUPPLY_PROP_CAPACITY, &raw_soc_val); raw_soc_val.intval /= 10; if(raw_soc_val.intval > fuelgauge->pdata->capacity_max) sec_fg_calculate_dynamic_scale(fuelgauge); /* if (!fuelgauge->pdata->fg_gpio_init()) { dev_err(&client->dev, "%s: Failed to Initialize GPIO\n", __func__); goto err_free; } */ ret = power_supply_register(&client->dev, &fuelgauge->psy_fg); if (ret) { dev_err(&client->dev, "%s: Failed to Register psy_fg\n", __func__); goto err_free; } if (fuelgauge->pdata->fg_irq) { fuelgauge->fg_irq = gpio_to_irq(fuelgauge->pdata->fg_irq); INIT_DELAYED_WORK( &fuelgauge->isr_work, sec_fg_isr_work); ret = request_threaded_irq(fuelgauge->fg_irq, NULL, sec_fg_irq_thread, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT, "fuelgauge-irq", fuelgauge); if (ret) { dev_err(&client->dev, "%s: Failed to Reqeust IRQ\n", __func__); goto err_supply_unreg; } ret = enable_irq_wake(fuelgauge->fg_irq); if (ret < 0) dev_err(&client->dev, "%s: Failed to Enable Wakeup Source(%d)\n", __func__, ret); } fuelgauge->is_fuel_alerted = false; if (fuelgauge->pdata->fuel_alert_soc >= 0) { if (sec_hal_fg_fuelalert_init(fuelgauge->client, fuelgauge->pdata->fuel_alert_soc)) wake_lock_init(&fuelgauge->fuel_alert_wake_lock, WAKE_LOCK_SUSPEND, "fuel_alerted"); else { dev_err(&client->dev, "%s: Failed to Initialize Fuel-alert\n", __func__); goto err_irq; } } fuelgauge->initial_update_of_soc = true; ret = sec_fg_create_attrs(fuelgauge->psy_fg.dev); if (ret) { dev_err(&client->dev, "%s : Failed to create_attrs\n", __func__); goto err_irq; } dev_info(&client->dev, "%s: SEC Fuelgauge Driver Loaded\n", __func__); return 0; err_irq: if (fuelgauge->fg_irq) free_irq(fuelgauge->fg_irq, fuelgauge); wake_lock_destroy(&fuelgauge->fuel_alert_wake_lock); err_supply_unreg: power_supply_unregister(&fuelgauge->psy_fg); err_free: mutex_destroy(&fuelgauge->fg_lock); kfree(fuelgauge); return ret; }
static int __init multipdp_init(void) { int ret; wake_lock_init(&pdp_wake_lock, WAKE_LOCK_SUSPEND, "MULTI_PDP"); pdp_arg_t pdp_arg = { .id = 1, .ifname = "ttyCSD", }; pdp_arg_t efs_arg = { .id = 8, .ifname = "ttyEFS", }; pdp_arg_t gps_arg = { .id = 5, .ifname = "ttyGPS", }; pdp_arg_t xtra_arg = { .id = 6, .ifname = "ttyXTRA", }; pdp_arg_t smd_arg = { .id = 25, .ifname = "ttySMD", }; pdp_arg_t pcm_arg = { .id = 30, .ifname = "ttyPCM", } ; #ifdef LOOP_BACK_TEST pdp_arg_t loopback_arg = { .id = 31, .ifname = "ttyLOBK", }; #endif /* run DPRAM I/O thread */ ret = kernel_thread(dpram_thread, NULL, CLONE_FS | CLONE_FILES); if (ret < 0) { EPRINTK("kernel_thread() failed\n"); return ret; } wait_for_completion(&dpram_complete); if (!dpram_task) { EPRINTK("DPRAM I/O thread error\n"); return -EIO; } /* create serial device for Circuit Switched Data */ ret = pdp_activate(&pdp_arg, DEV_TYPE_SERIAL, DEV_FLAG_STICKY); if (ret < 0) { EPRINTK("failed to create a serial device for CSD\n"); goto err0; } ret = pdp_activate(&efs_arg, DEV_TYPE_SERIAL, DEV_FLAG_STICKY); if (ret < 0) { EPRINTK("failed to create a serial device for EFS\n"); goto err1; } ret = pdp_activate(&gps_arg, DEV_TYPE_SERIAL, DEV_FLAG_STICKY); if (ret < 0) { EPRINTK("failed to create a serial device for GPS\n"); goto err2; } ret = pdp_activate(&xtra_arg, DEV_TYPE_SERIAL, DEV_FLAG_STICKY); if (ret < 0) { EPRINTK("failed to create a serial device for XTRA\n"); goto err3; } ret = pdp_activate(&smd_arg, DEV_TYPE_SERIAL, DEV_FLAG_STICKY); if (ret < 0) { EPRINTK("failed to create a serial device for SMD\n"); goto err4; } ret = pdp_activate(&pcm_arg, DEV_TYPE_SERIAL, DEV_FLAG_STICKY); if (ret < 0) { EPRINTK("failed to create a serial device for SMD\n"); goto err5; } #ifdef LOOP_BACK_TEST ret = pdp_activate(&loopback_arg, DEV_TYPE_SERIAL, DEV_FLAG_STICKY); if (ret < 0) { EPRINTK("failed to create a serial device for LoopBack\n"); goto err6; } #endif /* create app. interface device */ ret = misc_register(&multipdp_dev); if (ret < 0) { EPRINTK("misc_register() failed\n"); goto err1; } #ifdef LOOP_BACK_TEST ret = device_create_file(multipdp_dev.this_device, &dev_attr_loopback); #endif #ifdef CONFIG_PROC_FS create_proc_read_entry(APP_DEVNAME, 0, 0, multipdp_proc_read, NULL); #endif #ifdef NO_TTY_DPRAM printk("multipdp_init:multipdp_rx_noti_regi calling"); multipdp_rx_noti_regi(multipdp_rx_cback ); #endif // printk(KERN_INFO // "$Id: multipdp.c,v 1.10 2008/01/11 05:40:56 melonzz Exp $\n"); return 0; #ifdef LOOP_BACK_TEST err6: pdp_deactivate(&loopback_arg, 1); #endif err5: /* undo serial device for Circuit Switched Data */ pdp_deactivate(&pcm_arg, 1); err4: /* undo serial device for Circuit Switched Data */ pdp_deactivate(&smd_arg, 1); err3: /* undo serial device for Circuit Switched Data */ pdp_deactivate(&xtra_arg, 1); err2: /* undo serial device for Circuit Switched Data */ pdp_deactivate(&gps_arg, 1); err1: /* undo serial device for Circuit Switched Data */ pdp_deactivate(&pdp_arg, 1); err0: /* kill DPRAM I/O thread */ if (dpram_task) { send_sig(SIGUSR1, dpram_task, 1); wait_for_completion(&dpram_complete); } return ret; } static void __exit multipdp_exit(void) { wake_lock_destroy(&pdp_wake_lock); #ifdef CONFIG_PROC_FS remove_proc_entry(APP_DEVNAME, 0); #endif /* remove app. interface device */ misc_deregister(&multipdp_dev); /* clean up PDP context table */ pdp_cleanup(); /* kill DPRAM I/O thread */ if (dpram_task) { send_sig(SIGUSR1, dpram_task, 1); wait_for_completion(&dpram_complete); } } //module_init(multipdp_init); late_initcall(multipdp_init); module_exit(multipdp_exit); MODULE_AUTHOR("SAMSUNG ELECTRONICS CO., LTD"); MODULE_DESCRIPTION("Multiple PDP Muxer / Demuxer"); MODULE_LICENSE("GPL");
static void memdump_wake_lock_stop(void) { wake_unlock(&memdump_wake_lock); wake_lock_destroy(&memdump_wake_lock); }