drivers/misc/akm8963.c

   1 /* drivers/misc/akm8963.c - akm8963 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 /*#define DEBUG*/
  18 /*#define VERBOSE_DEBUG*/
  19
  20 #include <linux/device.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/i2c.h>
  23 #include <linux/slab.h>
  24 #include <linux/irq.h>
  25 #include <linux/miscdevice.h>
  26 #include <linux/gpio.h>
  27 #include <linux/uaccess.h>
  28 #include <linux/delay.h>
  29 #include <linux/input.h>
  30 #include <linux/workqueue.h>
  31 #include <linux/freezer.h>
  32 #include <linux/akm8963.h>
  33
  34 #define AKM8963_DEBUG_IF        0
  35 #define AKM8963_DEBUG_DATA      0
  36
  37 #define AKM_ACCEL_ITEMS 3
  38 /* Wait timeout in millisecond */
  39 #define AKM8963_DRDY_TIMEOUT    100
  40
  41 struct akm8963_data {
  42         struct i2c_client       *i2c;
  43         struct input_dev        *input;
  44         struct device           *class_dev;
  45         struct class            *compass;
  46         struct delayed_work     work;
  47
  48         wait_queue_head_t       drdy_wq;
  49         wait_queue_head_t       open_wq;
  50
  51         struct mutex sensor_mutex;
  52         int8_t  sense_data[SENSOR_DATA_SIZE];
  53         struct mutex accel_mutex;
  54         int16_t accel_data[AKM_ACCEL_ITEMS];
  55
  56         struct mutex    val_mutex;
  57         uint32_t        enable_flag;
  58         int64_t         delay[AKM_NUM_SENSORS];
  59
  60         atomic_t        active;
  61         atomic_t        is_busy;
  62         atomic_t        drdy;
  63         atomic_t        suspend;
  64
  65         char layout;
  66         char outbit;
  67         int     irq;
  68         int     rstn;
  69 };
  70
  71 static struct akm8963_data *s_akm;
  72
  73
  74
  75 /***** I2C I/O function ***********************************************/
  76 static int akm8963_i2c_rxdata(
  77         struct i2c_client *i2c,
  78         unsigned char *rxData,
  79         int length)
  80 {
  81         struct i2c_msg msgs[] = {
  82         {
  83                 .addr = i2c->addr,
  84                 .flags = 0,
  85                 .len = 1,
  86                 .buf = rxData,
  87                 .scl_rate = 200*1000,
  88         },
  89         {
  90                 .addr = i2c->addr,
  91                 .flags = I2C_M_RD,
  92                 .len = length,
  93                 .buf = rxData,
  94                 .scl_rate = 200*1000,
  95         }, };
  96         unsigned char addr = rxData[0];
  97
  98         if (i2c_transfer(i2c->adapter, msgs, 2) < 0) {
  99                 dev_err(&i2c->dev, "%s: transfer failed.", __func__);
 100                 return -EIO;
 101         }
 102
 103         dev_vdbg(&i2c->dev, "RxData: len=%02x, addr=%02x, data=%02x",
 104                 length, addr, rxData[0]);
 105         return 0;
 106 }
 107
 108 static int akm8963_i2c_txdata(
 109         struct i2c_client *i2c,
 110         unsigned char *txData,
 111         int length)
 112 {
 113         struct i2c_msg msg[] = {
 114         {
 115                 .addr = i2c->addr,
 116                 .flags = 0,
 117                 .len = length,
 118                 .buf = txData,
 119                 .scl_rate = 200*1000,
 120         }, };
 121
 122         if (i2c_transfer(i2c->adapter, msg, 1) < 0) {
 123                 dev_err(&i2c->dev, "%s: transfer failed.", __func__);
 124                 return -EIO;
 125         }
 126
 127         dev_vdbg(&i2c->dev, "TxData: len=%02x, addr=%02x data=%02x",
 128                 length, txData[0], txData[1]);
 129         return 0;
 130 }
 131
 132 static int akm8963_i2c_check_device(
 133         struct i2c_client *client)
 134 {
 135         unsigned char buffer[2];
 136         int err;
 137
 138         /* Set measure mode */
 139         buffer[0] = AK8963_REG_WIA;
 140         err = akm8963_i2c_rxdata(client, buffer, 1);
 141         if (err < 0) {
 142                 dev_err(&client->dev,
 143                         "%s: Can not read WIA.", __func__);
 144                 return err;
 145         }
 146         /* Check read data */
 147         if (buffer[0] != 0x48) {
 148                 dev_err(&client->dev,
 149                         "%s: The device is not AK8963.", __func__);
 150                 return -ENXIO;
 151         }
 152
 153         //printk("========[%x] ,[%x]" , buffer[0],buffer[1]);
 154         return err;
 155 }
 156
 157 /***** akm miscdevice functions *************************************/
 158 static int AKECS_Open(struct inode *inode, struct file *file);
 159 static int AKECS_Release(struct inode *inode, struct file *file);
 160 static long AKECS_ioctl(struct file *file,
 161                 unsigned int cmd, unsigned long arg);
 162
 163 static struct file_operations AKECS_fops = {
 164         .owner = THIS_MODULE,
 165         .open = AKECS_Open,
 166         .release = AKECS_Release,
 167         .unlocked_ioctl = AKECS_ioctl,
 168 };
 169
 170 static struct miscdevice akm8963_dev = {
 171         .minor = MISC_DYNAMIC_MINOR,
 172         .name = "akm8963_dev",
 173         .fops = &AKECS_fops,
 174 };
 175
 176 static int AKECS_Set_CNTL1(
 177         struct akm8963_data *akm,
 178         unsigned char mode)
 179 {
 180         unsigned char buffer[2];
 181         int err;
 182
 183         /* Busy check */
 184         if (atomic_cmpxchg(&akm->is_busy, 0, 1) != 0) {
 185                 dev_err(&akm->i2c->dev, "%s: device is busy.", __func__);
 186                 return -EBUSY;
 187         }
 188
 189         /* Set flag */
 190         atomic_set(&akm->drdy, 0);
 191
 192         /* Set measure mode */
 193         buffer[0] = AK8963_REG_CNTL1;
 194         buffer[1] = mode;
 195         err = akm8963_i2c_txdata(akm->i2c, buffer, 2);
 196         if (err < 0) {
 197                 dev_err(&akm->i2c->dev, "%s: Can not set CNTL.", __func__);
 198                 atomic_set(&akm->is_busy, 0);
 199         } else {
 200                 dev_dbg(&akm->i2c->dev, "Mode is set to (%d).", mode);
 201         }
 202
 203         return err;
 204 }
 205
 206 static int AKECS_Set_PowerDown(
 207         struct akm8963_data *akm)
 208 {
 209         unsigned char buffer[2];
 210         int err;
 211
 212         /* Set measure mode */
 213         buffer[0] = AK8963_REG_CNTL1;
 214         buffer[1] = AK8963_MODE_POWERDOWN;
 215         err = akm8963_i2c_txdata(akm->i2c, buffer, 2);
 216         if (err < 0) {
 217                 dev_err(&akm->i2c->dev,
 218                         "%s: Can not set to measurement mode.", __func__);
 219                 atomic_set(&akm->is_busy, 0);
 220         } else {
 221                 dev_dbg(&akm->i2c->dev, "Powerdown mode is set.");
 222         }
 223
 224         /* Set to initial status. */
 225         atomic_set(&akm->is_busy, 0);
 226         atomic_set(&akm->drdy, 0);
 227
 228         return err;
 229 }
 230
 231 static int AKECS_Reset(
 232         struct akm8963_data *akm,
 233         int hard)
 234 {
 235         unsigned char buffer[2];
 236         int err = 0;
 237
 238         if (hard != 0) {
 239                 gpio_set_value(akm->rstn, 0);
 240                 udelay(5);
 241                 gpio_set_value(akm->rstn, 1);
 242         } else {
 243                 /* Set measure mode */
 244                 buffer[0] = AK8963_REG_CNTL2;
 245                 buffer[1] = 0x01;
 246                 err = akm8963_i2c_txdata(akm->i2c, buffer, 2);
 247                 if (err < 0) {
 248                         dev_err(&akm->i2c->dev,
 249                                 "%s: Can not set SRST bit.", __func__);
 250                 } else {
 251                         dev_dbg(&akm->i2c->dev, "Soft reset is done.");
 252                 }
 253         }
 254
 255         /* Device will be accessible 100 us after */
 256         udelay(100);
 257
 258         return err;
 259 }
 260
 261 static int AKECS_SetMode(
 262         struct akm8963_data *akm,
 263         unsigned char mode)
 264 {
 265         int err;
 266
 267         switch (mode & 0x0F) {
 268         case AK8963_MODE_SNG_MEASURE:
 269         case AK8963_MODE_SELF_TEST:
 270         case AK8963_MODE_FUSE_ACCESS:
 271                 err = AKECS_Set_CNTL1(akm, mode);
 272                 if ((err >= 0) && (akm->irq == 0)) {
 273                         schedule_delayed_work(
 274                                 &akm->work,
 275                                 usecs_to_jiffies(AK8963_MEASUREMENT_TIME_US));
 276                 }
 277                 break;
 278         case AK8963_MODE_POWERDOWN:
 279                 err = AKECS_Set_PowerDown(akm);
 280                 break;
 281         default:
 282                 dev_err(&akm->i2c->dev,
 283                         "%s: Unknown mode(%d).", __func__, mode);
 284                 return -EINVAL;
 285         }
 286
 287         /* wait at least 100us after changing mode */
 288         udelay(100);
 289
 290         return err;
 291 }
 292
 293 /* This function will block a process until the latest measurement
 294  * data is available.
 295  */
 296 static int AKECS_GetData(
 297         struct akm8963_data *akm,
 298         char *rbuf,
 299         int size)
 300 {
 301         int err;
 302         err = wait_event_interruptible_timeout(
 303                         akm->drdy_wq,
 304                         atomic_read(&akm->drdy),
 305                         AKM8963_DRDY_TIMEOUT);
 306
 307         if (err < 0) {
 308                 dev_err(&akm->i2c->dev,
 309                         "%s: wait_event failed (%d).", __func__, err);
 310                 return -1;
 311         }
 312         if (!atomic_read(&akm->drdy)) {
 313                 dev_err(&akm->i2c->dev,
 314                         "%s: DRDY is not set.", __func__);
 315                 return -1;
 316         }
 317
 318         mutex_lock(&akm->sensor_mutex);
 319         memcpy(rbuf, akm->sense_data, size);
 320         atomic_set(&akm->drdy, 0);
 321         mutex_unlock(&akm->sensor_mutex);
 322
 323         return 0;
 324 }
 325
 326 static void AKECS_SetYPR(
 327         struct akm8963_data *akm,
 328         int *rbuf)
 329 {
 330         uint32_t ready;
 331         dev_vdbg(&akm->i2c->dev, "AKM8963 %s: flag =0x%X", __func__,
 332                 rbuf[0]);
 333         dev_vdbg(&akm->input->dev, "  Acceleration[LSB]: %6d,%6d,%6d stat=%d",
 334                 rbuf[1], rbuf[2], rbuf[3], rbuf[4]);
 335         dev_vdbg(&akm->input->dev, "  Geomagnetism[LSB]: %6d,%6d,%6d stat=%d",
 336                 rbuf[5], rbuf[6], rbuf[7], rbuf[8]);
 337         dev_vdbg(&akm->input->dev, "  Orientation[YPR] : %6d,%6d,%6d",
 338                 rbuf[9], rbuf[10], rbuf[11]);
 339
 340         /* No events are reported */
 341         if (!rbuf[0]) {
 342                 dev_dbg(&akm->i2c->dev, "Don't waste a time.");
 343                 return;
 344         }
 345
 346         mutex_lock(&akm->val_mutex);
 347         ready = (akm->enable_flag & (uint32_t)rbuf[0]);
 348         mutex_unlock(&akm->val_mutex);
 349
 350         /* Report acceleration sensor information */
 351         if (ready & ACC_DATA_READY) {
 352                 input_report_abs(akm->input, ABS_X, rbuf[1]);
 353                 input_report_abs(akm->input, ABS_Y, rbuf[2]);
 354                 input_report_abs(akm->input, ABS_Z, rbuf[3]);
 355                 input_report_abs(akm->input, ABS_THROTTLE, rbuf[4]);
 356         }
 357         /* Report magnetic vector information */
 358         if (ready & MAG_DATA_READY) {
 359                 input_report_abs(akm->input, ABS_RX, rbuf[5]);
 360                 input_report_abs(akm->input, ABS_RY, rbuf[6]);
 361                 input_report_abs(akm->input, ABS_RZ, rbuf[7]);
 362                 input_report_abs(akm->input, ABS_RUDDER, rbuf[8]);
 363         }
 364         /* Report orientation sensor information */
 365         if (ready & ORI_DATA_READY) {
 366                 input_report_abs(akm->input, ABS_HAT0X, rbuf[9]);
 367                 input_report_abs(akm->input, ABS_HAT0Y, rbuf[10]);
 368                 input_report_abs(akm->input, ABS_HAT1X, rbuf[11]);
 369                 input_report_abs(akm->input, ABS_HAT1Y, rbuf[4]);
 370         }
 371
 372         input_sync(akm->input);
 373 }
 374
 375 static int AKECS_GetOpenStatus(
 376         struct akm8963_data *akm)
 377 {
 378         return wait_event_interruptible(
 379                         akm->open_wq, (atomic_read(&akm->active) != 0));
 380 }
 381
 382 static int AKECS_GetCloseStatus(
 383         struct akm8963_data *akm)
 384 {
 385         return wait_event_interruptible(
 386                         akm->open_wq, (atomic_read(&akm->active) <= 0));
 387 }
 388
 389 static int AKECS_Open(struct inode *inode, struct file *file)
 390 {
 391         file->private_data = s_akm;
 392         return nonseekable_open(inode, file);
 393 }
 394
 395 static int AKECS_Release(struct inode *inode, struct file *file)
 396 {
 397         return 0;
 398 }
 399
 400 static long
 401 AKECS_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 402 {
 403         void __user *argp = (void __user *)arg;
 404         struct akm8963_data *akm = file->private_data;
 405
 406         /* NOTE: In this function the size of "char" should be 1-byte. */
 407         char i2c_buf[RWBUF_SIZE];               /* for READ/WRITE */
 408         int8_t sensor_buf[SENSOR_DATA_SIZE];/* for GETDATA */
 409         int32_t ypr_buf[YPR_DATA_SIZE]; /* for SET_YPR */
 410         int16_t acc_buf[3];                             /* for GET_ACCEL */
 411         int64_t delay[AKM_NUM_SENSORS]; /* for GET_DELAY */
 412         char mode;                      /* for SET_MODE*/
 413         char layout;            /* for GET_LAYOUT */
 414         char outbit;            /* for GET_OUTBIT */
 415         int status;                     /* for OPEN/CLOSE_STATUS */
 416         int ret = -1;           /* Return value. */
 417
 418         switch (cmd) {
 419         case ECS_IOCTL_READ:
 420         case ECS_IOCTL_WRITE:
 421                 if (argp == NULL) {
 422                         dev_err(&akm->i2c->dev, "invalid argument.");
 423                         return -EINVAL;
 424                 }
 425                 if (copy_from_user(&i2c_buf, argp, sizeof(i2c_buf))) {
 426                         dev_err(&akm->i2c->dev, "copy_from_user failed.");
 427                         return -EFAULT;
 428                 }
 429                 break;
 430         case ECS_IOCTL_SET_MODE:
 431                 if (argp == NULL) {
 432                         dev_err(&akm->i2c->dev, "invalid argument.");
 433                         return -EINVAL;
 434                 }
 435                 if (copy_from_user(&mode, argp, sizeof(mode))) {
 436                         dev_err(&akm->i2c->dev, "copy_from_user failed.");
 437                         return -EFAULT;
 438                 }
 439                 break;
 440         case ECS_IOCTL_SET_YPR:
 441                 if (argp == NULL) {
 442                         dev_err(&akm->i2c->dev, "invalid argument.");
 443                         return -EINVAL;
 444                 }
 445                 if (copy_from_user(&ypr_buf, argp, sizeof(ypr_buf))) {
 446                         dev_err(&akm->i2c->dev, "copy_from_user failed.");
 447                         return -EFAULT;
 448                 }
 449         case ECS_IOCTL_GETDATA:
 450         case ECS_IOCTL_GET_OPEN_STATUS:
 451         case ECS_IOCTL_GET_CLOSE_STATUS:
 452         case ECS_IOCTL_GET_DELAY:
 453         case ECS_IOCTL_GET_LAYOUT:
 454         case ECS_IOCTL_GET_OUTBIT:
 455         case ECS_IOCTL_GET_ACCEL:
 456                 /* Just check buffer pointer */
 457                 if (argp == NULL) {
 458                         dev_err(&akm->i2c->dev, "invalid argument.");
 459                         return -EINVAL;
 460                 }
 461                 break;
 462                 break;
 463         default:
 464                 break;
 465         }
 466
 467         switch (cmd) {
 468         case ECS_IOCTL_READ:
 469                 dev_vdbg(&akm->i2c->dev, "IOCTL_READ called.");
 470                 if ((i2c_buf[0] < 1) || (i2c_buf[0] > (RWBUF_SIZE-1))) {
 471                         dev_err(&akm->i2c->dev, "invalid argument.");
 472                         return -EINVAL;
 473                 }
 474                 ret = akm8963_i2c_rxdata(akm->i2c, &i2c_buf[1], i2c_buf[0]);
 475                 if (ret < 0)
 476                         return ret;
 477                 break;
 478         case ECS_IOCTL_WRITE:
 479                 dev_vdbg(&akm->i2c->dev, "IOCTL_WRITE called.");
 480                 if ((i2c_buf[0] < 2) || (i2c_buf[0] > (RWBUF_SIZE-1))) {
 481                         dev_err(&akm->i2c->dev, "invalid argument.");
 482                         return -EINVAL;
 483                 }
 484                 ret = akm8963_i2c_txdata(akm->i2c, &i2c_buf[1], i2c_buf[0]);
 485                 if (ret < 0)
 486                         return ret;
 487                 break;
 488         case ECS_IOCTL_SET_MODE:
 489                 dev_vdbg(&akm->i2c->dev, "IOCTL_SET_MODE called.");
 490                 ret = AKECS_SetMode(akm, mode);
 491                 if (ret < 0)
 492                         return ret;
 493                 break;
 494         case ECS_IOCTL_GETDATA:
 495                 dev_vdbg(&akm->i2c->dev, "IOCTL_GETDATA called.");
 496                 ret = AKECS_GetData(akm, sensor_buf, SENSOR_DATA_SIZE);
 497                 if (ret < 0)
 498                         return ret;
 499                 break;
 500         case ECS_IOCTL_SET_YPR:
 501                 dev_vdbg(&akm->i2c->dev, "IOCTL_SET_YPR called.");
 502                 AKECS_SetYPR(akm, ypr_buf);
 503                 break;
 504         case ECS_IOCTL_GET_OPEN_STATUS:
 505                 dev_vdbg(&akm->i2c->dev, "IOCTL_GET_OPEN_STATUS called.");
 506                 ret = AKECS_GetOpenStatus(akm);
 507                 if (ret < 0) {
 508                         dev_err(&akm->i2c->dev,
 509                                 "Get Open returns error (%d).", ret);
 510                 }
 511                 break;
 512         case ECS_IOCTL_GET_CLOSE_STATUS:
 513                 dev_vdbg(&akm->i2c->dev, "IOCTL_GET_CLOSE_STATUS called.");
 514                 ret = AKECS_GetCloseStatus(akm);
 515                 if (ret < 0) {
 516                         dev_err(&akm->i2c->dev,
 517                                 "Get Close returns error (%d).", ret);
 518                 }
 519                 break;
 520         case ECS_IOCTL_GET_DELAY:
 521                 dev_vdbg(&akm->i2c->dev, "IOCTL_GET_DELAY called.");
 522                 mutex_lock(&akm->val_mutex);
 523                 delay[0] = akm->delay[0];
 524                 delay[1] = akm->delay[1];
 525                 delay[2] = akm->delay[2];
 526                 mutex_unlock(&akm->val_mutex);
 527                 break;
 528         case ECS_IOCTL_GET_LAYOUT:
 529                 dev_vdbg(&akm->i2c->dev, "IOCTL_GET_LAYOUT called.");
 530                 layout = akm->layout;
 531                 break;
 532         case ECS_IOCTL_GET_OUTBIT:
 533                 dev_vdbg(&akm->i2c->dev, "IOCTL_GET_OUTBIT called.");
 534                 outbit = akm->outbit;
 535                 break;
 536         case ECS_IOCTL_RESET:
 537                 ret = AKECS_Reset(akm, akm->rstn);
 538                 if (ret < 0)
 539                         return ret;
 540                 break;
 541         case ECS_IOCTL_GET_ACCEL:
 542                 dev_vdbg(&akm->i2c->dev, "IOCTL_GET_ACCEL called.");
 543                 mutex_lock(&akm->accel_mutex);
 544                 acc_buf[0] = akm->accel_data[0];
 545                 acc_buf[1] = akm->accel_data[1];
 546                 acc_buf[2] = akm->accel_data[2];
 547                 mutex_unlock(&akm->accel_mutex);
 548                 break;
 549         default:
 550                 return -ENOTTY;
 551         }
 552
 553         switch (cmd) {
 554         case ECS_IOCTL_READ:
 555                 if (copy_to_user(argp, &i2c_buf, i2c_buf[0]+1)) {
 556                         dev_err(&akm->i2c->dev, "copy_to_user failed.");
 557                         return -EFAULT;
 558                 }
 559                 break;
 560         case ECS_IOCTL_GETDATA:
 561                 if (copy_to_user(argp, &sensor_buf, sizeof(sensor_buf))) {
 562                         dev_err(&akm->i2c->dev, "copy_to_user failed.");
 563                         return -EFAULT;
 564                 }
 565                 break;
 566         case ECS_IOCTL_GET_OPEN_STATUS:
 567         case ECS_IOCTL_GET_CLOSE_STATUS:
 568                 status = atomic_read(&akm->active);
 569                 if (copy_to_user(argp, &status, sizeof(status))) {
 570                         dev_err(&akm->i2c->dev, "copy_to_user failed.");
 571                         return -EFAULT;
 572                 }
 573                 break;
 574         case ECS_IOCTL_GET_DELAY:
 575                 if (copy_to_user(argp, &delay, sizeof(delay))) {
 576                         dev_err(&akm->i2c->dev, "copy_to_user failed.");
 577                         return -EFAULT;
 578                 }
 579                 break;
 580         case ECS_IOCTL_GET_LAYOUT:
 581                 if (copy_to_user(argp, &layout, sizeof(layout))) {
 582                         dev_err(&akm->i2c->dev, "copy_to_user failed.");
 583                         return -EFAULT;
 584                 }
 585                 break;
 586         case ECS_IOCTL_GET_OUTBIT:
 587                 if (copy_to_user(argp, &outbit, sizeof(outbit))) {
 588                         dev_err(&akm->i2c->dev, "copy_to_user failed.");
 589                         return -EFAULT;
 590                 }
 591                 break;
 592         case ECS_IOCTL_GET_ACCEL:
 593                 if (copy_to_user(argp, &acc_buf, sizeof(acc_buf))) {
 594                         dev_err(&akm->i2c->dev, "copy_to_user failed.");
 595                         return -EFAULT;
 596                 }
 597                 break;
 598         default:
 599                 break;
 600         }
 601
 602         return 0;
 603 }
 604
 605 /***** akm sysfs functions ******************************************/
 606 static int create_device_attributes(
 607         struct device *dev,
 608         struct device_attribute *attrs)
 609 {
 610         int i;
 611         int err = 0;
 612
 613         for (i = 0 ; NULL != attrs[i].attr.name ; ++i) {
 614                 err = device_create_file(dev, &attrs[i]);
 615                 if (0 != err)
 616                         break;
 617         }
 618
 619         if (0 != err) {
 620                 for (; i >= 0 ; --i)
 621                         device_remove_file(dev, &attrs[i]);
 622         }
 623
 624         return err;
 625 }
 626
 627 static void remove_device_attributes(
 628         struct device *dev,
 629         struct device_attribute *attrs)
 630 {
 631         int i;
 632
 633         for (i = 0 ; NULL != attrs[i].attr.name ; ++i)
 634                 device_remove_file(dev, &attrs[i]);
 635 }
 636
 637 static int create_device_binary_attributes(
 638         struct kobject *kobj,
 639         struct bin_attribute *attrs)
 640 {
 641         int i;
 642         int err = 0;
 643
 644         err = 0;
 645
 646         for (i = 0 ; NULL != attrs[i].attr.name ; ++i) {
 647                 err = sysfs_create_bin_file(kobj, &attrs[i]);
 648                 if (0 != err)
 649                         break;
 650         }
 651
 652         if (0 != err) {
 653                 for (; i >= 0 ; --i)
 654                         sysfs_remove_bin_file(kobj, &attrs[i]);
 655         }
 656
 657         return err;
 658 }
 659
 660 static void remove_device_binary_attributes(
 661         struct kobject *kobj,
 662         struct bin_attribute *attrs)
 663 {
 664         int i;
 665
 666         for (i = 0 ; NULL != attrs[i].attr.name ; ++i)
 667                 sysfs_remove_bin_file(kobj, &attrs[i]);
 668 }
 669
 670 static bool get_value_as_int(char const *buf, size_t size, int *value)
 671 {
 672         long tmp;
 673
 674         if (size == 0)
 675                 return false;
 676
 677         /* maybe text format value */
 678         if ((buf[0] == '0') && (size > 1)) {
 679                 if ((buf[1] == 'x') || (buf[1] == 'X')) {
 680                         /* hexadecimal format */
 681                         if (0 != strict_strtol(buf, 16, &tmp))
 682                                 return false;
 683                 } else {
 684                         /* octal format */
 685                         if (0 != strict_strtol(buf, 8, &tmp))
 686                                 return false;
 687                 }
 688         } else {
 689                 /* decimal format */
 690                 if (0 != strict_strtol(buf, 10, &tmp))
 691                         return false;
 692         }
 693
 694         if (tmp > INT_MAX)
 695                 return false;
 696
 697         *value = tmp;
 698
 699         return true;
 700 }
 701
 702 static bool get_value_as_int64(char const *buf, size_t size, long long *value)
 703 {
 704         long long tmp;
 705
 706         if (size == 0)
 707                 return false;
 708
 709         /* maybe text format value */
 710         if ((buf[0] == '0') && (size > 1)) {
 711                 if ((buf[1] == 'x') || (buf[1] == 'X')) {
 712                         /* hexadecimal format */
 713                         if (0 != strict_strtoll(buf, 16, &tmp))
 714                                 return false;
 715                 } else {
 716                         /* octal format */
 717                         if (0 != strict_strtoll(buf, 8, &tmp))
 718                                 return false;
 719                 }
 720         } else {
 721                 /* decimal format */
 722                 if (0 != strict_strtoll(buf, 10, &tmp))
 723                         return false;
 724         }
 725
 726         if (tmp > LLONG_MAX)
 727                 return false;
 728
 729         *value = tmp;
 730
 731         return true;
 732 }
 733
 734 /*********************************************************************
 735  *
 736  * SysFS attribute functions
 737  *
 738  * directory : /sys/class/compass/akm8963/
 739  * files :
 740  *  - enable_acc [rw] [t] : enable flag for accelerometer
 741  *  - enable_mag [rw] [t] : enable flag for magnetometer
 742  *  - enable_ori [rw] [t] : enable flag for orientation
 743  *  - delay_acc  [rw] [t] : delay in nanosecond for accelerometer
 744  *  - delay_mag  [rw] [t] : delay in nanosecond for magnetometer
 745  *  - delay_ori  [rw] [t] : delay in nanosecond for orientation
 746  *  - accel          [w]  [b] : accelerometer data
 747  *
 748  * debug :
 749  *  - mode       [w]  [t] : AK8963's mode
 750  *  - bdata      [r]  [t] : raw data
 751  *  - asa        [r]  [t] : FUSEROM data
 752  *
 753  * [b] = binary format
 754  * [t] = text format
 755  */
 756
 757 /***** sysfs enable *************************************************/
 758 static void akm8963_sysfs_update_active_status(
 759         struct akm8963_data *akm)
 760 {
 761         uint32_t en;
 762         mutex_lock(&akm->val_mutex);
 763         en = akm->enable_flag;
 764         mutex_unlock(&akm->val_mutex);
 765
 766         if (en == 0) {
 767                 if (atomic_cmpxchg(&akm->active, 1, 0) == 1) {
 768                         wake_up(&akm->open_wq);
 769                         dev_dbg(akm->class_dev, "Deactivated");
 770                 }
 771         } else {
 772                 if (atomic_cmpxchg(&akm->active, 0, 1) == 0) {
 773                         wake_up(&akm->open_wq);
 774                         dev_dbg(akm->class_dev, "Activated");
 775                 }
 776         }
 777         dev_dbg(&akm->i2c->dev,
 778                 "Status updated: enable=0x%X, active=%d",
 779                 en, atomic_read(&akm->active));
 780 }
 781
 782 static ssize_t akm8963_sysfs_enable_show(
 783         struct akm8963_data *akm, char *buf, int pos)
 784 {
 785         int flag;
 786
 787         mutex_lock(&akm->val_mutex);
 788         flag = ((akm->enable_flag >> pos) & 1);
 789         mutex_unlock(&akm->val_mutex);
 790
 791         return sprintf(buf, "%d\n", flag);
 792 }
 793
 794 static ssize_t akm8963_sysfs_enable_store(
 795         struct akm8963_data *akm, char const *buf, size_t count, int pos)
 796 {
 797         int en = 0;
 798
 799         if (NULL == buf)
 800                 return -EINVAL;
 801
 802         if (0 == count)
 803                 return 0;
 804
 805         if (false == get_value_as_int(buf, count, &en))
 806                 return -EINVAL;
 807
 808         en = en ? 1 : 0;
 809
 810         mutex_lock(&akm->val_mutex);
 811         akm->enable_flag &= ~(1<<pos);
 812         akm->enable_flag |= ((uint32_t)(en))<<pos;
 813         mutex_unlock(&akm->val_mutex);
 814
 815         akm8963_sysfs_update_active_status(akm);
 816
 817         return count;
 818 }
 819
 820 /***** Acceleration ***/
 821 static ssize_t akm8963_enable_acc_show(
 822         struct device *dev, struct device_attribute *attr, char *buf)
 823 {
 824         return akm8963_sysfs_enable_show(
 825                 dev_get_drvdata(dev), buf, ACC_DATA_FLAG);
 826 }
 827 static ssize_t akm8963_enable_acc_store(
 828         struct device *dev, struct device_attribute *attr,
 829         char const *buf, size_t count)
 830 {
 831         return akm8963_sysfs_enable_store(
 832                 dev_get_drvdata(dev), buf, count, ACC_DATA_FLAG);
 833 }
 834
 835 /***** Magnetic field ***/
 836 static ssize_t akm8963_enable_mag_show(
 837         struct device *dev, struct device_attribute *attr, char *buf)
 838 {
 839         return akm8963_sysfs_enable_show(
 840                 dev_get_drvdata(dev), buf, MAG_DATA_FLAG);
 841 }
 842 static ssize_t akm8963_enable_mag_store(
 843         struct device *dev, struct device_attribute *attr,
 844         char const *buf, size_t count)
 845 {
 846         return akm8963_sysfs_enable_store(
 847                 dev_get_drvdata(dev), buf, count, MAG_DATA_FLAG);
 848 }
 849
 850 /***** Orientation ***/
 851 static ssize_t akm8963_enable_ori_show(
 852         struct device *dev, struct device_attribute *attr, char *buf)
 853 {
 854         return akm8963_sysfs_enable_show(
 855                 dev_get_drvdata(dev), buf, ORI_DATA_FLAG);
 856 }
 857 static ssize_t akm8963_enable_ori_store(
 858         struct device *dev, struct device_attribute *attr,
 859         char const *buf, size_t count)
 860 {
 861         return akm8963_sysfs_enable_store(
 862                 dev_get_drvdata(dev), buf, count, ORI_DATA_FLAG);
 863 }
 864
 865 /***** sysfs delay **************************************************/
 866 static ssize_t akm8963_sysfs_delay_show(
 867         struct akm8963_data *akm, char *buf, int pos)
 868 {
 869         int64_t val;
 870
 871         mutex_lock(&akm->val_mutex);
 872         val = akm->delay[pos];
 873         mutex_unlock(&akm->val_mutex);
 874
 875         return sprintf(buf, "%lld\n", val);
 876 }
 877
 878 static ssize_t akm8963_sysfs_delay_store(
 879         struct akm8963_data *akm, char const *buf, size_t count, int pos)
 880 {
 881         long long val = 0;
 882
 883         if (NULL == buf)
 884                 return -EINVAL;
 885
 886         if (0 == count)
 887                 return 0;
 888
 889         if (false == get_value_as_int64(buf, count, &val))
 890                 return -EINVAL;
 891
 892         mutex_lock(&akm->val_mutex);
 893         akm->delay[pos] = val;
 894         mutex_unlock(&akm->val_mutex);
 895
 896         return count;
 897 }
 898
 899 /***** Accelerometer ***/
 900 static ssize_t akm8963_delay_acc_show(
 901         struct device *dev, struct device_attribute *attr, char *buf)
 902 {
 903         return akm8963_sysfs_delay_show(
 904                 dev_get_drvdata(dev), buf, ACC_DATA_FLAG);
 905 }
 906 static ssize_t akm8963_delay_acc_store(
 907         struct device *dev, struct device_attribute *attr,
 908         char const *buf, size_t count)
 909 {
 910         return akm8963_sysfs_delay_store(
 911                 dev_get_drvdata(dev), buf, count, ACC_DATA_FLAG);
 912 }
 913
 914 /***** Magnetic field ***/
 915 static ssize_t akm8963_delay_mag_show(
 916         struct device *dev, struct device_attribute *attr, char *buf)
 917 {
 918         return akm8963_sysfs_delay_show(
 919                 dev_get_drvdata(dev), buf, MAG_DATA_FLAG);
 920 }
 921 static ssize_t akm8963_delay_mag_store(
 922         struct device *dev, struct device_attribute *attr,
 923         char const *buf, size_t count)
 924 {
 925         return akm8963_sysfs_delay_store(
 926                 dev_get_drvdata(dev), buf, count, MAG_DATA_FLAG);
 927 }
 928
 929 /***** Orientation ***/
 930 static ssize_t akm8963_delay_ori_show(
 931         struct device *dev, struct device_attribute *attr, char *buf)
 932 {
 933         return akm8963_sysfs_delay_show(
 934                 dev_get_drvdata(dev), buf, ORI_DATA_FLAG);
 935 }
 936 static ssize_t akm8963_delay_ori_store(
 937         struct device *dev, struct device_attribute *attr,
 938         char const *buf, size_t count)
 939 {
 940         return akm8963_sysfs_delay_store(
 941                 dev_get_drvdata(dev), buf, count, ORI_DATA_FLAG);
 942 }
 943
 944
 945 /***** accel (binary) ***/
 946 static ssize_t akm8963_bin_accel_write(
 947         struct file *file,
 948         struct kobject *kobj,
 949         struct bin_attribute *attr,
 950                         char *buf,
 951                         loff_t pos,
 952                         size_t size)
 953 {
 954         struct device *dev = container_of(kobj, struct device, kobj);
 955         struct akm8963_data *akm = dev_get_drvdata(dev);
 956         int16_t *accel_data;
 957
 958         if (size == 0)
 959                 return 0;
 960
 961         accel_data = (int16_t*)buf;
 962
 963         mutex_lock(&akm->accel_mutex);
 964         akm->accel_data[0] = accel_data[0];
 965         akm->accel_data[1] = accel_data[1];
 966         akm->accel_data[2] = accel_data[2];
 967         mutex_unlock(&akm->accel_mutex);
 968
 969         dev_vdbg(&akm->i2c->dev, "accel:%d,%d,%d\n",
 970                 accel_data[0], accel_data[1], accel_data[2]);
 971
 972         return size;
 973 }
 974
 975
 976 #ifdef AKM8963_DEBUG_IF
 977 static ssize_t akm8963_mode_store(
 978         struct device *dev, struct device_attribute *attr,
 979         char const *buf, size_t count)
 980 {
 981         struct akm8963_data *akm = dev_get_drvdata(dev);
 982         int mode = 0;
 983
 984         if (NULL == buf)
 985                 return -EINVAL;
 986
 987         if (0 == count)
 988                 return 0;
 989
 990         if (false == get_value_as_int(buf, count, &mode))
 991                 return -EINVAL;
 992
 993         if (AKECS_SetMode(akm, mode) < 0)
 994                 return -EINVAL;
 995
 996         return 1;
 997 }
 998
 999 static ssize_t akm8963_bdata_show(
1000         struct device *dev, struct device_attribute *attr, char *buf)
1001 {
1002         struct akm8963_data *akm = dev_get_drvdata(dev);
1003         char rbuf[SENSOR_DATA_SIZE];
1004
1005         mutex_lock(&akm->sensor_mutex);
1006         memcpy(&rbuf, akm->sense_data, sizeof(rbuf));
1007         mutex_unlock(&akm->sensor_mutex);
1008
1009         return sprintf(buf,
1010                 "0x%02X,0x%02X,0x%02X,0x%02X,"
1011                 "0x%02X,0x%02X,0x%02X,0x%02X\n",
1012                 rbuf[0],rbuf[1],rbuf[2],rbuf[3],
1013                 rbuf[4],rbuf[5],rbuf[6],rbuf[7]);
1014 }
1015
1016 static ssize_t akm8963_asa_show(
1017         struct device *dev, struct device_attribute *attr, char *buf)
1018 {
1019         struct akm8963_data *akm = dev_get_drvdata(dev);
1020         int err;
1021         unsigned char asa[3];
1022
1023         err = AKECS_SetMode(akm, AK8963_MODE_FUSE_ACCESS);
1024         if (err < 0)
1025                 return err;
1026
1027         asa[0] = AK8963_FUSE_ASAX;
1028         err = akm8963_i2c_rxdata(akm->i2c, asa, 3);
1029         if (err < 0)
1030                 return err;
1031
1032         err = AKECS_SetMode(akm, AK8963_MODE_POWERDOWN);
1033         if (err < 0)
1034                 return err;
1035
1036         return sprintf(buf, "0x%02X,0x%02X,0x%02X\n",
1037                 asa[0], asa[1], asa[2]);
1038 }
1039 #endif
1040
1041 static struct device_attribute akm8963_attributes[] = {
1042         __ATTR(enable_acc, 0660, akm8963_enable_acc_show, akm8963_enable_acc_store),
1043         __ATTR(enable_mag, 0660, akm8963_enable_mag_show, akm8963_enable_mag_store),
1044         __ATTR(enable_ori, 0660, akm8963_enable_ori_show, akm8963_enable_ori_store),
1045         __ATTR(delay_acc,  0660, akm8963_delay_acc_show,  akm8963_delay_acc_store),
1046         __ATTR(delay_mag,  0660, akm8963_delay_mag_show,  akm8963_delay_mag_store),
1047         __ATTR(delay_ori,  0660, akm8963_delay_ori_show,  akm8963_delay_ori_store),
1048 #ifdef AKM8963_DEBUG_IF
1049         __ATTR(mode,  0220, NULL, akm8963_mode_store),
1050         __ATTR(bdata, 0440, akm8963_bdata_show, NULL),
1051         __ATTR(asa,   0440, akm8963_asa_show, NULL),
1052 #endif
1053         __ATTR_NULL,
1054 };
1055
1056 #define __BIN_ATTR(name_, mode_, size_, private_, read_, write_) \
1057         { \
1058                 .attr    = { .name = __stringify(name_), .mode = mode_ }, \
1059                 .size    = size_, \
1060                 .private = private_, \
1061                 .read    = read_, \
1062                 .write   = write_, \
1063         }
1064
1065 #define __BIN_ATTR_NULL \
1066         { \
1067                 .attr   = { .name = NULL }, \
1068         }
1069
1070 static struct bin_attribute akm8963_bin_attributes[] = {
1071         __BIN_ATTR(accel, 0220, 6, NULL,
1072                                 NULL, akm8963_bin_accel_write),
1073         __BIN_ATTR_NULL
1074 };
1075
1076 static char const *const compass_class_name = "compass";
1077 static char const *const akm8963_device_name = "akm8963";
1078 static char const *const device_link_name = "i2c";
1079 static dev_t const akm8963_device_dev_t = MKDEV(MISC_MAJOR, 240);
1080
1081 static int create_sysfs_interfaces(struct akm8963_data *akm)
1082 {
1083         int err;
1084
1085         if (NULL == akm)
1086                 return -EINVAL;
1087
1088         err = 0;
1089
1090         akm->compass = class_create(THIS_MODULE, compass_class_name);
1091         if (IS_ERR(akm->compass)) {
1092                 err = PTR_ERR(akm->compass);
1093                 goto exit_class_create_failed;
1094         }
1095
1096         akm->class_dev = device_create(
1097                                                 akm->compass,
1098                                                 NULL,
1099                                                 akm8963_device_dev_t,
1100                                                 akm,
1101                                                 akm8963_device_name);
1102         if (IS_ERR(akm->class_dev)) {
1103                 err = PTR_ERR(akm->class_dev);
1104                 goto exit_class_device_create_failed;
1105         }
1106
1107         err = sysfs_create_link(
1108                         &akm->class_dev->kobj,
1109                         &akm->i2c->dev.kobj,
1110                         device_link_name);
1111         if (0 > err)
1112                 goto exit_sysfs_create_link_failed;
1113
1114         err = create_device_attributes(
1115                         akm->class_dev,
1116                         akm8963_attributes);
1117         if (0 > err)
1118                 goto exit_device_attributes_create_failed;
1119
1120         err = create_device_binary_attributes(
1121                         &akm->class_dev->kobj,
1122                         akm8963_bin_attributes);
1123         if (0 > err)
1124                 goto exit_device_binary_attributes_create_failed;
1125
1126         return err;
1127
1128 exit_device_binary_attributes_create_failed:
1129         remove_device_attributes(akm->class_dev, akm8963_attributes);
1130 exit_device_attributes_create_failed:
1131         sysfs_remove_link(&akm->class_dev->kobj, device_link_name);
1132 exit_sysfs_create_link_failed:
1133         device_destroy(akm->compass, akm8963_device_dev_t);
1134 exit_class_device_create_failed:
1135         akm->class_dev = NULL;
1136         class_destroy(akm->compass);
1137 exit_class_create_failed:
1138         akm->compass = NULL;
1139         return err;
1140 }
1141
1142 static void remove_sysfs_interfaces(struct akm8963_data *akm)
1143 {
1144         if (NULL == akm)
1145                 return;
1146
1147         if (NULL != akm->class_dev) {
1148                 remove_device_binary_attributes(
1149                         &akm->class_dev->kobj,
1150                         akm8963_bin_attributes);
1151                 remove_device_attributes(
1152                         akm->class_dev,
1153                         akm8963_attributes);
1154                 sysfs_remove_link(
1155                         &akm->class_dev->kobj,
1156                         device_link_name);
1157                 akm->class_dev = NULL;
1158         }
1159         if (NULL != akm->compass) {
1160                 device_destroy(
1161                         akm->compass,
1162                         akm8963_device_dev_t);
1163                 class_destroy(akm->compass);
1164                 akm->compass = NULL;
1165         }
1166 }
1167
1168
1169 /***** akm input device functions ***********************************/
1170 static int akm8963_input_init(
1171         struct input_dev **input)
1172 {
1173         int err = 0;
1174
1175         /* Declare input device */
1176         *input = input_allocate_device();
1177         if (!*input)
1178                 return -ENOMEM;
1179
1180         /* Setup input device */
1181         set_bit(EV_ABS, (*input)->evbit);
1182         /* Accelerometer (720 x 16G)*/
1183         input_set_abs_params(*input, ABS_X,
1184                         -11520, 11520, 0, 0);
1185         input_set_abs_params(*input, ABS_Y,
1186                         -11520, 11520, 0, 0);
1187         input_set_abs_params(*input, ABS_Z,
1188                         -11520, 11520, 0, 0);
1189         input_set_abs_params(*input, ABS_THROTTLE,
1190                         0, 3, 0, 0);
1191         /* Magnetic field (-81900, 81900) -> limited to 16bit*/
1192         input_set_abs_params(*input, ABS_RX,
1193                         -32768, 32767, 0, 0);
1194         input_set_abs_params(*input, ABS_RY,
1195                         -32768, 32767, 0, 0);
1196         input_set_abs_params(*input, ABS_RZ,
1197                         -32768, 32767, 0, 0);
1198         input_set_abs_params(*input, ABS_RUDDER,
1199                         0, 3, 0, 0);
1200         /* Orientation (yaw:0,360 pitch:-180,180 roll:-90,90) */
1201         input_set_abs_params(*input, ABS_HAT0X,
1202                         0, 23040, 0, 0);
1203         input_set_abs_params(*input, ABS_HAT0Y,
1204                         -11520, 11520, 0, 0);
1205         input_set_abs_params(*input, ABS_HAT1X,
1206                         -5760, 5760, 0, 0);
1207         input_set_abs_params(*input, ABS_HAT1Y,
1208                         0, 3, 0, 0);
1209
1210         /* Set name */
1211         (*input)->name = "compass";
1212
1213         /* Register */
1214         err = input_register_device(*input);
1215         if (err) {
1216                 input_free_device(*input);
1217                 return err;
1218         }
1219
1220         return err;
1221 }
1222
1223 /***** akm functions ************************************************/
1224
1225 static irqreturn_t akm8963_irq(int irq, void *handle)
1226 {
1227         struct akm8963_data *akm = handle;
1228         char buffer[SENSOR_DATA_SIZE];
1229         int err;
1230
1231         memset(buffer, 0, sizeof(buffer));
1232         buffer[0] = AK8963_REG_ST1;
1233         err = akm8963_i2c_rxdata(akm->i2c, buffer, SENSOR_DATA_SIZE);
1234         if (err < 0) {
1235                 dev_err(&akm->i2c->dev, "%s failed.", __func__);
1236                 goto work_func_end;
1237         }
1238         /* Check ST bit */
1239         if ((buffer[0] & 0x01) != 0x01) {
1240                 dev_err(&akm->i2c->dev, "%s ST is not set.", __func__);
1241                 goto work_func_end;
1242         }
1243
1244         mutex_lock(&akm->sensor_mutex);
1245         memcpy(akm->sense_data, buffer, SENSOR_DATA_SIZE);
1246         mutex_unlock(&akm->sensor_mutex);
1247
1248         atomic_set(&akm->drdy, 1);
1249         atomic_set(&akm->is_busy, 0);
1250         wake_up(&akm->drdy_wq);
1251
1252 work_func_end:
1253         return IRQ_HANDLED;
1254 }
1255
1256 static void akm8963_delayed_work(struct work_struct *work)
1257 {
1258         struct akm8963_data *akm = container_of(
1259                 work, struct akm8963_data, work.work);
1260
1261         akm8963_irq(akm->irq, akm);
1262 }
1263
1264 static int akm8963_suspend(struct device *dev)
1265 {
1266         struct akm8963_data *akm = dev_get_drvdata(dev);
1267         dev_dbg(&akm->i2c->dev, "suspended\n");
1268
1269         return 0;
1270 }
1271
1272 static int akm8963_resume(struct device *dev)
1273 {
1274         struct akm8963_data *akm = dev_get_drvdata(dev);
1275         dev_dbg(&akm->i2c->dev, "resumed\n");
1276
1277         return 0;
1278 }
1279
1280 int akm8963_probe(struct i2c_client *client, const struct i2c_device_id *id)
1281 {
1282         struct akm8963_platform_data *pdata;
1283         int err = 0;
1284         int i;
1285
1286         dev_dbg(&client->dev, "start probing.");
1287
1288         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
1289                 dev_err(&client->dev, "%s: check_functionality failed.", __func__);
1290                 err = -ENODEV;
1291                 goto exit0;
1292         }
1293
1294         /* Allocate memory for driver data */
1295         s_akm = kzalloc(sizeof(struct akm8963_data), GFP_KERNEL);
1296         if (!s_akm) {
1297                 dev_err(&client->dev, "%s: memory allocation failed.", __func__);
1298                 err = -ENOMEM;
1299                 goto exit1;
1300         }
1301
1302         /***** Set layout information *****/
1303         pdata = client->dev.platform_data;
1304         if (pdata) {
1305                 /* Platform data is available. copy its value to local. */
1306                 s_akm->layout = pdata->layout;
1307                 s_akm->outbit = pdata->outbit;
1308                 s_akm->rstn = pdata->gpio_RST;
1309         } else {
1310                 /* Platform data is not available.
1311                    Layout and Outbit information should be set by each application. */
1312                 dev_dbg(&client->dev, "%s: No platform data.", __func__);
1313                 s_akm->layout = 0;
1314                 s_akm->outbit = 0;
1315                 s_akm->rstn = 0;
1316         }
1317
1318         /***** I2C initialization *****/
1319         s_akm->i2c = client;
1320         /* check connection */
1321         err = akm8963_i2c_check_device(client);
1322         if (err < 0)
1323                 goto exit2;
1324         /* set client data */
1325         i2c_set_clientdata(client, s_akm);
1326
1327
1328         /***** input *****/
1329         err = akm8963_input_init(&s_akm->input);
1330         if (err) {
1331                 dev_err(&client->dev,
1332                         "%s: input_dev register failed", __func__);
1333                 goto exit3;
1334         }
1335         input_set_drvdata(s_akm->input, s_akm);
1336
1337
1338         /**** initialize variables in akm8963_data *****/
1339         init_waitqueue_head(&s_akm->drdy_wq);
1340         init_waitqueue_head(&s_akm->open_wq);
1341
1342         mutex_init(&s_akm->sensor_mutex);
1343         mutex_init(&s_akm->accel_mutex);
1344         mutex_init(&s_akm->val_mutex);
1345
1346         atomic_set(&s_akm->active, 0);
1347         atomic_set(&s_akm->is_busy, 0);
1348         atomic_set(&s_akm->drdy, 0);
1349         atomic_set(&s_akm->suspend, 0);
1350
1351         s_akm->enable_flag = 0;
1352         for (i=0; i<AKM_NUM_SENSORS; i++)
1353                 s_akm->delay[i] = -1;
1354
1355
1356         /***** IRQ setup *****/
1357         s_akm->irq = client->irq;
1358
1359
1360         if (s_akm->irq == 0) {
1361                 dev_dbg(&client->dev, "%s: IRQ is not set.", __func__);
1362                 /* Use timer to notify measurement end */
1363                 INIT_DELAYED_WORK(&s_akm->work, akm8963_delayed_work);
1364         } else {
1365                 err = request_threaded_irq(
1366                                 s_akm->irq,
1367                                 NULL,
1368                                 akm8963_irq,
1369                                 IRQF_TRIGGER_HIGH|IRQF_ONESHOT,
1370                                 dev_name(&client->dev),
1371                                 s_akm);
1372                 if (err < 0) {
1373                         dev_err(&client->dev,
1374                                 "%s: request irq failed.", __func__);
1375                         goto exit4;
1376                 }
1377         }
1378
1379         /***** misc *****/
1380         err = misc_register(&akm8963_dev);
1381         if (err) {
1382                 dev_err(&client->dev,
1383                         "%s: akm8963_dev register failed", __func__);
1384                 goto exit5;
1385         }
1386
1387         /***** sysfs *****/
1388         err = create_sysfs_interfaces(s_akm);
1389         if (0 > err) {
1390                 dev_err(&client->dev,
1391                         "%s: create sysfs failed.", __func__);
1392                 goto exit6;
1393         }
1394
1395         dev_info(&client->dev, "successfully probed.");
1396         return 0;
1397
1398 exit6:
1399         misc_deregister(&akm8963_dev);
1400 exit5:
1401         if (s_akm->irq)
1402                 free_irq(s_akm->irq, s_akm);
1403 exit4:
1404         input_unregister_device(s_akm->input);
1405 exit3:
1406 exit2:
1407         kfree(s_akm);
1408 exit1:
1409 exit0:
1410         return err;
1411 }
1412
1413 static int akm8963_remove(struct i2c_client *client)
1414 {
1415         struct akm8963_data *akm = i2c_get_clientdata(client);
1416
1417         remove_sysfs_interfaces(akm);
1418         if (misc_deregister(&akm8963_dev) < 0)
1419                 dev_err(&client->dev, "misc deregister failed.");
1420         if (akm->irq)
1421                 free_irq(akm->irq, akm);
1422         input_unregister_device(akm->input);
1423         kfree(akm);
1424         dev_info(&client->dev, "successfully removed.");
1425         return 0;
1426 }
1427
1428 static const struct i2c_device_id akm8963_id[] = {
1429         {AKM8963_I2C_NAME, 0 },
1430         { }
1431 };
1432
1433 static const struct dev_pm_ops akm8963_pm_ops = {
1434         .suspend    = akm8963_suspend,
1435         .resume     = akm8963_resume,
1436 };
1437
1438 static struct i2c_driver akm8963_driver = {
1439         .probe          = akm8963_probe,
1440         .remove         = akm8963_remove,
1441         .id_table       = akm8963_id,
1442         .driver = {
1443                 .name   = AKM8963_I2C_NAME,
1444                 .pm             = &akm8963_pm_ops,
1445         },
1446 };
1447
1448 static int __init akm8963_init(void)
1449 {
1450         printk(KERN_INFO "AKM8963 compass driver: initialize.");
1451         return i2c_add_driver(&akm8963_driver);
1452 }
1453
1454 static void __exit akm8963_exit(void)
1455 {
1456         printk(KERN_INFO "AKM8963 compass driver: release.");
1457         i2c_del_driver(&akm8963_driver);
1458 }
1459
1460 module_init(akm8963_init);
1461 module_exit(akm8963_exit);
1462
1463 MODULE_AUTHOR("viral wang <viral_wang@htc.com>");
1464 MODULE_DESCRIPTION("AKM8963 compass driver");
1465 MODULE_LICENSE("GPL");
1466