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