1 /* drivers/i2c/chips/l3g4200d.c - l3g4200d compass driver
3 * Copyright (C) 2007-2008 HTC Corporation.
4 * Author: Hou-Kun Chen <houkun.chen@gmail.com>
6 * This software is licensed under the terms of the GNU General Public
7 * License version 2, as published by the Free Software Foundation, and
8 * may be copied, distributed, and modified under those terms.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
17 #include <linux/interrupt.h>
18 #include <linux/i2c.h>
19 #include <linux/slab.h>
20 #include <linux/irq.h>
21 #include <linux/miscdevice.h>
22 #include <linux/gpio.h>
23 #include <asm/uaccess.h>
24 #include <linux/delay.h>
25 #include <linux/input.h>
26 #include <linux/workqueue.h>
27 #include <linux/freezer.h>
28 #include <linux/l3g4200d.h>
29 #include <mach/gpio.h>
30 #include <mach/board.h>
31 #ifdef CONFIG_HAS_EARLYSUSPEND
32 #include <linux/earlysuspend.h>
36 #define DBG(x...) printk(x)
40 static int l3g4200d_probe(struct i2c_client *client, const struct i2c_device_id *id);
42 #define L3G4200D_SPEED 200 * 1000
43 #define L3G4200D_DEVID 0xD3
45 #define L3G4200D_MAJOR 102
46 #define L3G4200D_MINOR 4
48 /* l3g4200d gyroscope registers */
51 #define CTRL_REG1 0x20 /* power control reg */
52 #define CTRL_REG2 0x21 /* power control reg */
53 #define CTRL_REG3 0x22 /* power control reg */
54 #define CTRL_REG4 0x23 /* interrupt control reg */
55 #define CTRL_REG5 0x24 /* interrupt control reg */
56 #define AXISDATA_REG 0x28
59 /* Addresses to scan -- protected by sense_data_mutex */
60 //static char sense_data[RBUFF_SIZE + 1];
61 static struct i2c_client *this_client;
62 static struct l3g4200d_data *this_data;
63 static struct miscdevice l3g4200d_device;
65 static DECLARE_WAIT_QUEUE_HEAD(data_ready_wq);
67 #ifdef CONFIG_HAS_EARLYSUSPEND
68 static struct early_suspend l3g4200d_early_suspend;
70 static int revision = -1;
72 static ssize_t gsensor_vendor_show(struct device *dev,
73 struct device_attribute *attr, char *buf)
77 sprintf(buf, "%#x\n", revision);
78 ret = strlen(buf) + 1;
83 static DEVICE_ATTR(vendor, 0444, gsensor_vendor_show, NULL);
85 static struct kobject *android_gsensor_kobj;
87 static int gsensor_sysfs_init(void)
91 android_gsensor_kobj = kobject_create_and_add("android_gyrosensor", NULL);
92 if (android_gsensor_kobj == NULL) {
94 "L3G4200D gsensor_sysfs_init:"\
95 "subsystem_register failed\n");
100 ret = sysfs_create_file(android_gsensor_kobj, &dev_attr_vendor.attr);
103 "L3G4200D gsensor_sysfs_init:"\
104 "sysfs_create_group failed\n");
110 kobject_del(android_gsensor_kobj);
116 static int l3g4200d_rx_data(struct i2c_client *client, char *rxData, int length)
119 char reg = rxData[0];
120 ret = i2c_master_reg8_recv(client, reg, rxData, length, L3G4200D_SPEED);
121 return (ret > 0)? 0 : ret;
124 static int l3g4200d_rx_data(struct i2c_client *client, char *rxData, int length)
127 char reg = rxData[0];
131 ret = i2c_master_reg8_recv(client, reg, rxData, length, L3G4200D_SPEED);
137 return (ret > 0)? 0 : ret;
141 static int l3g4200d_tx_data(struct i2c_client *client, char *txData, int length)
144 char reg = txData[0];
145 ret = i2c_master_reg8_send(client, reg, &txData[1], length-1, L3G4200D_SPEED);
146 return (ret > 0)? 0 : ret;
149 static int l3g4200d_tx_data(struct i2c_client *client, char *txData, int length)
152 char reg = txData[0];
156 ret = i2c_master_reg8_send(client, reg, &txData[1], length-1, L3G4200D_SPEED);
162 return (ret > 0)? 0 : ret;
167 static int gyro_rx_data(struct i2c_client *client, char *rxData, int length)
171 char reg = rxData[0];
174 ret = i2c_master_reg8_recv(client, reg, rxData, length, L3G4200D_SPEED);
180 return (ret > 0)? 0 : ret;
184 static int gyro_tx_data(struct i2c_client *client, char *txData, int length)
187 char reg = txData[0];
192 ret = i2c_master_reg8_send(client, reg, &txData[1], length-1, L3G4200D_SPEED);
198 return (ret > 0)? 0 : ret;
202 /* i2c read routine for l3g4200d digital gyroscope */
203 static char l3g4200d_i2c_read(unsigned char reg_addr,
209 if (this_client == NULL) /* No global client pointer? */
213 ret = gyro_rx_data(this_client, data, len);
217 /* i2c write routine for l3g4200d digital gyroscope */
218 static char l3g4200d_i2c_write(unsigned char reg_addr,
226 if (this_client == NULL) /* No global client pointer? */
228 for (i = 0; i < len; i++)
230 buffer[0] = reg_addr+i;
232 ret = gyro_tx_data(this_client, &buffer[0], 2);
238 static char l3g4200d_read_reg(struct i2c_client *client,int addr)
244 // ret = l3g4200d_tx_data(client, &tmp, 1);
245 ret = l3g4200d_rx_data(client, &tmp, 1);
249 static int l3g4200d_write_reg(struct i2c_client *client,int addr,int value)
256 ret = l3g4200d_tx_data(client, &buffer[0], 2);
261 static char l3g4200d_get_devid(struct i2c_client *client)
263 unsigned int devid = 0;
264 struct l3g4200d_data *l3g4200d = (struct l3g4200d_data *)i2c_get_clientdata(client);
266 devid = l3g4200d_read_reg(client, WHO_AM_I)&0xff;
267 if (devid == GYRO_DEVID_L3G4200D) {
268 l3g4200d->devid = devid;
269 printk(KERN_INFO "gyro is L3G4200D and devid=0x%x\n",devid);
271 } else if (devid == GYRO_DEVID_L3G20D)
273 l3g4200d->devid = devid;
274 printk(KERN_INFO "gyro is L3G20D and devid=0x%x\n",devid);
279 printk(KERN_ERR "%s:gyro device id is error,devid=%d\n",__func__,devid);
284 static int l3g4200d_active(struct i2c_client *client,int enable)
289 tmp = l3g4200d_read_reg(client,CTRL_REG1);
294 DBG("l3g4200d_active %s (0x%x)\n",enable?"active":"standby",tmp);
295 ret = l3g4200d_write_reg(client,CTRL_REG1,tmp);
301 static int device_init(void)
304 unsigned char buf[5];
308 buf[3] = 0x20; //0x00
310 res = l3g4200d_i2c_write(CTRL_REG1, &buf[0], 5);
314 int l3g4200d_set_bandwidth(char bw)
319 res = l3g4200d_read_reg(this_client, CTRL_REG1);
324 res = l3g4200d_i2c_write(CTRL_REG1, &data, 1);
328 static int l3g4200d_start_dev(struct i2c_client *client, char rate)
332 //struct l3g4200d_data *l3g4200d = (struct l3g4200d_data *)i2c_get_clientdata(client);
335 l3g4200d_active(client,0);
337 l3g4200d_set_bandwidth(rate);
338 l3g4200d_active(client,1);
340 enable_irq(client->irq);
345 static int l3g4200d_start(struct i2c_client *client, char rate)
347 struct l3g4200d_data *l3g4200d = (struct l3g4200d_data *)i2c_get_clientdata(client);
349 DBG("%s::enter\n",__FUNCTION__);
350 if (l3g4200d->status == L3G4200D_OPEN) {
353 l3g4200d->status = L3G4200D_OPEN;
354 return l3g4200d_start_dev(client, rate);
357 static int l3g4200d_close_dev(struct i2c_client *client)
359 DBG("%s :enter\n",__FUNCTION__);
360 disable_irq_nosync(client->irq);
361 return l3g4200d_active(client,0);
364 static int l3g4200d_close(struct i2c_client *client)
366 struct l3g4200d_data *l3g4200d = (struct l3g4200d_data *)i2c_get_clientdata(client);
367 DBG("%s::enter\n",__FUNCTION__);
368 l3g4200d->status = L3G4200D_CLOSE;
370 return l3g4200d_close_dev(client);
373 static int l3g4200d_reset_rate(struct i2c_client *client, char rate)
377 DBG("%s\n",__func__);
379 // ret = l3g4200d_close_dev(client);
380 ret = l3g4200d_start_dev(client, rate);
385 static inline int l3g4200d_convert_to_int(char value)
392 result = ~(((~value & 0x7f) + 1)* 1) + 1;
398 static void l3g4200d_report_value(struct i2c_client *client, struct l3g4200d_axis *axis)
400 struct l3g4200d_data *l3g4200d = i2c_get_clientdata(client);
401 //struct l3g4200d_axis *axis = (struct l3g4200d_axis *)rbuf;
403 /* Report acceleration sensor information */
404 input_report_rel(l3g4200d->input_dev, ABS_RX, axis->x);
405 input_report_rel(l3g4200d->input_dev, ABS_RY, axis->y);
406 input_report_rel(l3g4200d->input_dev, ABS_RZ, axis->z);
407 input_sync(l3g4200d->input_dev);
408 DBG("%s:x==%d y==%d z==%d\n",__func__,axis->x,axis->y,axis->z);
412 static int l3g4200d_get_data(struct i2c_client *client)
416 struct l3g4200d_axis axis;
417 struct l3g4200d_platform_data *pdata = client->dev.platform_data;
418 struct l3g4200d_data *l3g4200d = (struct l3g4200d_data *)i2c_get_clientdata(client);
420 unsigned char gyro_data[6];
421 /* x,y,z hardware data */
422 int x = 0, y = 0, z = 0;
426 gyro_data[i] = AXISDATA_REG+i;
427 //ret = l3g4200d_tx_data(client, &buffer[0], 1);
428 ret = l3g4200d_rx_data(client, &gyro_data[i], 1);
431 x = (short) (((gyro_data[1]) << 8) | gyro_data[0]);
432 y = (short) (((gyro_data[3]) << 8) | gyro_data[2]);
433 z = (short) (((gyro_data[5]) << 8) | gyro_data[4]);
435 DBG("%s: x=%d y=%d z=%d \n",__func__, x,y,z);
436 if(pdata && pdata->orientation)
438 axis.x = (pdata->orientation[0])*x + (pdata->orientation[1])*y + (pdata->orientation[2])*z;
439 axis.y = (pdata->orientation[3])*x + (pdata->orientation[4])*y + (pdata->orientation[5])*z;
440 axis.z = (pdata->orientation[6])*x + (pdata->orientation[7])*y + (pdata->orientation[8])*z;
450 if((abs(l3g4200d->axis.x - axis.x) > pdata->x_min)||(abs(l3g4200d->axis.y - axis.y) > pdata->y_min)||(abs(l3g4200d->axis.z - axis.z) > pdata->z_min))
452 l3g4200d->axis.x = axis.x;
453 l3g4200d->axis.y = axis.y;
454 l3g4200d->axis.z = axis.z;
455 if(abs(l3g4200d->axis.x) <= pdata->x_min) l3g4200d->axis.x = 0;
456 if(abs(l3g4200d->axis.y) <= pdata->y_min) l3g4200d->axis.y = 0;
457 if(abs(l3g4200d->axis.z) <= pdata->z_min) l3g4200d->axis.z = 0;
459 l3g4200d_report_value(client, &l3g4200d->axis);
466 static int l3g4200d_trans_buff(char *rbuf, int size)
468 //wait_event_interruptible_timeout(data_ready_wq,
469 // atomic_read(&data_ready), 1000);
470 wait_event_interruptible(data_ready_wq,
471 atomic_read(&data_ready));
473 atomic_set(&data_ready, 0);
474 memcpy(rbuf, &sense_data[0], size);
480 static int l3g4200d_open(struct inode *inode, struct file *file)
482 DBG("%s :enter\n",__FUNCTION__);
483 return 0;//nonseekable_open(inode, file);
486 static int l3g4200d_release(struct inode *inode, struct file *file)
488 DBG("%s :enter\n",__FUNCTION__);
491 #define RBUFF_SIZE 12 /* Rx buffer size */
493 static long l3g4200d_ioctl( struct file *file, unsigned int cmd,unsigned long arg)
496 struct l3g4200d_data *l3g4200d = (struct l3g4200d_data *)i2c_get_clientdata(this_client);
497 void __user *argp = (void __user *)arg;
498 //char msg[RBUFF_SIZE + 1];
501 struct i2c_client *client = container_of(l3g4200d_device.parent, struct i2c_client, dev);
504 case L3G4200D_IOCTL_GET_ENABLE:
505 DBG("%s :L3G4200D_IOCTL_GET_ENABLE\n",__FUNCTION__);
506 ret=!l3g4200d->status;
507 if (copy_to_user(argp, &ret, sizeof(ret)))
509 printk("%s:failed to copy status to user space.\n",__FUNCTION__);
513 case L3G4200D_IOCTL_SET_ENABLE:
514 DBG("%s :L3G4200D_IOCTL_SET_ENABLE,flag=%d\n",__FUNCTION__,*(unsigned int *)argp);
515 if(*(unsigned int *)argp)
517 ret = l3g4200d_start(client, ODR100_BW12_5);
523 ret = l3g4200d_close(client);
527 ret=l3g4200d->status;
528 if (copy_to_user(argp, &ret, sizeof(ret)))
530 printk("%s:failed to copy sense data to user space.\n",__FUNCTION__);
534 case L3G4200D_IOCTL_SET_DELAY:
535 DBG("%s :L3G4200D_IOCTL_SET_DELAY,rate=%d\n",__FUNCTION__,rate);
536 if (copy_from_user(&rate, argp, sizeof(rate)))
538 ret = l3g4200d_reset_rate(client, 0x00);//rate<<4);//0x20
543 case ECS_IOCTL_GETDATA:
544 ret = l3g4200d_trans_buff(msg, RBUFF_SIZE);
547 if (copy_to_user(argp, &msg, sizeof(msg)))
552 printk("%s:error,cmd=0x%x\n",__func__,cmd);
556 DBG("%s:line=%d,cmd=0x%x\n",__func__,__LINE__,cmd);
560 static void l3g4200d_work_func(struct work_struct *work)
562 struct l3g4200d_data *l3g4200d = container_of(work, struct l3g4200d_data, work);
563 struct i2c_client *client = l3g4200d->client;
565 if (l3g4200d_get_data(client) < 0)
566 DBG(KERN_ERR "L3G4200D mma_work_func: Get data failed\n");
568 enable_irq(client->irq);
571 static void l3g4200d_delaywork_func(struct work_struct *work)
573 struct delayed_work *delaywork = container_of(work, struct delayed_work, work);
574 struct l3g4200d_data *l3g4200d = container_of(delaywork, struct l3g4200d_data, delaywork);
575 struct i2c_client *client = l3g4200d->client;
577 if (l3g4200d_get_data(client) < 0)
578 DBG(KERN_ERR "L3G4200D mma_work_func: Get data failed\n");
579 enable_irq(client->irq);
582 static irqreturn_t l3g4200d_interrupt(int irq, void *dev_id)
584 struct l3g4200d_data *l3g4200d = (struct l3g4200d_data *)dev_id;
586 disable_irq_nosync(irq);
587 schedule_delayed_work(&l3g4200d->delaywork, msecs_to_jiffies(10));
588 DBG("%s :enter\n",__FUNCTION__);
592 static struct file_operations l3g4200d_fops = {
593 .owner = THIS_MODULE,
594 .open = l3g4200d_open,
595 .release = l3g4200d_release,
596 .unlocked_ioctl = l3g4200d_ioctl,
599 static struct miscdevice l3g4200d_device = {
600 .minor = MISC_DYNAMIC_MINOR,
601 .name = "gyrosensor",//"l3g4200d_daemon",
602 .fops = &l3g4200d_fops,
605 static int l3g4200d_remove(struct i2c_client *client)
607 struct l3g4200d_data *l3g4200d = i2c_get_clientdata(client);
609 misc_deregister(&l3g4200d_device);
610 input_unregister_device(l3g4200d->input_dev);
611 input_free_device(l3g4200d->input_dev);
612 free_irq(client->irq, l3g4200d);
614 #ifdef CONFIG_HAS_EARLYSUSPEND
615 unregister_early_suspend(&l3g4200d_early_suspend);
621 #ifdef CONFIG_HAS_EARLYSUSPEND
622 static void l3g4200d_suspend(struct early_suspend *h)
624 struct i2c_client *client = container_of(l3g4200d_device.parent, struct i2c_client, dev);
625 struct l3g4200d_data *l3g4200d = (struct l3g4200d_data *)i2c_get_clientdata(client);
626 if(l3g4200d->status == L3G4200D_OPEN)
628 l3g4200d_close_dev(client);
631 DBG("%s:%d\n",__func__,l3g4200d->status);
634 static void l3g4200d_resume(struct early_suspend *h)
636 struct i2c_client *client = container_of(l3g4200d_device.parent, struct i2c_client, dev);
637 struct l3g4200d_data *l3g4200d = (struct l3g4200d_data *)i2c_get_clientdata(client);
638 if (l3g4200d->status == L3G4200D_OPEN)
639 l3g4200d_start_dev(client,l3g4200d->curr_tate);
641 DBG("%s:%d\n",__func__,l3g4200d->status);
644 static int l3g4200d_suspend(struct i2c_client *client, pm_message_t mesg)
647 //DBG("Gsensor mma7760 enter 2 level suspend l3g4200d->status %d\n",l3g4200d->status);
648 //struct l3g4200d_data *l3g4200d = (struct l3g4200d_data *)i2c_get_clientdata(client);
649 //if(l3g4200d->status == L3G4200D_OPEN)
651 //l3g4200d->status = L3G4200D_SUSPEND;
652 //ret = l3g4200d_close_dev(client);
656 static int l3g4200d_resume(struct i2c_client *client)
659 //struct l3g4200d_data *l3g4200d = (struct l3g4200d_data *)i2c_get_clientdata(client);
660 //DBG("Gsensor mma7760 2 level resume!! l3g4200d->status %d\n",l3g4200d->status);
661 //if((l3g4200d->status == L3G4200D_SUSPEND) && (l3g4200d->status != L3G4200D_OPEN))
662 //if (l3g4200d->status == L3G4200D_OPEN)
663 //ret = l3g4200d_start_dev(client, l3g4200d->curr_tate);
668 static const struct i2c_device_id l3g4200d_id[] = {
669 {"l3g4200d_gryo", 0},
673 static struct i2c_driver l3g4200d_driver = {
675 .name = "l3g4200d_gryo",
677 .id_table = l3g4200d_id,
678 .probe = l3g4200d_probe,
679 .remove = __devexit_p(l3g4200d_remove),
680 #ifndef CONFIG_HAS_EARLYSUSPEND
681 .suspend = &l3g4200d_suspend,
682 .resume = &l3g4200d_resume,
687 static int l3g4200d_init_irq(struct i2c_client *client)
689 struct l3g4200d_data *l3g4200d;
691 l3g4200d = i2c_get_clientdata(client);
692 DBG("gpio_to_irq(%d) is %d\n",client->irq,gpio_to_irq(client->irq));
693 if ( !gpio_is_valid(client->irq)) {
694 DBG("+++++++++++gpio_is_invalid\n");
697 ret = gpio_request(client->irq, "l3g4200d_int");
699 DBG( "failed to request mma7990_trig GPIO%d\n",gpio_to_irq(client->irq));
702 ret = gpio_direction_input(client->irq);
704 DBG("failed to set mma7990_trig GPIO gpio input\n");
707 gpio_pull_updown(client->irq, GPIOPullUp);
708 client->irq = gpio_to_irq(client->irq);
709 ret = request_irq(client->irq, l3g4200d_interrupt, IRQF_TRIGGER_LOW, client->dev.driver->name, l3g4200d);
710 DBG("request irq is %d,ret is 0x%x\n",client->irq,ret);
712 DBG(KERN_ERR "l3g4200d_init_irq: request irq failed,ret is %d\n",ret);
715 disable_irq(client->irq);
716 init_waitqueue_head(&data_ready_wq);
722 static int l3g4200d_validate_pdata(struct l3g4200d_data *gyro)
724 if (gyro->pdata->axis_map_x > 2 ||
725 gyro->pdata->axis_map_y > 2 ||
726 gyro->pdata->axis_map_z > 2) {
727 dev_err(&gyro->client->dev,
728 "invalid axis_map value x:%u y:%u z%u\n",
729 gyro->pdata->axis_map_x, gyro->pdata->axis_map_y,
730 gyro->pdata->axis_map_z);
734 /* Only allow 0 and 1 for negation boolean flag */
735 if (gyro->pdata->negate_x > 1 ||
736 gyro->pdata->negate_y > 1 ||
737 gyro->pdata->negate_z > 1) {
738 dev_err(&gyro->client->dev,
739 "invalid negate value x:%u y:%u z:%u\n",
740 gyro->pdata->negate_x, gyro->pdata->negate_y,
741 gyro->pdata->negate_z);
751 static int l3g4200d_probe(struct i2c_client *client, const struct i2c_device_id *id)
753 struct l3g4200d_data *l3g4200d;
754 struct l3g4200d_platform_data *pdata = pdata = client->dev.platform_data;
757 if(pdata && pdata->init)
760 l3g4200d = kzalloc(sizeof(struct l3g4200d_data), GFP_KERNEL);
762 DBG("[l3g4200d]:alloc data failed.\n");
764 goto exit_alloc_data_failed;
767 INIT_WORK(&l3g4200d->work, l3g4200d_work_func);
768 INIT_DELAYED_WORK(&l3g4200d->delaywork, l3g4200d_delaywork_func);
770 l3g4200d->client = client;
771 i2c_set_clientdata(client, l3g4200d);
773 this_client = client;
775 l3g4200d->pdata = kmalloc(sizeof(*l3g4200d->pdata), GFP_KERNEL);
777 if (l3g4200d->pdata == NULL)
780 memcpy(l3g4200d->pdata, client->dev.platform_data, sizeof(*l3g4200d->pdata));
782 err = l3g4200d_validate_pdata(l3g4200d);
784 dev_err(&client->dev, "failed to validate platform data\n");
785 goto exit_kfree_pdata;
792 err = l3g4200d_get_devid(client);
798 printk("%s:fail\n",__func__);
799 goto exit_kfree_pdata;
803 err = l3g4200d_init_irq(client);
806 "l3g4200d_probe: l3g4200d_init_irq failed\n");
807 goto exit_request_gpio_irq_failed;
810 l3g4200d->input_dev = input_allocate_device();
811 if (!l3g4200d->input_dev) {
814 "l3g4200d_probe: Failed to allocate input device\n");
815 goto exit_input_allocate_device_failed;
818 //set_bit(EV_ABS, l3g4200d->input_dev->evbit);
820 /* x-axis acceleration */
821 input_set_capability(l3g4200d->input_dev, EV_REL, REL_RX);
822 input_set_abs_params(l3g4200d->input_dev, ABS_RX, -32768, 32768, 0, 0); //2g full scale range
823 /* y-axis acceleration */
824 input_set_capability(l3g4200d->input_dev, EV_REL, REL_RY);
825 input_set_abs_params(l3g4200d->input_dev, ABS_RY, -32768, 32768, 0, 0); //2g full scale range
826 /* z-axis acceleration */
827 input_set_capability(l3g4200d->input_dev, EV_REL, REL_RZ);
828 input_set_abs_params(l3g4200d->input_dev, ABS_RZ, -32768, 32768, 0, 0); //2g full scale range
830 l3g4200d->input_dev->name = "gyro";
831 l3g4200d->input_dev->dev.parent = &client->dev;
832 l3g4200d->axis.x = 0;
833 l3g4200d->axis.y = 0;
834 l3g4200d->axis.z = 0;
836 err = input_register_device(l3g4200d->input_dev);
839 "l3g4200d_probe: Unable to register input device: %s\n",
840 l3g4200d->input_dev->name);
841 goto exit_input_register_device_failed;
844 l3g4200d_device.parent = &client->dev;
845 err = misc_register(&l3g4200d_device);
848 "l3g4200d_probe: mmad_device register failed\n");
849 goto exit_misc_device_register_l3g4200d_device_failed;
852 err = gsensor_sysfs_init();
855 "l3g4200d_probe: gsensor sysfs init failed\n");
856 goto exit_gsensor_sysfs_init_failed;
859 #ifdef CONFIG_HAS_EARLYSUSPEND
860 l3g4200d_early_suspend.suspend = l3g4200d_suspend;
861 l3g4200d_early_suspend.resume = l3g4200d_resume;
862 l3g4200d_early_suspend.level = 0x2;
863 register_early_suspend(&l3g4200d_early_suspend);
866 l3g4200d->status = L3G4200D_CLOSE;
868 // l3g4200d_start_test(this_client);
869 l3g4200d_start(client, L3G4200D_RATE_12P5);
874 exit_gsensor_sysfs_init_failed:
875 misc_deregister(&l3g4200d_device);
876 exit_misc_device_register_l3g4200d_device_failed:
877 input_unregister_device(l3g4200d->input_dev);
878 exit_input_register_device_failed:
879 input_free_device(l3g4200d->input_dev);
880 exit_input_allocate_device_failed:
881 free_irq(client->irq, l3g4200d);
883 exit_request_gpio_irq_failed:
884 kfree(l3g4200d->pdata);
887 exit_alloc_data_failed:
888 DBG("%s error\n",__FUNCTION__);
893 static int __init l3g4200d_i2c_init(void)
895 return i2c_add_driver(&l3g4200d_driver);
898 static void __exit l3g4200d_i2c_exit(void)
900 i2c_del_driver(&l3g4200d_driver);
903 module_init(l3g4200d_i2c_init);
904 module_exit(l3g4200d_i2c_exit);