drivers/misc/akm8975.c

   1 /* drivers/misc/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  * Revised by Motorola 2010/05/27
  20  *
  21  */
  22
  23 #include <linux/interrupt.h>
  24 #include <linux/i2c.h>
  25 #include <linux/slab.h>
  26 #include <linux/irq.h>
  27 #include <linux/miscdevice.h>
  28 #include <linux/gpio.h>
  29 #include <linux/uaccess.h>
  30 #include <linux/delay.h>
  31 #include <linux/input.h>
  32 #include <linux/workqueue.h>
  33 #include <linux/freezer.h>
  34 #include <linux/akm8975.h>
  35 #include <linux/earlysuspend.h>
  36
  37 #define AK8975DRV_CALL_DBG 0
  38 #if AK8975DRV_CALL_DBG
  39 #define FUNCDBG(msg)    pr_err("%s:%s\n", __func__, msg);
  40 #else
  41 #define FUNCDBG(msg)
  42 #endif
  43
  44 #define AK8975DRV_DATA_DBG 0
  45 #define MAX_FAILURE_COUNT 10
  46
  47 struct akm8975_data {
  48         struct i2c_client *this_client;
  49         struct akm8975_platform_data *pdata;
  50         struct input_dev *input_dev;
  51         struct work_struct work;
  52         struct mutex flags_lock;
  53 #ifdef CONFIG_HAS_EARLYSUSPEND
  54         struct early_suspend early_suspend;
  55 #endif
  56 };
  57
  58 /*
  59 * Because misc devices can not carry a pointer from driver register to
  60 * open, we keep this global. This limits the driver to a single instance.
  61 */
  62 struct akm8975_data *akmd_data;
  63
  64 static DECLARE_WAIT_QUEUE_HEAD(open_wq);
  65
  66 static atomic_t open_flag;
  67
  68 static short m_flag;
  69 static short a_flag;
  70 static short t_flag;
  71 static short mv_flag;
  72
  73 static short akmd_delay;
  74
  75 static ssize_t akm8975_show(struct device *dev, struct device_attribute *attr,
  76                                  char *buf)
  77 {
  78         struct i2c_client *client = to_i2c_client(dev);
  79         return sprintf(buf, "%u\n", i2c_smbus_read_byte_data(client,
  80                                                              AK8975_REG_CNTL));
  81 }
  82 static ssize_t akm8975_store(struct device *dev, struct device_attribute *attr,
  83                             const char *buf, size_t count)
  84 {
  85         struct i2c_client *client = to_i2c_client(dev);
  86         unsigned long val;
  87         strict_strtoul(buf, 10, &val);
  88         if (val > 0xff)
  89                 return -EINVAL;
  90         i2c_smbus_write_byte_data(client, AK8975_REG_CNTL, val);
  91         return count;
  92 }
  93 static DEVICE_ATTR(akm_ms1, S_IWUSR | S_IRUGO, akm8975_show, akm8975_store);
  94
  95 static int akm8975_i2c_rxdata(struct akm8975_data *akm, char *buf, int length)
  96 {
  97         struct i2c_msg msgs[] = {
  98                 {
  99                         .addr = akm->this_client->addr,
 100                         .flags = 0,
 101                         .len = 1,
 102                         .buf = buf,
 103                 },
 104                 {
 105                         .addr = akm->this_client->addr,
 106                         .flags = I2C_M_RD,
 107                         .len = length,
 108                         .buf = buf,
 109                 },
 110         };
 111
 112         FUNCDBG("called");
 113
 114         if (i2c_transfer(akm->this_client->adapter, msgs, 2) < 0) {
 115                 pr_err("akm8975_i2c_rxdata: transfer error\n");
 116                 return EIO;
 117         } else
 118                 return 0;
 119 }
 120
 121 static int akm8975_i2c_txdata(struct akm8975_data *akm, char *buf, int length)
 122 {
 123         struct i2c_msg msgs[] = {
 124                 {
 125                         .addr = akm->this_client->addr,
 126                         .flags = 0,
 127                         .len = length,
 128                         .buf = buf,
 129                 },
 130         };
 131
 132         FUNCDBG("called");
 133
 134         if (i2c_transfer(akm->this_client->adapter, msgs, 1) < 0) {
 135                 pr_err("akm8975_i2c_txdata: transfer error\n");
 136                 return -EIO;
 137         } else
 138                 return 0;
 139 }
 140
 141 static void akm8975_ecs_report_value(struct akm8975_data *akm, short *rbuf)
 142 {
 143         struct akm8975_data *data = i2c_get_clientdata(akm->this_client);
 144
 145         FUNCDBG("called");
 146
 147 #if AK8975DRV_DATA_DBG
 148         pr_info("akm8975_ecs_report_value: yaw = %d, pitch = %d, roll = %d\n",
 149                                  rbuf[0], rbuf[1], rbuf[2]);
 150         pr_info("tmp = %d, m_stat= %d, g_stat=%d\n", rbuf[3], rbuf[4], rbuf[5]);
 151         pr_info("Acceleration:   x = %d LSB, y = %d LSB, z = %d LSB\n",
 152                                  rbuf[6], rbuf[7], rbuf[8]);
 153         pr_info("Magnetic:       x = %d LSB, y = %d LSB, z = %d LSB\n\n",
 154                                  rbuf[9], rbuf[10], rbuf[11]);
 155 #endif
 156         mutex_lock(&akm->flags_lock);
 157         /* Report magnetic sensor information */
 158         if (m_flag) {
 159                 input_report_abs(data->input_dev, ABS_RX, rbuf[0]);
 160                 input_report_abs(data->input_dev, ABS_RY, rbuf[1]);
 161                 input_report_abs(data->input_dev, ABS_RZ, rbuf[2]);
 162                 input_report_abs(data->input_dev, ABS_RUDDER, rbuf[4]);
 163         }
 164
 165         /* Report acceleration sensor information */
 166         if (a_flag) {
 167                 input_report_abs(data->input_dev, ABS_X, rbuf[6]);
 168                 input_report_abs(data->input_dev, ABS_Y, rbuf[7]);
 169                 input_report_abs(data->input_dev, ABS_Z, rbuf[8]);
 170                 input_report_abs(data->input_dev, ABS_WHEEL, rbuf[5]);
 171         }
 172
 173         /* Report temperature information */
 174         if (t_flag)
 175                 input_report_abs(data->input_dev, ABS_THROTTLE, rbuf[3]);
 176
 177         if (mv_flag) {
 178                 input_report_abs(data->input_dev, ABS_HAT0X, rbuf[9]);
 179                 input_report_abs(data->input_dev, ABS_HAT0Y, rbuf[10]);
 180                 input_report_abs(data->input_dev, ABS_BRAKE, rbuf[11]);
 181         }
 182         mutex_unlock(&akm->flags_lock);
 183
 184         input_sync(data->input_dev);
 185 }
 186
 187 static void akm8975_ecs_close_done(struct akm8975_data *akm)
 188 {
 189         FUNCDBG("called");
 190         mutex_lock(&akm->flags_lock);
 191         m_flag = 1;
 192         a_flag = 1;
 193         t_flag = 1;
 194         mv_flag = 1;
 195         mutex_unlock(&akm->flags_lock);
 196 }
 197
 198 static int akm_aot_open(struct inode *inode, struct file *file)
 199 {
 200         int ret = -1;
 201
 202         FUNCDBG("called");
 203         if (atomic_cmpxchg(&open_flag, 0, 1) == 0) {
 204                 wake_up(&open_wq);
 205                 ret = 0;
 206         }
 207
 208         ret = nonseekable_open(inode, file);
 209         if (ret)
 210                 return ret;
 211
 212         file->private_data = akmd_data;
 213
 214         return ret;
 215 }
 216
 217 static int akm_aot_release(struct inode *inode, struct file *file)
 218 {
 219         FUNCDBG("called");
 220         atomic_set(&open_flag, 0);
 221         wake_up(&open_wq);
 222         return 0;
 223 }
 224
 225 static int akm_aot_ioctl(struct inode *inode, struct file *file,
 226               unsigned int cmd, unsigned long arg)
 227 {
 228         void __user *argp = (void __user *) arg;
 229         short flag;
 230         struct akm8975_data *akm = file->private_data;
 231
 232         FUNCDBG("called");
 233
 234         switch (cmd) {
 235         case ECS_IOCTL_APP_SET_MFLAG:
 236         case ECS_IOCTL_APP_SET_AFLAG:
 237         case ECS_IOCTL_APP_SET_MVFLAG:
 238                 if (copy_from_user(&flag, argp, sizeof(flag)))
 239                         return -EFAULT;
 240                 if (flag < 0 || flag > 1)
 241                         return -EINVAL;
 242                 break;
 243         case ECS_IOCTL_APP_SET_DELAY:
 244                 if (copy_from_user(&flag, argp, sizeof(flag)))
 245                         return -EFAULT;
 246                 break;
 247         default:
 248                 break;
 249         }
 250
 251         mutex_lock(&akm->flags_lock);
 252         switch (cmd) {
 253         case ECS_IOCTL_APP_SET_MFLAG:
 254           m_flag = flag;
 255                 break;
 256         case ECS_IOCTL_APP_GET_MFLAG:
 257                 flag = m_flag;
 258                 break;
 259         case ECS_IOCTL_APP_SET_AFLAG:
 260                 a_flag = flag;
 261                 break;
 262         case ECS_IOCTL_APP_GET_AFLAG:
 263                 flag = a_flag;
 264                 break;
 265         case ECS_IOCTL_APP_SET_MVFLAG:
 266                 mv_flag = flag;
 267                 break;
 268         case ECS_IOCTL_APP_GET_MVFLAG:
 269                 flag = mv_flag;
 270                 break;
 271         case ECS_IOCTL_APP_SET_DELAY:
 272                 akmd_delay = flag;
 273                 break;
 274         case ECS_IOCTL_APP_GET_DELAY:
 275                 flag = akmd_delay;
 276                 break;
 277         default:
 278                 return -ENOTTY;
 279         }
 280         mutex_unlock(&akm->flags_lock);
 281
 282         switch (cmd) {
 283         case ECS_IOCTL_APP_GET_MFLAG:
 284         case ECS_IOCTL_APP_GET_AFLAG:
 285         case ECS_IOCTL_APP_GET_MVFLAG:
 286         case ECS_IOCTL_APP_GET_DELAY:
 287                 if (copy_to_user(argp, &flag, sizeof(flag)))
 288                         return -EFAULT;
 289                 break;
 290         default:
 291                 break;
 292         }
 293
 294         return 0;
 295 }
 296
 297 static int akmd_open(struct inode *inode, struct file *file)
 298 {
 299         int err = 0;
 300
 301         FUNCDBG("called");
 302         err = nonseekable_open(inode, file);
 303         if (err)
 304                 return err;
 305
 306         file->private_data = akmd_data;
 307         return 0;
 308 }
 309
 310 static int akmd_release(struct inode *inode, struct file *file)
 311 {
 312         struct akm8975_data *akm = file->private_data;
 313
 314         FUNCDBG("called");
 315         akm8975_ecs_close_done(akm);
 316         return 0;
 317 }
 318
 319 static int akmd_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 320                       unsigned long arg)
 321 {
 322         void __user *argp = (void __user *) arg;
 323
 324         char rwbuf[16];
 325         int ret = -1;
 326         int status;
 327         short value[12];
 328         short delay;
 329         struct akm8975_data *akm = file->private_data;
 330
 331         FUNCDBG("called");
 332
 333         switch (cmd) {
 334         case ECS_IOCTL_READ:
 335         case ECS_IOCTL_WRITE:
 336                 if (copy_from_user(&rwbuf, argp, sizeof(rwbuf)))
 337                         return -EFAULT;
 338                 break;
 339
 340         case ECS_IOCTL_SET_YPR:
 341                 if (copy_from_user(&value, argp, sizeof(value)))
 342                         return -EFAULT;
 343                 break;
 344
 345         default:
 346                 break;
 347         }
 348
 349         switch (cmd) {
 350         case ECS_IOCTL_READ:
 351                 if (rwbuf[0] < 1)
 352                         return -EINVAL;
 353
 354                 ret = akm8975_i2c_rxdata(akm, &rwbuf[1], rwbuf[0]);
 355                 if (ret < 0)
 356                         return ret;
 357                 break;
 358
 359         case ECS_IOCTL_WRITE:
 360                 if (rwbuf[0] < 2)
 361                         return -EINVAL;
 362
 363                 ret = akm8975_i2c_txdata(akm, &rwbuf[1], rwbuf[0]);
 364                 if (ret < 0)
 365                         return ret;
 366                 break;
 367         case ECS_IOCTL_SET_YPR:
 368                 akm8975_ecs_report_value(akm, value);
 369                 break;
 370
 371         case ECS_IOCTL_GET_OPEN_STATUS:
 372                 wait_event_interruptible(open_wq,
 373                                          (atomic_read(&open_flag) != 0));
 374                 status = atomic_read(&open_flag);
 375                 break;
 376         case ECS_IOCTL_GET_CLOSE_STATUS:
 377                 wait_event_interruptible(open_wq,
 378                                          (atomic_read(&open_flag) == 0));
 379                 status = atomic_read(&open_flag);
 380                 break;
 381
 382         case ECS_IOCTL_GET_DELAY:
 383                 delay = akmd_delay;
 384                 break;
 385
 386         default:
 387                 FUNCDBG("Unknown cmd\n");
 388                 return -ENOTTY;
 389         }
 390
 391         switch (cmd) {
 392         case ECS_IOCTL_READ:
 393                 if (copy_to_user(argp, &rwbuf, sizeof(rwbuf)))
 394                         return -EFAULT;
 395                 break;
 396         case ECS_IOCTL_GET_OPEN_STATUS:
 397         case ECS_IOCTL_GET_CLOSE_STATUS:
 398                 if (copy_to_user(argp, &status, sizeof(status)))
 399                         return -EFAULT;
 400                 break;
 401         case ECS_IOCTL_GET_DELAY:
 402                 if (copy_to_user(argp, &delay, sizeof(delay)))
 403                         return -EFAULT;
 404                 break;
 405         default:
 406                 break;
 407         }
 408
 409         return 0;
 410 }
 411
 412 /* needed to clear the int. pin */
 413 static void akm_work_func(struct work_struct *work)
 414 {
 415         struct akm8975_data *akm =
 416             container_of(work, struct akm8975_data, work);
 417
 418         FUNCDBG("called");
 419         enable_irq(akm->this_client->irq);
 420 }
 421
 422 static irqreturn_t akm8975_interrupt(int irq, void *dev_id)
 423 {
 424         struct akm8975_data *akm = dev_id;
 425         FUNCDBG("called");
 426
 427         disable_irq_nosync(akm->this_client->irq);
 428         schedule_work(&akm->work);
 429         return IRQ_HANDLED;
 430 }
 431
 432 static int akm8975_power_off(struct akm8975_data *akm)
 433 {
 434 #if AK8975DRV_CALL_DBG
 435         pr_info("%s\n", __func__);
 436 #endif
 437         if (akm->pdata->power_off)
 438                 akm->pdata->power_off();
 439
 440         return 0;
 441 }
 442
 443 static int akm8975_power_on(struct akm8975_data *akm)
 444 {
 445         int err;
 446
 447 #if AK8975DRV_CALL_DBG
 448         pr_info("%s\n", __func__);
 449 #endif
 450         if (akm->pdata->power_on) {
 451                 err = akm->pdata->power_on();
 452                 if (err < 0)
 453                         return err;
 454         }
 455         return 0;
 456 }
 457
 458 static int akm8975_suspend(struct i2c_client *client, pm_message_t mesg)
 459 {
 460         struct akm8975_data *akm = i2c_get_clientdata(client);
 461
 462 #if AK8975DRV_CALL_DBG
 463         pr_info("%s\n", __func__);
 464 #endif
 465         /* TO DO: might need more work after power mgmt
 466            is enabled */
 467         return akm8975_power_off(akm);
 468 }
 469
 470 static int akm8975_resume(struct i2c_client *client)
 471 {
 472         struct akm8975_data *akm = i2c_get_clientdata(client);
 473
 474 #if AK8975DRV_CALL_DBG
 475         pr_info("%s\n", __func__);
 476 #endif
 477         /* TO DO: might need more work after power mgmt
 478            is enabled */
 479         return akm8975_power_on(akm);
 480 }
 481
 482 #ifdef CONFIG_HAS_EARLYSUSPEND
 483 static void akm8975_early_suspend(struct early_suspend *handler)
 484 {
 485         struct akm8975_data *akm;
 486         akm = container_of(handler, struct akm8975_data, early_suspend);
 487
 488 #if AK8975DRV_CALL_DBG
 489         pr_info("%s\n", __func__);
 490 #endif
 491         akm8975_suspend(akm->this_client, PMSG_SUSPEND);
 492 }
 493
 494 static void akm8975_early_resume(struct early_suspend *handler)
 495 {
 496         struct akm8975_data *akm;
 497         akm = container_of(handler, struct akm8975_data, early_suspend);
 498
 499 #if AK8975DRV_CALL_DBG
 500         pr_info("%s\n", __func__);
 501 #endif
 502         akm8975_resume(akm->this_client);
 503 }
 504 #endif
 505
 506
 507 static int akm8975_init_client(struct i2c_client *client)
 508 {
 509         struct akm8975_data *data;
 510         int ret;
 511
 512         data = i2c_get_clientdata(client);
 513
 514         ret = request_irq(client->irq, akm8975_interrupt, IRQF_TRIGGER_RISING,
 515                                 "akm8975", data);
 516
 517         if (ret < 0) {
 518                 pr_err("akm8975_init_client: request irq failed\n");
 519                 goto err;
 520         }
 521
 522         init_waitqueue_head(&open_wq);
 523
 524         mutex_lock(&data->flags_lock);
 525         m_flag = 1;
 526         a_flag = 1;
 527         t_flag = 1;
 528         mv_flag = 1;
 529         mutex_unlock(&data->flags_lock);
 530
 531         return 0;
 532 err:
 533   return ret;
 534 }
 535
 536 static const struct file_operations akmd_fops = {
 537         .owner = THIS_MODULE,
 538         .open = akmd_open,
 539         .release = akmd_release,
 540         .ioctl = akmd_ioctl,
 541 };
 542
 543 static const struct file_operations akm_aot_fops = {
 544         .owner = THIS_MODULE,
 545         .open = akm_aot_open,
 546         .release = akm_aot_release,
 547         .ioctl = akm_aot_ioctl,
 548 };
 549
 550 static struct miscdevice akm_aot_device = {
 551         .minor = MISC_DYNAMIC_MINOR,
 552         .name = "akm8975_aot",
 553         .fops = &akm_aot_fops,
 554 };
 555
 556 static struct miscdevice akmd_device = {
 557         .minor = MISC_DYNAMIC_MINOR,
 558         .name = "akm8975_dev",
 559         .fops = &akmd_fops,
 560 };
 561
 562 int akm8975_probe(struct i2c_client *client,
 563                   const struct i2c_device_id *devid)
 564 {
 565         struct akm8975_data *akm;
 566         int err;
 567         FUNCDBG("called");
 568
 569         if (client->dev.platform_data == NULL) {
 570                 dev_err(&client->dev, "platform data is NULL. exiting.\n");
 571                 err = -ENODEV;
 572                 goto exit_platform_data_null;
 573         }
 574
 575         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 576                 dev_err(&client->dev, "platform data is NULL. exiting.\n");
 577                 err = -ENODEV;
 578                 goto exit_check_functionality_failed;
 579         }
 580
 581         akm = kzalloc(sizeof(struct akm8975_data), GFP_KERNEL);
 582         if (!akm) {
 583                 dev_err(&client->dev,
 584                         "failed to allocate memory for module data\n");
 585                 err = -ENOMEM;
 586                 goto exit_alloc_data_failed;
 587         }
 588
 589         akm->pdata = client->dev.platform_data;
 590
 591         mutex_init(&akm->flags_lock);
 592         INIT_WORK(&akm->work, akm_work_func);
 593         i2c_set_clientdata(client, akm);
 594
 595         err = akm8975_power_on(akm);
 596         if (err < 0)
 597                 goto exit_power_on_failed;
 598
 599         akm8975_init_client(client);
 600         akm->this_client = client;
 601         akmd_data = akm;
 602
 603         akm->input_dev = input_allocate_device();
 604         if (!akm->input_dev) {
 605                 err = -ENOMEM;
 606                 dev_err(&akm->this_client->dev,
 607                         "input device allocate failed\n");
 608                 goto exit_input_dev_alloc_failed;
 609         }
 610
 611         set_bit(EV_ABS, akm->input_dev->evbit);
 612
 613         /* yaw */
 614         input_set_abs_params(akm->input_dev, ABS_RX, 0, 23040, 0, 0);
 615         /* pitch */
 616         input_set_abs_params(akm->input_dev, ABS_RY, -11520, 11520, 0, 0);
 617         /* roll */
 618         input_set_abs_params(akm->input_dev, ABS_RZ, -5760, 5760, 0, 0);
 619         /* x-axis acceleration */
 620         input_set_abs_params(akm->input_dev, ABS_X, -5760, 5760, 0, 0);
 621         /* y-axis acceleration */
 622         input_set_abs_params(akm->input_dev, ABS_Y, -5760, 5760, 0, 0);
 623         /* z-axis acceleration */
 624         input_set_abs_params(akm->input_dev, ABS_Z, -5760, 5760, 0, 0);
 625         /* temparature */
 626         input_set_abs_params(akm->input_dev, ABS_THROTTLE, -30, 85, 0, 0);
 627         /* status of magnetic sensor */
 628         input_set_abs_params(akm->input_dev, ABS_RUDDER, 0, 3, 0, 0);
 629         /* status of acceleration sensor */
 630         input_set_abs_params(akm->input_dev, ABS_WHEEL, 0, 3, 0, 0);
 631         /* x-axis of raw magnetic vector */
 632         input_set_abs_params(akm->input_dev, ABS_HAT0X, -20480, 20479, 0, 0);
 633         /* y-axis of raw magnetic vector */
 634         input_set_abs_params(akm->input_dev, ABS_HAT0Y, -20480, 20479, 0, 0);
 635         /* z-axis of raw magnetic vector */
 636         input_set_abs_params(akm->input_dev, ABS_BRAKE, -20480, 20479, 0, 0);
 637
 638         akm->input_dev->name = "compass";
 639
 640         err = input_register_device(akm->input_dev);
 641         if (err) {
 642                 pr_err("akm8975_probe: Unable to register input device: %s\n",
 643                                          akm->input_dev->name);
 644                 goto exit_input_register_device_failed;
 645         }
 646
 647         err = misc_register(&akmd_device);
 648         if (err) {
 649                 pr_err("akm8975_probe: akmd_device register failed\n");
 650                 goto exit_misc_device_register_failed;
 651         }
 652
 653         err = misc_register(&akm_aot_device);
 654         if (err) {
 655                 pr_err("akm8975_probe: akm_aot_device register failed\n");
 656                 goto exit_misc_device_register_failed;
 657         }
 658
 659         err = device_create_file(&client->dev, &dev_attr_akm_ms1);
 660
 661 #ifdef CONFIG_HAS_EARLYSUSPEND
 662         akm->early_suspend.suspend = akm8975_early_suspend;
 663         akm->early_suspend.resume = akm8975_early_resume;
 664         register_early_suspend(&akm->early_suspend);
 665 #endif
 666         return 0;
 667
 668 exit_misc_device_register_failed:
 669 exit_input_register_device_failed:
 670         input_free_device(akm->input_dev);
 671 exit_input_dev_alloc_failed:
 672         akm8975_power_off(akm);
 673 exit_power_on_failed:
 674         kfree(akm);
 675 exit_alloc_data_failed:
 676 exit_check_functionality_failed:
 677 exit_platform_data_null:
 678         return err;
 679 }
 680
 681 static int __devexit akm8975_remove(struct i2c_client *client)
 682 {
 683         struct akm8975_data *akm = i2c_get_clientdata(client);
 684         FUNCDBG("called");
 685         free_irq(client->irq, NULL);
 686         input_unregister_device(akm->input_dev);
 687         misc_deregister(&akmd_device);
 688         misc_deregister(&akm_aot_device);
 689         akm8975_power_off(akm);
 690         kfree(akm);
 691         return 0;
 692 }
 693
 694 static const struct i2c_device_id akm8975_id[] = {
 695         { "akm8975", 0 },
 696         { }
 697 };
 698
 699 MODULE_DEVICE_TABLE(i2c, akm8975_id);
 700
 701 static struct i2c_driver akm8975_driver = {
 702         .probe = akm8975_probe,
 703         .remove = akm8975_remove,
 704 #ifndef CONFIG_HAS_EARLYSUSPEND
 705         .resume = akm8975_resume,
 706         .suspend = akm8975_suspend,
 707 #endif
 708         .id_table = akm8975_id,
 709         .driver = {
 710                 .name = "akm8975",
 711         },
 712 };
 713
 714 static int __init akm8975_init(void)
 715 {
 716         pr_info("AK8975 compass driver: init\n");
 717         FUNCDBG("AK8975 compass driver: init\n");
 718         return i2c_add_driver(&akm8975_driver);
 719 }
 720
 721 static void __exit akm8975_exit(void)
 722 {
 723         FUNCDBG("AK8975 compass driver: exit\n");
 724         i2c_del_driver(&akm8975_driver);
 725 }
 726
 727 module_init(akm8975_init);
 728 module_exit(akm8975_exit);
 729
 730 MODULE_AUTHOR("Hou-Kun Chen <hk_chen@htc.com>");
 731 MODULE_DESCRIPTION("AK8975 compass driver");
 732 MODULE_LICENSE("GPL");