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