drivers/input/magnetometer/ak8973.c

   1 /*
   2  * drivers/i2c/chips/ak8973.c - ak8973 compass driver
   3  *
   4  *  Copyright (C) 2008 viral wang <viralwang@gmail.com>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; version 2 of the License.
   9  */
  10
  11 #include <linux/interrupt.h>
  12 #include <linux/i2c.h>
  13 #include <linux/slab.h>
  14 #include <linux/irq.h>
  15 #include <linux/miscdevice.h>
  16 #include <asm/gpio.h>
  17 #include <asm/uaccess.h>
  18 #include <linux/delay.h>
  19 #include <linux/input.h>
  20 #include <linux/workqueue.h>
  21 #include <linux/freezer.h>
  22 #include "ak8973.h"
  23 #include<linux/earlysuspend.h>
  24
  25 #define DEBUG 0
  26 #define MAX_FAILURE_COUNT 3
  27
  28 static struct i2c_client *this_client;
  29
  30 struct akm8973_data {
  31         struct input_dev *input_dev;
  32         struct work_struct work;
  33 #ifdef CONFIG_HAS_EARLYSUSPEND
  34         struct early_suspend early_suspend_akm;
  35 #endif
  36 };
  37
  38 /* Addresses to scan -- protected by sense_data_mutex */
  39 static char sense_data[RBUFF_SIZE + 1];
  40 static struct mutex sense_data_mutex;
  41 #define AKM8973_RETRY_COUNT 10
  42 static DECLARE_WAIT_QUEUE_HEAD(data_ready_wq);
  43 static DECLARE_WAIT_QUEUE_HEAD(open_wq);
  44
  45 static atomic_t data_ready;
  46 static atomic_t open_count;
  47 static atomic_t open_flag;
  48 static atomic_t reserve_open_flag;
  49
  50 static atomic_t m_flag;
  51 static atomic_t a_flag;
  52 static atomic_t t_flag;
  53 static atomic_t mv_flag;
  54
  55 static int failure_count = 0;
  56
  57 static short akmd_delay = 0;
  58 #ifdef CONFIG_HAS_EARLYSUSPEND
  59 static atomic_t suspend_flag = ATOMIC_INIT(0);
  60 #endif
  61
  62 static int AKI2C_RxData(char *rxData, int length)
  63 {
  64         uint8_t loop_i;
  65         struct i2c_msg msgs[] = {
  66                 {
  67                  .addr = this_client->addr,
  68                  .flags = 0,
  69                  .len = 1,
  70                  .buf = rxData,
  71                  },
  72                 {
  73                  .addr = this_client->addr,
  74                  .flags = I2C_M_RD,
  75                  .len = length,
  76                  .buf = rxData,
  77                  },
  78         };
  79
  80         for (loop_i = 0; loop_i < AKM8973_RETRY_COUNT; loop_i++) {
  81                 if (i2c_transfer(this_client->adapter, msgs, 2) > 0) {
  82                         break;
  83                 }
  84                 mdelay(10);
  85         }
  86
  87         if (loop_i >= AKM8973_RETRY_COUNT) {
  88                 printk(KERN_ERR "%s retry over %d\n", __func__, AKM8973_RETRY_COUNT);
  89                 return -EIO;
  90         }
  91         return 0;
  92 }
  93
  94 static int AKI2C_TxData(char *txData, int length)
  95 {
  96         uint8_t loop_i;
  97         struct i2c_msg msg[] = {
  98                 {
  99                  .addr = this_client->addr,
 100                  .flags = 0,
 101                  .len = length,
 102                  .buf = txData,
 103                  },
 104         };
 105
 106         for (loop_i = 0; loop_i < AKM8973_RETRY_COUNT; loop_i++) {
 107                 if (i2c_transfer(this_client->adapter, msg, 1) > 0) {
 108                         break;
 109                 }
 110                 mdelay(10);
 111         }
 112
 113         if (loop_i >= AKM8973_RETRY_COUNT) {
 114                 printk(KERN_ERR "%s retry over %d\n", __func__, AKM8973_RETRY_COUNT);
 115                 return -EIO;
 116         }
 117         return 0;
 118 }
 119
 120 static int AKECS_StartMeasure(void)
 121 {
 122         char buffer[2];
 123
 124         /* Set measure mode */
 125         buffer[0] = AKECS_REG_MS1;
 126         buffer[1] = AKECS_MODE_MEASURE;
 127
 128         /* Set data */
 129         return AKI2C_TxData(buffer, 2);
 130 }
 131
 132 static int AKECS_PowerDown(void)
 133 {
 134         char buffer[2];
 135         int ret;
 136
 137         /* Set powerdown mode */
 138         buffer[0] = AKECS_REG_MS1;
 139         buffer[1] = AKECS_MODE_POWERDOWN;
 140         /* Set data */
 141         ret = AKI2C_TxData(buffer, 2);
 142         if (ret < 0)
 143                 return ret;
 144
 145         /* Dummy read for clearing INT pin */
 146         buffer[0] = AKECS_REG_TMPS;
 147         /* Read data */
 148         ret = AKI2C_RxData(buffer, 1);
 149         if (ret < 0)
 150                 return ret;
 151         return ret;
 152 }
 153
 154 static int AKECS_StartE2PRead(void)
 155 {
 156         char buffer[2];
 157
 158         /* Set measure mode */
 159         buffer[0] = AKECS_REG_MS1;
 160         buffer[1] = AKECS_MODE_E2P_READ;
 161         /* Set data */
 162         return AKI2C_TxData(buffer, 2);
 163 }
 164
 165 static int AKECS_GetData(void)
 166 {
 167         char buffer[RBUFF_SIZE + 1];
 168         int ret;
 169
 170         memset(buffer, 0, RBUFF_SIZE + 1);
 171         buffer[0] = AKECS_REG_ST;
 172         ret = AKI2C_RxData(buffer, RBUFF_SIZE+1);
 173         if (ret < 0)
 174                 return ret;
 175
 176         mutex_lock(&sense_data_mutex);
 177         memcpy(sense_data, buffer, sizeof(buffer));
 178         atomic_set(&data_ready, 1);
 179         wake_up(&data_ready_wq);
 180         mutex_unlock(&sense_data_mutex);
 181
 182         return 0;
 183 }
 184
 185 static int AKECS_SetMode(char mode)
 186 {
 187         int ret;
 188
 189         switch (mode) {
 190         case AKECS_MODE_MEASURE:
 191                 ret = AKECS_StartMeasure();
 192                 break;
 193         case AKECS_MODE_E2P_READ:
 194                 ret = AKECS_StartE2PRead();
 195                 break;
 196         case AKECS_MODE_POWERDOWN:
 197                 ret = AKECS_PowerDown();
 198                 break;
 199         default:
 200                 return -EINVAL;
 201         }
 202
 203         /* wait at least 300us after changing mode */
 204         msleep(1);
 205         return ret;
 206 }
 207
 208 static int AKECS_TransRBuff(char *rbuf, int size)
 209 {
 210         wait_event_interruptible_timeout(data_ready_wq,
 211                                          atomic_read(&data_ready), 1000);
 212         if (!atomic_read(&data_ready)) {
 213                 #ifdef CONFIG_HAS_EARLYSUSPEND
 214                 if (!atomic_read(&suspend_flag)) {
 215                         printk(KERN_ERR
 216                                 "AKM8973 AKECS_TransRBUFF: Data not ready\n");
 217                         failure_count++;
 218                         if (failure_count >= MAX_FAILURE_COUNT) {
 219                                 printk(KERN_ERR
 220                                        "AKM8973 AKECS_TransRBUFF: successive %d failure.\n",
 221                                        failure_count);
 222                                 atomic_set(&open_flag, -1);
 223                                 wake_up(&open_wq);
 224                                 failure_count = 0;
 225                         }
 226                 }
 227                 #endif
 228                 return -1;
 229         }
 230
 231         mutex_lock(&sense_data_mutex);
 232         memcpy(&rbuf[1], &sense_data[1], size);
 233         atomic_set(&data_ready, 0);
 234         mutex_unlock(&sense_data_mutex);
 235
 236         failure_count = 0;
 237         return 0;
 238 }
 239
 240
 241 static void AKECS_Report_Value(short *rbuf)
 242 {
 243         struct akm8973_data *data = i2c_get_clientdata(this_client);
 244 #if DEBUG
 245         printk(KERN_INFO"AKECS_Report_Value: yaw = %d, pitch = %d, roll = %d\n", rbuf[0],
 246                rbuf[1], rbuf[2]);
 247         printk(KERN_INFO"                    tmp = %d, m_stat= %d, g_stat=%d\n", rbuf[3],
 248                rbuf[4], rbuf[5]);
 249         printk(KERN_INFO"          G_Sensor:   x = %d LSB, y = %d LSB, z = %d LSB\n",
 250                rbuf[6], rbuf[7], rbuf[8]);
 251 #endif
 252         /* Report magnetic sensor information */
 253         if (atomic_read(&m_flag)) {
 254                 input_report_abs(data->input_dev, ABS_RX, rbuf[0]);
 255                 input_report_abs(data->input_dev, ABS_RY, rbuf[1]);
 256                 input_report_abs(data->input_dev, ABS_RZ, rbuf[2]);
 257                 input_report_abs(data->input_dev, ABS_RUDDER, rbuf[4]);
 258         }
 259
 260         /* Report acceleration sensor information */
 261         if (atomic_read(&a_flag)) {
 262                 input_report_abs(data->input_dev, ABS_X, rbuf[6]);
 263                 input_report_abs(data->input_dev, ABS_Y, rbuf[7]);
 264                 input_report_abs(data->input_dev, ABS_Z, rbuf[8]);
 265                 input_report_abs(data->input_dev, ABS_WHEEL, rbuf[5]);
 266         }
 267
 268         /* Report temperature information */
 269         if (atomic_read(&t_flag))
 270                 input_report_abs(data->input_dev, ABS_THROTTLE, rbuf[3]);
 271
 272         if (atomic_read(&mv_flag)) {
 273                 input_report_abs(data->input_dev, ABS_HAT0X, rbuf[9]);
 274                 input_report_abs(data->input_dev, ABS_HAT0Y, rbuf[10]);
 275                 input_report_abs(data->input_dev, ABS_BRAKE, rbuf[11]);
 276         }
 277
 278         input_sync(data->input_dev);
 279 }
 280
 281 static int AKECS_GetOpenStatus(void)
 282 {
 283         wait_event_interruptible(open_wq, (atomic_read(&open_flag) != 0));
 284         return atomic_read(&open_flag);
 285 }
 286
 287 static int AKECS_GetCloseStatus(void)
 288 {
 289         wait_event_interruptible(open_wq, (atomic_read(&open_flag) <= 0));
 290         return atomic_read(&open_flag);
 291 }
 292
 293 static void AKECS_CloseDone(void)
 294 {
 295         atomic_set(&m_flag, 1);
 296         atomic_set(&a_flag, 1);
 297         atomic_set(&t_flag, 1);
 298         atomic_set(&mv_flag, 1);
 299 }
 300
 301 static int akm_aot_open(struct inode *inode, struct file *file)
 302 {
 303         int ret = -1;
 304         if (atomic_cmpxchg(&open_count, 0, 1) == 0) {
 305                 if (atomic_cmpxchg(&open_flag, 0, 1) == 0) {
 306                         atomic_set(&reserve_open_flag, 1);
 307                         wake_up(&open_wq);
 308                         ret = 0;
 309                 }
 310         }
 311         return ret;
 312 }
 313
 314 static int akm_aot_release(struct inode *inode, struct file *file)
 315 {
 316         atomic_set(&reserve_open_flag, 0);
 317         atomic_set(&open_flag, 0);
 318         atomic_set(&open_count, 0);
 319         wake_up(&open_wq);
 320         return 0;
 321 }
 322
 323 static int
 324 akm_aot_ioctl(struct inode *inode, struct file *file,
 325               unsigned int cmd, unsigned long arg)
 326 {
 327         void __user *argp = (void __user *)arg;
 328         short flag;
 329
 330         switch (cmd) {
 331         case ECS_IOCTL_APP_SET_MFLAG:
 332         case ECS_IOCTL_APP_SET_AFLAG:
 333         case ECS_IOCTL_APP_SET_TFLAG:
 334         case ECS_IOCTL_APP_SET_MVFLAG:
 335                 if (copy_from_user(&flag, argp, sizeof(flag)))
 336                         return -EFAULT;
 337                 if (flag < 0 || flag > 1)
 338                         return -EINVAL;
 339                 break;
 340         case ECS_IOCTL_APP_SET_DELAY:
 341                 if (copy_from_user(&flag, argp, sizeof(flag)))
 342                         return -EFAULT;
 343                 break;
 344         default:
 345                 break;
 346         }
 347
 348         switch (cmd) {
 349         case ECS_IOCTL_APP_SET_MFLAG:
 350                 atomic_set(&m_flag, flag);
 351                 break;
 352         case ECS_IOCTL_APP_GET_MFLAG:
 353                 flag = atomic_read(&m_flag);
 354                 break;
 355         case ECS_IOCTL_APP_SET_AFLAG:
 356                 atomic_set(&a_flag, flag);
 357                 break;
 358         case ECS_IOCTL_APP_GET_AFLAG:
 359                 flag = atomic_read(&a_flag);
 360                 break;
 361         case ECS_IOCTL_APP_SET_TFLAG:
 362                 atomic_set(&t_flag, flag);
 363                 break;
 364         case ECS_IOCTL_APP_GET_TFLAG:
 365                 flag = atomic_read(&t_flag);
 366                 break;
 367         case ECS_IOCTL_APP_SET_MVFLAG:
 368                 atomic_set(&mv_flag, flag);
 369                 break;
 370         case ECS_IOCTL_APP_GET_MVFLAG:
 371                 flag = atomic_read(&mv_flag);
 372                 break;
 373         case ECS_IOCTL_APP_SET_DELAY:
 374                 akmd_delay = flag;
 375                 break;
 376         case ECS_IOCTL_APP_GET_DELAY:
 377                 flag = akmd_delay;
 378                 break;
 379         default:
 380                 return -ENOTTY;
 381         }
 382
 383         switch (cmd) {
 384         case ECS_IOCTL_APP_GET_MFLAG:
 385         case ECS_IOCTL_APP_GET_AFLAG:
 386         case ECS_IOCTL_APP_GET_TFLAG:
 387         case ECS_IOCTL_APP_GET_MVFLAG:
 388         case ECS_IOCTL_APP_GET_DELAY:
 389                 if (copy_to_user(argp, &flag, sizeof(flag)))
 390                         return -EFAULT;
 391                 break;
 392         default:
 393                 break;
 394         }
 395
 396         return 0;
 397 }
 398
 399 static int akmd_open(struct inode *inode, struct file *file)
 400 {
 401         return nonseekable_open(inode, file);
 402 }
 403
 404 static int akmd_release(struct inode *inode, struct file *file)
 405 {
 406         AKECS_CloseDone();
 407         return 0;
 408 }
 409
 410 static int
 411 akmd_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 412            unsigned long arg)
 413 {
 414
 415         void __user *argp = (void __user *)arg;
 416
 417         char msg[RBUFF_SIZE + 1], rwbuf[5];
 418         int ret = -1, status;
 419         short mode, value[12], delay;
 420
 421         switch (cmd) {
 422         case ECS_IOCTL_WRITE:
 423         case ECS_IOCTL_READ:
 424                 if (copy_from_user(&rwbuf, argp, sizeof(rwbuf)))
 425                         return -EFAULT;
 426                 break;
 427         case ECS_IOCTL_SET_MODE:
 428                 if (copy_from_user(&mode, argp, sizeof(mode)))
 429                         return -EFAULT;
 430                 break;
 431         case ECS_IOCTL_SET_YPR:
 432                 if (copy_from_user(&value, argp, sizeof(value)))
 433                         return -EFAULT;
 434                 break;
 435         default:
 436                 break;
 437         }
 438
 439         switch (cmd) {
 440         case ECS_IOCTL_WRITE:
 441                 if (rwbuf[0] < 2)
 442                         return -EINVAL;
 443                 ret = AKI2C_TxData(&rwbuf[1], rwbuf[0]);
 444                 if (ret < 0)
 445                         return ret;
 446                 break;
 447         case ECS_IOCTL_READ:
 448                 if (rwbuf[0] < 1)
 449                         return -EINVAL;
 450                 ret = AKI2C_RxData(&rwbuf[1], rwbuf[0]);
 451                 if (ret < 0)
 452                         return ret;
 453                 break;
 454         case ECS_IOCTL_SET_MODE:
 455                 ret = AKECS_SetMode((char)mode);
 456                 if (ret < 0)
 457                         return ret;
 458                 break;
 459         case ECS_IOCTL_GETDATA:
 460                 ret = AKECS_TransRBuff(msg, RBUFF_SIZE);
 461                 if (ret < 0)
 462                         return ret;
 463                 break;
 464         case ECS_IOCTL_SET_YPR:
 465                 AKECS_Report_Value(value);
 466                 break;
 467         case ECS_IOCTL_GET_OPEN_STATUS:
 468                 status = AKECS_GetOpenStatus();
 469                 break;
 470         case ECS_IOCTL_GET_CLOSE_STATUS:
 471                 status = AKECS_GetCloseStatus();
 472                 break;
 473         case ECS_IOCTL_GET_DELAY:
 474                 delay = akmd_delay;
 475                 break;
 476         default:
 477                 return -ENOTTY;
 478         }
 479
 480         switch (cmd) {
 481         case ECS_IOCTL_READ:
 482                 if (copy_to_user(argp, &rwbuf, sizeof(rwbuf)))
 483                         return -EFAULT;
 484                 break;
 485         case ECS_IOCTL_GETDATA:
 486                 if (copy_to_user(argp, &msg, sizeof(msg)))
 487                         return -EFAULT;
 488                 break;
 489         case ECS_IOCTL_GET_OPEN_STATUS:
 490         case ECS_IOCTL_GET_CLOSE_STATUS:
 491                 if (copy_to_user(argp, &status, sizeof(status)))
 492                         return -EFAULT;
 493                 break;
 494         case ECS_IOCTL_GET_DELAY:
 495                 if (copy_to_user(argp, &delay, sizeof(delay)))
 496                         return -EFAULT;
 497                 break;
 498         default:
 499                 break;
 500         }
 501
 502         return 0;
 503 }
 504
 505 static void akm_work_func(struct work_struct *work)
 506 {
 507         if (AKECS_GetData() < 0)
 508                 printk(KERN_ERR "AKM8973 akm_work_func: Get data failed\n");
 509         enable_irq(this_client->irq);
 510 }
 511
 512 static irqreturn_t akm8973_interrupt(int irq, void *dev_id)
 513 {
 514         struct akm8973_data *data = dev_id;
 515         disable_irq(this_client->irq);
 516         schedule_work(&data->work);
 517         return IRQ_HANDLED;
 518 }
 519 #ifdef CONFIG_HAS_EARLYSUSPEND
 520 static void akm8973_early_suspend(struct early_suspend *handler)
 521 {
 522         atomic_set(&suspend_flag, 1);
 523         atomic_set(&reserve_open_flag, atomic_read(&open_flag));
 524         atomic_set(&open_flag, 0);
 525         wake_up(&open_wq);
 526         disable_irq(this_client->irq);
 527 }
 528
 529 static void akm8973_early_resume(struct early_suspend *handler)
 530 {
 531         enable_irq(this_client->irq);
 532         atomic_set(&suspend_flag, 0);
 533         atomic_set(&open_flag, atomic_read(&reserve_open_flag));
 534         wake_up(&open_wq);
 535 }
 536 #endif
 537 static struct file_operations akmd_fops = {
 538         .owner = THIS_MODULE,
 539         .open = akmd_open,
 540         .release = akmd_release,
 541         .ioctl = akmd_ioctl,
 542 };
 543
 544 static struct file_operations akm_aot_fops = {
 545         .owner = THIS_MODULE,
 546         .open = akm_aot_open,
 547         .release = akm_aot_release,
 548         .ioctl = akm_aot_ioctl,
 549 };
 550
 551
 552 static struct miscdevice akm_aot_device = {
 553         .minor = MISC_DYNAMIC_MINOR,
 554         .name = "akm8973_aot",
 555         .fops = &akm_aot_fops,
 556 };
 557
 558
 559 static struct miscdevice akmd_device = {
 560         .minor = MISC_DYNAMIC_MINOR,
 561         .name = "akm8973_daemon",
 562         .fops = &akmd_fops,
 563 };
 564
 565 static ssize_t compass_reset_store(struct device *dev,
 566                                    struct device_attribute *attr,
 567                                    const char *buf, size_t count)
 568 {
 569         int val;
 570
 571         val = -1;
 572         sscanf(buf, "%u", &val);
 573         if (val != 1)
 574                 return -EINVAL;
 575
 576         return count;
 577 }
 578
 579 static DEVICE_ATTR(reset, 0644, NULL, compass_reset_store);
 580
 581 int akm8973_probe(struct i2c_client *client, const struct i2c_device_id *id)
 582 {
 583         struct akm8973_data *akm;
 584         int err = 0;
 585
 586         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 587                 err = -ENODEV;
 588                 goto exit_check_functionality_failed;
 589         }
 590
 591         akm = kzalloc(sizeof(struct akm8973_data), GFP_KERNEL);
 592         if (!akm) {
 593                 err = -ENOMEM;
 594                 goto exit_alloc_data_failed;
 595         }
 596
 597         INIT_WORK(&akm->work, akm_work_func);
 598         i2c_set_clientdata(client, akm);
 599
 600         this_client = client;
 601
 602         err = AKECS_PowerDown();
 603         if (err < 0) {
 604                 printk(KERN_ERR"AKM8973 akm8973_probe: set power down mode error\n");
 605                 goto exit_set_mode_failed;
 606         }
 607
 608         err = request_irq(client->irq, akm8973_interrupt, IRQF_TRIGGER_HIGH,
 609                           "akm8973", akm);
 610
 611         if (err < 0) {
 612                 printk(KERN_ERR"AKM8973 akm8973_probe: request irq failed\n");
 613                 goto exit_irq_request_failed;
 614         }
 615
 616         akm->input_dev = input_allocate_device();
 617
 618         if (!akm->input_dev) {
 619                 err = -ENOMEM;
 620                 printk(KERN_ERR
 621                        "AKM8973 akm8973_probe: Failed to allocate input device\n");
 622                 goto exit_input_dev_alloc_failed;
 623         }
 624
 625         set_bit(EV_ABS, akm->input_dev->evbit);
 626         /* yaw */
 627         input_set_abs_params(akm->input_dev, ABS_RX, 0, 360, 0, 0);
 628         /* pitch */
 629         input_set_abs_params(akm->input_dev, ABS_RY, -180, 180, 0, 0);
 630         /* roll */
 631         input_set_abs_params(akm->input_dev, ABS_RZ, -90, 90, 0, 0);
 632         /* x-axis acceleration */
 633         input_set_abs_params(akm->input_dev, ABS_X, -1872, 1872, 0, 0);
 634         /* y-axis acceleration */
 635         input_set_abs_params(akm->input_dev, ABS_Y, -1872, 1872, 0, 0);
 636         /* z-axis acceleration */
 637         input_set_abs_params(akm->input_dev, ABS_Z, -1872, 1872, 0, 0);
 638         /* temparature */
 639         input_set_abs_params(akm->input_dev, ABS_THROTTLE, -30, 85, 0, 0);
 640         /* status of magnetic sensor */
 641         input_set_abs_params(akm->input_dev, ABS_RUDDER, -32768, 3, 0, 0);
 642         /* status of acceleration sensor */
 643         input_set_abs_params(akm->input_dev, ABS_WHEEL, -32768, 3, 0, 0);
 644         /* step count */
 645         input_set_abs_params(akm->input_dev, ABS_GAS, 0, 65535, 0, 0);
 646         /* x-axis of raw magnetic vector */
 647         input_set_abs_params(akm->input_dev, ABS_HAT0X, -2048, 2032, 0, 0);
 648         /* y-axis of raw magnetic vector */
 649         input_set_abs_params(akm->input_dev, ABS_HAT0Y, -2048, 2032, 0, 0);
 650         /* z-axis of raw magnetic vector */
 651         input_set_abs_params(akm->input_dev, ABS_BRAKE, -2048, 2032, 0, 0);
 652
 653         akm->input_dev->name = "compass";
 654
 655         err = input_register_device(akm->input_dev);
 656
 657         if (err) {
 658                 printk(KERN_ERR
 659                        "AKM8973 akm8973_probe: Unable to register input device: %s\n",
 660                        akm->input_dev->name);
 661                 goto exit_input_register_device_failed;
 662         }
 663
 664         err = misc_register(&akmd_device);
 665         if (err) {
 666                 printk(KERN_ERR "AKM8973 akm8973_probe: akmd_device register failed\n");
 667                 goto exit_misc_device_register_failed;
 668         }
 669
 670         err = misc_register(&akm_aot_device);
 671         if (err) {
 672                 printk(KERN_ERR
 673                        "AKM8973 akm8973_probe: akm_aot_device register failed\n");
 674                 goto exit_misc_device_register_failed;
 675         }
 676
 677         mutex_init(&sense_data_mutex);
 678
 679         init_waitqueue_head(&data_ready_wq);
 680         init_waitqueue_head(&open_wq);
 681
 682         /* As default, report all information */
 683         atomic_set(&m_flag, 1);
 684         atomic_set(&a_flag, 1);
 685         atomic_set(&t_flag, 1);
 686         atomic_set(&mv_flag, 1);
 687 #ifdef CONFIG_HAS_EARLYSUSPEND
 688         akm->early_suspend_akm.suspend = akm8973_early_suspend;
 689         akm->early_suspend_akm.resume = akm8973_early_resume;
 690         register_early_suspend(&akm->early_suspend_akm);
 691 #endif
 692         err = device_create_file(&client->dev, &dev_attr_reset);
 693         if (err)
 694                 printk(KERN_ERR
 695                 "AKM8973 akm8973_probe: create dev_attr_reset failed\n");
 696
 697         return 0;
 698
 699 exit_misc_device_register_failed:
 700 exit_input_register_device_failed:
 701         input_free_device(akm->input_dev);
 702 exit_input_dev_alloc_failed:
 703         free_irq(client->irq, akm);
 704 exit_irq_request_failed:
 705 exit_set_mode_failed:
 706         kfree(akm);
 707 exit_alloc_data_failed:
 708 exit_check_functionality_failed:
 709         return err;
 710
 711 }
 712
 713 static int akm8973_remove(struct i2c_client *client)
 714 {
 715         struct akm8973_data *akm = i2c_get_clientdata(client);
 716         free_irq(client->irq, akm);
 717         input_unregister_device(akm->input_dev);
 718         kfree(akm);
 719         return 0;
 720 }
 721 static const struct i2c_device_id akm8973_id[] = {
 722         { AKM8973_I2C_NAME, 0 },
 723         { }
 724 };
 725
 726 static struct i2c_driver akm8973_driver = {
 727         .probe  = akm8973_probe,
 728         .remove         = akm8973_remove,
 729         .id_table       = akm8973_id,
 730         .driver = {
 731                    .name = AKM8973_I2C_NAME,
 732                 },
 733 };
 734
 735 static int __init akm8973_init(void)
 736 {
 737         printk(KERN_INFO "AKM8973 compass driver: init\n");
 738         return i2c_add_driver(&akm8973_driver);
 739 }
 740
 741 static void __exit akm8973_exit(void)
 742 {
 743         i2c_del_driver(&akm8973_driver);
 744 }
 745
 746 module_init(akm8973_init);
 747 module_exit(akm8973_exit);
 748
 749 MODULE_AUTHOR("viral wang <viral_wang@htc.com>");
 750 MODULE_DESCRIPTION("AKM8973 compass driver");
 751 MODULE_LICENSE("GPL");