/* * Copyright (C) 2012 Motorola, Inc. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * Adds ability to program periodic interrupts from user space that * can wake the phone out of low power modes. * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef CONFIG_DEBUG_FS #define MPU9150_DEBUG 1 #else #define MPU9150_DEBUG 0 #endif #define MPU9150_CLIENT_DRIVER_NAME "m4sensorhub_mpu9150" #define SENSOR_IRQ_ENABLE 1 #define SENSOR_IRQ_DISABLE 0 struct mpu9150_accel_data { int x; int y; int z; }; struct mpu9150_gyro_data { int rx; int ry; int rz; }; struct mpu9150_compass_data { int cx; int cy; int cz; int ca; }; enum mpu9150_sensor { TYPE_GYRO, TYPE_COMPASS, TYPE_ACCEL, NUM_TYPES, /* Leave as last element */ } sensor; struct mpu9150_client { struct m4sensorhub_data *m4sensorhub; struct input_dev *input_dev; signed short samplerate[NUM_TYPES]; signed short latest_samplerate[NUM_TYPES]; struct mpu9150_accel_data accel_data; struct mpu9150_gyro_data gyro_data; struct mpu9150_compass_data compass_data; struct mutex mutex; /* prevent concurrent thread access */ struct delayed_work mpu9150_work[NUM_TYPES]; signed short fastest_rate[NUM_TYPES]; }; struct mpu9150_client *misc_mpu9150_data; static int mpu9150_client_open(struct inode *inode, struct file *file) { int err = 0; err = nonseekable_open(inode, file); if (err < 0) { KDEBUG(M4SH_ERROR, "%s failed\n", __func__); return err; } file->private_data = misc_mpu9150_data; return 0; } static int mpu9150_client_close(struct inode *inode, struct file *file) { KDEBUG(M4SH_DEBUG, "mpu9150_client in %s\n", __func__); return 0; } static void m4_report_mpu9150_inputevent( struct mpu9150_client *mpu9150_client_data, enum mpu9150_sensor type) { switch (type) { case TYPE_GYRO: input_report_rel(mpu9150_client_data->input_dev, REL_RX, mpu9150_client_data->gyro_data.rx); input_report_rel(mpu9150_client_data->input_dev, REL_RY, mpu9150_client_data->gyro_data.ry); input_report_rel(mpu9150_client_data->input_dev, REL_RZ, mpu9150_client_data->gyro_data.rz); input_sync(mpu9150_client_data->input_dev); break; case TYPE_ACCEL: input_report_abs(mpu9150_client_data->input_dev, ABS_X, mpu9150_client_data->accel_data.x); input_report_abs(mpu9150_client_data->input_dev, ABS_Y, mpu9150_client_data->accel_data.y); input_report_abs(mpu9150_client_data->input_dev, ABS_Z, mpu9150_client_data->accel_data.z); input_sync(mpu9150_client_data->input_dev); break; case TYPE_COMPASS: input_report_rel(mpu9150_client_data->input_dev, REL_X, mpu9150_client_data->compass_data.cx); input_report_rel(mpu9150_client_data->input_dev, REL_Y, mpu9150_client_data->compass_data.cy); input_report_rel(mpu9150_client_data->input_dev, REL_Z, mpu9150_client_data->compass_data.cz); /* TODO : accuracy needs to be sent out through sysfs*/ input_sync(mpu9150_client_data->input_dev); break; default: break; } } static void m4_set_mpu9150_delay(struct mpu9150_client *mpu9150_client_data, int delay, enum mpu9150_sensor type) { struct mpu9150_client *dd = mpu9150_client_data; if ((delay >= 0) && (delay <= dd->fastest_rate[type])) delay = dd->fastest_rate[type]; dd->latest_samplerate[type] = delay; if (delay != dd->samplerate[type]) { switch (type) { case TYPE_GYRO: m4sensorhub_reg_write(dd->m4sensorhub, M4SH_REG_GYRO_SAMPLERATE, (char *)&delay, m4sh_no_mask); break; case TYPE_ACCEL: m4sensorhub_reg_write(dd->m4sensorhub, M4SH_REG_ACCEL_SAMPLERATE, (char *)&delay, m4sh_no_mask); break; case TYPE_COMPASS: m4sensorhub_reg_write(dd->m4sensorhub, M4SH_REG_COMPASS_SAMPLERATE, (char *)&delay, m4sh_no_mask); break; default: return; break; } KDEBUG(M4SH_DEBUG, "%s() updating samplerate for type %d from" " %d to %d\n", __func__, type, mpu9150_client_data->samplerate[type], delay); cancel_delayed_work(&(dd->mpu9150_work[type])); dd->samplerate[type] = delay; if (dd->samplerate[type] > 0) queue_delayed_work(system_freezable_wq, &(dd->mpu9150_work[type]), msecs_to_jiffies(delay)); } } static void m4_read_mpu9150_data(struct mpu9150_client *mpu9150_client_data, enum mpu9150_sensor type) { sCompassData compassdata; sAccelData acceldata; sGyroData gyrodata; switch (type) { case TYPE_GYRO: m4sensorhub_reg_read(mpu9150_client_data->m4sensorhub, M4SH_REG_GYRO_X, (char *)&gyrodata.x); m4sensorhub_reg_read(mpu9150_client_data->m4sensorhub, M4SH_REG_GYRO_Y, (char *)&gyrodata.y); m4sensorhub_reg_read(mpu9150_client_data->m4sensorhub, M4SH_REG_GYRO_Z, (char *)&gyrodata.z); mpu9150_client_data->gyro_data.rx = gyrodata.x; mpu9150_client_data->gyro_data.ry = gyrodata.y; mpu9150_client_data->gyro_data.rz = gyrodata.z; break; case TYPE_ACCEL: m4sensorhub_reg_read(mpu9150_client_data->m4sensorhub, M4SH_REG_ACCEL_X, (char *)&acceldata.x); m4sensorhub_reg_read(mpu9150_client_data->m4sensorhub, M4SH_REG_ACCEL_Y, (char *)&acceldata.y); m4sensorhub_reg_read(mpu9150_client_data->m4sensorhub, M4SH_REG_ACCEL_Z, (char *)&acceldata.z); mpu9150_client_data->accel_data.x = acceldata.x; mpu9150_client_data->accel_data.y = acceldata.y; mpu9150_client_data->accel_data.z = acceldata.z; break; case TYPE_COMPASS: m4sensorhub_reg_read(mpu9150_client_data->m4sensorhub, M4SH_REG_COMPASS_X, (char *)&compassdata.x); m4sensorhub_reg_read(mpu9150_client_data->m4sensorhub, M4SH_REG_COMPASS_Y, (char *)&compassdata.y); m4sensorhub_reg_read(mpu9150_client_data->m4sensorhub, M4SH_REG_COMPASS_Z, (char *)&compassdata.z); m4sensorhub_reg_read(mpu9150_client_data->m4sensorhub, M4SH_REG_COMPASS_ACCURACY, (char *)&compassdata.accuracy); mpu9150_client_data->compass_data.cx = compassdata.x; mpu9150_client_data->compass_data.cy = compassdata.y; mpu9150_client_data->compass_data.cz = compassdata.z; mpu9150_client_data->compass_data.ca = compassdata.accuracy; break; default: break; } } static void m4gyro_work_func(struct work_struct *work) { struct mpu9150_client *dd = container_of(work, struct mpu9150_client, mpu9150_work[TYPE_GYRO].work); signed short rate; mutex_lock(&(dd->mutex)); m4_read_mpu9150_data(dd, TYPE_GYRO); m4_report_mpu9150_inputevent(dd, TYPE_GYRO); rate = dd->samplerate[TYPE_GYRO]; if (rate > 0) queue_delayed_work(system_freezable_wq, &(dd->mpu9150_work[TYPE_GYRO]), msecs_to_jiffies(rate)); mutex_unlock(&(dd->mutex)); } static void m4accel_work_func(struct work_struct *work) { struct mpu9150_client *dd = container_of(work, struct mpu9150_client, mpu9150_work[TYPE_ACCEL].work); signed short rate; mutex_lock(&(dd->mutex)); m4_read_mpu9150_data(dd, TYPE_ACCEL); m4_report_mpu9150_inputevent(dd, TYPE_ACCEL); rate = dd->samplerate[TYPE_ACCEL]; if (rate > 0) queue_delayed_work(system_freezable_wq, &(dd->mpu9150_work[TYPE_ACCEL]), msecs_to_jiffies(rate)); mutex_unlock(&(dd->mutex)); } static void m4compass_work_func(struct work_struct *work) { struct mpu9150_client *dd = container_of(work, struct mpu9150_client, mpu9150_work[TYPE_COMPASS].work); signed short rate; mutex_lock(&(dd->mutex)); m4_read_mpu9150_data(dd, TYPE_COMPASS); m4_report_mpu9150_inputevent(dd, TYPE_COMPASS); rate = dd->samplerate[TYPE_COMPASS]; if (rate > 0) queue_delayed_work(system_freezable_wq, &(dd->mpu9150_work[TYPE_COMPASS]), msecs_to_jiffies(rate)); mutex_unlock(&(dd->mutex)); } static ssize_t m4_mpu9150_write_accel_setdelay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int scanresult, err; err = kstrtoint(buf, 10, &scanresult); if (err < 0) { KDEBUG(M4SH_ERROR, "%s: conversion failed\n", __func__); return err; } /* Input validation */ if (scanresult < -1) { KDEBUG( M4SH_ERROR, "%s() invalid input %d\n", __func__ , scanresult ); return -EINVAL; } mutex_lock(&(misc_mpu9150_data->mutex)); m4_set_mpu9150_delay(misc_mpu9150_data, scanresult, TYPE_ACCEL); mutex_unlock(&(misc_mpu9150_data->mutex)); return count; } static DEVICE_ATTR(accel_setdelay, S_IWUSR, NULL, m4_mpu9150_write_accel_setdelay); static ssize_t m4_mpu9150_write_gyro_setdelay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int scanresult, err; err = kstrtoint(buf, 10, &scanresult); if (err < 0) { KDEBUG(M4SH_ERROR, "%s: conversion failed\n", __func__); return err; } /* Input validation */ if (scanresult < -1) { KDEBUG( M4SH_ERROR, "%s() invalid input %d\n", __func__ , scanresult ); return -EINVAL; } mutex_lock(&(misc_mpu9150_data->mutex)); m4_set_mpu9150_delay(misc_mpu9150_data, scanresult, TYPE_GYRO); mutex_unlock(&(misc_mpu9150_data->mutex)); return count; } static DEVICE_ATTR(gyro_setdelay, S_IWUSR, NULL, m4_mpu9150_write_gyro_setdelay); static ssize_t m4_mpu9150_write_compass_setdelay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int scanresult, err; err = kstrtoint(buf, 10, &scanresult); if (err < 0) { KDEBUG(M4SH_ERROR, "%s: conversion failed\n", __func__); return err; } /* Input validation */ if (scanresult < -1) { KDEBUG( M4SH_ERROR, "%s() invalid input %d\n", __func__ , scanresult ); return -EINVAL; } mutex_lock(&(misc_mpu9150_data->mutex)); m4_set_mpu9150_delay(misc_mpu9150_data, scanresult, TYPE_COMPASS); mutex_unlock(&(misc_mpu9150_data->mutex)); return count; } static DEVICE_ATTR(compass_setdelay, S_IWUSR, NULL, m4_mpu9150_write_compass_setdelay); static struct attribute *mpu9150_control_attributes[] = { &dev_attr_accel_setdelay.attr, &dev_attr_gyro_setdelay.attr, &dev_attr_compass_setdelay.attr, NULL }; static const struct attribute_group mpu9150_control_group = { .attrs = mpu9150_control_attributes, }; #ifdef MPU9150_DEBUG static ssize_t m4_mpu9150_x(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = to_platform_device(dev); struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev); KDEBUG(M4SH_DEBUG, "%s : raw x = %d\n", __func__, mpu9150_client_data->accel_data.x); return sprintf(buf, "%d\n", mpu9150_client_data->accel_data.x); } static ssize_t m4_mpu9150_y(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = to_platform_device(dev); struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev); KDEBUG(M4SH_DEBUG, "%s : raw y = %d\n", __func__, mpu9150_client_data->accel_data.y); return sprintf(buf, "%d\n", mpu9150_client_data->accel_data.y); } static ssize_t m4_mpu9150_z(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = to_platform_device(dev); struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev); KDEBUG(M4SH_DEBUG, "%s : raw z = %d\n", __func__, mpu9150_client_data->accel_data.z); return sprintf(buf, "%d\n", mpu9150_client_data->accel_data.z); } static ssize_t m4_mpu9150_cx(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = to_platform_device(dev); struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev); KDEBUG(M4SH_DEBUG, "%s : compass cx = %d\n", __func__, mpu9150_client_data->compass_data.cx); return sprintf(buf, "%d\n", mpu9150_client_data->compass_data.cx); } static ssize_t m4_mpu9150_cy(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = to_platform_device(dev); struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev); KDEBUG(M4SH_DEBUG, "%s : compass cy = %d\n", __func__, mpu9150_client_data->compass_data.cy); return sprintf(buf, "%d\n", mpu9150_client_data->compass_data.cy); } static ssize_t m4_mpu9150_cz(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = to_platform_device(dev); struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev); KDEBUG(M4SH_DEBUG, "%s : compass cz = %d\n", __func__, mpu9150_client_data->compass_data.cz); return sprintf(buf, "%d\n", mpu9150_client_data->compass_data.cz); } static ssize_t m4_mpu9150_ca(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = to_platform_device(dev); struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev); KDEBUG(M4SH_DEBUG, "%s : compass ca = %d\n", __func__, mpu9150_client_data->compass_data.ca); return sprintf(buf, "%d\n", mpu9150_client_data->compass_data.ca); } static ssize_t m4_mpu9150_rx(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = to_platform_device(dev); struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev); KDEBUG(M4SH_DEBUG, "%s : rx = %d\n", __func__, mpu9150_client_data->gyro_data.rx); return sprintf(buf, "%d\n", mpu9150_client_data->gyro_data.rx); } static ssize_t m4_mpu9150_ry(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = to_platform_device(dev); struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev); KDEBUG(M4SH_DEBUG, "%s : ry = %d\n", __func__, mpu9150_client_data->gyro_data.ry); return sprintf(buf, "%d\n", mpu9150_client_data->gyro_data.ry); } static ssize_t m4_mpu9150_rz(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = to_platform_device(dev); struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev); KDEBUG(M4SH_DEBUG, "%s : rz = %d\n", __func__, mpu9150_client_data->gyro_data.rz); return sprintf(buf, "%d\n", mpu9150_client_data->gyro_data.rz); } static DEVICE_ATTR(raw_x, 0444, m4_mpu9150_x, NULL); static DEVICE_ATTR(raw_y, 0444, m4_mpu9150_y, NULL); static DEVICE_ATTR(raw_z, 0444, m4_mpu9150_z, NULL); static DEVICE_ATTR(compass_cx, 0444, m4_mpu9150_cx, NULL); static DEVICE_ATTR(compass_cy, 0444, m4_mpu9150_cy, NULL); static DEVICE_ATTR(compass_cz, 0444, m4_mpu9150_cz, NULL); static DEVICE_ATTR(compass_ca, 0444, m4_mpu9150_ca, NULL); static DEVICE_ATTR(rx, 0444, m4_mpu9150_rx, NULL); static DEVICE_ATTR(ry, 0444, m4_mpu9150_ry, NULL); static DEVICE_ATTR(rz, 0444, m4_mpu9150_rz, NULL); static struct attribute *mpu9150_attributes[] = { &dev_attr_raw_x.attr, &dev_attr_raw_y.attr, &dev_attr_raw_z.attr, &dev_attr_compass_cx.attr, &dev_attr_compass_cy.attr, &dev_attr_compass_cz.attr, &dev_attr_compass_ca.attr, &dev_attr_rx.attr, &dev_attr_ry.attr, &dev_attr_rz.attr, NULL }; static const struct attribute_group mpu9150_group = { .attrs = mpu9150_attributes, }; #endif static const struct file_operations mpu9150_client_fops = { .owner = THIS_MODULE, .open = mpu9150_client_open, .release = mpu9150_client_close, }; static struct miscdevice mpu9150_client_miscdrv = { .minor = MISC_DYNAMIC_MINOR, .name = MPU9150_CLIENT_DRIVER_NAME, .fops = &mpu9150_client_fops, }; static void mpu9150_panic_restore(struct m4sensorhub_data *m4sensorhub, void *data) { struct mpu9150_client *dd = (struct mpu9150_client *)data; int type; signed short rate; if (dd == NULL) { KDEBUG(M4SH_INFO, "%s: Driver data is null,unable to restore\n", __func__); return; } mutex_lock(&(dd->mutex)); KDEBUG(M4SH_INFO, "Executing mpu9150 panic restore\n"); for (type = 0; type < NUM_TYPES; type++) { rate = dd->samplerate[type]; m4_set_mpu9150_delay(dd, rate, type); cancel_delayed_work(&(dd->mpu9150_work[type])); if (rate > 0) queue_delayed_work(system_freezable_wq, &(dd->mpu9150_work[type]), msecs_to_jiffies(rate)); } mutex_unlock(&(dd->mutex)); } static int mpu9150_driver_init(struct init_calldata *p_arg) { int ret; struct mpu9150_client *dd = p_arg->p_data; mutex_lock(&(dd->mutex)); INIT_DELAYED_WORK(&(dd->mpu9150_work[TYPE_ACCEL]), m4accel_work_func); INIT_DELAYED_WORK(&(dd->mpu9150_work[TYPE_COMPASS]), m4compass_work_func); INIT_DELAYED_WORK(&(dd->mpu9150_work[TYPE_GYRO]), m4gyro_work_func); ret = m4sensorhub_panic_register(dd->m4sensorhub, PANICHDL_MPU9150_RESTORE, mpu9150_panic_restore, dd); if (ret < 0) KDEBUG(M4SH_ERROR, "HR panic callback register failed\n"); mutex_unlock(&(dd->mutex)); return ret; } static int mpu9150_client_probe(struct platform_device *pdev) { int ret = -1; struct mpu9150_client *mpu9150_client_data; struct m4sensorhub_data *m4sensorhub = m4sensorhub_client_get_drvdata(); if (!m4sensorhub) return -EFAULT; mpu9150_client_data = kzalloc(sizeof(*mpu9150_client_data), GFP_KERNEL); if (!mpu9150_client_data) return -ENOMEM; mpu9150_client_data->m4sensorhub = m4sensorhub; platform_set_drvdata(pdev, mpu9150_client_data); mpu9150_client_data->samplerate[TYPE_ACCEL] = -1; mpu9150_client_data->samplerate[TYPE_GYRO] = -1; mpu9150_client_data->samplerate[TYPE_COMPASS] = -1; mpu9150_client_data->latest_samplerate[TYPE_ACCEL] = mpu9150_client_data->samplerate[TYPE_ACCEL]; mpu9150_client_data->latest_samplerate[TYPE_GYRO] = mpu9150_client_data->samplerate[TYPE_GYRO]; mpu9150_client_data->latest_samplerate[TYPE_COMPASS] = mpu9150_client_data->samplerate[TYPE_COMPASS]; mpu9150_client_data->fastest_rate[TYPE_ACCEL] = 40; mpu9150_client_data->fastest_rate[TYPE_GYRO] = 40; mpu9150_client_data->fastest_rate[TYPE_COMPASS] = 40; mpu9150_client_data->input_dev = input_allocate_device(); if (!mpu9150_client_data->input_dev) { ret = -ENOMEM; KDEBUG(M4SH_ERROR, "%s: input device allocate failed: %d\n", __func__, ret); goto free_mem; } mpu9150_client_data->input_dev->name = MPU9150_CLIENT_DRIVER_NAME; set_bit(EV_ABS, mpu9150_client_data->input_dev->evbit); set_bit(EV_REL, mpu9150_client_data->input_dev->evbit); input_set_abs_params(mpu9150_client_data->input_dev, ABS_X, -2147483647, 2147483647, 0, 0); input_set_abs_params(mpu9150_client_data->input_dev, ABS_Y, -2147483647, 2147483647, 0, 0); input_set_abs_params(mpu9150_client_data->input_dev, ABS_Z, -2147483647, 2147483647, 0, 0); set_bit(REL_X, mpu9150_client_data->input_dev->relbit); set_bit(REL_Y, mpu9150_client_data->input_dev->relbit); set_bit(REL_Z, mpu9150_client_data->input_dev->relbit); set_bit(REL_RX, mpu9150_client_data->input_dev->relbit); set_bit(REL_RY, mpu9150_client_data->input_dev->relbit); set_bit(REL_RZ, mpu9150_client_data->input_dev->relbit); if (input_register_device(mpu9150_client_data->input_dev)) { KDEBUG(M4SH_ERROR, "%s: input device register failed\n", __func__); input_free_device(mpu9150_client_data->input_dev); goto free_mem; } ret = misc_register(&mpu9150_client_miscdrv); if (ret < 0) { KDEBUG(M4SH_ERROR, "Error registering %s driver\n", __func__); goto unregister_input_device; } misc_mpu9150_data = mpu9150_client_data; mutex_init(&(misc_mpu9150_data->mutex)); ret = m4sensorhub_register_initcall(mpu9150_driver_init, mpu9150_client_data); if (ret < 0) { KDEBUG(M4SH_ERROR, "Unable to register init function" "for mpu9150 client = %d\n", ret); goto unregister_misc_device; } ret = sysfs_create_group(&pdev->dev.kobj, &mpu9150_control_group); if (ret) goto unregister_initcall; #ifdef MPU9150_DEBUG ret = sysfs_create_group(&pdev->dev.kobj, &mpu9150_group); if (ret) goto unregister_control_group; #endif KDEBUG(M4SH_INFO, "Initialized %s driver\n", __func__); return 0; #ifdef MPU9150_DEBUG unregister_control_group: sysfs_remove_group(&pdev->dev.kobj, &mpu9150_control_group); #endif unregister_initcall: m4sensorhub_unregister_initcall(mpu9150_driver_init); unregister_misc_device: mutex_destroy(&(misc_mpu9150_data->mutex)); misc_mpu9150_data = NULL; misc_deregister(&mpu9150_client_miscdrv); unregister_input_device: input_unregister_device(mpu9150_client_data->input_dev); free_mem: platform_set_drvdata(pdev, NULL); mpu9150_client_data->m4sensorhub = NULL; kfree(mpu9150_client_data); mpu9150_client_data = NULL; return ret; } static int __exit mpu9150_client_remove(struct platform_device *pdev) { struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev); if (mpu9150_client_data == NULL) return 0; mutex_lock(&(mpu9150_client_data->mutex)); sysfs_remove_group(&pdev->dev.kobj, &mpu9150_control_group); #ifdef MPU9150_DEBUG sysfs_remove_group(&pdev->dev.kobj, &mpu9150_group); #endif cancel_delayed_work(&(mpu9150_client_data->mpu9150_work[TYPE_COMPASS])); cancel_delayed_work(&(mpu9150_client_data->mpu9150_work[TYPE_ACCEL])); cancel_delayed_work(&(mpu9150_client_data->mpu9150_work[TYPE_GYRO])); m4sensorhub_unregister_initcall(mpu9150_driver_init); misc_mpu9150_data = NULL; misc_deregister(&mpu9150_client_miscdrv); input_unregister_device(mpu9150_client_data->input_dev); platform_set_drvdata(pdev, NULL); mpu9150_client_data->m4sensorhub = NULL; mutex_destroy(&(mpu9150_client_data->mutex)); kfree(mpu9150_client_data); mpu9150_client_data = NULL; return 0; } static int mpu9150_client_suspend(struct platform_device *pdev, pm_message_t state) { struct mpu9150_client *dd = platform_get_drvdata(pdev); if (dd == NULL) { KDEBUG(M4SH_ERROR, "%s: Driver data is NULL--%s.\n", __func__, "cannot suspend"); return 0; } m4_set_mpu9150_delay(dd, dd->latest_samplerate[TYPE_ACCEL], TYPE_ACCEL); m4_set_mpu9150_delay(dd, dd->latest_samplerate[TYPE_GYRO], TYPE_GYRO); m4_set_mpu9150_delay(dd, dd->latest_samplerate[TYPE_COMPASS], TYPE_COMPASS); return 0; } static struct of_device_id m4mpu9150_match_tbl[] = { { .compatible = "mot,m4mpu9150" }, {}, }; static struct platform_driver mpu9150_client_driver = { .probe = mpu9150_client_probe, .remove = __exit_p(mpu9150_client_remove), .shutdown = NULL, .suspend = mpu9150_client_suspend, .resume = NULL, .driver = { .name = MPU9150_CLIENT_DRIVER_NAME, .owner = THIS_MODULE, .of_match_table = of_match_ptr(m4mpu9150_match_tbl), }, }; static int __init mpu9150_client_init(void) { return platform_driver_register(&mpu9150_client_driver); } static void __exit mpu9150_client_exit(void) { platform_driver_unregister(&mpu9150_client_driver); } module_init(mpu9150_client_init); module_exit(mpu9150_client_exit); MODULE_ALIAS("platform:mpu9150_client"); MODULE_DESCRIPTION("M4 Sensor Hub Mpu9150 client driver"); MODULE_AUTHOR("Motorola"); MODULE_LICENSE("GPL");