static int mma8451_remove(struct i2c_client *client) { int ret; ret = mma8451_stop_chip(client); if (client_id == FXOS8700_ID) { input_unregister_polled_device(fxos8700_m_idev); input_free_polled_device(fxos8700_m_idev); } input_unregister_polled_device(mma8451_idev); input_free_polled_device(mma8451_idev); hwmon_device_unregister(hwmon_dev); return ret; }
static void __exit peaq_wmi_exit(void) { if (!wmi_has_guid(PEAQ_DOLBY_BUTTON_GUID)) return; input_unregister_polled_device(peaq_poll_dev); }
static void pega_accel_exit(struct asus_laptop *asus) { if (asus->pega_accel_poll) { input_unregister_polled_device(asus->pega_accel_poll); input_free_polled_device(asus->pega_accel_poll); } asus->pega_accel_poll = NULL; }
/* Call with ams_info.lock held! */ static void ams_input_disable(void) { if (ams_info.idev) { input_unregister_polled_device(ams_info.idev); input_free_polled_device(ams_info.idev); ams_info.idev = NULL; } }
static int rb532_button_remove(struct platform_device *pdev) { struct input_polled_dev *poll_dev = dev_get_drvdata(&pdev->dev); input_unregister_polled_device(poll_dev); input_free_polled_device(poll_dev); return 0; }
static void __exit light_sensor_exit(void) { input_unregister_polled_device(light_sensor_idev); input_free_polled_device(light_sensor_idev); sysfs_remove_group(&pdev->dev.kobj, &light_sensor_attribute_group); platform_device_unregister(pdev); platform_driver_unregister(&light_sensor_driver); printk(KERN_INFO "light_sensor: driver unloaded.\n"); }
void lis3lv02d_joystick_disable(void) { if (!lis3_dev.idev) return; if (lis3_dev.irq) misc_deregister(&lis3lv02d_misc_device); input_unregister_polled_device(lis3_dev.idev); lis3_dev.idev = NULL; }
static void __exit hdaps_exit(void) { input_unregister_polled_device(hdaps_idev); input_free_polled_device(hdaps_idev); sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group); platform_device_unregister(pdev); platform_driver_unregister(&hdaps_driver); release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS); printk(KERN_INFO "hdaps: driver unloaded.\n"); }
static void __exit ScalarPolicy_exit(void) { input_unregister_polled_device(ScalarPolicy_dev); misc_deregister(&misc_scalar_dev); platform_driver_unregister(&scalar_plfdevice_driver); ScalarPolicy_dev = NULL; printk ("Goodbey linux_driver_module\n"); }
static int stmp3xxx_rotdec_remove(struct platform_device *pdev) { input_unregister_polled_device(rotdec); input_free_polled_device(rotdec); rotdec_pinmux_free(); /* restore original register state */ HW_TIMROT_ROTCTRL_WR(rotctrl); return 0; }
static void __exit alps_exit(void) { misc_deregister(&alps_device); pr_info("alps-exit: misc_deregister\n"); input_unregister_polled_device(alps_idev); pr_info("alps-exit: input_unregister_polled_device\n"); input_free_polled_device(alps_idev); pr_info("alps-exit: input_free_polled_device\n"); sysfs_remove_group(&pdev->dev.kobj, &alps_attribute_group); pr_info("alps-exit: sysfs_remove_group\n"); platform_device_unregister(pdev); pr_info("alps-exit: platform_device_unregister\n"); platform_driver_unregister(&alps_driver); pr_info("alps-exit: platform_driver_unregister\n"); }
void lis3lv02d_joystick_disable(void) { if (lis3_dev.irq) free_irq(lis3_dev.irq, &lis3_dev); if (lis3_dev.pdata && lis3_dev.pdata->irq2) free_irq(lis3_dev.pdata->irq2, &lis3_dev); if (!lis3_dev.idev) return; if (lis3_dev.irq) misc_deregister(&lis3lv02d_misc_device); input_unregister_polled_device(lis3_dev.idev); input_free_polled_device(lis3_dev.idev); lis3_dev.idev = NULL; }
static void __exit alps_exit(void) { printk(KERN_INFO "[ALPS] alps_exit\n"); misc_deregister(&alps_device); printk(KERN_INFO "[ALPS] misc_deregister\n"); input_unregister_polled_device(alps_idev); printk(KERN_INFO "[ALPS] input_unregister_polled_device\n"); input_free_polled_device(alps_idev); printk(KERN_INFO "[ALPS] input_free_polled_device\n"); sysfs_remove_group(&pdev->dev.kobj, &alps_attribute_group); printk(KERN_INFO "[ALPS] sysfs_remove_group\n"); platform_device_unregister(pdev); printk(KERN_INFO "[ALPS] platform_device_unregister\n"); platform_driver_unregister(&alps_driver); printk(KERN_INFO "[ALPS] platform_driver_unregister\n"); }
static void __exit alps_exit(void) { alps_info("is called\n"); #ifdef CONFIG_HAS_EARLYSUSPEND unregister_early_suspend(&alps_early_suspend_handler); alps_dbgmsg("early_suspend_unregister\n"); #endif misc_deregister(&alps_device); alps_dbgmsg("misc_deregister\n"); input_unregister_polled_device(alps_idev); alps_dbgmsg("input_unregister_polled_device\n"); input_free_polled_device(alps_idev); alps_dbgmsg("input_free_polled_device\n"); platform_device_unregister(pdev); alps_dbgmsg("platform_device_unregister\n"); platform_driver_unregister(&alps_driver); alps_dbgmsg("platform_driver_unregister\n"); }
static int mag3110_remove(struct i2c_client *client) { struct mag3110_data *data; int ret; data = i2c_get_clientdata(client); data->ctl_reg1 = mag3110_read_reg(client, MAG3110_CTRL_REG1); ret = mag3110_write_reg(client, MAG3110_CTRL_REG1, data->ctl_reg1 & ~MAG3110_AC_MASK); free_irq(client->irq, data); input_unregister_polled_device(data->poll_dev); input_free_polled_device(data->poll_dev); hwmon_device_unregister(data->hwmon_dev); sysfs_remove_group(&client->dev.kobj, &mag3110_attr_group); kfree(data); mag3110_pdata = NULL; return ret; }
/** * Remove implementation * @param i2c I2C client * @return 0 in success, or negative error code */ static int accel_remove(struct i2c_client *i2c) { u8 buf[2] = {ACCEL_I2C_PORT_REG1, 0x0}; /* complete all scheduled work */ flush_scheduled_work (); /* remove irq handler */ if (accel_info.irq1 > 0) { free_irq (accel_info.irq1, &accel_info); /* release GPIOs */ gpio_free (accel_gpio_one); } #ifdef ACCEL_DATA_READY_IRQ if (accel_info.irq2 > 0) { free_irq (accel_info.irq2, &accel_info); /* release GPIOs */ gpio_free (accel_gpio_two); } #endif /* power down accelerometer */ i2c_master_send (i2c, buf, 2); sysfs_remove_group (&i2c->dev.kobj, &accel_defattr_group); if (accel_info.idev) { input_unregister_polled_device (accel_info.ipdev); input_free_polled_device (accel_info.ipdev); } misc_deregister (&accel_misc_driver); /* platform_device_del (accel_platform_device); device_remove_file (&accel_platform_device->dev, ); */ vprintk ("driver exited"); return 0; }
static int __devinit mag3110_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter; struct input_dev *idev; struct mag3110_data *data; int ret = 0; adapter = to_i2c_adapter(client->dev.parent); if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK)) return -EIO; dev_info(&client->dev, "check mag3110 chip ID\n"); ret = mag3110_read_reg(client, MAG3110_WHO_AM_I); if (MAG3110_ID != ret) { dev_err(&client->dev, "read chip ID 0x%x is not equal to 0x%x!\n", ret, MAG3110_ID); return -EINVAL; } data = kzalloc(sizeof(struct mag3110_data), GFP_KERNEL); if (!data) return -ENOMEM; data->client = client; i2c_set_clientdata(client, data); /* Init queue */ init_waitqueue_head(&data->waitq); data->hwmon_dev = hwmon_device_register(&client->dev); if (IS_ERR(data->hwmon_dev)) { dev_err(&client->dev, "hwmon register failed!\n"); ret = PTR_ERR(data->hwmon_dev); goto error_rm_dev_sysfs; } /*input poll device register */ data->poll_dev = input_allocate_polled_device(); if (!data->poll_dev) { dev_err(&client->dev, "alloc poll device failed!\n"); ret = -ENOMEM; goto error_rm_hwmon_dev; } data->poll_dev->poll = mag3110_dev_poll; data->poll_dev->poll_interval = POLL_INTERVAL; data->poll_dev->poll_interval_max = POLL_INTERVAL_MAX; idev = data->poll_dev->input; idev->name = MAG3110_DRV_NAME; idev->id.bustype = BUS_I2C; idev->evbit[0] = BIT_MASK(EV_ABS); input_set_abs_params(idev, ABS_X, -15000, 15000, 0, 0); input_set_abs_params(idev, ABS_Y, -15000, 15000, 0, 0); input_set_abs_params(idev, ABS_Z, -15000, 15000, 0, 0); ret = input_register_polled_device(data->poll_dev); if (ret) { dev_err(&client->dev, "register poll device failed!\n"); goto error_free_poll_dev; } /*create device group in sysfs as user interface */ ret = sysfs_create_group(&idev->dev.kobj, &mag3110_attr_group); if (ret) { dev_err(&client->dev, "create device file failed!\n"); ret = -EINVAL; goto error_rm_poll_dev; } /* set irq type to edge rising */ #if MAG3110_IRQ_USED ret = request_irq(client->irq, mag3110_irq_handler, IRQF_TRIGGER_RISING, client->dev.driver->name, idev); if (ret < 0) { dev_err(&client->dev, "failed to register irq %d!\n", client->irq); goto error_rm_dev_sysfs; } #endif /* Initialize mag3110 chip */ mag3110_init_client(client); mag3110_pdata = data; mag3110_pdata->active = MAG_STANDBY; mag3110_pdata->position = *(int *)client->dev.platform_data; dev_info(&client->dev, "mag3110 is probed\n"); return 0; error_rm_dev_sysfs: sysfs_remove_group(&client->dev.kobj, &mag3110_attr_group); error_rm_poll_dev: input_unregister_polled_device(data->poll_dev); error_free_poll_dev: input_free_polled_device(data->poll_dev); error_rm_hwmon_dev: hwmon_device_unregister(data->hwmon_dev); kfree(data); mag3110_pdata = NULL; return ret; }
static int mag3110_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter; struct input_dev *idev; struct mag3110_data *data; int ret = 0; struct regulator *vdd, *vdd_io; u32 pos = 0; struct device_node *of_node = client->dev.of_node; #if MAG3110_IRQ_USED struct irq_data *irq_data = irq_get_irq_data(client->irq); u32 irq_flag; bool shared_irq = of_property_read_bool(of_node, "shared-interrupt"); #endif vdd = NULL; vdd_io = NULL; vdd = devm_regulator_get(&client->dev, "vdd"); if (!IS_ERR(vdd)) { ret = regulator_enable(vdd); if (ret) { dev_err(&client->dev, "vdd set voltage error\n"); return ret; } } vdd_io = devm_regulator_get(&client->dev, "vddio"); if (!IS_ERR(vdd_io)) { ret = regulator_enable(vdd_io); if (ret) { dev_err(&client->dev, "vddio set voltage error\n"); return ret; } } adapter = to_i2c_adapter(client->dev.parent); if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK)) return -EIO; dev_info(&client->dev, "check mag3110 chip ID\n"); ret = mag3110_read_reg(client, MAG3110_WHO_AM_I); if (MAG3110_ID != ret) { dev_err(&client->dev, "read chip ID 0x%x is not equal to 0x%x!\n", ret, MAG3110_ID); return -EINVAL; } data = kzalloc(sizeof(struct mag3110_data), GFP_KERNEL); if (!data) return -ENOMEM; data->client = client; i2c_set_clientdata(client, data); /* Init queue */ init_waitqueue_head(&data->waitq); data->hwmon_dev = hwmon_device_register(&client->dev); if (IS_ERR(data->hwmon_dev)) { dev_err(&client->dev, "hwmon register failed!\n"); ret = PTR_ERR(data->hwmon_dev); goto error_rm_dev_sysfs; } /*input poll device register */ data->poll_dev = input_allocate_polled_device(); if (!data->poll_dev) { dev_err(&client->dev, "alloc poll device failed!\n"); ret = -ENOMEM; goto error_rm_hwmon_dev; } data->poll_dev->poll = mag3110_dev_poll; data->poll_dev->poll_interval = POLL_INTERVAL; data->poll_dev->poll_interval_max = POLL_INTERVAL_MAX; idev = data->poll_dev->input; idev->name = MAG3110_DRV_NAME; idev->id.bustype = BUS_I2C; idev->evbit[0] = BIT_MASK(EV_ABS); input_set_abs_params(idev, ABS_X, -15000, 15000, 0, 0); input_set_abs_params(idev, ABS_Y, -15000, 15000, 0, 0); input_set_abs_params(idev, ABS_Z, -15000, 15000, 0, 0); ret = input_register_polled_device(data->poll_dev); if (ret) { dev_err(&client->dev, "register poll device failed!\n"); goto error_free_poll_dev; } /*create device group in sysfs as user interface */ ret = sysfs_create_group(&idev->dev.kobj, &mag3110_attr_group); if (ret) { dev_err(&client->dev, "create device file failed!\n"); ret = -EINVAL; goto error_rm_poll_dev; } #if MAG3110_IRQ_USED irq_flag = irqd_get_trigger_type(irq_data); irq_flag |= IRQF_ONESHOT; if (shared_irq) irq_flag |= IRQF_SHARED; ret = request_threaded_irq(client->irq, NULL, mag3110_irq_handler, irq_flag, client->dev.driver->name, idev); if (ret < 0) { dev_err(&client->dev, "failed to register irq %d!\n", client->irq); goto error_rm_dev_sysfs; } #endif /* Initialize mag3110 chip */ mag3110_init_client(client); mag3110_pdata = data; mag3110_pdata->active = MAG_STANDBY; ret = of_property_read_u32(of_node, "position", &pos); if (ret) pos = DEFAULT_POSITION; mag3110_pdata->position = (int)pos; dev_info(&client->dev, "mag3110 is probed\n"); return 0; error_rm_dev_sysfs: sysfs_remove_group(&client->dev.kobj, &mag3110_attr_group); error_rm_poll_dev: input_unregister_polled_device(data->poll_dev); error_free_poll_dev: input_free_polled_device(data->poll_dev); error_rm_hwmon_dev: hwmon_device_unregister(data->hwmon_dev); kfree(data); mag3110_pdata = NULL; return ret; }
static int __init alps_init(void) { int ret; alps_info("is called\n"); ret = platform_driver_register(&alps_driver); if (ret) goto out_region; alps_dbgmsg("platform_driver_register\n"); pdev = platform_device_register_simple("alps_compass", -1, NULL, 0); if (IS_ERR(pdev)) { ret = PTR_ERR(pdev); goto out_driver; } alps_dbgmsg("platform_device_register_simple\n"); alps_idev = input_allocate_polled_device(); if (!alps_idev) { ret = -ENOMEM; goto out_device; } alps_dbgmsg("input_allocate_polled_device\n"); alps_idev->poll = alps_poll; alps_idev->poll_interval = ALPS_POLL_INTERVAL; /* initialize the input class */ idev = alps_idev->input; idev->name = "magnetic_sensor"; //idev->phys = "alps_compass/input0"; idev->id.bustype = BUS_I2C; //idev->dev.parent = &pdev->dev; //idev->evbit[0] = BIT_MASK(EV_ABS); set_bit(EV_REL, idev->evbit); input_set_capability(idev, EV_REL, REL_X); input_set_capability(idev, EV_REL, REL_Y); input_set_capability(idev, EV_REL, REL_Z); #if 0//defined(MAG_15BIT) input_set_abs_params(idev, EVENT_TYPE_MAGV_X, -16384, 16383, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT); input_set_abs_params(idev, EVENT_TYPE_MAGV_Y, -16384, 16383, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT); input_set_abs_params(idev, EVENT_TYPE_MAGV_Z, -16384, 16383, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT); //#elif defined(MAG_13BIT) input_set_abs_params(idev, EVENT_TYPE_MAGV_X, -4096, 4095, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT); input_set_abs_params(idev, EVENT_TYPE_MAGV_Y, -4096, 4095, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT); input_set_abs_params(idev, EVENT_TYPE_MAGV_Z, -4096, 4095, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT); #endif ret = input_register_polled_device(alps_idev); if (ret) goto out_alc_poll; alps_dbgmsg("input_register_polled_device\n"); ret = misc_register(&alps_device); if (ret) { alps_info("alps_io_device register failed\n"); goto out_reg_poll; } alps_dbgmsg("misc_register\n"); ret = sysfs_create_group(&idev->dev.kobj, &magnetic_attribute_group); #if defined(CONFIG_SENSOR_USE_SYMLINK) ret = sensors_initialize_symlink(alps_idev->input); if (ret < 0) { pr_err("%s: apls_sensors_initialize_symlink error(%d).\n", __func__, ret); goto out_reg_poll; } #endif #ifdef CONFIG_HAS_EARLYSUSPEND register_early_suspend(&alps_early_suspend_handler); alps_dbgmsg("register_early_suspend\n"); #endif mutex_lock(&alps_lock); flg_suspend = 0; mutex_unlock(&alps_lock); return 0; out_reg_poll: input_unregister_polled_device(alps_idev); alps_info("input_unregister_polled_device\n"); out_alc_poll: input_free_polled_device(alps_idev); alps_info("input_free_polled_device\n"); out_device: platform_device_unregister(pdev); alps_info("platform_device_unregister\n"); out_driver: platform_driver_unregister(&alps_driver); alps_info("platform_driver_unregister\n"); out_region: return ret; }
static int mma8451_probe(struct i2c_client *client, const struct i2c_device_id *id) { int result; struct input_dev *idev; struct i2c_adapter *adapter; u32 pos; struct device_node *of_node = client->dev.of_node; struct regulator *vdd, *vdd_io; mma8451_i2c_client = client; vdd = devm_regulator_get(&client->dev, "vdd"); if (!IS_ERR(vdd)) { result = regulator_enable(vdd); if (result) { dev_err(&client->dev, "vdd set voltage error\n"); return result; } } vdd_io = devm_regulator_get(&client->dev, "vddio"); if (!IS_ERR(vdd_io)) { result = regulator_enable(vdd_io); if (result) { dev_err(&client->dev, "vddio set voltage error\n"); return result; } } adapter = to_i2c_adapter(client->dev.parent); result = i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA); if (!result) goto err_out; client_id = i2c_smbus_read_byte_data(client, MMA8451_WHO_AM_I); if (client_id != MMA8451_ID && client_id != MMA8452_ID && client_id != MMA8453_ID && client_id != FXOS8700_ID) { dev_err(&client->dev, "read chip ID 0x%x is not equal to 0x%x,0x%x,0x%x!\n", result, MMA8451_ID, MMA8452_ID, FXOS8700_ID); result = -EINVAL; goto err_out; } /* Initialize the MMA8451 chip */ result = mma8451_change_mode(client, senstive_mode); if (result) { dev_err(&client->dev, "error when init mma8451 chip:(%d)\n", result); goto err_out; } hwmon_dev = hwmon_device_register(&client->dev); if (!hwmon_dev) { result = -ENOMEM; dev_err(&client->dev, "error when register hwmon device\n"); goto err_out; } /* create a polled input device for accelerometer */ mma8451_idev = input_allocate_polled_device(); if (!mma8451_idev) { result = -ENOMEM; dev_err(&client->dev, "alloc poll device failed!\n"); goto err_register_polled_device; } mma8451_idev->poll = mma8451_dev_poll; mma8451_idev->poll_interval = POLL_INTERVAL; mma8451_idev->poll_interval_min = POLL_INTERVAL_MIN; mma8451_idev->poll_interval_max = POLL_INTERVAL_MAX; idev = mma8451_idev->input; if (client_id == FXOS8700_ID) idev->name = "mma845x_a"; else idev->name = "mma845x"; idev->id.bustype = BUS_I2C; idev->evbit[0] = BIT_MASK(EV_ABS); input_set_abs_params(idev, ABS_X, -8192, 8191, INPUT_FUZZ, INPUT_FLAT); input_set_abs_params(idev, ABS_Y, -8192, 8191, INPUT_FUZZ, INPUT_FLAT); input_set_abs_params(idev, ABS_Z, -8192, 8191, INPUT_FUZZ, INPUT_FLAT); result = input_register_polled_device(mma8451_idev); if (result) { dev_err(&client->dev, "register poll device failed!\n"); goto err_register_polled_device; } result = sysfs_create_group(&idev->dev.kobj, &mma8451_attr_group); if (result) { dev_err(&client->dev, "create device file failed!\n"); result = -EINVAL; goto err_register_polled_device; } /* create a polled input device for magnetometer */ if (client_id == FXOS8700_ID) { fxos8700_m_idev = input_allocate_polled_device(); if (!fxos8700_m_idev) { result = -ENOMEM; dev_err(&client->dev, "alloc poll device failed!\n"); goto err_alloc_poll_device; } fxos8700_m_idev->poll = mma8451_dev_poll; fxos8700_m_idev->poll_interval = POLL_INTERVAL; fxos8700_m_idev->poll_interval_min = POLL_INTERVAL_MIN; fxos8700_m_idev->poll_interval_max = POLL_INTERVAL_MAX; idev = fxos8700_m_idev->input; idev->name = "fxos8700_m"; idev->id.bustype = BUS_I2C; idev->evbit[0] = BIT_MASK(EV_ABS); input_set_abs_params(idev, ABS_X, -8192, 8191, INPUT_FUZZ, INPUT_FLAT); input_set_abs_params(idev, ABS_Y, -8192, 8191, INPUT_FUZZ, INPUT_FLAT); input_set_abs_params(idev, ABS_Z, -8192, 8191, INPUT_FUZZ, INPUT_FLAT); result = input_register_polled_device(fxos8700_m_idev); if (result) { dev_err(&client->dev, "register poll device failed!\n"); goto err_register_polled_device1; } result = sysfs_create_group(&idev->dev.kobj, &mma8451_attr_group); if (result) { dev_err(&client->dev, "create device file failed!\n"); result = -EINVAL; goto err_create_sysfs1; } } result = of_property_read_u32(of_node, "position", &pos); if (result) pos = DEFAULT_POSITION; mma_status.position = (int)pos; return 0; err_create_sysfs1: input_unregister_polled_device(fxos8700_m_idev); err_register_polled_device1: input_free_polled_device(fxos8700_m_idev); err_register_polled_device: input_free_polled_device(mma8451_idev); err_alloc_poll_device: hwmon_device_unregister(&client->dev); err_out: return result; }