2 /****************************************************************************************
3 * File: driver/input/gsensor/lis3dh.c
4 * Copyright: Copyright (C) 2012-2013 RK Corporation.
5 * Author: LiBing <libing@rock-chips.com>
7 * Description: This driver use for rk29 chip extern gsensor. Use i2c IF ,the chip is
8 * STMicroelectronics lis3dh.
9 *****************************************************************************************/
10 #include <linux/interrupt.h>
11 #include <linux/i2c.h>
12 #include <linux/slab.h>
13 #include <linux/irq.h>
14 #include <linux/miscdevice.h>
15 #include <linux/gpio.h>
16 #include <asm/uaccess.h>
17 #include <asm/atomic.h>
18 #include <linux/delay.h>
19 #include <linux/input.h>
20 #include <linux/workqueue.h>
21 #include <linux/freezer.h>
22 #include <mach/gpio.h>
23 #include <mach/board.h>
24 #ifdef CONFIG_HAS_EARLYSUSPEND
25 #include <linux/earlysuspend.h>
31 #define stprintk(x...) printk(x)
33 #define stprintk(x...)
37 #define stprintkd(x...) printk(x)
39 #define stprintkd(x...)
43 #define stprintkf(x...) printk(x)
45 #define stprintkf(x...)
49 static struct i2c_client *this_client;
50 static struct miscdevice lis3dh_device;
51 static struct kobject *android_gsensor_kobj;
52 static const char* vendor = "STMicroelectronics";
53 static int suspend_flag;
54 static int lis3dh_probe(struct i2c_client *client, const struct i2c_device_id *id);
55 static DECLARE_WAIT_QUEUE_HEAD(data_ready_wq);
58 static ssize_t gsensor_vendor_show(struct device *dev, struct device_attribute *attr, char *buf)
62 sprintf(buf, "%s.\n", vendor);
63 liRet = strlen(buf) + 1;
68 static DEVICE_ATTR(vendor, 0444, gsensor_vendor_show, NULL);
70 static int gsensor_sysfs_init(void)
74 android_gsensor_kobj = kobject_create_and_add("android_gsensor", NULL);
75 if (android_gsensor_kobj == NULL)
77 stprintk(KERN_ERR "LIS3DH gsensor_sysfs_init:subsystem_register failed\n");
79 goto kobject_create_failed;
86 liRet = sysfs_create_file(android_gsensor_kobj, &dev_attr_vendor.attr); // "vendor"
88 stprintk(KERN_ERR "LIS3DH gsensor_sysfs_init:sysfs_create_group failed\n");
89 goto sysfs_create_failed;
99 kobject_del(android_gsensor_kobj);
101 kobject_create_failed:
106 static int lis3dh_rx_data(struct i2c_client *client, char *rxData, int length)
109 char lcReg = rxData[0];
110 liRet = i2c_master_reg8_recv(client, lcReg, rxData, length, LIS3DH_SPEED);
112 return (liRet > 0)? 0 : liRet;
115 static int lis3dh_tx_data(struct i2c_client *client, char *txData, int length)
118 char lcReg = txData[0];
119 liRet = i2c_master_reg8_send(client, lcReg, &txData[1], length-1, LIS3DH_SPEED);
121 return (liRet > 0)? 0 : liRet;
124 static char lis3dh_read_reg(struct i2c_client *client, int addr)
130 liRet = lis3dh_rx_data(client, &liTmp, 1);
134 static int lis3dh_write_reg(struct i2c_client *client,int addr,int value)
141 liRet = lis3dh_tx_data(client, &buffer[0], 2);
145 static int lis3dh_init_device(struct lis3dh_data *lis3dh)
149 memset(lis3dh->resume_state, 0, ARRAY_SIZE(lis3dh->resume_state));
150 lis3dh->resume_state[RES_CTRL_REG1] = LIS3DH_ACC_ENABLE_ALL_AXES;
151 lis3dh->resume_state[RES_CTRL_REG2] = 0x00;
152 lis3dh->resume_state[RES_CTRL_REG3] = 0x40;
153 lis3dh->resume_state[RES_CTRL_REG4] = 0x08;
154 lis3dh->resume_state[RES_CTRL_REG5] = 0x08;
155 lis3dh->resume_state[RES_CTRL_REG6] = 0x40;
156 lis3dh->resume_state[RES_TEMP_CFG_REG] = 0x00;
157 lis3dh->resume_state[RES_FIFO_CTRL_REG] = 0x00;
158 lis3dh->resume_state[RES_INT_CFG1] = 0xFF;
159 lis3dh->resume_state[RES_INT_THS1] = 0x7F;
160 lis3dh->resume_state[RES_INT_DUR1] = 0x7F; //0x00->ox7f
161 lis3dh->resume_state[RES_TT_CFG] = 0x00;
162 lis3dh->resume_state[RES_TT_THS] = 0x00;
163 lis3dh->resume_state[RES_TT_LIM] = 0x00;
164 lis3dh->resume_state[RES_TT_TLAT] = 0x00;
165 lis3dh->resume_state[RES_TT_TW] = 0x00;
167 liRet =lis3dh_write_reg(lis3dh->client, CTRL_REG1, lis3dh->resume_state[RES_CTRL_REG1]);
170 printk("RES_CTRL_REG1 err\n");
178 liRet =lis3dh_write_reg(lis3dh->client, TEMP_CFG_REG, lis3dh->resume_state[RES_TEMP_CFG_REG]);
181 printk("TEMP_CFG_REG err\n");
189 liRet =lis3dh_write_reg(lis3dh->client, FIFO_CTRL_REG, lis3dh->resume_state[RES_FIFO_CTRL_REG]);
192 printk("FIFO_CTRL_REG err\n");
200 liRet =lis3dh_write_reg(lis3dh->client, TT_THS, lis3dh->resume_state[RES_TT_THS]);
201 liRet =lis3dh_write_reg(lis3dh->client, TT_LIM, lis3dh->resume_state[RES_TT_LIM]);
202 liRet =lis3dh_write_reg(lis3dh->client, TT_TLAT, lis3dh->resume_state[RES_TT_TLAT]);
203 liRet =lis3dh_write_reg(lis3dh->client, TT_TW, lis3dh->resume_state[RES_TT_TW]);
206 printk("I2C_AUTO_INCREMENT err\n");
214 liRet =lis3dh_write_reg(lis3dh->client, TT_CFG, lis3dh->resume_state[RES_TT_CFG]);
217 printk("TT_CFG err\n");
225 liRet =lis3dh_write_reg(lis3dh->client, INT_THS1, lis3dh->resume_state[RES_INT_THS1]);
226 liRet =lis3dh_write_reg(lis3dh->client, INT_DUR1, lis3dh->resume_state[RES_INT_DUR1]);
229 printk("I2C_AUTO_INCREMENT err\n");
237 liRet =lis3dh_write_reg(lis3dh->client, INT_CFG1, lis3dh->resume_state[RES_INT_CFG1]);
240 printk("INT_CFG1 err\n");
248 liRet =lis3dh_write_reg(lis3dh->client, CTRL_REG2, lis3dh->resume_state[RES_CTRL_REG2]);
249 liRet =lis3dh_write_reg(lis3dh->client, CTRL_REG3, lis3dh->resume_state[RES_CTRL_REG3]);
250 liRet =lis3dh_write_reg(lis3dh->client, CTRL_REG4, lis3dh->resume_state[RES_CTRL_REG4]);
251 liRet =lis3dh_write_reg(lis3dh->client, CTRL_REG5, lis3dh->resume_state[RES_CTRL_REG5]);
252 liRet =lis3dh_write_reg(lis3dh->client, CTRL_REG6, lis3dh->resume_state[RES_CTRL_REG6]);
255 printk("I2C_AUTO_INCREMENT err\n");
266 static char lis3dh_get_devid(struct lis3dh_data *lis3dh)
270 lcDeviceID = lis3dh_read_reg(lis3dh->client,WHO_AM_I);
273 printk("devid err\n");
278 printk("lis3dh devid:%x\n",lcDeviceID);
284 static int lis3dh_active(struct i2c_client *client,int enable)
289 liTmp =lis3dh_read_reg(client, CTRL_REG1);
292 liTmp |= LIS3DH_ACC_ENABLE_ALL_AXES;
299 liRet =lis3dh_write_reg(client, CTRL_REG1, liTmp);
304 static int lis3dh_start_dev(struct i2c_client *client, char rate)
309 struct lis3dh_data *lis3dh = (struct lis3dh_data *)i2c_get_clientdata(client);
315 else if((int)rate == 6)
324 lcTmp = liRate<<4 | LIS3DH_ACC_ENABLE_ALL_AXES;
326 liRet =lis3dh_write_reg(lis3dh->client, CTRL_REG1, lcTmp);
329 printk(KERN_ERR "lis3dh_start_dev err\n");
333 stprintkf("lis3dh_start_dev\n");
335 lis3dh_active(client,1);
336 enable_irq(client->irq);
340 static int lis3dh_start(struct i2c_client *client, char rate)
342 struct lis3dh_data *lis3dh = (struct lis3dh_data *)i2c_get_clientdata(client);
344 stprintkf("%s::enter\n",__FUNCTION__);
345 if (lis3dh->status == LIS3DH_OPEN)
353 lis3dh->status = LIS3DH_OPEN;
355 return lis3dh_start_dev(client, rate);
358 static int lis3dh_close_dev(struct i2c_client *client)
360 disable_irq_nosync(client->irq);
361 return lis3dh_active(client,0);
364 static int lis3dh_close(struct i2c_client *client)
366 struct lis3dh_data *lis3dh = (struct lis3dh_data *)i2c_get_clientdata(client);
367 stprintkf("%s::enter\n",__FUNCTION__);
368 lis3dh->status = LIS3DH_CLOSE;
369 return lis3dh_close_dev(client);
372 static int lis3dh_reset_rate(struct i2c_client *client, char rate)
376 liRet = lis3dh_close_dev(client);
377 liRet = lis3dh_start_dev(client, rate);
382 static void lis3dh_report_value(struct i2c_client *client, struct lis3dh_axis *axis)
384 struct lis3dh_data *lis3dh = i2c_get_clientdata(client);
386 /* Report acceleration sensor information */
387 input_report_abs(lis3dh->input_dev, ABS_X, axis->x);
388 input_report_abs(lis3dh->input_dev, ABS_Y, axis->y);
389 input_report_abs(lis3dh->input_dev, ABS_Z, axis->z);
390 input_sync(lis3dh->input_dev);
391 stprintkd("Gsensor x==%d y==%d z==%d\n",axis->x,axis->y,axis->z);
394 static inline s64 lis3dh_convert_to_int(const char High_Value, const char Low_Value)
398 liResult = ((long) High_Value << 8) | Low_Value;
400 if (liResult < LIS3DH_BOUNDARY)
402 liResult = liResult * LIS3DH_GRAVITY_STEP;
406 liResult = ~(((~liResult & 0x7fff) + 1)* LIS3DH_GRAVITY_STEP) + 1;
412 /**get the gsensor data. */
413 static int lis3dh_get_data(struct i2c_client *client)
419 struct lis3dh_axis axis;
420 struct lis3dh_data* lis3dh = i2c_get_clientdata(client);
421 struct gsensor_platform_data *pdata = pdata = client->dev.platform_data;
423 /* x,y,z hardware data */
426 memset(acc_data, 0, 6);
427 acc_data[0] = (I2C_AUTO_INCREMENT | AXISDATA_REG);
429 liResult = lis3dh_rx_data(client, &acc_data[0], 6);
440 stprintkd("0x%02x 0x%02x 0x%02x \n",acc_data[1],acc_data[3],acc_data[5]);
442 z = -lis3dh_convert_to_int(acc_data[1],acc_data[0]);
443 x = -lis3dh_convert_to_int(acc_data[3],acc_data[2]);
444 y = lis3dh_convert_to_int(acc_data[5],acc_data[4]);
452 axis.x = (pdata->orientation[0])*x + (pdata->orientation[1])*y + (pdata->orientation[2])*z;
453 axis.y = (pdata->orientation[3])*x + (pdata->orientation[4])*y + (pdata->orientation[5])*z;
454 axis.z = (pdata->orientation[6])*x + (pdata->orientation[7])*y + (pdata->orientation[8])*z;
469 stprintkd( "%s: GetData axis = %d %d %d-------\n",__func__, axis.x, axis.y, axis.z);
471 lis3dh_report_value(client, &axis);
473 /* Caching data mutually exclusive.*/
474 mutex_lock(&(lis3dh->sense_data_mutex) );
475 lis3dh->sense_data = axis;
476 mutex_unlock(&(lis3dh->sense_data_mutex) );
479 atomic_set(&(lis3dh->data_ready), 1);
480 /* wakeup the data_ready,the first of wait queue */
481 wake_up(&(lis3dh->data_ready_wq) );
486 static int lis3dh_get_cached_data(struct i2c_client* client, struct lis3dh_axis* sense_data)
488 struct lis3dh_data* lis3dh = (struct lis3dh_data *)i2c_get_clientdata(client);
490 wait_event_interruptible_timeout(lis3dh->data_ready_wq,
491 atomic_read(&(lis3dh->data_ready) ),msecs_to_jiffies(1000) );
493 if ( 0 == atomic_read(&(lis3dh->data_ready) ) )
495 printk("waiting 'data_ready_wq' timed out.");
503 mutex_lock(&(lis3dh->sense_data_mutex));
504 *sense_data = lis3dh->sense_data;
505 mutex_unlock(&(lis3dh->sense_data_mutex));
510 static int lis3dh_open(struct inode *inode, struct file *file)
512 return 0;//nonseekable_open(inode, file);
515 static int lis3dh_release(struct inode *inode, struct file *file)
520 static long lis3dh_ioctl(struct file *file, unsigned int cmd,unsigned long arg)
524 void __user *argp = (void __user *)arg;
526 struct lis3dh_axis sense_data = {0};
527 struct i2c_client *client = container_of(lis3dh_device.parent, struct i2c_client, dev);
528 struct lis3dh_data* lis3dh = (struct lis3dh_data *)i2c_get_clientdata(client);
532 case ST_IOCTL_APP_SET_RATE:
534 if (copy_from_user(&rate, argp, sizeof(rate)))
553 mutex_lock(&(lis3dh->operation_mutex) );
554 stprintkd("to perform 'ST_IOCTL_START', former 'start_count' is %d.", lis3dh->start_count);
555 (lis3dh->start_count)++;
557 if ( 1 == lis3dh->start_count )
559 atomic_set(&(lis3dh->data_ready), 0);
560 if ( (liRet = lis3dh_start(client, LIS3DH_RATE_12P5) ) < 0 )
562 mutex_unlock(&(lis3dh->operation_mutex) );
574 mutex_unlock(&(lis3dh->operation_mutex) );
575 stprintkd("finish 'ST_IOCTL_START', ret = %d.", liRet);
580 mutex_lock(&(lis3dh->operation_mutex) );
581 stprintkd("to perform 'ST_IOCTL_CLOSE', former 'start_count' is %d, PID : %d", lis3dh->start_count, get_current()->pid);
582 if ( 0 == (--(lis3dh->start_count) ) )
584 atomic_set(&(lis3dh->data_ready), 0);
585 if ( (liRet = lis3dh_close(client) ) < 0 )
587 mutex_unlock(&(lis3dh->operation_mutex) );
595 mutex_unlock(&(lis3dh->operation_mutex) );
598 case ST_IOCTL_APP_SET_RATE:
600 liRet = lis3dh_reset_rate(client, rate);
612 case ST_IOCTL_GETDATA:
613 if ( (liRet = lis3dh_get_cached_data(client, &sense_data) ) < 0 )
615 printk("failed to get cached sense data, ret = %d.", liRet);
630 case ST_IOCTL_GETDATA:
631 if ( copy_to_user(argp, &sense_data, sizeof(sense_data) ) )
633 printk("failed to copy sense data to user space.");
648 static void lis3dh_work_func(struct work_struct *work)
650 struct lis3dh_data *lis3dh = container_of(work, struct lis3dh_data, work);
651 struct i2c_client *client = lis3dh->client;
653 if (lis3dh_get_data(client) < 0)
655 stprintkd(KERN_ERR "LIS3DH lis3dh_work_func: Get data failed\n");
662 enable_irq(client->irq);
665 static void lis3dh_delaywork_func(struct work_struct *work)
667 struct delayed_work *delaywork = container_of(work, struct delayed_work, work);
668 struct lis3dh_data *lis3dh = container_of(delaywork, struct lis3dh_data, delaywork);
669 struct i2c_client *client = lis3dh->client;
671 if (lis3dh_get_data(client) < 0)
673 printk(KERN_ERR " lis3dh_work_func: Get data failed\n");
680 stprintkd("%s :int src:0x%02x\n",__FUNCTION__,lis3dh_read_reg(lis3dh->client,INT_SRC1));
682 enable_irq(client->irq);
686 static irqreturn_t lis3dh_interrupt(int irq, void *dev_id)
688 struct lis3dh_data *lis3dh = (struct lis3dh_data *)dev_id;
690 disable_irq_nosync(irq);
691 schedule_delayed_work(&lis3dh->delaywork, msecs_to_jiffies(30));
692 stprintkf("%s :enter\n",__FUNCTION__);
696 static struct file_operations lis3dh_fops = {
697 .owner = THIS_MODULE,
699 .release = lis3dh_release,
700 .unlocked_ioctl = lis3dh_ioctl,
703 static struct miscdevice lis3dh_device = {
704 .minor = MISC_DYNAMIC_MINOR,
705 .name = "mma8452_daemon",//"mma8452_daemon",
706 .fops = &lis3dh_fops,
709 static int lis3dh_remove(struct i2c_client *client)
711 struct lis3dh_data *lis3dh = i2c_get_clientdata(client);
713 misc_deregister(&lis3dh_device);
714 input_unregister_device(lis3dh->input_dev);
715 input_free_device(lis3dh->input_dev);
716 free_irq(client->irq, lis3dh);
718 #ifdef CONFIG_HAS_EARLYSUSPEND
719 unregister_early_suspend(&lis3dh_early_suspend);
725 #ifdef CONFIG_HAS_EARLYSUSPEND
726 static void lis3dh_suspend(struct early_suspend *h)
728 struct i2c_client *client = container_of(lis3dh_device.parent, struct i2c_client, dev);
729 struct lis3dh_data *lis3dh = (struct lis3dh_data *)i2c_get_clientdata(client);
731 cancel_delayed_work_sync(&(lis3dh->delaywork));
732 lis3dh_close(client);
735 static void lis3dh_resume(struct early_suspend *h)
737 struct i2c_client *client = container_of(lis3dh_device.parent, struct i2c_client, dev);
738 struct lis3dh_data *lis3dh = (struct lis3dh_data *)i2c_get_clientdata(client);
740 lis3dh_start_dev(client,lis3dh->curr_tate);
741 enable_irq(client->irq);
744 static int lis3dh_suspend(struct i2c_client *client, pm_message_t mesg)
747 stprintkd("Gsensor lis3dh enter 2 level suspend lis3dh->status %d\n",lis3dh->status);
748 struct lis3dh_data *lis3dh = (struct lis3dh_data *)i2c_get_clientdata(client);
752 static int lis3dh_resume(struct i2c_client *client)
755 struct lis3dh_data *lis3dh = (struct lis3dh_data *)i2c_get_clientdata(client);
756 stprintkd("Gsensor lis3dh 2 level resume!! lis3dh->status %d\n",lis3dh->status);
761 static const struct i2c_device_id lis3dh_id[] = {
766 static struct i2c_driver lis3dh_driver = {
770 .id_table = lis3dh_id,
771 .probe = lis3dh_probe,
772 .remove = __devexit_p(lis3dh_remove),
773 #ifndef CONFIG_HAS_EARLYSUSPEND
774 .suspend = &lis3dh_suspend,
775 .resume = &lis3dh_resume,
779 static int lis3dh_init_client(struct i2c_client *client)
783 struct lis3dh_data *lis3dh;
785 lis3dh = i2c_get_clientdata(client);
787 liRet = gpio_request(client->irq, "lis3dh_int");
789 stprintk( "failed to request lis3dh_trig GPIO%d\n",gpio_to_irq(client->irq));
797 gpio_direction_output(client->irq, 1);
798 liRet = gpio_direction_input(client->irq);
801 stprintk("failed to set lis3dh_trig GPIO gpio input\n");
802 gpio_free(client->irq);
810 irq = gpio_to_irq(client->irq);
811 liRet = request_irq(irq, lis3dh_interrupt, IRQF_TRIGGER_LOW, client->dev.driver->name, lis3dh);
814 gpio_free(client->irq);
815 stprintk(KERN_ERR "lis3dh_init_client: request irq failed,ret is %d\n",liRet);
820 stprintk("request irq is %d,ret is 0x%x\n",irq,liRet);
824 disable_irq(client->irq);
825 init_waitqueue_head(&data_ready_wq);
830 static int lis3dh_probe(struct i2c_client *client, const struct i2c_device_id *id)
832 struct lis3dh_data *lis3dh;
833 struct lis3dh_platform_data *pdata = pdata = client->dev.platform_data;
837 stprintkf("%s enter\n",__FUNCTION__);
839 lis3dh = kzalloc(sizeof(struct lis3dh_data), GFP_KERNEL);
842 stprintk("[lis3dh]:alloc data failed.\n");
844 goto exit_alloc_data_failed;
851 INIT_WORK(&lis3dh->work, lis3dh_work_func);
852 INIT_DELAYED_WORK(&lis3dh->delaywork, lis3dh_delaywork_func);
854 memset(&(lis3dh->sense_data), 0, sizeof(struct lis3dh_axis) );
855 mutex_init(&(lis3dh->sense_data_mutex) );
857 atomic_set(&(lis3dh->data_ready), 0);
858 init_waitqueue_head(&(lis3dh->data_ready_wq) );
860 lis3dh->start_count = 0;
861 mutex_init(&(lis3dh->operation_mutex) );
863 lis3dh->status = LIS3DH_CLOSE;
864 lis3dh->client = client;
866 i2c_set_clientdata(client, lis3dh);
868 this_client = client;
870 devid = lis3dh_get_devid(lis3dh);
871 if (devid != WHOAMI_LIS3DH_ACC)
873 pr_info("lis3dh: invalid devid\n");
874 goto exit_invalid_devid;
881 liRet = lis3dh_init_device(lis3dh);
884 pr_info("lis3dh: init err\n");
885 goto exit_invalid_devid;
892 liRet = lis3dh_init_client(client);
895 stprintk(KERN_ERR "lis3dh_probe: lis3dh_init_client failed\n");
896 goto exit_request_irq_failed;
903 lis3dh->input_dev = input_allocate_device();
904 if (!lis3dh->input_dev)
907 stprintk(KERN_ERR "lis3dh_probe: Failed to allocate input device\n");
908 goto exit_input_allocate_device_failed;
915 set_bit(EV_ABS, lis3dh->input_dev->evbit);
917 /* x-axis acceleration */
918 input_set_abs_params(lis3dh->input_dev, ABS_X, -LIS3DH_RANGE, LIS3DH_RANGE, 0, 0); //2g full scale range
919 /* y-axis acceleration */
920 input_set_abs_params(lis3dh->input_dev, ABS_Y, -LIS3DH_RANGE, LIS3DH_RANGE, 0, 0); //2g full scale range
921 /* z-axis acceleration */
922 input_set_abs_params(lis3dh->input_dev, ABS_Z, -LIS3DH_RANGE, LIS3DH_RANGE, 0, 0); //2g full scale range
924 lis3dh->input_dev->name = "gsensor";
925 lis3dh->input_dev->dev.parent = &client->dev;
927 liRet = input_register_device(lis3dh->input_dev);
930 stprintk(KERN_ERR "lis3dh_probe: Unable to register input device: %s\n",lis3dh->input_dev->name);
931 goto exit_input_register_device_failed;
938 lis3dh_device.parent = &client->dev;
939 liRet = misc_register(&lis3dh_device);
942 stprintk(KERN_ERR"lis3dh_probe: mmad_device register failed\n");
943 goto exit_misc_device_failed;
950 liRet = gsensor_sysfs_init();
953 stprintk(KERN_ERR "lis3dh_probe: gsensor sysfs init failed\n");
954 goto exit_gsensor_sysfs_init_failed;
961 #ifdef CONFIG_HAS_EARLYSUSPEND
962 lis3dh_early_suspend.suspend = lis3dh_suspend;
963 lis3dh_early_suspend.resume = lis3dh_resume;
964 lis3dh_early_suspend.level = 0x2;
965 register_early_suspend(&lis3dh_early_suspend);
968 printk(KERN_INFO "lis3dh probe ok\n");
972 exit_gsensor_sysfs_init_failed:
973 misc_deregister(&lis3dh_device);
974 exit_misc_device_failed:
975 input_unregister_device(lis3dh->input_dev);
976 exit_input_register_device_failed:
977 input_free_device(lis3dh->input_dev);
978 exit_input_allocate_device_failed:
979 free_irq(client->irq, lis3dh);
980 exit_request_irq_failed:
981 cancel_delayed_work_sync(&lis3dh->delaywork);
982 cancel_work_sync(&lis3dh->work);
985 exit_alloc_data_failed:
986 stprintk("%s error\n",__FUNCTION__);
990 static int __init lis3dh_i2c_init(void)
992 return i2c_add_driver(&lis3dh_driver);
995 static void __exit lis3dh_i2c_exit(void)
997 i2c_del_driver(&lis3dh_driver);
1000 module_init(lis3dh_i2c_init);
1001 module_exit(lis3dh_i2c_exit);
1003 MODULE_DESCRIPTION ("STMicroelectronics gsensor driver");
1004 MODULE_AUTHOR("LB<libing@rock-chips.com>");
1005 MODULE_LICENSE("GPL");