drivers/input/gsensor/mma8452.c

   1 /* drivers/i2c/chips/mma8452.c - mma8452 compass driver
   2  *
   3  * Copyright (C) 2007-2008 HTC Corporation.
   4  * Author: Hou-Kun Chen <houkun.chen@gmail.com>
   5  *
   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.
   9  *
  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.
  14  *
  15  */
  16
  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 <asm/atomic.h>
  25 #include <linux/delay.h>
  26 #include <linux/input.h>
  27 #include <linux/workqueue.h>
  28 #include <linux/freezer.h>
  29 #include <linux/mma8452.h>
  30 #include <mach/gpio.h>
  31 #include <mach/board.h>
  32
  33 #if 0
  34 #define mmaprintk(x...) printk(x)
  35 #else
  36 #define mmaprintk(x...)
  37 #endif
  38
  39 #if 0
  40 #define mmaprintkd(x...) printk(x)
  41 #else
  42 #define mmaprintkd(x...)
  43 #endif
  44
  45 #if 0
  46 #define mmaprintkf(x...) printk(x)
  47 #else
  48 #define mmaprintkf(x...)
  49 #endif
  50
  51 static int  mma8452_probe(struct i2c_client *client, const struct i2c_device_id *id);
  52
  53 #define MMA8452_SPEED           200 * 1000
  54 #define MMA8451_DEVID           0x1a
  55 #define MMA8452_DEVID           0x2a
  56 #define MMA8453_DEVID           0x3a
  57 /* Addresses to scan -- protected by sense_data_mutex */
  58 //static char sense_data[RBUFF_SIZE + 1];
  59 static struct i2c_client *this_client;
  60 static struct miscdevice mma8452_device;
  61
  62 static DECLARE_WAIT_QUEUE_HEAD(data_ready_wq);
  63
  64 static int revision = -1;
  65 static const char* vendor = "Freescale Semiconductor";
  66 static char devid;
  67
  68
  69 typedef char status_t;
  70 /*status*/
  71 #define MMA8452_OPEN           1
  72 #define MMA8452_CLOSE          0
  73
  74 struct mma8452_data {
  75     status_t status;
  76     char  curr_tate;
  77         struct input_dev *input_dev;
  78         struct i2c_client *client;
  79         struct work_struct work;
  80         struct delayed_work delaywork;  /*report second event*/
  81
  82     struct mma8452_axis sense_data;
  83     struct mutex sense_data_mutex;
  84     atomic_t data_ready;
  85     wait_queue_head_t data_ready_wq;
  86
  87     int start_count;
  88     struct mutex operation_mutex;
  89 };
  90
  91 /* AKM HW info */
  92 static ssize_t gsensor_vendor_show(struct device *dev,
  93                 struct device_attribute *attr, char *buf)
  94 {
  95         ssize_t ret = 0;
  96
  97         // sprintf(buf, "%#x\n", revision);
  98         sprintf(buf, "%s.\n", vendor);
  99         ret = strlen(buf) + 1;
 100
 101         return ret;
 102 }
 103
 104 static DEVICE_ATTR(vendor, 0444, gsensor_vendor_show, NULL);
 105
 106 static struct kobject *android_gsensor_kobj;
 107
 108 static int gsensor_sysfs_init(void)
 109 {
 110         int ret ;
 111
 112         android_gsensor_kobj = kobject_create_and_add("android_gsensor", NULL);
 113         if (android_gsensor_kobj == NULL) {
 114                 mmaprintk(KERN_ERR
 115                        "MMA8452 gsensor_sysfs_init:"\
 116                        "subsystem_register failed\n");
 117                 ret = -ENOMEM;
 118                 goto err;
 119         }
 120
 121         ret = sysfs_create_file(android_gsensor_kobj, &dev_attr_vendor.attr);   // "vendor"
 122         if (ret) {
 123                 mmaprintk(KERN_ERR
 124                        "MMA8452 gsensor_sysfs_init:"\
 125                        "sysfs_create_group failed\n");
 126                 goto err4;
 127         }
 128
 129         return 0 ;
 130 err4:
 131         kobject_del(android_gsensor_kobj);
 132 err:
 133         return ret ;
 134 }
 135
 136 static int mma8452_rx_data(struct i2c_client *client, char *rxData, int length)
 137 {
 138         int ret = 0;
 139         char reg = rxData[0];
 140         ret = i2c_master_reg8_recv(client, reg, rxData, length, MMA8452_SPEED);
 141         return (ret > 0)? 0 : ret;
 142 }
 143
 144 static int mma8452_tx_data(struct i2c_client *client, char *txData, int length)
 145 {
 146         int ret = 0;
 147         char reg = txData[0];
 148         ret = i2c_master_reg8_send(client, reg, &txData[1], length-1, MMA8452_SPEED);
 149         return (ret > 0)? 0 : ret;
 150 }
 151
 152 static char mma845x_read_reg(struct i2c_client *client,int addr)
 153 {
 154         char tmp;
 155         int ret = 0;
 156
 157         tmp = addr;
 158 //      ret = mma8452_tx_data(client, &tmp, 1);
 159         ret = mma8452_rx_data(client, &tmp, 1);
 160         return tmp;
 161 }
 162
 163 static int mma845x_write_reg(struct i2c_client *client,int addr,int value)
 164 {
 165         char buffer[3];
 166         int ret = 0;
 167
 168         buffer[0] = addr;
 169         buffer[1] = value;
 170         ret = mma8452_tx_data(client, &buffer[0], 2);
 171         return ret;
 172 }
 173
 174
 175 static char mma8452_get_devid(struct i2c_client *client)
 176 {
 177         printk("mma8452 devid:%x\n",mma845x_read_reg(client,MMA8452_REG_WHO_AM_I));
 178         return mma845x_read_reg(client,MMA8452_REG_WHO_AM_I);
 179 }
 180
 181 static int mma845x_active(struct i2c_client *client,int enable)
 182 {
 183         int tmp;
 184         int ret = 0;
 185
 186         tmp = mma845x_read_reg(client,MMA8452_REG_CTRL_REG1);
 187         if(enable)
 188                 tmp |=ACTIVE_MASK;
 189         else
 190                 tmp &=~ACTIVE_MASK;
 191         mmaprintkd("mma845x_active %s (0x%x)\n",enable?"active":"standby",tmp);
 192         ret = mma845x_write_reg(client,MMA8452_REG_CTRL_REG1,tmp);
 193         return ret;
 194 }
 195
 196 static int mma8452_start_test(struct i2c_client *client)
 197 {
 198         int ret = 0;
 199         int tmp;
 200
 201         mmaprintkf("-------------------------mma8452 start test------------------------\n");
 202
 203         /* standby */
 204         mma845x_active(client,0);
 205         mmaprintkd("mma8452 MMA8452_REG_SYSMOD:%x\n",mma845x_read_reg(client,MMA8452_REG_SYSMOD));
 206
 207         /* disable FIFO  FMODE = 0*/
 208         ret = mma845x_write_reg(client,MMA8452_REG_F_SETUP,0);
 209         mmaprintkd("mma8452 MMA8452_REG_F_SETUP:%x\n",mma845x_read_reg(client,MMA8452_REG_F_SETUP));
 210
 211         /* set full scale range to 2g */
 212         ret = mma845x_write_reg(client,MMA8452_REG_XYZ_DATA_CFG,0);
 213         mmaprintkd("mma8452 MMA8452_REG_XYZ_DATA_CFG:%x\n",mma845x_read_reg(client,MMA8452_REG_XYZ_DATA_CFG));
 214
 215         /* set bus 8bit/14bit(FREAD = 1,FMODE = 0) ,data rate*/
 216         tmp = (MMA8452_RATE_12P5<< MMA8452_RATE_SHIFT) | FREAD_MASK;
 217         ret = mma845x_write_reg(client,MMA8452_REG_CTRL_REG1,tmp);
 218         mmaprintkd("mma8452 MMA8452_REG_CTRL_REG1:%x\n",mma845x_read_reg(client,MMA8452_REG_CTRL_REG1));
 219
 220         mmaprintkd("mma8452 MMA8452_REG_SYSMOD:%x\n",mma845x_read_reg(client,MMA8452_REG_SYSMOD));
 221
 222         ret = mma845x_write_reg(client,MMA8452_REG_CTRL_REG3,5);
 223         mmaprintkd("mma8452 MMA8452_REG_CTRL_REG3:%x\n",mma845x_read_reg(client,MMA8452_REG_CTRL_REG3));
 224
 225         ret = mma845x_write_reg(client,MMA8452_REG_CTRL_REG4,1);
 226         mmaprintkd("mma8452 MMA8452_REG_CTRL_REG4:%x\n",mma845x_read_reg(client,MMA8452_REG_CTRL_REG4));
 227
 228         ret = mma845x_write_reg(client,MMA8452_REG_CTRL_REG5,1);
 229         mmaprintkd("mma8452 MMA8452_REG_CTRL_REG5:%x\n",mma845x_read_reg(client,MMA8452_REG_CTRL_REG5));
 230
 231         mmaprintkd("mma8452 MMA8452_REG_SYSMOD:%x\n",mma845x_read_reg(client,MMA8452_REG_SYSMOD));
 232         mma845x_active(client,1);
 233         mmaprintkd("mma8452 MMA8452_REG_SYSMOD:%x\n",mma845x_read_reg(client,MMA8452_REG_SYSMOD));
 234
 235         enable_irq(client->irq);
 236         msleep(50);
 237
 238         return ret;
 239 }
 240
 241 static int mma8452_start_dev(struct i2c_client *client, char rate)
 242 {
 243         int ret = 0;
 244         int tmp;
 245         struct mma8452_data *mma8452 = (struct mma8452_data *)i2c_get_clientdata(client);   // mma8452_data ¶¨ÒåÔÚ mma8452.h ÖÐ.
 246
 247         mmaprintkf("-------------------------mma8452 start ------------------------\n");
 248         /* standby */
 249         mma845x_active(client,0);
 250         mmaprintkd("mma8452 MMA8452_REG_SYSMOD:%x\n",mma845x_read_reg(client,MMA8452_REG_SYSMOD));
 251
 252         /* disable FIFO  FMODE = 0*/
 253         ret = mma845x_write_reg(client,MMA8452_REG_F_SETUP,0);
 254         mmaprintkd("mma8452 MMA8452_REG_F_SETUP:%x\n",mma845x_read_reg(client,MMA8452_REG_F_SETUP));
 255
 256         /* set full scale range to 2g */
 257         ret = mma845x_write_reg(client,MMA8452_REG_XYZ_DATA_CFG,0);
 258         mmaprintkd("mma8452 MMA8452_REG_XYZ_DATA_CFG:%x\n",mma845x_read_reg(client,MMA8452_REG_XYZ_DATA_CFG));
 259
 260         /* set bus 8bit/14bit(FREAD = 1,FMODE = 0) ,data rate*/
 261         tmp = (rate<< MMA8452_RATE_SHIFT) | FREAD_MASK;
 262         ret = mma845x_write_reg(client,MMA8452_REG_CTRL_REG1,tmp);
 263         mma8452->curr_tate = rate;
 264         mmaprintkd("mma8452 MMA8452_REG_CTRL_REG1:%x\n",mma845x_read_reg(client,MMA8452_REG_CTRL_REG1));
 265
 266         mmaprintkd("mma8452 MMA8452_REG_SYSMOD:%x\n",mma845x_read_reg(client,MMA8452_REG_SYSMOD));
 267
 268         ret = mma845x_write_reg(client,MMA8452_REG_CTRL_REG3,5);
 269         mmaprintkd("mma8452 MMA8452_REG_CTRL_REG3:%x\n",mma845x_read_reg(client,MMA8452_REG_CTRL_REG3));
 270
 271         ret = mma845x_write_reg(client,MMA8452_REG_CTRL_REG4,1);
 272         mmaprintkd("mma8452 MMA8452_REG_CTRL_REG4:%x\n",mma845x_read_reg(client,MMA8452_REG_CTRL_REG4));
 273
 274         ret = mma845x_write_reg(client,MMA8452_REG_CTRL_REG5,1);
 275         mmaprintkd("mma8452 MMA8452_REG_CTRL_REG5:%x\n",mma845x_read_reg(client,MMA8452_REG_CTRL_REG5));
 276
 277         mmaprintkd("mma8452 MMA8452_REG_SYSMOD:%x\n",mma845x_read_reg(client,MMA8452_REG_SYSMOD));
 278         mma845x_active(client,1);
 279         mmaprintkd("mma8452 MMA8452_REG_SYSMOD:%x\n",mma845x_read_reg(client,MMA8452_REG_SYSMOD));
 280
 281         enable_irq(client->irq);
 282         return ret;
 283
 284 }
 285
 286 static int mma8452_start(struct i2c_client *client, char rate)
 287 {
 288     struct mma8452_data *mma8452 = (struct mma8452_data *)i2c_get_clientdata(client);
 289
 290    mmaprintkf("%s::enter\n",__FUNCTION__);
 291     if (mma8452->status == MMA8452_OPEN) {
 292         return 0;
 293     }
 294     mma8452->status = MMA8452_OPEN;
 295     return mma8452_start_dev(client, rate);
 296 }
 297
 298 static int mma8452_close_dev(struct i2c_client *client)
 299 {
 300         disable_irq_nosync(client->irq);
 301         return mma845x_active(client,0);
 302 }
 303
 304 static int mma8452_close(struct i2c_client *client)
 305 {
 306     struct mma8452_data *mma8452 = (struct mma8452_data *)i2c_get_clientdata(client);
 307    mmaprintkf("%s::enter\n",__FUNCTION__);
 308     mma8452->status = MMA8452_CLOSE;
 309
 310     return mma8452_close_dev(client);
 311 }
 312
 313 static int mma8452_reset_rate(struct i2c_client *client, char rate)
 314 {
 315         int ret = 0;
 316
 317         mmaprintkf("\n----------------------------mma8452_reset_rate------------------------\n");
 318
 319     ret = mma8452_close_dev(client);
 320     ret = mma8452_start_dev(client, rate);
 321
 322         return ret ;
 323 }
 324
 325 static inline int mma8452_convert_to_int(const char high_byte, const char low_byte)
 326 {
 327     s64 result;
 328 /* enabled only if FREAD MODE */
 329 /*
 330     if (high_byte < MMA8452_BOUNDARY) {
 331        result = high_byte * MMA8452_GRAVITY_STEP;
 332     } else {
 333        result = ~(((~high_byte&0x7f) + 1) * MMA8452_GRAVITY_STEP) + 1;
 334     }
 335 */
 336         switch (devid) {
 337
 338                 case MMA8451_DEVID:
 339                         result = ((int)high_byte << (MMA8451_PRECISION-8))
 340                                         | ((int)low_byte >> (16-MMA8451_PRECISION));
 341                         if (result < MMA8451_BOUNDARY)
 342                         result = result* MMA8451_GRAVITY_STEP;
 343                 else
 344                         result = ~( ((~result & (0x7fff>>(16-MMA8451_PRECISION)) ) + 1)
 345                                                 * MMA8451_GRAVITY_STEP) + 1;
 346                         break;
 347
 348                 case MMA8452_DEVID:
 349                         result = ((int)high_byte << (MMA8452_PRECISION-8))
 350                                         | ((int)low_byte >> (16-MMA8452_PRECISION));
 351                         if (result < MMA8452_BOUNDARY)
 352                         result = result* MMA8452_GRAVITY_STEP;
 353                 else
 354                         result = ~( ((~result & (0x7fff>>(16-MMA8452_PRECISION)) ) + 1)
 355                                                 * MMA8452_GRAVITY_STEP) + 1;
 356                         break;
 357
 358                 case MMA8453_DEVID:
 359                         result = ((int)high_byte << (MMA8453_PRECISION-8))
 360                                         | ((int)low_byte >> (16-MMA8453_PRECISION));
 361                         if (result < MMA8453_BOUNDARY)
 362                         result = result* MMA8453_GRAVITY_STEP;
 363                 else
 364                         result = ~( ((~result & (0x7fff>>(16-MMA8453_PRECISION)) ) + 1)
 365                                                 * MMA8453_GRAVITY_STEP) + 1;
 366                         break;
 367
 368                 default:
 369                         mmaprintk(KERN_ERR
 370                        "mma8452_convert_to_int: devid wasn't set correctly\n");
 371                         return -EFAULT;
 372     }
 373
 374     return (int)result;
 375 }
 376
 377 static void mma8452_report_value(struct i2c_client *client, struct mma8452_axis *axis)
 378 {
 379         struct mma8452_data *mma8452 = i2c_get_clientdata(client);
 380     //struct mma8452_axis *axis = (struct mma8452_axis *)rbuf;
 381
 382         /* Report acceleration sensor information */
 383     input_report_abs(mma8452->input_dev, ABS_X, axis->x);
 384     input_report_abs(mma8452->input_dev, ABS_Y, axis->y);
 385     input_report_abs(mma8452->input_dev, ABS_Z, axis->z);
 386     input_sync(mma8452->input_dev);
 387     mmaprintkd("Gsensor x==%d  y==%d z==%d\n",axis->x,axis->y,axis->z);
 388 }
 389
 390 /** ÔÚ µ×°ë²¿Ö´ÐÐ, ¾ßÌå»ñÈ¡ g sensor Êý¾Ý. */
 391 static int mma8452_get_data(struct i2c_client *client)
 392 {
 393     struct mma8452_data* mma8452 = i2c_get_clientdata(client);
 394         int ret;
 395         int x,y,z;
 396     struct mma8452_axis axis;
 397     struct gsensor_platform_data *pdata = pdata = client->dev.platform_data;
 398
 399 /* enabled only if FREAD MODE */
 400 /*
 401         char buffer[3];
 402     do {
 403         memset(buffer, 0, 3);
 404         buffer[0] = MMA8452_REG_X_OUT_MSB;
 405         ret = mma8452_rx_data(client, &buffer[0], 3);
 406         if (ret < 0)
 407             return ret;
 408     } while (0);
 409
 410         x = mma8452_convert_to_int(buffer[0],0);
 411         y = mma8452_convert_to_int(buffer[1],0);
 412         z = mma8452_convert_to_int(buffer[2],0);
 413 */
 414         char buffer[6];
 415     do {
 416         memset(buffer, 0, 6);
 417         buffer[0] = MMA8452_REG_X_OUT_MSB;
 418         ret = mma8452_rx_data(client, &buffer[0], 6);
 419         if (ret < 0)
 420             return ret;
 421     } while (0);
 422
 423         x = mma8452_convert_to_int(buffer[0],buffer[1]);
 424         y = mma8452_convert_to_int(buffer[2],buffer[3]);
 425         z = mma8452_convert_to_int(buffer[4],buffer[5]);
 426
 427         if (pdata->swap_xyz) {
 428                 axis.x = (pdata->orientation[0])*x + (pdata->orientation[1])*y + (pdata->orientation[2])*z;
 429                 axis.y = (pdata->orientation[3])*x + (pdata->orientation[4])*y + (pdata->orientation[5])*z;
 430                 axis.z = (pdata->orientation[6])*x + (pdata->orientation[7])*y + (pdata->orientation[8])*z;
 431         }
 432         else {
 433                 axis.x = x;
 434                 axis.y = y;
 435                 axis.z = z;
 436         }
 437
 438         if(pdata->swap_xy)
 439         {
 440              axis.x = -axis.x;
 441              swap(axis.x,axis.y);
 442         }
 443
 444     mmaprintkd( "%s: ------------------mma8452_GetData axis = %d  %d  %d--------------\n",
 445             __func__, axis.x, axis.y, axis.z);
 446
 447     //memcpy(sense_data, &axis, sizeof(axis));
 448     mma8452_report_value(client, &axis);
 449         //atomic_set(&data_ready, 0);
 450         //wake_up(&data_ready_wq);
 451
 452     /* »¥³âµØ»º´æÊý¾Ý. */
 453     mutex_lock(&(mma8452->sense_data_mutex) );
 454     mma8452->sense_data = axis;
 455     mutex_unlock(&(mma8452->sense_data_mutex) );
 456
 457     /* ÖÃÎ» data_ready */
 458     atomic_set(&(mma8452->data_ready), 1);
 459     /* »½ÐÑ data_ready µÈ´ý¶ÓÁÐÍ·. */
 460         wake_up(&(mma8452->data_ready_wq) );
 461
 462         return 0;
 463 }
 464
 465 /*
 466 static int mma8452_trans_buff(char *rbuf, int size)
 467 {
 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));
 472
 473         atomic_set(&data_ready, 0);
 474         memcpy(rbuf, &sense_data[0], size);
 475
 476         return 0;
 477 }
 478 */
 479
 480 static int mma8452_get_cached_data(struct i2c_client* client, struct mma8452_axis* sense_data)
 481 {
 482     struct mma8452_data* this = (struct mma8452_data *)i2c_get_clientdata(client);
 483
 484     wait_event_interruptible_timeout(this->data_ready_wq,
 485                                      atomic_read(&(this->data_ready) ),
 486                                      msecs_to_jiffies(1000) );
 487     if ( 0 == atomic_read(&(this->data_ready) ) ) {
 488         printk("waiting 'data_ready_wq' timed out.");
 489         return -1;
 490     }
 491     mutex_lock(&(this->sense_data_mutex) );
 492     *sense_data = this->sense_data;
 493     mutex_unlock(&(this->sense_data_mutex) );
 494     return 0;
 495 }
 496
 497 static int mma8452_open(struct inode *inode, struct file *file)
 498 {
 499         return 0;//nonseekable_open(inode, file);
 500 }
 501
 502 static int mma8452_release(struct inode *inode, struct file *file)
 503 {
 504         return 0;
 505 }
 506
 507 static long mma8452_ioctl( struct file *file, unsigned int cmd,unsigned long arg)
 508 {
 509
 510         void __user *argp = (void __user *)arg;
 511         // char msg[RBUFF_SIZE + 1];
 512     struct mma8452_axis sense_data = {0};
 513         int ret = -1;
 514         char rate;
 515         struct i2c_client *client = container_of(mma8452_device.parent, struct i2c_client, dev);
 516     struct mma8452_data* this = (struct mma8452_data *)i2c_get_clientdata(client);  /* Éè±¸Êý¾ÝÊµÀýµÄÖ¸Õë. */
 517
 518         switch (cmd) {
 519         case MMA_IOCTL_APP_SET_RATE:
 520                 if (copy_from_user(&rate, argp, sizeof(rate)))
 521                         return -EFAULT;
 522                 break;
 523         default:
 524                 break;
 525         }
 526
 527         switch (cmd) {
 528         case MMA_IOCTL_START:
 529         mutex_lock(&(this->operation_mutex) );
 530         mmaprintkd("to perform 'MMA_IOCTL_START', former 'start_count' is %d.", this->start_count);
 531         (this->start_count)++;
 532         if ( 1 == this->start_count ) {
 533             atomic_set(&(this->data_ready), 0);
 534             if ( (ret = mma8452_start(client, MMA8452_RATE_12P5) ) < 0 ) {
 535                 mutex_unlock(&(this->operation_mutex) );
 536                 return ret;
 537             }
 538         }
 539         mutex_unlock(&(this->operation_mutex) );
 540         mmaprintkd("finish 'MMA_IOCTL_START', ret = %d.", ret);
 541         return 0;
 542
 543         case MMA_IOCTL_CLOSE:
 544         mutex_lock(&(this->operation_mutex) );
 545         mmaprintkd("to perform 'MMA_IOCTL_CLOSE', former 'start_count' is %d, PID : %d", this->start_count, get_current()->pid);
 546         if ( 0 == (--(this->start_count) ) ) {
 547             atomic_set(&(this->data_ready), 0);
 548             if ( (ret = mma8452_close(client) ) < 0 ) {
 549                 mutex_unlock(&(this->operation_mutex) );
 550                 return ret;
 551             }
 552         }
 553         mutex_unlock(&(this->operation_mutex) );
 554         return 0;
 555
 556         case MMA_IOCTL_APP_SET_RATE:
 557                 ret = mma8452_reset_rate(client, rate);
 558                 if (ret < 0)
 559                         return ret;
 560                 break;
 561         case MMA_IOCTL_GETDATA:
 562                 // ret = mma8452_trans_buff(msg, RBUFF_SIZE);
 563                 if ( (ret = mma8452_get_cached_data(client, &sense_data) ) < 0 ) {
 564             printk("failed to get cached sense data, ret = %d.", ret);
 565                         return ret;
 566         }
 567                 break;
 568         default:
 569                 return -ENOTTY;
 570         }
 571
 572         switch (cmd) {
 573         case MMA_IOCTL_GETDATA:
 574         /*
 575                 if (copy_to_user(argp, &msg, sizeof(msg)))
 576                         return -EFAULT;
 577         */
 578         if ( copy_to_user(argp, &sense_data, sizeof(sense_data) ) ) {
 579             printk("failed to copy sense data to user space.");
 580                         return -EFAULT;
 581         }
 582                 break;
 583         default:
 584                 break;
 585         }
 586
 587         return 0;
 588 }
 589
 590 static void mma8452_work_func(struct work_struct *work)
 591 {
 592         struct mma8452_data *mma8452 = container_of(work, struct mma8452_data, work);
 593         struct i2c_client *client = mma8452->client;
 594
 595         if (mma8452_get_data(client) < 0)
 596                 mmaprintkd(KERN_ERR "MMA8452 mma_work_func: Get data failed\n");
 597
 598         enable_irq(client->irq);
 599 }
 600
 601 static void  mma8452_delaywork_func(struct work_struct *work)
 602 {
 603         struct delayed_work *delaywork = container_of(work, struct delayed_work, work);
 604         struct mma8452_data *mma8452 = container_of(delaywork, struct mma8452_data, delaywork);
 605         struct i2c_client *client = mma8452->client;
 606
 607         if (mma8452_get_data(client) < 0)
 608                 printk(KERN_ERR "MMA8452 mma_work_func: Get data failed\n");
 609         mmaprintkd("%s :int src:0x%02x\n",__FUNCTION__,mma845x_read_reg(mma8452->client,MMA8452_REG_INTSRC));
 610         enable_irq(client->irq);
 611 }
 612
 613 static irqreturn_t mma8452_interrupt(int irq, void *dev_id)
 614 {
 615         struct mma8452_data *mma8452 = (struct mma8452_data *)dev_id;
 616
 617         disable_irq_nosync(irq);
 618         schedule_delayed_work(&mma8452->delaywork, msecs_to_jiffies(30));
 619         mmaprintkf("%s :enter\n",__FUNCTION__);
 620         return IRQ_HANDLED;
 621 }
 622
 623 static struct file_operations mma8452_fops = {
 624         .owner = THIS_MODULE,
 625         .open = mma8452_open,
 626         .release = mma8452_release,
 627         .unlocked_ioctl = mma8452_ioctl,
 628 };
 629
 630 static struct miscdevice mma8452_device = {
 631         .minor = MISC_DYNAMIC_MINOR,
 632         .name = "mma8452_daemon",//"mma8452_daemon",
 633         .fops = &mma8452_fops,
 634 };
 635
 636 static int mma8452_remove(struct i2c_client *client)
 637 {
 638         struct mma8452_data *mma8452 = i2c_get_clientdata(client);
 639
 640     misc_deregister(&mma8452_device);
 641     input_unregister_device(mma8452->input_dev);
 642     input_free_device(mma8452->input_dev);
 643     free_irq(client->irq, mma8452);
 644     kfree(mma8452);
 645     this_client = NULL;
 646         return 0;
 647 }
 648
 649 static const struct i2c_device_id mma8452_id[] = {
 650                 {"gs_mma8452", 0},
 651                 { }
 652 };
 653
 654 static struct i2c_driver mma8452_driver = {
 655         .driver = {
 656                 .name = "gs_mma8452",
 657             },
 658         .id_table       = mma8452_id,
 659         .probe          = mma8452_probe,
 660         .remove         = __devexit_p(mma8452_remove),
 661 };
 662
 663
 664 static int mma8452_init_client(struct i2c_client *client)
 665 {
 666         struct mma8452_data *mma8452;
 667         int ret,irq;
 668         mma8452 = i2c_get_clientdata(client);
 669         mmaprintk("gpio_to_irq(%d) is %d\n",client->irq,gpio_to_irq(client->irq));
 670         if ( !gpio_is_valid(client->irq)) {
 671                 mmaprintk("+++++++++++gpio_is_invalid\n");
 672                 return -EINVAL;
 673         }
 674         ret = gpio_request(client->irq, "mma8452_int");
 675         if (ret) {
 676                 mmaprintk( "failed to request mma7990_trig GPIO%d\n",gpio_to_irq(client->irq));
 677                 return ret;
 678         }
 679     ret = gpio_direction_input(client->irq);
 680     if (ret) {
 681         mmaprintk("failed to set mma7990_trig GPIO gpio input\n");
 682                 gpio_free(client->irq);
 683                 return ret;
 684     }
 685         gpio_pull_updown(client->irq, GPIOPullUp);
 686         irq = gpio_to_irq(client->irq);
 687         ret = request_irq(irq, mma8452_interrupt, IRQF_TRIGGER_LOW, client->dev.driver->name, mma8452);
 688         mmaprintk("request irq is %d,ret is  0x%x\n",irq,ret);
 689         if (ret ) {
 690                 gpio_free(client->irq);
 691                 mmaprintk(KERN_ERR "mma8452_init_client: request irq failed,ret is %d\n",ret);
 692         return ret;
 693         }
 694         client->irq = irq;
 695         disable_irq(client->irq);
 696         init_waitqueue_head(&data_ready_wq);
 697
 698         return 0;
 699 }
 700
 701 static int  mma8452_probe(struct i2c_client *client, const struct i2c_device_id *id)
 702 {
 703         struct mma8452_data *mma8452;
 704         struct gsensor_platform_data *pdata = pdata = client->dev.platform_data;
 705         int err;
 706
 707         mmaprintkf("%s enter\n",__FUNCTION__);
 708
 709         mma8452 = kzalloc(sizeof(struct mma8452_data), GFP_KERNEL);
 710         if (!mma8452) {
 711                 mmaprintk("[mma8452]:alloc data failed.\n");
 712                 err = -ENOMEM;
 713                 goto exit_alloc_data_failed;
 714         }
 715
 716         INIT_WORK(&mma8452->work, mma8452_work_func);
 717         INIT_DELAYED_WORK(&mma8452->delaywork, mma8452_delaywork_func);
 718
 719         memset(&(mma8452->sense_data), 0, sizeof(struct mma8452_axis) );
 720         mutex_init(&(mma8452->sense_data_mutex) );
 721
 722         atomic_set(&(mma8452->data_ready), 0);
 723         init_waitqueue_head(&(mma8452->data_ready_wq) );
 724
 725         mma8452->start_count = 0;
 726         mutex_init(&(mma8452->operation_mutex) );
 727
 728         mma8452->status = MMA8452_CLOSE;
 729
 730         mma8452->client = client;
 731         i2c_set_clientdata(client, mma8452);
 732
 733         this_client = client;
 734
 735         devid = mma8452_get_devid(this_client);
 736         if ((MMA8452_DEVID != devid)
 737                 && (MMA8451_DEVID != devid)
 738                 && (MMA8453_DEVID != devid)) {
 739                 pr_info("mma8452: invalid devid\n");
 740                 goto exit_invalid_devid;
 741         }
 742
 743         err = mma8452_init_client(client);
 744         if (err < 0) {
 745                 mmaprintk(KERN_ERR
 746                        "mma8452_probe: mma8452_init_client failed\n");
 747                 goto exit_request_gpio_irq_failed;
 748         }
 749
 750         mma8452->input_dev = input_allocate_device();
 751         if (!mma8452->input_dev) {
 752                 err = -ENOMEM;
 753                 mmaprintk(KERN_ERR
 754                        "mma8452_probe: Failed to allocate input device\n");
 755                 goto exit_input_allocate_device_failed;
 756         }
 757
 758         set_bit(EV_ABS, mma8452->input_dev->evbit);
 759
 760         /* x-axis acceleration */
 761         input_set_abs_params(mma8452->input_dev, ABS_X, -MMA845X_RANGE, MMA845X_RANGE, 0, 0); //2g full scale range
 762         /* y-axis acceleration */
 763         input_set_abs_params(mma8452->input_dev, ABS_Y, -MMA845X_RANGE, MMA845X_RANGE, 0, 0); //2g full scale range
 764         /* z-axis acceleration */
 765         input_set_abs_params(mma8452->input_dev, ABS_Z, -MMA845X_RANGE, MMA845X_RANGE, 0, 0); //2g full scale range
 766
 767         // mma8452->input_dev->name = "compass";
 768         mma8452->input_dev->name = "gsensor";
 769         mma8452->input_dev->dev.parent = &client->dev;
 770
 771         err = input_register_device(mma8452->input_dev);
 772         if (err < 0) {
 773                 mmaprintk(KERN_ERR
 774                        "mma8452_probe: Unable to register input device: %s\n",
 775                        mma8452->input_dev->name);
 776                 goto exit_input_register_device_failed;
 777         }
 778
 779     mma8452_device.parent = &client->dev;
 780         err = misc_register(&mma8452_device);
 781         if (err < 0) {
 782                 mmaprintk(KERN_ERR
 783                        "mma8452_probe: mmad_device register failed\n");
 784                 goto exit_misc_device_register_mma8452_device_failed;
 785         }
 786
 787         err = gsensor_sysfs_init();
 788         if (err < 0) {
 789                 mmaprintk(KERN_ERR
 790             "mma8452_probe: gsensor sysfs init failed\n");
 791                 goto exit_gsensor_sysfs_init_failed;
 792         }
 793
 794         printk(KERN_INFO "mma8452 probe ok\n");
 795 #if  0
 796 //      mma8452_start_test(this_client);
 797         mma8452_start(client, MMA8452_RATE_12P5);
 798 #endif
 799         return 0;
 800
 801 exit_gsensor_sysfs_init_failed:
 802     misc_deregister(&mma8452_device);
 803 exit_misc_device_register_mma8452_device_failed:
 804     input_unregister_device(mma8452->input_dev);
 805 exit_input_register_device_failed:
 806         input_free_device(mma8452->input_dev);
 807 exit_input_allocate_device_failed:
 808         free_irq(client->irq, mma8452);
 809 exit_request_gpio_irq_failed:
 810         cancel_delayed_work_sync(&mma8452->delaywork);
 811         cancel_work_sync(&mma8452->work);
 812 exit_invalid_devid:
 813         kfree(mma8452);
 814 exit_alloc_data_failed:
 815     ;
 816         mmaprintk("%s error\n",__FUNCTION__);
 817         return -1;
 818 }
 819
 820
 821 static int __init mma8452_i2c_init(void)
 822 {
 823         return i2c_add_driver(&mma8452_driver);
 824 }
 825
 826 static void __exit mma8452_i2c_exit(void)
 827 {
 828         i2c_del_driver(&mma8452_driver);
 829 }
 830
 831 module_init(mma8452_i2c_init);
 832 module_exit(mma8452_i2c_exit);
 833