drivers/input/magnetometer/ak8975.c

   1 /* drivers/i2c/chips/akm8975.c - akm8975 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 /*
  18  * Revised by AKM 2009/04/02
  19  *
  20  */
  21
  22 #include <linux/interrupt.h>
  23 #include <linux/i2c.h>
  24 #include <linux/slab.h>
  25 #include <linux/irq.h>
  26 #include <linux/miscdevice.h>
  27 #include <linux/gpio.h>
  28 #include <linux/uaccess.h>
  29 #include <linux/delay.h>
  30 #include <linux/input.h>
  31 #include <linux/workqueue.h>
  32 #include <linux/freezer.h>
  33 #include <linux/earlysuspend.h>
  34 #include "ak8975.h"
  35
  36 #define AKM8975_DEBUG           1
  37 #define AKM8975_DEBUG_MSG       0
  38 #define AKM8975_DEBUG_FUNC      0
  39 #define AKM8975_DEBUG_DATA      0
  40 #define MAX_FAILURE_COUNT       3
  41 #define AKM8975_RETRY_COUNT     10
  42 #define AKM8975_DEFAULT_DELAY   100
  43
  44 #if AKM8975_DEBUG_MSG
  45 #define AKMDBG(format, ...)     printk(KERN_INFO "AKM8975 " format "\n", ## __VA_ARGS__)
  46 #else
  47 #define AKMDBG(format, ...)
  48 #endif
  49
  50 #if AKM8975_DEBUG_FUNC
  51 #define AKMFUNC(func) printk(KERN_INFO "AKM8975 " func " is called\n")
  52 #else
  53 #define AKMFUNC(func)
  54 #endif
  55
  56 static struct i2c_client *this_client;
  57
  58 struct akm8975_data {
  59         struct i2c_client *client;
  60         struct input_dev *input_dev;
  61         struct work_struct work;
  62         struct early_suspend akm_early_suspend;
  63         int eoc_irq;
  64         struct akm8975_platform_data *pdata;
  65 };
  66
  67 /* Addresses to scan -- protected by sense_data_mutex */
  68 static char sense_data[SENSOR_DATA_SIZE];
  69 static struct mutex sense_data_mutex;
  70 static DECLARE_WAIT_QUEUE_HEAD(data_ready_wq);
  71 static DECLARE_WAIT_QUEUE_HEAD(open_wq);
  72
  73 static atomic_t data_ready;
  74 static atomic_t open_count;
  75 static atomic_t open_flag;
  76 static atomic_t reserve_open_flag;
  77
  78 static atomic_t m_flag;
  79 static atomic_t a_flag;
  80 static atomic_t mv_flag;
  81
  82 static int failure_count = 0;
  83
  84 static short akmd_delay = AKM8975_DEFAULT_DELAY;
  85
  86 static atomic_t suspend_flag = ATOMIC_INIT(0);
  87
  88 //static struct akm8975_platform_data *pdata;
  89
  90 #define AKM_I2C_RATE 100*1000
  91
  92 static int AKI2C_RxData(char *rxData, int length)
  93 {
  94         uint8_t loop_i;
  95         struct i2c_msg msgs[] = {
  96                 {
  97                         .addr = this_client->addr,
  98                         .flags = 0,
  99                         .len = 1,
 100                         .buf = rxData,
 101                         .scl_rate = AKM_I2C_RATE,
 102                 },
 103                 {
 104                         .addr = this_client->addr,
 105                         .flags = I2C_M_RD,
 106                         .len = length,
 107                         .buf = rxData,
 108                         .scl_rate = AKM_I2C_RATE,
 109                 },
 110         };
 111 #if AKM8975_DEBUG_DATA
 112         int i;
 113         char addr = rxData[0];
 114 #endif
 115 #ifdef AKM8975_DEBUG
 116         /* Caller should check parameter validity.*/
 117         if ((rxData == NULL) || (length < 1)) {
 118                 return -EINVAL;
 119         }
 120 #endif
 121         for (loop_i = 0; loop_i < AKM8975_RETRY_COUNT; loop_i++) {
 122                 if (i2c_transfer(this_client->adapter, msgs, 2) > 0) {
 123                         break;
 124                 }
 125                 mdelay(10);
 126         }
 127
 128         if (loop_i >= AKM8975_RETRY_COUNT) {
 129                 printk(KERN_ERR "%s retry over %d\n", __func__, AKM8975_RETRY_COUNT);
 130                 return -EIO;
 131         }
 132 #if AKM8975_DEBUG_DATA
 133         printk(KERN_INFO "RxData: len=%02x, addr=%02x\n  data=", length, addr);
 134         for (i = 0; i < length; i++) {
 135                 printk(KERN_INFO " %02x", rxData[i]);
 136         }
 137     printk(KERN_INFO "\n");
 138 #endif
 139         return 0;
 140 }
 141
 142 static int AKI2C_TxData(char *txData, int length)
 143 {
 144         uint8_t loop_i;
 145         struct i2c_msg msg[] = {
 146                 {
 147                         .addr = this_client->addr,
 148                         .flags = 0,
 149                         .len = length,
 150                         .buf = txData,
 151                         .scl_rate = AKM_I2C_RATE,
 152                 },
 153         };
 154 #if AKM8975_DEBUG_DATA
 155         int i;
 156 #endif
 157 #ifdef AKM8975_DEBUG
 158         /* Caller should check parameter validity.*/
 159         if ((txData == NULL) || (length < 2)) {
 160                 return -EINVAL;
 161         }
 162 #endif
 163         for (loop_i = 0; loop_i < AKM8975_RETRY_COUNT; loop_i++) {
 164                 if (i2c_transfer(this_client->adapter, msg, 1) > 0) {
 165                         break;
 166                 }
 167                 mdelay(10);
 168         }
 169
 170         if (loop_i >= AKM8975_RETRY_COUNT) {
 171                 printk(KERN_ERR "%s retry over %d\n", __func__, AKM8975_RETRY_COUNT);
 172                 return -EIO;
 173         }
 174 #if AKM8975_DEBUG_DATA
 175         printk(KERN_INFO "TxData: len=%02x, addr=%02x\n  data=", length, txData[0]);
 176         for (i = 0; i < (length-1); i++) {
 177                 printk(KERN_INFO " %02x", txData[i + 1]);
 178         }
 179         printk(KERN_INFO "\n");
 180 #endif
 181         return 0;
 182 }
 183
 184 static int AKECS_SetMode_SngMeasure(void)
 185 {
 186         char buffer[2];
 187
 188         AKMDBG("enter %s\n", __func__);
 189
 190         atomic_set(&data_ready, 0);
 191
 192         /* Set measure mode */
 193         buffer[0] = AK8975_REG_CNTL;
 194         buffer[1] = AK8975_MODE_SNG_MEASURE;
 195
 196         /* Set data */
 197         return AKI2C_TxData(buffer, 2);
 198 }
 199
 200 static int AKECS_SetMode_SelfTest(void)
 201 {
 202         char buffer[2];
 203         AKMDBG("enter %s\n", __func__);
 204
 205         /* Set measure mode */
 206         buffer[0] = AK8975_REG_CNTL;
 207         buffer[1] = AK8975_MODE_SELF_TEST;
 208         /* Set data */
 209         return AKI2C_TxData(buffer, 2);
 210 }
 211
 212 static int AKECS_SetMode_FUSEAccess(void)
 213 {
 214         char buffer[2];
 215         AKMDBG("enter %s\n", __func__);
 216
 217         /* Set measure mode */
 218         buffer[0] = AK8975_REG_CNTL;
 219         buffer[1] = AK8975_MODE_FUSE_ACCESS;
 220         /* Set data */
 221         return AKI2C_TxData(buffer, 2);
 222 }
 223
 224 static int AKECS_SetMode_PowerDown(void)
 225 {
 226         char buffer[2];
 227         AKMDBG("enter %s\n", __func__);
 228
 229         /* Set powerdown mode */
 230         buffer[0] = AK8975_REG_CNTL;
 231         buffer[1] = AK8975_MODE_POWERDOWN;
 232         /* Set data */
 233         return AKI2C_TxData(buffer, 2);
 234 }
 235
 236 static int AKECS_SetMode(char mode)
 237 {
 238         int ret;
 239         AKMDBG("enter %s\n", __func__);
 240
 241         switch (mode) {
 242                 case AK8975_MODE_SNG_MEASURE:
 243                         ret = AKECS_SetMode_SngMeasure();
 244                         break;
 245                 case AK8975_MODE_SELF_TEST:
 246                         ret = AKECS_SetMode_SelfTest();
 247                         break;
 248                 case AK8975_MODE_FUSE_ACCESS:
 249                         ret = AKECS_SetMode_FUSEAccess();
 250                         break;
 251                 case AK8975_MODE_POWERDOWN:
 252                         ret = AKECS_SetMode_PowerDown();
 253                         /* wait at least 100us after changing mode */
 254                         udelay(100);
 255                         break;
 256                 default:
 257                         AKMDBG("%s: Unknown mode(%d)", __func__, mode);
 258                         return -EINVAL;
 259         }
 260
 261         return ret;
 262 }
 263
 264 static int AKECS_CheckDevice(void)
 265 {
 266         char buffer[2];
 267         int ret;
 268         AKMDBG("enter %s\n", __func__);
 269
 270         /* Set measure mode */
 271         buffer[0] = AK8975_REG_WIA;
 272
 273         /* Read data */
 274         ret = AKI2C_RxData(buffer, 1);
 275         if (ret < 0) {
 276                 return ret;
 277         }
 278         /* Check read data */
 279         if (buffer[0] != 0x48) {
 280                 return -ENXIO;
 281         }
 282
 283         return 0;
 284 }
 285
 286 static int AKECS_GetData(char *rbuf, int size)
 287 {
 288 #ifdef AKM8975_DEBUG
 289         /* This function is not exposed, so parameters
 290          should be checked internally.*/
 291         if ((rbuf == NULL) || (size < SENSOR_DATA_SIZE)) {
 292                 return -EINVAL;
 293         }
 294 #endif
 295         AKMDBG("enter %s\n", __func__);
 296         wait_event_interruptible_timeout(data_ready_wq,
 297                                                                          atomic_read(&data_ready), 1000);
 298         if (!atomic_read(&data_ready)) {
 299                 AKMDBG("%s: data_ready is not set.", __func__);
 300                 if (!atomic_read(&suspend_flag)) {
 301                         AKMDBG("%s: suspend_flag is not set.", __func__);
 302                         failure_count++;
 303                         if (failure_count >= MAX_FAILURE_COUNT) {
 304                                 printk(KERN_ERR
 305                                        "AKM8975 AKECS_GetData: successive %d failure.\n",
 306                                        failure_count);
 307                                 atomic_set(&open_flag, -1);
 308                                 wake_up(&open_wq);
 309                                 failure_count = 0;
 310                         }
 311                 }
 312                 return -1;
 313         }
 314
 315         mutex_lock(&sense_data_mutex);
 316         memcpy(rbuf, sense_data, size);
 317         atomic_set(&data_ready, 0);
 318         mutex_unlock(&sense_data_mutex);
 319
 320         failure_count = 0;
 321         return 0;
 322 }
 323
 324 static void AKECS_SetYPR(short *rbuf)
 325 {
 326         struct akm8975_data *data = i2c_get_clientdata(this_client);
 327 #if AKM8975_DEBUG_DATA
 328         printk(KERN_INFO "AKM8975 %s:\n", __func__);
 329         printk(KERN_INFO "  yaw =%6d, pitch =%6d, roll =%6d\n",
 330                    rbuf[0], rbuf[1], rbuf[2]);
 331         printk(KERN_INFO "  tmp =%6d, m_stat =%6d, g_stat =%6d\n",
 332                    rbuf[3], rbuf[4], rbuf[5]);
 333         printk(KERN_INFO "  Acceleration[LSB]: %6d,%6d,%6d\n",
 334                rbuf[6], rbuf[7], rbuf[8]);
 335         printk(KERN_INFO "  Geomagnetism[LSB]: %6d,%6d,%6d\n",
 336                rbuf[9], rbuf[10], rbuf[11]);
 337 #endif
 338         AKMDBG("enter %s\n", __func__);
 339         /* Report magnetic sensor information */
 340         if (atomic_read(&m_flag)) {
 341                 input_report_abs(data->input_dev, ABS_RX, rbuf[0]);
 342                 input_report_abs(data->input_dev, ABS_RY, rbuf[1]);
 343                 input_report_abs(data->input_dev, ABS_RZ, rbuf[2]);
 344                 input_report_abs(data->input_dev, ABS_RUDDER, rbuf[4]);
 345         }
 346
 347         /* Report acceleration sensor information */
 348         if (atomic_read(&a_flag)) {
 349                 input_report_abs(data->input_dev, ABS_X, rbuf[6]);
 350                 input_report_abs(data->input_dev, ABS_Y, rbuf[7]);
 351                 input_report_abs(data->input_dev, ABS_Z, rbuf[8]);
 352                 input_report_abs(data->input_dev, ABS_WHEEL, rbuf[5]);
 353         }
 354
 355         /* Report magnetic vector information */
 356         if (atomic_read(&mv_flag)) {
 357                 input_report_abs(data->input_dev, ABS_HAT0X, rbuf[9]);
 358                 input_report_abs(data->input_dev, ABS_HAT0Y, rbuf[10]);
 359                 input_report_abs(data->input_dev, ABS_BRAKE, rbuf[11]);
 360         }
 361
 362         input_sync(data->input_dev);
 363 }
 364
 365 static int AKECS_GetOpenStatus(void)
 366 {
 367         AKMDBG("enter %s\n", __func__);
 368         wait_event_interruptible(open_wq, (atomic_read(&open_flag) != 0));
 369         return atomic_read(&open_flag);
 370 }
 371
 372 static int AKECS_GetCloseStatus(void)
 373 {
 374         AKMDBG("enter %s\n", __func__);
 375         wait_event_interruptible(open_wq, (atomic_read(&open_flag) <= 0));
 376         return atomic_read(&open_flag);
 377 }
 378
 379 static void AKECS_CloseDone(void)
 380 {
 381         AKMDBG("enter %s\n", __func__);
 382         atomic_set(&m_flag, 1);
 383         atomic_set(&a_flag, 1);
 384         atomic_set(&mv_flag, 1);
 385 }
 386
 387 /***** akm_aot functions ***************************************/
 388 static int akm_aot_open(struct inode *inode, struct file *file)
 389 {
 390         int ret = -1;
 391
 392         AKMFUNC("akm_aot_open");
 393         if (atomic_cmpxchg(&open_count, 0, 1) == 0) {
 394                 if (atomic_cmpxchg(&open_flag, 0, 1) == 0) {
 395                         atomic_set(&reserve_open_flag, 1);
 396                         wake_up(&open_wq);
 397                         ret = 0;
 398                 }
 399         }
 400         return ret;
 401 }
 402
 403 static int akm_aot_release(struct inode *inode, struct file *file)
 404 {
 405         AKMFUNC("akm_aot_release");
 406         atomic_set(&reserve_open_flag, 0);
 407         atomic_set(&open_flag, 0);
 408         atomic_set(&open_count, 0);
 409         wake_up(&open_wq);
 410         return 0;
 411 }
 412
 413 //static int
 414 //akm_aot_ioctl(struct inode *inode, struct file *file,
 415 //                        unsigned int cmd, unsigned long arg)
 416 static long akm_aot_ioctl(struct file *file,unsigned int cmd, unsigned long arg)
 417 {
 418         void __user *argp = (void __user *)arg;
 419         short flag;
 420         AKMDBG("enter %s\n", __func__);
 421
 422         switch (cmd) {
 423                 case ECS_IOCTL_APP_SET_MFLAG:
 424                 case ECS_IOCTL_APP_SET_AFLAG:
 425                 case ECS_IOCTL_APP_SET_MVFLAG:
 426                         if (copy_from_user(&flag, argp, sizeof(flag))) {
 427                                 return -EFAULT;
 428                         }
 429                         if (flag < 0 || flag > 1) {
 430                                 return -EINVAL;
 431                         }
 432                         break;
 433                 case ECS_IOCTL_APP_SET_DELAY:
 434                         if (copy_from_user(&flag, argp, sizeof(flag))) {
 435                                 return -EFAULT;
 436                         }
 437                         break;
 438                 default:
 439                         break;
 440         }
 441
 442         switch (cmd) {
 443                 case ECS_IOCTL_APP_SET_MFLAG:
 444                         atomic_set(&m_flag, flag);
 445                         AKMDBG("MFLAG is set to %d", flag);
 446                         break;
 447                 case ECS_IOCTL_APP_GET_MFLAG:
 448                         flag = atomic_read(&m_flag);
 449                         break;
 450                 case ECS_IOCTL_APP_SET_AFLAG:
 451                         atomic_set(&a_flag, flag);
 452                         AKMDBG("AFLAG is set to %d", flag);
 453                         break;
 454                 case ECS_IOCTL_APP_GET_AFLAG:
 455                         flag = atomic_read(&a_flag);
 456                         break;
 457                 case ECS_IOCTL_APP_SET_MVFLAG:
 458                         atomic_set(&mv_flag, flag);
 459                         AKMDBG("MVFLAG is set to %d", flag);
 460                         break;
 461                 case ECS_IOCTL_APP_GET_MVFLAG:
 462                         flag = atomic_read(&mv_flag);
 463                         break;
 464                 case ECS_IOCTL_APP_SET_DELAY:
 465                         akmd_delay = flag;
 466                         AKMDBG("Delay is set to %d", flag);
 467                         break;
 468                 case ECS_IOCTL_APP_GET_DELAY:
 469                         flag = akmd_delay;
 470                         break;
 471                 default:
 472                         return -ENOTTY;
 473         }
 474
 475         switch (cmd) {
 476                 case ECS_IOCTL_APP_GET_MFLAG:
 477                 case ECS_IOCTL_APP_GET_AFLAG:
 478                 case ECS_IOCTL_APP_GET_MVFLAG:
 479                 case ECS_IOCTL_APP_GET_DELAY:
 480                         if (copy_to_user(argp, &flag, sizeof(flag))) {
 481                                 return -EFAULT;
 482                         }
 483                         break;
 484                 default:
 485                         break;
 486         }
 487
 488         return 0;
 489 }
 490
 491 /***** akmd functions ********************************************/
 492 static int akmd_open(struct inode *inode, struct file *file)
 493 {
 494         AKMFUNC("akmd_open");
 495         return nonseekable_open(inode, file);
 496 }
 497
 498 static int akmd_release(struct inode *inode, struct file *file)
 499 {
 500         AKMFUNC("akmd_release");
 501         AKECS_CloseDone();
 502         return 0;
 503 }
 504
 505
 506 static int akm_get_platform_data(struct akm8975_platform_data __user *arg)
 507 {
 508         struct akm8975_data *data = (struct akm8975_data *)i2c_get_clientdata(this_client);
 509         struct akm8975_platform_data *pdata_slave;
 510 //      struct akm8975_platform_data local_pdata_slave;
 511
 512 //      if (copy_from_user(&local_pdata_slave, arg, sizeof(local_pdata_slave)))
 513 //              return -EFAULT;
 514         pdata_slave = data->pdata;
 515         if (!pdata_slave)
 516                 return -ENODEV;
 517         if (copy_to_user(arg, pdata_slave, sizeof(*pdata_slave)))
 518                 return -EFAULT;
 519
 520         return 0;
 521 }
 522
 523
 524
 525 //static int akmd_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 526 //                 unsigned long arg)
 527
 528 static long akmd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 529 {
 530         void __user *argp = (void __user *)arg;
 531         AKMDBG("enter %s\n", __func__);
 532
 533         /* NOTE: In this function the size of "char" should be 1-byte. */
 534         char sData[SENSOR_DATA_SIZE];/* for GETDATA */
 535         char rwbuf[RWBUF_SIZE];         /* for READ/WRITE */
 536         char mode;                                      /* for SET_MODE*/
 537         short value[12];                        /* for SET_YPR */
 538         short delay;                            /* for GET_DELAY */
 539         int status;                                     /* for OPEN/CLOSE_STATUS */
 540         int ret = -1;                           /* Return value. */
 541         /*AKMDBG("%s (0x%08X).", __func__, cmd);*/
 542
 543         switch (cmd) {
 544                 case ECS_IOCTL_WRITE:
 545                 case ECS_IOCTL_READ:
 546                         if (argp == NULL) {
 547                                 AKMDBG("invalid argument.");
 548                                 return -EINVAL;
 549                         }
 550                         if (copy_from_user(&rwbuf, argp, sizeof(rwbuf))) {
 551                                 AKMDBG("copy_from_user failed.");
 552                                 return -EFAULT;
 553                         }
 554                         break;
 555                 case ECS_IOCTL_SET_MODE:
 556                         if (argp == NULL) {
 557                                 AKMDBG("invalid argument.");
 558                                 return -EINVAL;
 559                         }
 560                         if (copy_from_user(&mode, argp, sizeof(mode))) {
 561                                 AKMDBG("copy_from_user failed.");
 562                                 return -EFAULT;
 563                         }
 564                         break;
 565                 case ECS_IOCTL_SET_YPR:
 566                         if (argp == NULL) {
 567                                 AKMDBG("invalid argument.");
 568                                 return -EINVAL;
 569                         }
 570                         if (copy_from_user(&value, argp, sizeof(value))) {
 571                                 AKMDBG("copy_from_user failed.");
 572                                 return -EFAULT;
 573                         }
 574                         break;
 575                 default:
 576                         break;
 577         }
 578
 579         switch (cmd) {
 580                 case ECS_IOCTL_WRITE:
 581                         AKMFUNC("IOCTL_WRITE");
 582                         if ((rwbuf[0] < 2) || (rwbuf[0] > (RWBUF_SIZE-1))) {
 583                                 AKMDBG("invalid argument.");
 584                                 return -EINVAL;
 585                         }
 586                         ret = AKI2C_TxData(&rwbuf[1], rwbuf[0]);
 587                         if (ret < 0) {
 588                                 return ret;
 589                         }
 590                         break;
 591                 case ECS_IOCTL_READ:
 592                         AKMFUNC("IOCTL_READ");
 593                         if ((rwbuf[0] < 1) || (rwbuf[0] > (RWBUF_SIZE-1))) {
 594                                 AKMDBG("invalid argument.");
 595                                 return -EINVAL;
 596                         }
 597                         ret = AKI2C_RxData(&rwbuf[1], rwbuf[0]);
 598                         if (ret < 0) {
 599                                 return ret;
 600                         }
 601                         break;
 602                 case ECS_IOCTL_SET_MODE:
 603                         AKMFUNC("IOCTL_SET_MODE");
 604                         ret = AKECS_SetMode(mode);
 605                         if (ret < 0) {
 606                                 return ret;
 607                         }
 608                         break;
 609                 case ECS_IOCTL_GETDATA:
 610                         AKMFUNC("IOCTL_GET_DATA");
 611                         ret = AKECS_GetData(sData, SENSOR_DATA_SIZE);
 612                         if (ret < 0) {
 613                                 return ret;
 614                         }
 615                         break;
 616                 case ECS_IOCTL_SET_YPR:
 617                         AKECS_SetYPR(value);
 618                         break;
 619                 case ECS_IOCTL_GET_OPEN_STATUS:
 620                         AKMFUNC("IOCTL_GET_OPEN_STATUS");
 621                         status = AKECS_GetOpenStatus();
 622                         AKMDBG("AKECS_GetOpenStatus returned (%d)", status);
 623                         break;
 624                 case ECS_IOCTL_GET_CLOSE_STATUS:
 625                         AKMFUNC("IOCTL_GET_CLOSE_STATUS");
 626                         status = AKECS_GetCloseStatus();
 627                         AKMDBG("AKECS_GetCloseStatus returned (%d)", status);
 628                         break;
 629                 case ECS_IOCTL_GET_DELAY:
 630                         AKMFUNC("IOCTL_GET_DELAY");
 631                         delay = akmd_delay;
 632                         break;
 633                 case ECS_IOCTL_GET_PLATFORM_DATA:
 634                         ret = akm_get_platform_data((struct akm8975_platform_data __user *)arg);
 635                         if(ret < 0)
 636                         {
 637                                 printk("%s:error,ret=%d\n",__FUNCTION__, ret);
 638                                 return ret;
 639                         }
 640                         break;
 641
 642                 default:
 643                         return -ENOTTY;
 644         }
 645
 646         switch (cmd) {
 647                 case ECS_IOCTL_READ:
 648                         if (copy_to_user(argp, &rwbuf, rwbuf[0]+1)) {
 649                                 AKMDBG("copy_to_user failed.");
 650                                 return -EFAULT;
 651                         }
 652                         break;
 653                 case ECS_IOCTL_GETDATA:
 654                         if (copy_to_user(argp, &sData, sizeof(sData))) {
 655                                 AKMDBG("copy_to_user failed.");
 656                                 return -EFAULT;
 657                         }
 658                         break;
 659                 case ECS_IOCTL_GET_OPEN_STATUS:
 660                 case ECS_IOCTL_GET_CLOSE_STATUS:
 661                         if (copy_to_user(argp, &status, sizeof(status))) {
 662                                 AKMDBG("copy_to_user failed.");
 663                                 return -EFAULT;
 664                         }
 665                         break;
 666                 case ECS_IOCTL_GET_DELAY:
 667                         if (copy_to_user(argp, &delay, sizeof(delay))) {
 668                                 AKMDBG("copy_to_user failed.");
 669                                 return -EFAULT;
 670                         }
 671                         break;
 672                 default:
 673                         break;
 674         }
 675
 676         return 0;
 677 }
 678
 679 static void akm8975_work_func(struct work_struct *work)
 680 {
 681         char buffer[SENSOR_DATA_SIZE];
 682         int ret;
 683         AKMDBG("enter %s\n", __func__);
 684
 685         memset(buffer, 0, SENSOR_DATA_SIZE);
 686         buffer[0] = AK8975_REG_ST1;
 687         ret = AKI2C_RxData(buffer, SENSOR_DATA_SIZE);
 688         if (ret < 0) {
 689                 printk(KERN_ERR "AKM8975 akm8975_work_func: I2C failed\n");
 690                 return;
 691         }
 692         /* Check ST bit */
 693         if ((buffer[0] & 0x01) != 0x01) {
 694                 printk(KERN_ERR "AKM8975 akm8975_work_func: ST is not set\n");
 695                 return;
 696         }
 697
 698         mutex_lock(&sense_data_mutex);
 699         memcpy(sense_data, buffer, SENSOR_DATA_SIZE);
 700         atomic_set(&data_ready, 1);
 701         wake_up(&data_ready_wq);
 702         mutex_unlock(&sense_data_mutex);
 703
 704         enable_irq(this_client->irq);
 705
 706         AKMFUNC("akm8975_work_func");
 707 }
 708
 709 static irqreturn_t akm8975_interrupt(int irq, void *dev_id)
 710 {
 711         struct akm8975_data *data = dev_id;
 712         AKMFUNC("akm8975_interrupt");
 713         disable_irq_nosync(this_client->irq);
 714         schedule_work(&data->work);
 715         AKMDBG("exit %s\n", __func__);
 716         return IRQ_HANDLED;
 717 }
 718
 719 static void akm8975_early_suspend(struct early_suspend *handler)
 720 {
 721         AKMFUNC("akm8975_early_suspend");
 722         atomic_set(&suspend_flag, 1);
 723         atomic_set(&reserve_open_flag, atomic_read(&open_flag));
 724         atomic_set(&open_flag, 0);
 725         wake_up(&open_wq);
 726         disable_irq(this_client->irq);
 727         AKMDBG("suspended with flag=%d",
 728                atomic_read(&reserve_open_flag));
 729 }
 730
 731 static void akm8975_early_resume(struct early_suspend *handler)
 732 {
 733         AKMFUNC("akm8975_early_resume");
 734         enable_irq(this_client->irq);
 735         atomic_set(&suspend_flag, 0);
 736         atomic_set(&open_flag, atomic_read(&reserve_open_flag));
 737         wake_up(&open_wq);
 738         AKMDBG("resumed with flag=%d",
 739                atomic_read(&reserve_open_flag));
 740 }
 741 static int akm8975_suspend(struct i2c_client *client, pm_message_t mesg)
 742 {
 743         AKMFUNC("akm8975_early_suspend");
 744         atomic_set(&suspend_flag, 1);
 745         atomic_set(&reserve_open_flag, atomic_read(&open_flag));
 746         atomic_set(&open_flag, 0);
 747         wake_up(&open_wq);
 748         disable_irq(this_client->irq);
 749         AKMDBG("suspended with flag=%d",
 750                atomic_read(&reserve_open_flag));
 751         return 0;
 752 }
 753
 754 static int akm8975_resume(struct i2c_client *client)
 755 {
 756         AKMFUNC("akm8975_early_resume");
 757         enable_irq(this_client->irq);
 758         atomic_set(&suspend_flag, 0);
 759         atomic_set(&open_flag, atomic_read(&reserve_open_flag));
 760         wake_up(&open_wq);
 761         AKMDBG("resumed with flag=%d",
 762                atomic_read(&reserve_open_flag));
 763         return 0;
 764 }
 765 /*********************************************/
 766 static struct file_operations akmd_fops = {
 767         .owner = THIS_MODULE,
 768         .open = akmd_open,
 769         .release = akmd_release,
 770         .unlocked_ioctl = akmd_ioctl,
 771 };
 772
 773 static struct file_operations akm_aot_fops = {
 774         .owner = THIS_MODULE,
 775         .open = akm_aot_open,
 776         .release = akm_aot_release,
 777         .unlocked_ioctl = akm_aot_ioctl,
 778 };
 779
 780 static struct miscdevice akmd_device = {
 781         .minor = MISC_DYNAMIC_MINOR,
 782         .name = "akm8975_dev",
 783         .fops = &akmd_fops,
 784 };
 785
 786 static struct miscdevice akm_aot_device = {
 787         .minor = MISC_DYNAMIC_MINOR,
 788         .name = "akm8975_aot",
 789         .fops = &akm_aot_fops,
 790 };
 791
 792 /*********************************************/
 793 int akm8975_probe(struct i2c_client *client, const struct i2c_device_id *id)
 794 {
 795         struct akm8975_data *akm;
 796         int err = 0;
 797
 798         AKMFUNC("akm8975_probe");
 799
 800         if (client->dev.platform_data == NULL) {
 801                 dev_err(&client->dev, "platform data is NULL. exiting.\n");
 802                 err = -ENODEV;
 803                 goto exit0;
 804         }
 805
 806         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 807                 printk(KERN_ERR "AKM8975 akm8975_probe: check_functionality failed.\n");
 808                 err = -ENODEV;
 809                 goto exit0;
 810         }
 811
 812         /* Allocate memory for driver data */
 813         akm = kzalloc(sizeof(struct akm8975_data), GFP_KERNEL);
 814         if (!akm) {
 815                 printk(KERN_ERR "AKM8975 akm8975_probe: memory allocation failed.\n");
 816                 err = -ENOMEM;
 817                 goto exit1;
 818         }
 819
 820         akm->pdata = client->dev.platform_data;
 821
 822         INIT_WORK(&akm->work, akm8975_work_func);
 823         i2c_set_clientdata(client, akm);
 824
 825         this_client = client;
 826
 827         /* Check connection */
 828         err = AKECS_CheckDevice();
 829         if (err < 0) {
 830                 printk(KERN_ERR "AKM8975 akm8975_probe: set power down mode error\n");
 831                 goto exit3;
 832         }
 833         akm->eoc_irq = client->irq;
 834         if (!akm->eoc_irq) {
 835                 dev_dbg(&akm->client->dev, "no IRQ?\n");
 836                 return -ENODEV;
 837         }else{
 838                 AKMDBG("gpio %d to irq %d\n", akm->eoc_irq, gpio_to_irq(akm->eoc_irq));
 839                 akm->eoc_irq = gpio_to_irq(akm->eoc_irq);
 840         }
 841         err = gpio_request(client->irq, "ak_8975");
 842         if (err < 0) {
 843                 dev_err(&client->dev, "failed to request GPIO, error %d\n", err);
 844                 goto exit3;
 845         }
 846
 847         err = gpio_direction_input(client->irq);
 848         if (err) {
 849                 dev_err(&client->dev, "failed to set GPIO direction, error %d\n", err);
 850                 goto exit3;
 851         }
 852         gpio_pull_updown(client->irq, GPIOPullDown);
 853
 854         /* IRQ */
 855         err = request_irq(akm->eoc_irq, akm8975_interrupt, IRQ_TYPE_EDGE_RISING,
 856                                           "akm8975_DRDY", akm);
 857         if (err < 0) {
 858                 printk(KERN_ERR "AKM8975 akm8975_probe: request irq failed\n");
 859                 goto exit4;
 860         }
 861
 862         client->irq = akm->eoc_irq;
 863
 864         /* Declare input device */
 865         akm->input_dev = input_allocate_device();
 866         if (!akm->input_dev) {
 867                 err = -ENOMEM;
 868                 printk(KERN_ERR
 869                        "AKM8975 akm8975_probe: Failed to allocate input device\n");
 870                 goto exit5;
 871         }
 872         /* Setup input device */
 873         set_bit(EV_ABS, akm->input_dev->evbit);
 874         /* yaw (0, 360) */
 875         input_set_abs_params(akm->input_dev, ABS_RX, 0, 23040, 0, 0);
 876         /* pitch (-180, 180) */
 877         input_set_abs_params(akm->input_dev, ABS_RY, -11520, 11520, 0, 0);
 878         /* roll (-90, 90) */
 879         input_set_abs_params(akm->input_dev, ABS_RZ, -5760, 5760, 0, 0);
 880         /* x-axis acceleration (720 x 8G) */
 881         input_set_abs_params(akm->input_dev, ABS_X, -5760, 5760, 0, 0);
 882         /* y-axis acceleration (720 x 8G) */
 883         input_set_abs_params(akm->input_dev, ABS_Y, -5760, 5760, 0, 0);
 884         /* z-axis acceleration (720 x 8G) */
 885         input_set_abs_params(akm->input_dev, ABS_Z, -5760, 5760, 0, 0);
 886         /* temparature */
 887         /*
 888         input_set_abs_params(akm->input_dev, ABS_THROTTLE, -30, 85, 0, 0);
 889          */
 890         /* status of magnetic sensor */
 891         input_set_abs_params(akm->input_dev, ABS_RUDDER, -32768, 3, 0, 0);
 892         /* status of acceleration sensor */
 893         input_set_abs_params(akm->input_dev, ABS_WHEEL, -32768, 3, 0, 0);
 894         /* x-axis of raw magnetic vector (-4096, 4095) */
 895         input_set_abs_params(akm->input_dev, ABS_HAT0X, -20480, 20479, 0, 0);
 896         /* y-axis of raw magnetic vector (-4096, 4095) */
 897         input_set_abs_params(akm->input_dev, ABS_HAT0Y, -20480, 20479, 0, 0);
 898         /* z-axis of raw magnetic vector (-4096, 4095) */
 899         input_set_abs_params(akm->input_dev, ABS_BRAKE, -20480, 20479, 0, 0);
 900         /* Set name */
 901         akm->input_dev->name = "compass";
 902
 903         /* Register */
 904         err = input_register_device(akm->input_dev);
 905         if (err) {
 906                 printk(KERN_ERR
 907                        "AKM8975 akm8975_probe: Unable to register input device\n");
 908                 goto exit6;
 909         }
 910
 911         err = misc_register(&akmd_device);
 912         if (err) {
 913                 printk(KERN_ERR
 914                            "AKM8975 akm8975_probe: akmd_device register failed\n");
 915                 goto exit7;
 916         }
 917
 918         err = misc_register(&akm_aot_device);
 919         if (err) {
 920                 printk(KERN_ERR
 921                        "AKM8975 akm8975_probe: akm_aot_device register failed\n");
 922                 goto exit8;
 923         }
 924
 925         mutex_init(&sense_data_mutex);
 926
 927         init_waitqueue_head(&data_ready_wq);
 928         init_waitqueue_head(&open_wq);
 929
 930         /* As default, report all information */
 931         atomic_set(&m_flag, 1);
 932         atomic_set(&a_flag, 1);
 933         atomic_set(&mv_flag, 1);
 934
 935         //akm->akm_early_suspend.suspend = akm8975_early_suspend;
 936         //akm->akm_early_suspend.resume = akm8975_early_resume;
 937         //register_early_suspend(&akm->akm_early_suspend);
 938
 939         AKMDBG("successfully probed.");
 940         return 0;
 941
 942 exit8:
 943         misc_deregister(&akmd_device);
 944 exit7:
 945         input_unregister_device(akm->input_dev);
 946 exit6:
 947         input_free_device(akm->input_dev);
 948 exit5:
 949         free_irq(client->irq, akm);
 950 exit4:
 951 exit3:
 952         kfree(akm);
 953 exit1:
 954 exit0:
 955         return err;
 956
 957 }
 958
 959 static int akm8975_remove(struct i2c_client *client)
 960 {
 961         struct akm8975_data *akm = i2c_get_clientdata(client);
 962         AKMFUNC("akm8975_remove");
 963         unregister_early_suspend(&akm->akm_early_suspend);
 964         misc_deregister(&akm_aot_device);
 965         misc_deregister(&akmd_device);
 966         input_unregister_device(akm->input_dev);
 967         free_irq(client->irq, akm);
 968         kfree(akm);
 969         AKMDBG("successfully removed.");
 970         return 0;
 971 }
 972
 973 static const struct i2c_device_id akm8975_id[] = {
 974         {AKM8975_I2C_NAME, 0 },
 975         { }
 976 };
 977
 978 static struct i2c_driver akm8975_driver = {
 979         .probe          = akm8975_probe,
 980         .remove         = akm8975_remove,
 981         .suspend = akm8975_suspend,
 982         .resume = akm8975_resume,
 983         .id_table       = akm8975_id,
 984         .driver = {
 985                 .name = AKM8975_I2C_NAME,
 986         },
 987 };
 988
 989 static int __init akm8975_init(void)
 990 {
 991         printk(KERN_INFO "AKM8975 compass driver: initialize\n");
 992         return i2c_add_driver(&akm8975_driver);
 993 }
 994
 995 static void __exit akm8975_exit(void)
 996 {
 997         printk(KERN_INFO "AKM8975 compass driver: release\n");
 998         i2c_del_driver(&akm8975_driver);
 999 }
1000
1001 module_init(akm8975_init);
1002 module_exit(akm8975_exit);
1003
1004 MODULE_AUTHOR("viral wang <viral_wang@htc.com>");
1005 MODULE_DESCRIPTION("AKM8975 compass driver");
1006 MODULE_LICENSE("GPL");
1007