static int cm36686_i2c_remove(struct i2c_client *client) { struct cm36686_data *cm36686 = i2c_get_clientdata(client); /* free irq */ if (cm36686->power_state & PROXIMITY_ENABLED) { disable_irq_wake(cm36686->irq); disable_irq(cm36686->irq); } free_irq(cm36686->irq, cm36686); gpio_free(cm36686->pdata->irq); /* device off */ if (cm36686->power_state & LIGHT_ENABLED) cm36686_light_disable(cm36686); if (cm36686->power_state & PROXIMITY_ENABLED) { cm36686_i2c_write_word(cm36686, REG_PS_CONF1, 0x0001); } /* destroy workqueue */ destroy_workqueue(cm36686->light_wq); destroy_workqueue(cm36686->prox_wq); /* sysfs destroy */ sensors_unregister(cm36686->light_dev, light_sensor_attrs); sensors_unregister(cm36686->proximity_dev, prox_sensor_attrs); sensors_remove_symlink(&cm36686->light_input_dev->dev.kobj, cm36686->light_input_dev->name); sensors_remove_symlink(&cm36686->proximity_input_dev->dev.kobj, cm36686->proximity_input_dev->name); /* input device destroy */ sysfs_remove_group(&cm36686->light_input_dev->dev.kobj, &light_attribute_group); input_unregister_device(cm36686->light_input_dev); sysfs_remove_group(&cm36686->proximity_input_dev->dev.kobj, &proximity_attribute_group); input_unregister_device(cm36686->proximity_input_dev); #if defined(CONFIG_SENSORS_CM36686_LEDA_EN_GPIO) cm36686_leden_gpio_onoff(cm36686, 0); gpio_free(cm36686->pdata->leden_gpio); #else prox_led_onoff(cm36686, 0); #endif /* lock destroy */ mutex_destroy(&cm36686->read_lock); mutex_destroy(&cm36686->power_lock); wake_lock_destroy(&cm36686->prx_wake_lock); kfree(cm36686); return 0; }
static void gp2a_shutdown(struct i2c_client *client) { struct gp2a_data *data = i2c_get_clientdata(client); pr_info("%s, is called\n", __func__); if (data->light_enabled) { cancel_delayed_work_sync(&data->light_work); lightsensor_onoff(0, data); input_report_rel(data->light_input_dev, REL_MISC, data->lux + 1); input_sync(data->light_input_dev); } if (data->prox_enabled) { disable_irq(data->irq); disable_irq_wake(data->irq); gp2a_prox_onoff(0, data); wake_unlock(&data->prx_wake_lock); } wake_lock_destroy(&data->prx_wake_lock); mutex_destroy(&data->light_mutex); mutex_destroy(&data->data_mutex); sensors_unregister(data->prox_sensor_device, prox_sensor_attrs); sensors_unregister(data->light_sensor_device, light_sensor_attrs); sysfs_remove_group(&data->prox_input_dev->dev.kobj, &gp2a_prox_attribute_group); sensors_remove_symlink(&data->prox_input_dev->dev.kobj, data->prox_input_dev->name); input_unregister_device(data->prox_input_dev); input_free_device(data->prox_input_dev); gpio_free(data->gpio); sysfs_remove_group(&data->light_input_dev->dev.kobj, &gp2a_light_attribute_group); sensors_remove_symlink(&data->light_input_dev->dev.kobj, data->light_input_dev->name); input_unregister_device(data->light_input_dev); input_free_device(data->light_input_dev); sensor_power_on_vdd(data, 0); kfree(data); bShutdown = true; }
static int __devexit cm3323_remove(struct i2c_client *client) { struct cm3323_p *data = i2c_get_clientdata(client); /* device off */ if (data->power_state & LIGHT_ENABLED) cm3323_light_disable(data); /* destroy workqueue */ destroy_workqueue(data->light_wq); /* lock destroy */ mutex_destroy(&data->read_lock); mutex_destroy(&data->power_lock); /* sysfs destroy */ sensors_unregister(data->light_dev, sensor_attrs); sensors_remove_symlink(&data->input->dev.kobj, data->input->name); /* input device destroy */ sysfs_remove_group(&data->input->dev.kobj, &light_attribute_group); input_unregister_device(data->input); kfree(data); return 0; }
static int __devexit bma280_remove(struct i2c_client *client) { struct bma280_p *data = (struct bma280_p *)i2c_get_clientdata(client); if (atomic_read(&data->enable) == ON) bma280_set_enable(data, OFF); atomic_set(&data->enable, OFF); cancel_delayed_work_sync(&data->irq_work); bma280_set_mode(data, BMA280_MODE_SUSPEND); sensors_unregister(data->factory_device, sensor_attrs); sensors_remove_symlink(&data->input->dev.kobj, data->input->name); sysfs_remove_group(&data->input->dev.kobj, &bma280_attribute_group); input_unregister_device(data->input); free_irq(data->irq1, data); wake_lock_destroy(&data->reactive_wake_lock); mutex_destroy(&data->mode_mutex); gpio_free(data->acc_int1); kfree(data); return 0; }
void remove_magnetic_sensor(struct ssp_data *data) { sensors_unregister(data->mag_device, mag_attrs); device_remove_file(&data->mag_input_dev->dev, &dev_attr_mag_poll_delay); sensors_remove_symlink(&data->mag_input_dev->dev.kobj, data->mag_input_dev->name); input_unregister_device(data->mag_input_dev); }
int initialize_magnetic_sensor(struct ssp_data *data) { int iRet; struct input_dev *input_dev; /* allocate input_device */ input_dev = input_allocate_device(); if (input_dev == NULL) return ERROR; input_dev->name = MODULE_NAME; input_set_capability(input_dev, EV_REL, REL_RX); input_set_capability(input_dev, EV_REL, REL_RY); input_set_capability(input_dev, EV_REL, REL_RZ); input_set_drvdata(input_dev, data); /* register input_device */ iRet = input_register_device(input_dev); if (iRet < 0) { input_free_device(input_dev); return ERROR; } iRet = sensors_create_symlink(&input_dev->dev.kobj, input_dev->name); if (iRet < 0) goto err_creat_symlink; iRet = device_create_file(&input_dev->dev, &dev_attr_mag_poll_delay); if (iRet < 0) goto err_creat_file; iRet = sensors_register(data->mag_device, data, mag_attrs, MODULE_NAME); if (iRet < 0) goto err_sensor_register; data->mag_input_dev = input_dev; return SUCCESS; err_sensor_register: device_remove_file(&input_dev->dev, &dev_attr_mag_poll_delay); err_creat_file: sensors_remove_symlink(&input_dev->dev.kobj, input_dev->name); err_creat_symlink: input_unregister_device(input_dev); pr_err("[SSP]: %s - fail!\n", __func__); return ERROR; }
static int cm3323_input_init(struct cm3323_p *data) { int ret = 0; struct input_dev *dev; /* allocate lightsensor input_device */ dev = input_allocate_device(); if (!dev) return -ENOMEM; dev->name = MODULE_NAME; dev->id.bustype = BUS_I2C; input_set_capability(dev, EV_REL, REL_RED); input_set_capability(dev, EV_REL, REL_GREEN); input_set_capability(dev, EV_REL, REL_BLUE); input_set_capability(dev, EV_REL, REL_WHITE); input_set_drvdata(dev, data); ret = input_register_device(dev); if (ret < 0) { input_free_device(data->input); return ret; } ret = sensors_create_symlink(&dev->dev.kobj, dev->name); if (ret < 0) { input_unregister_device(dev); return ret; } ret = sysfs_create_group(&dev->dev.kobj, &light_attribute_group); if (ret < 0) { sensors_remove_symlink(&data->input->dev.kobj, data->input->name); input_unregister_device(dev); return ret; } data->input = dev; return 0; }
static int __devexit ak09911c_remove(struct i2c_client *client) { struct ak09911c_p *data = (struct ak09911c_p *)i2c_get_clientdata(client); if (atomic_read(&data->enable) == 1) ak09911c_set_enable(data, 0); gpio_free(data->m_rst_n); mutex_destroy(&data->lock); sensors_unregister(data->factory_device, sensor_attrs); sensors_remove_symlink(&data->input->dev.kobj, data->input->name); sysfs_remove_group(&data->input->dev.kobj, &ak09911c_attribute_group); input_unregister_device(data->input); kfree(data); return 0; }
static int ak09911c_input_init(struct ak09911c_p *data) { int ret = 0; struct input_dev *dev; dev = input_allocate_device(); if (!dev) return -ENOMEM; dev->name = MODULE_NAME; dev->id.bustype = BUS_I2C; input_set_capability(dev, EV_REL, REL_X); input_set_capability(dev, EV_REL, REL_Y); input_set_capability(dev, EV_REL, REL_Z); input_set_drvdata(dev, data); ret = input_register_device(dev); if (ret < 0) { input_free_device(dev); return ret; } ret = sensors_create_symlink(&dev->dev.kobj, dev->name); if (ret < 0) { input_unregister_device(dev); return ret; } /* sysfs node creation */ ret = sysfs_create_group(&dev->dev.kobj, &ak09911c_attribute_group); if (ret < 0) { sensors_remove_symlink(&data->input->dev.kobj, data->input->name); input_unregister_device(dev); return ret; } data->input = dev; return 0; }
static int ak09911c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = -ENODEV; struct ak09911c_p *data = NULL; struct ak09911c_platform_data *pdata; pr_info("%s Probe Start!\n", __func__); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s i2c_check_functionality error\n", __func__); goto exit; } ak09911c_regulator_onoff(&client->dev, 1); data = kzalloc(sizeof(struct ak09911c_p), GFP_KERNEL); if (data == NULL) { pr_err("%s kzalloc error\n", __func__); ret = -ENOMEM; goto exit_kzalloc; } if (client->dev.of_node) { pdata = devm_kzalloc(&client->dev, sizeof(struct ak09911c_platform_data), GFP_KERNEL); if (!pdata) { dev_err(&client->dev, "Failed to allocate memory\n"); return -ENOMEM; } ret = ak09911c_parse_dt(&client->dev, pdata); if (ret < 0) { pr_err("%s of_node error\n", __func__); ret = -ENODEV; goto exit_of_node; } } else pdata = client->dev.platform_data; if (!pdata) { ret = -EINVAL; goto exit_pdata; } data->pdata = pdata; ret = ak09911c_setup_pin(pdata); if (ret) { pr_err("%s could not setup pin\n", __func__); goto exit_setup_pin; } /* ak09911c chip reset */ ak09911c_reset(data); i2c_set_clientdata(client, data); data->client = client; ret = ak09911c_check_device(data); if (ret < 0) goto exit_set_mode_check_device; /* input device init */ ret = ak09911c_input_init(data); if (ret < 0) goto exit_input_init; ret = sensors_register(data->factory_device, data, sensor_attrs, MODULE_NAME); if (ret) { pr_err("%s: failed to sensors_register (%d)\n", __func__, ret); goto exit_register_failed; } /* workqueue init */ INIT_DELAYED_WORK(&data->work, ak09911c_work_func); mutex_init(&data->lock); atomic_set(&data->delay, AK09911C_DEFAULT_DELAY); atomic_set(&data->enable, 0); ak09911c_read_fuserom(data); pr_info("%s Probe done!(chip pos : %d)\n", __func__, pdata->chip_pos); return 0; exit_register_failed: sysfs_remove_group(&data->input->dev.kobj, &ak09911c_attribute_group); sensors_remove_symlink(&data->input->dev.kobj, data->input->name); input_unregister_device(data->input); exit_input_init: exit_set_mode_check_device: gpio_free(data->pdata->m_rst_n); exit_setup_pin: exit_pdata: exit_of_node: kfree(data); exit_kzalloc: ak09911c_regulator_onoff(&client->dev, 0); exit: pr_err("%s Probe fail!\n", __func__); return ret; }
static int bma254_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = 0; struct bma254_data *bma254; struct input_dev *dev; #ifdef CONFIG_BMA254_SMART_ALERT int err = 0; struct bma254_platform_data *pdata; #endif pr_info("%s, is called\n", __func__); if (client == NULL) { pr_err("%s, client doesn't exist\n", __func__); ret = -ENOMEM; return ret; } #ifdef CONFIG_SENSORS_POWERCONTROL ret = bma254_regulator_onoff(&client->dev, true); if (ret) { pr_err("%s, Power Up Failed\n", __func__); return ret; } #endif if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s,client not i2c capable\n", __func__); return -ENOMEM; } ret = i2c_smbus_read_word_data(client, BMA254_CHIP_ID); if ((ret & 0x00ff) != 0xfa) { pr_err("%s,i2c failed(%x)\n", __func__, ret & 0x00ff); ret = -ENOMEM; return ret; } else { pr_err("%s,chip id %x\n", __func__, ret & 0x00ff); } bma254 = kzalloc(sizeof(struct bma254_data), GFP_KERNEL); if (!bma254) { pr_err("%s, kzalloc error\n", __func__); ret = -ENOMEM; return ret; } #ifdef CONFIG_BMA254_SMART_ALERT if(client->dev.of_node) { pdata = devm_kzalloc(&client->dev, sizeof(struct bma254_platform_data), GFP_KERNEL); if (!pdata) { dev_err(&client->dev, "Failed to allocate memory \n"); kfree(bma254); return -ENOMEM; } }else{ pr_err("%s,this_node is empty\n", __func__); kfree(bma254); return -ENODEV; } bma254->pdata = pdata; #endif ret = bma254_parse_dt(bma254, &client->dev); if (ret) { pr_err("%s, get gpio is failed\n", __func__); goto parse_dt_err; } i2c_set_clientdata(client, bma254); bma254->client = client; bma254_activate(bma254, false); dev = input_allocate_device(); if (!dev){ goto input_allocate_device_err; } dev->name = "accelerometer"; dev->id.bustype = BUS_I2C; #if !defined(CONFIG_MACH_VICTORLTE) && !defined(CONFIG_MACH_VICTOR3GDSDTV_LTN) dev->dev.parent = &client->dev; #endif #ifdef REPORT_ABS input_set_capability(dev, EV_ABS, ABS_MISC); input_set_abs_params(dev, ABS_X, ABSMIN, ABSMAX, 0, 0); input_set_abs_params(dev, ABS_Y, ABSMIN, ABSMAX, 0, 0); input_set_abs_params(dev, ABS_Z, ABSMIN, ABSMAX, 0, 0); #else input_set_capability(dev, EV_REL, REL_X); input_set_capability(dev, EV_REL, REL_Y); input_set_capability(dev, EV_REL, REL_Z); #endif input_set_drvdata(dev, bma254); ret = input_register_device(dev); if (ret < 0) { pr_err("%s,sysfs_create_group failed\n", __func__); goto input_register_device_err; } bma254->input = dev; #ifdef CONFIG_BMA254_SMART_ALERT pr_info("%s: HW_rev success %d\n", __func__, system_rev); INIT_WORK(&bma254->alert_work, bma254_work_func_alert); wake_lock_init(&bma254->reactive_wake_lock, WAKE_LOCK_SUSPEND, "reactive_wake_lock"); err = bma254_setup_irq(bma254); if (err) { bma254->pin_check_fail = true; pr_err("%s: could not setup irq\n", __func__); goto err_setup_irq; } mutex_init(&bma254->data_mutex); #endif ret = sensors_create_symlink(&dev->dev.kobj, dev->name); if (ret < 0) { input_unregister_device(dev); return ret; } ret = sysfs_create_group(&bma254->input->dev.kobj, &bma254_attribute_group); if (ret < 0) { pr_err("%s,sysfs_create_group failed\n", __func__); sensors_remove_symlink(&bma254->input->dev.kobj, bma254->input->name); goto sysfs_create_group_err; } INIT_DELAYED_WORK(&bma254->work, bma254_work_func); bma254->delay = MAX_DELAY; bma254->enable = 0; ret = sensors_register(bma254->dev, bma254, bma254_attrs, "accelerometer_sensor"); if (ret < 0) { pr_info("%s: could not sensors_register\n", __func__); goto sensors_register_err; } #ifdef CONFIG_SENSORS_POWERCONTROL bma254_regulator_onoff(&client->dev, false); #endif pr_info("[SENSOR]: %s - Probe done!(chip pos : %d)\n", __func__, bma254->position); return 0; sensors_register_err: sysfs_remove_group(&bma254->input->dev.kobj, &bma254_attribute_group); sensors_remove_symlink(&bma254->input->dev.kobj, bma254->input->name); sysfs_create_group_err: input_unregister_device(bma254->input); #ifdef CONFIG_BMA254_SMART_ALERT err_setup_irq: wake_lock_destroy(&bma254->reactive_wake_lock); #endif input_register_device_err: input_free_device(dev); input_allocate_device_err: parse_dt_err: kfree(bma254); pr_err("[SENSOR]: %s - Probe fail!\n", __func__); #ifdef CONFIG_SENSORS_POWERCONTROL bma254_regulator_onoff(&client->dev, false); #endif return ret; }
static int cm36686_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = -ENODEV; struct cm36686_data *cm36686 = NULL; struct cm36686_platform_data *pdata = NULL; int err; pr_info("[SENSOR] %s: Probe Start!\n", __func__); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("[SENSOR] %s: i2c functionality check failed!\n", __func__); return ret; } cm36686 = kzalloc(sizeof(struct cm36686_data), GFP_KERNEL); if (!cm36686) { pr_err ("[SENSOR] %s: failed to alloc memory for RGB sensor module data\n", __func__); return -ENOMEM; } if(client->dev.of_node) { pdata = devm_kzalloc (&client->dev , sizeof(struct cm36686_platform_data ), GFP_KERNEL); if(!pdata) { dev_err(&client->dev, "Failed to allocate memory\n"); if(cm36686) kfree(cm36686); return -ENOMEM; } err = cm36686_parse_dt(&client->dev, pdata); if(err) goto err_devicetree; } else pdata = client->dev.platform_data; if (!pdata) { pr_err("%s: missing pdata!\n", __func__); if(cm36686) kfree(cm36686); return ret; } prox_regulator_onoff(&client->dev,1); cm36686->pdata = pdata; cm36686->i2c_client = client; i2c_set_clientdata(client, cm36686); mutex_init(&cm36686->power_lock); mutex_init(&cm36686->read_lock); /* wake lock init for proximity sensor */ wake_lock_init(&cm36686->prx_wake_lock, WAKE_LOCK_SUSPEND, "prx_wake_lock"); #if defined(CONFIG_SENSORS_CM36686_LEDA_EN_GPIO) /* setup leden_gpio */ ret = cm36686_setup_leden_gpio(cm36686); if (ret) { pr_err("%s: could not setup leden_gpio\n", __func__); goto err_setup_leden_gpio; } cm36686_leden_gpio_onoff(cm36686, 1); #else prox_led_onoff(cm36686, 1); #endif /* Check if the device is there or not. */ ret = cm36686_i2c_write_word(cm36686, REG_CS_CONF1, 0x0001); if (ret < 0) { pr_err("[SENSOR] %s: cm36686 is not connected.(%d)\n", __func__, ret); goto err_setup_reg; } /* setup initial registers */ ret = cm36686_setup_reg(cm36686); if (ret < 0) { pr_err("[SENSOR] %s: could not setup regs\n", __func__); goto err_setup_reg; } #if defined(CONFIG_SENSORS_CM36686_LEDA_EN_GPIO) cm36686_leden_gpio_onoff(cm36686, 0); #else prox_led_onoff(cm36686, 0); #endif /* allocate proximity input_device */ cm36686->proximity_input_dev = input_allocate_device(); if (!cm36686->proximity_input_dev) { pr_err("%s: could not allocate proximity input device\n", __func__); goto err_input_allocate_device_proximity; } input_set_drvdata(cm36686->proximity_input_dev, cm36686); cm36686->proximity_input_dev->name = "proximity_sensor"; input_set_capability(cm36686->proximity_input_dev, EV_ABS, ABS_DISTANCE); input_set_abs_params(cm36686->proximity_input_dev, ABS_DISTANCE, 0, 1, 0, 0); ret = input_register_device(cm36686->proximity_input_dev); if (ret < 0) { input_free_device(cm36686->proximity_input_dev); pr_err("[SENSOR] %s: could not register input device\n", __func__); goto err_input_register_device_proximity; } ret = sensors_create_symlink(&cm36686->proximity_input_dev->dev.kobj, cm36686->proximity_input_dev->name); if (ret < 0) { pr_err("[SENSOR] %s: create_symlink error\n", __func__); goto err_sensors_create_symlink_prox; } ret = sysfs_create_group(&cm36686->proximity_input_dev->dev.kobj, &proximity_attribute_group); if (ret) { pr_err("[SENSOR] %s: could not create sysfs group\n", __func__); goto err_sysfs_create_group_proximity; } /* setup irq */ ret = cm36686_setup_irq(cm36686); if (ret) { pr_err("%s: could not setup irq\n", __func__); goto err_setup_irq; } /* For factory test mode, we use timer to get average proximity data. */ /* prox_timer settings. we poll for light values using a timer. */ hrtimer_init(&cm36686->prox_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); cm36686->prox_poll_delay = ns_to_ktime(2000 * NSEC_PER_MSEC);/*2 sec*/ cm36686->prox_timer.function = cm36686_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). */ cm36686->prox_wq = create_singlethread_workqueue("cm36686_prox_wq"); if (!cm36686->prox_wq) { ret = -ENOMEM; pr_err("[SENSOR] %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(&cm36686->work_prox, cm36686_work_func_prox); /* allocate lightsensor input_device */ cm36686->light_input_dev = input_allocate_device(); if (!cm36686->light_input_dev) { pr_err("%s: could not allocate light input device\n", __func__); goto err_input_allocate_device_light; } input_set_drvdata(cm36686->light_input_dev, cm36686); cm36686->light_input_dev->name = "light_sensor"; input_set_capability(cm36686->light_input_dev, EV_REL, REL_MISC); input_set_capability(cm36686->light_input_dev, EV_REL, REL_DIAL); input_set_capability(cm36686->light_input_dev, EV_REL, REL_WHEEL); ret = input_register_device(cm36686->light_input_dev); if (ret < 0) { input_free_device(cm36686->light_input_dev); pr_err("%s: could not register input device\n", __func__); goto err_input_register_device_light; } ret = sensors_create_symlink(&cm36686->light_input_dev->dev.kobj, cm36686->light_input_dev->name); if (ret < 0) { pr_err("[SENSOR] %s: create_symlink error\n", __func__); goto err_sensors_create_symlink_light; } ret = sysfs_create_group(&cm36686->light_input_dev->dev.kobj, &light_attribute_group); if (ret) { pr_err("[SENSOR] %s: could not create sysfs group\n", __func__); goto err_sysfs_create_group_light; } /* light_timer settings. we poll for light values using a timer. */ hrtimer_init(&cm36686->light_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); cm36686->light_poll_delay = ns_to_ktime(200 * NSEC_PER_MSEC); cm36686->light_timer.function = cm36686_light_timer_func; /* the timer just fires off a work queue request. we need a thread to read the i2c (can be slow and blocking). */ cm36686->light_wq = create_singlethread_workqueue("cm36686_light_wq"); if (!cm36686->light_wq) { ret = -ENOMEM; pr_err("[SENSOR] %s: could not create light workqueue\n", __func__); goto err_create_light_workqueue; } /* this is the thread function we run on the work queue */ INIT_WORK(&cm36686->work_light, cm36686_work_func_light); /* set sysfs for proximity sensor */ ret = sensors_register(cm36686->proximity_dev, cm36686, prox_sensor_attrs, "proximity_sensor"); if (ret) { pr_err("[SENSOR] %s: cound not register\ proximity sensor device(%d).\n", __func__, ret); goto prox_sensor_register_failed; } /* set sysfs for light sensor */ ret = sensors_register(cm36686->light_dev, cm36686, light_sensor_attrs, "light_sensor"); if (ret) { pr_err("[SENSOR] %s: cound not register\ light sensor device(%d).\n", __func__, ret); goto light_sensor_register_failed; } pr_info("[SENSOR] %s is success.\n", __func__); goto done; err_devicetree: printk("\n error in device tree"); /* error, unwind it all */ light_sensor_register_failed: sensors_unregister(cm36686->proximity_dev, prox_sensor_attrs); prox_sensor_register_failed: destroy_workqueue(cm36686->light_wq); err_create_light_workqueue: sysfs_remove_group(&cm36686->light_input_dev->dev.kobj, &light_attribute_group); err_sysfs_create_group_light: sensors_remove_symlink(&cm36686->light_input_dev->dev.kobj, cm36686->light_input_dev->name); err_sensors_create_symlink_light: input_unregister_device(cm36686->light_input_dev); err_input_register_device_light: err_input_allocate_device_light: destroy_workqueue(cm36686->prox_wq); err_create_prox_workqueue: free_irq(cm36686->irq, cm36686); gpio_free(cm36686->pdata->irq); err_setup_irq: sysfs_remove_group(&cm36686->proximity_input_dev->dev.kobj, &proximity_attribute_group); err_sysfs_create_group_proximity: sensors_remove_symlink(&cm36686->proximity_input_dev->dev.kobj, cm36686->proximity_input_dev->name); err_sensors_create_symlink_prox: input_unregister_device(cm36686->proximity_input_dev); err_input_register_device_proximity: err_input_allocate_device_proximity: err_setup_reg: #if defined(CONFIG_SENSORS_CM36686_LEDA_EN_GPIO) cm36686_leden_gpio_onoff(cm36686, 0); gpio_free(cm36686->pdata->leden_gpio); err_setup_leden_gpio: #else prox_led_onoff(cm36686, 0); #endif wake_lock_destroy(&cm36686->prx_wake_lock); mutex_destroy(&cm36686->read_lock); mutex_destroy(&cm36686->power_lock); kfree(cm36686); prox_regulator_onoff(&client->dev,0); done: return ret; }
static int cm3323_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = -ENODEV; struct cm3323_p *data = NULL; pr_info("[SENSOR]: %s - Probe Start!\n", __func__); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("[SENSOR]: %s - i2c_check_functionality error\n", __func__); goto exit; } data = kzalloc(sizeof(struct cm3323_p), GFP_KERNEL); if (data == NULL) { pr_err("[SENSOR]: %s - kzalloc error\n", __func__); ret = -ENOMEM; goto exit_kzalloc; } data->i2c_client = client; i2c_set_clientdata(client, data); mutex_init(&data->power_lock); mutex_init(&data->read_lock); /* Check if the device is there or not. */ ret = cm3323_setup_reg(data); if (ret < 0) { pr_err("[SENSOR]: %s - could not setup regs\n", __func__); goto exit_setup_reg; } /* input device init */ ret = cm3323_input_init(data); if (ret < 0) goto exit_input_init; /* light_timer settings. we poll for light values using a timer. */ hrtimer_init(&data->light_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); data->poll_delay = ns_to_ktime(200 * NSEC_PER_MSEC); data->light_timer.function = cm3323_light_timer_func; data->time_count = 0; /* the timer just fires off a work queue request. we need a thread to read the i2c (can be slow and blocking). */ data->light_wq = create_singlethread_workqueue("cm3323_light_wq"); if (!data->light_wq) { ret = -ENOMEM; pr_err("[SENSOR]: %s - could not create light workqueue\n", __func__); goto exit_create_light_workqueue; } /* this is the thread function we run on the work queue */ INIT_WORK(&data->work_light, cm3323_work_func_light); /* set sysfs for light sensor */ sensors_register(data->light_dev, data, sensor_attrs, MODULE_NAME); pr_info("[SENSOR]: %s - Probe done!\n", __func__); return 0; exit_create_light_workqueue: sysfs_remove_group(&data->input->dev.kobj, &light_attribute_group); sensors_remove_symlink(&data->input->dev.kobj, data->input->name); input_unregister_device(data->input); exit_input_init: exit_setup_reg: mutex_destroy(&data->read_lock); mutex_destroy(&data->power_lock); kfree(data); exit_kzalloc: exit: pr_err("[SENSOR]: %s - Probe fail!\n", __func__); return ret; }
static int gp2a_probe(struct i2c_client *client, const struct i2c_device_id *id) { int err = 0; struct gp2a_data *data; u8 value; pr_info("%s, is called\n", __func__); if (client == NULL) { pr_err("%s, client doesn't exist\n", __func__); err = -ENOMEM; return err; } data = kzalloc(sizeof(struct gp2a_data), GFP_KERNEL); if (!data) { pr_err("%s, kzalloc error\n", __func__); err = -ENOMEM; return err; } err = gp2a_parse_dt(data, &client->dev); if (err) { pr_err("%s, get gpio is failed\n", __func__); goto gp2a_parse_dt_err; } data->client = client; data->light_delay = MAX_DELAY; bShutdown = false; i2c_set_clientdata(client, data); sensor_power_on_vdd(data, 1); value = 0x00; err = gp2a_i2c_write(data, (u8) (COMMAND1), &value); if (err < 0) { pr_err("%s failed : threre is no such device.\n", __func__); goto i2c_fail_err; } data->light_input_dev = input_allocate_device(); if (!data->light_input_dev) { pr_err("%s input_allocate_device error\n", __func__); err = -ENOMEM; goto input_allocate_light_device_err; } data->light_input_dev->name = "light_sensor"; input_set_capability(data->light_input_dev, EV_REL, REL_MAX); input_set_capability(data->light_input_dev, EV_REL, REL_MISC); input_set_drvdata(data->light_input_dev, data); err = input_register_device(data->light_input_dev); if (err < 0) { pr_err("%s input_register_device light error\n", __func__); goto input_register_device_err; } err = sensors_create_symlink(&data->light_input_dev->dev.kobj, data->light_input_dev->name); if (err < 0) { pr_err("%s sensors_create_symlink light error\n", __func__); goto sensors_create_symlink_err; } err = sysfs_create_group(&data->light_input_dev->dev.kobj, &gp2a_light_attribute_group); if (err) { pr_err("%s sysfs_create_group light error\n", __func__); goto sysfs_create_group_light_err; } err = gp2a_setup_irq(data); if (err) { pr_err("%s: could not setup irq\n", __func__); goto err_setup_irq; } data->prox_input_dev = input_allocate_device(); if (!data->prox_input_dev) { pr_err("%s input_allocate_device error\n", __func__); err = -ENOMEM; goto input_allocate_prox_device_err; } data->prox_input_dev->name = "proximity_sensor"; input_set_capability(data->prox_input_dev, EV_ABS, ABS_DISTANCE); input_set_capability(data->prox_input_dev, EV_ABS, ABS_MAX); input_set_abs_params(data->prox_input_dev, ABS_DISTANCE, 0, 1, 0, 0); input_set_abs_params(data->prox_input_dev, ABS_MAX, 0, 1, 0, 0); input_set_drvdata(data->prox_input_dev, data); err = input_register_device(data->prox_input_dev); if (err < 0) { pr_err("%s input_register_device prox error\n", __func__); goto input_register_prox_device_err; } err = sensors_create_symlink(&data->prox_input_dev->dev.kobj, data->prox_input_dev->name); if (err < 0) { pr_err("%s sensors_create_symlink light error\n", __func__); goto sensors_create_symlink_light_err; } err = sysfs_create_group(&data->prox_input_dev->dev.kobj, &gp2a_prox_attribute_group); if (err) { pr_err("%s sysfs_create_group prox error\n", __func__); goto sysfs_create_group_prox_err; } err = sensors_register(data->light_sensor_device, data, light_sensor_attrs, "light_sensor"); if (err) { pr_err("%s: cound not register prox sensor device(%d).\n", __func__, err); goto sensors_register_light_err; } err = sensors_register(data->prox_sensor_device, data, prox_sensor_attrs, "proximity_sensor"); if (err) { pr_err("%s: cound not register prox sensor device(%d).\n", __func__, err); goto sensors_register_prox_err; } mutex_init(&data->light_mutex); mutex_init(&data->data_mutex); INIT_DELAYED_WORK(&data->light_work, gp2a_work_func_light); wake_lock_init(&data->prx_wake_lock, WAKE_LOCK_SUSPEND, "prx_wake_lock"); INIT_WORK(&data->proximity_work, gp2a_work_func_prox); INIT_DELAYED_WORK(&data->prox_avg_work, gp2a_work_avg_prox); goto done; mutex_destroy(&data->light_mutex); mutex_destroy(&data->data_mutex); sensors_unregister(data->prox_sensor_device, prox_sensor_attrs); sensors_register_prox_err: sensors_unregister(data->light_sensor_device, light_sensor_attrs); sensors_register_light_err: sysfs_remove_group(&data->prox_input_dev->dev.kobj, &gp2a_prox_attribute_group); sysfs_create_group_prox_err: sensors_remove_symlink(&data->prox_input_dev->dev.kobj, data->prox_input_dev->name); sensors_create_symlink_err: input_unregister_device(data->prox_input_dev); input_register_prox_device_err: input_free_device(data->prox_input_dev); input_allocate_prox_device_err: gpio_free(data->gpio); err_setup_irq: sysfs_remove_group(&data->light_input_dev->dev.kobj, &gp2a_light_attribute_group); sysfs_create_group_light_err: sensors_remove_symlink(&data->light_input_dev->dev.kobj, data->light_input_dev->name); sensors_create_symlink_light_err: input_unregister_device(data->light_input_dev); input_register_device_err: input_free_device(data->light_input_dev); input_allocate_light_device_err: i2c_fail_err: gp2a_parse_dt_err: sensor_power_on_vdd(data, 0); kfree(data); bShutdown = true; done: return err; }
static int gp2a_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = 0; struct input_dev *input_dev; struct gp2a_data *gp2a; struct gp2a_platform_data *pdata = client->dev.platform_data; pr_info("%s, start\n", __func__); ret = gp2a_regulator_onoff(&client->dev, true); if (ret) { pr_err("%s, Power Up Failed\n", __func__); return ret; } if (client->dev.of_node) { pdata = devm_kzalloc(&client->dev, sizeof(struct gp2a_platform_data), GFP_KERNEL); if (!pdata) { pr_err("%s,Failed to allocate memory\n", __func__); return -ENOMEM; } ret = gp2a_parse_dt(&client->dev, pdata); if (ret < 0) return ret; ret = gp2a_request_gpio(pdata); if (ret < 0) return ret; } if (!pdata) { pr_err("%s,missing pdata\n", __func__); return -ENOMEM; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s,i2c functionality failed\n", __func__); return -ENOMEM; } gp2a = kzalloc(sizeof(struct gp2a_data), GFP_KERNEL); if (!gp2a) { pr_err("%s,failed memory alloc\n", __func__); return -ENOMEM; } gp2a->pdata = pdata; gp2a->i2c_client = client; i2c_set_clientdata(client, gp2a); wake_lock_init(&gp2a->prx_wake_lock, WAKE_LOCK_SUSPEND, "prx_wake_lock"); mutex_init(&gp2a->power_lock); input_dev = input_allocate_device(); if (!input_dev) { pr_err("%s,could not allocate input device\n", __func__); goto err_input_allocate_device_proximity; } gp2a->input = input_dev; 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); input_set_drvdata(input_dev, gp2a); ret = input_register_device(input_dev); if (ret < 0) { pr_err("%s,could not register input device\n", __func__); goto err_input_register_device_proximity; } ret = sensors_create_symlink(&input_dev->dev.kobj, input_dev->name); if (ret < 0) { pr_err("%s,create sysfs symlink error\n", __func__); goto err_sysfs_create_symlink_proximity; } ret = sysfs_create_group(&input_dev->dev.kobj, &proximity_attribute_group); if (ret) { pr_err("%s,create sysfs group error\n", __func__); goto err_sysfs_create_group_proximity; } INIT_WORK(&gp2a->work_prox, gp2a_prox_work_func); gp2a_leda_onoff(gp2a, 1); ret = gp2a_setup_irq(gp2a); if (ret) { pr_err("%s,could not setup irq\n", __func__); goto err_setup_irq; } gp2a_leda_onoff(gp2a, 0); ret = sensors_register(gp2a->dev, gp2a, proxi_attrs, "proximity_sensor"); if (ret < 0) { pr_info("%s,could not sensors_register\n", __func__); goto exit_gp2a_sensors_register; } pr_info("%s done\n", __func__); goto done; exit_gp2a_sensors_register: free_irq(gp2a->irq, gp2a); gpio_free(gp2a->pdata->p_out); err_setup_irq: gp2a_leda_onoff(gp2a, 0); sysfs_remove_group(&gp2a->input->dev.kobj, &proximity_attribute_group); err_sysfs_create_group_proximity: sensors_remove_symlink(&gp2a->input->dev.kobj, gp2a->input->name); err_sysfs_create_symlink_proximity: input_unregister_device(gp2a->input); err_input_register_device_proximity: input_free_device(input_dev); err_input_allocate_device_proximity: mutex_destroy(&gp2a->power_lock); wake_lock_destroy(&gp2a->prx_wake_lock); kfree(gp2a); done: gp2a_regulator_onoff(&client->dev, false); return ret; }
static int bma280_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = -ENODEV, i; struct bma280_p *data = NULL; pr_info("##########################################################\n"); pr_info("[SENSOR]: %s - Probe Start!\n", __func__); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("[SENSOR]: %s - i2c_check_functionality error\n", __func__); goto exit; } data = kzalloc(sizeof(struct bma280_p), GFP_KERNEL); if (data == NULL) { pr_err("[SENSOR]: %s - kzalloc error\n", __func__); ret = -ENOMEM; goto exit_kzalloc; } ret = bma280_parse_dt(data, client->dev.platform_data); if (ret < 0) { pr_err("[SENSOR]: %s - of_node error\n", __func__); ret = -ENODEV; goto exit_of_node; } ret = bma280_setup_pin(data); if (ret < 0) { pr_err("[SENSOR]: %s - could not setup pin\n", __func__); goto exit_setup_pin; } i2c_set_clientdata(client, data); data->client = client; mutex_init(&data->mode_mutex); wake_lock_init(&data->reactive_wake_lock, WAKE_LOCK_SUSPEND, "reactive_wake_lock"); /* read chip id */ for (i = 0; i < CHIP_ID_RETRIES; i++) { ret = i2c_smbus_read_word_data(client, BMA280_CHIP_ID_REG); if ((ret & 0x00ff) != BMA280_CHIP_ID) { pr_err("[SENSOR]: %s - chip id failed 0x%x\n", __func__, (unsigned int)ret & 0x00ff); } else { pr_info("[SENSOR]: %s - chip id success 0x%x\n", __func__, (unsigned int)ret & 0x00ff); break; } msleep(20); } if (i >= CHIP_ID_RETRIES) { ret = -ENODEV; goto exit_read_chipid; } /* input device init */ ret = bma280_input_init(data); if (ret < 0) goto exit_input_init; sensors_register(data->factory_device, data, sensor_attrs, MODULE_NAME); /* accel_timer settings. we poll for light values using a timer. */ hrtimer_init(&data->accel_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); data->poll_delay = ns_to_ktime(BMA280_DEFAULT_DELAY); data->accel_timer.function = bma280_timer_func; /* the timer just fires off a work queue request. we need a thread to read the i2c (can be slow and blocking). */ data->accel_wq = create_singlethread_workqueue("accel_wq"); if (!data->accel_wq) { ret = -ENOMEM; pr_err("[SENSOR]: %s - could not create workqueue\n", __func__); goto exit_create_workqueue; } /* this is the thread function we run on the work queue */ INIT_WORK(&data->work, bma280_work_func); INIT_DELAYED_WORK(&data->irq_work, bma280_irq_work_func); data->irq1 = gpio_to_irq(data->acc_int1); ret = request_threaded_irq(data->irq1, NULL, bma280_irq_thread, IRQF_TRIGGER_RISING | IRQF_ONESHOT, "bma280_accel", data); if (ret < 0) { pr_err("[SENSOR]: %s - can't allocate irq.\n", __func__); goto exit_request_threaded_irq; } disable_irq(data->irq1); atomic_set(&data->enable, OFF); data->time_count = 0; data->irq_state = 0; data->recog_flag = OFF; bma280_set_bandwidth(data, BMA280_BW_125HZ); bma280_set_range(data, BMA280_RANGE_2G); bma280_set_mode(data, BMA280_MODE_SUSPEND); pr_info("[SENSOR]: %s - Probe done!(chip pos : %d)\n", __func__, data->chip_pos); return 0; exit_request_threaded_irq: exit_create_workqueue: sensors_unregister(data->factory_device, sensor_attrs); sensors_remove_symlink(&data->input->dev.kobj, data->input->name); sysfs_remove_group(&data->input->dev.kobj, &bma280_attribute_group); input_unregister_device(data->input); exit_input_init: exit_read_chipid: mutex_destroy(&data->mode_mutex); wake_lock_destroy(&data->reactive_wake_lock); gpio_free(data->acc_int1); exit_setup_pin: exit_of_node: kfree(data); exit_kzalloc: exit: pr_err("[SENSOR]: %s - Probe fail!\n", __func__); return ret; }
static int mlx90615_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = -ENODEV; struct mlx90615_data *mlx90615 = NULL; pr_info("[BODYTEMP] %s is called.\n", __func__); /* Check i2c functionality */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("[BODYTEMP] %s: i2c functionality check failed!\n", __func__); return ret; } mlx90615 = kzalloc(sizeof(struct mlx90615_data), GFP_KERNEL); if (!mlx90615) { pr_err("[BODYTEMP] %s: failed to alloc memory mlx90615_data\n", __func__); return -ENOMEM; } if (client-> dev.of_node) pr_info("[BODYTEMP] %s : of node\n", __func__); else { pr_err("[BODYTEMP] %s : no of node\n", __func__); goto err_setup_reg; } ret = mlx90615_parse_dt(&client->dev, mlx90615); if (ret) { pr_err("[BODYTEMP] %s : parse dt error\n", __func__); //goto err_parse_dt; } mlx90615->i2c_client = client; mlx90615->always_on = 0; i2c_set_clientdata(client, mlx90615); mutex_init(&mlx90615->power_lock); mutex_init(&mlx90615->read_lock); #if 0 /* Check if the device is there or not. */ ret = i2c_master_send(mlx90615->i2c_client, CMD_READ_ID_REG, MLX90615_CMD_LENGTH); if (ret < 0) { pr_err("[BODYTEMP] %s: failed i2c_master_send (err = %d)\n", __func__, ret); /* goto err_i2c_master_send;*/ } #endif /* allocate mlx90615 input_device */ mlx90615->input = input_allocate_device(); if (!mlx90615->input) { pr_err("[BODYTEMP] %s: could not allocate input device\n", __func__); goto err_input_allocate_device; } mlx90615->input->name = "bodytemp_sensor"; input_set_capability(mlx90615->input, EV_REL, EVENT_TYPE_AMBIENT_TEMP); input_set_capability(mlx90615->input, EV_REL, EVENT_TYPE_OBJECT_TEMP); input_set_drvdata(mlx90615->input, mlx90615); ret = input_register_device(mlx90615->input); if (ret < 0) { input_free_device(mlx90615->input); pr_err("[BODYTEMP] %s: could not register input device\n", __func__); goto err_input_register_device; } ret = sensors_create_symlink(&mlx90615->input->dev.kobj, mlx90615->input->name); if (ret < 0) { input_unregister_device(mlx90615->input); goto err_sysfs_create_symlink; } ret = sysfs_create_group(&mlx90615->input->dev.kobj, &mlx90615_attribute_group); if (ret) { pr_err("[BODYTEMP] %s: could not create sysfs group\n", __func__); goto err_sysfs_create_group; } ret = sensors_register(mlx90615->mlx90615_dev, mlx90615, bodytemp_sensor_attrs, "bodytemp_sensor"); if (ret) { pr_err("[BODYTEMP] %s: cound not register sensor device(%d).\n", __func__, ret); goto err_sysfs_create_symlink; } /* Timer settings. We poll for mlx90615 values using a timer. */ hrtimer_init(&mlx90615->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); mlx90615->poll_delay = ns_to_ktime(DEFAULT_DELAY * NSEC_PER_MSEC); mlx90615->timer.function = timer_func; /* Timer just fires off a work queue request. We need a thread to read the i2c (can be slow and blocking). */ mlx90615->mlx90615_wq = create_singlethread_workqueue("mlx90615_bidytemp_wq"); if (!mlx90615->mlx90615_wq) { ret = -ENOMEM; pr_err("[BODYTEMP] %s: could not create mlx90615 workqueue\n", __func__); goto err_create_workqueue; } /* This is the thread function we run on the work queue */ INIT_WORK(&mlx90615->work_mlx90615, mlx90615_work_func); pr_info("[BODYTEMP] %s is success.\n", __func__); goto done; err_create_workqueue: sysfs_remove_group(&mlx90615->input->dev.kobj, &mlx90615_attribute_group); /* sensors_classdev_unregister(mlx90615->mlx90615_dev);*/ destroy_workqueue(mlx90615->mlx90615_wq); err_sysfs_create_group: input_unregister_device(mlx90615->input); err_sysfs_create_symlink: sensors_remove_symlink(&mlx90615->input->dev.kobj, mlx90615->input->name); err_input_register_device: err_input_allocate_device: mutex_destroy(&mlx90615->read_lock); mutex_destroy(&mlx90615->power_lock); err_setup_reg: //err_parse_dt: kfree(mlx90615); done: return ret; }