1 /* drivers/misc/akm8963.c - akm8963 compass driver
3 * Copyright (C) 2007-2008 HTC Corporation.
4 * Author: Hou-Kun Chen <houkun.chen@gmail.com>
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.
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.
18 /*#define VERBOSE_DEBUG*/
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>
34 #define AKM8963_DEBUG_IF 0
35 #define AKM8963_DEBUG_DATA 0
37 #define AKM_ACCEL_ITEMS 3
38 /* Wait timeout in millisecond */
39 #define AKM8963_DRDY_TIMEOUT 100
42 struct i2c_client *i2c;
43 struct input_dev *input;
44 struct device *class_dev;
45 struct class *compass;
46 struct delayed_work work;
48 wait_queue_head_t drdy_wq;
49 wait_queue_head_t open_wq;
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];
56 struct mutex val_mutex;
58 int64_t delay[AKM_NUM_SENSORS];
71 static struct akm8963_data *s_akm;
75 /***** I2C I/O function ***********************************************/
76 static int akm8963_i2c_rxdata(
77 struct i2c_client *i2c,
78 unsigned char *rxData,
81 struct i2c_msg msgs[] = {
96 unsigned char addr = rxData[0];
98 if (i2c_transfer(i2c->adapter, msgs, 2) < 0) {
99 dev_err(&i2c->dev, "%s: transfer failed.", __func__);
103 dev_vdbg(&i2c->dev, "RxData: len=%02x, addr=%02x, data=%02x",
104 length, addr, rxData[0]);
108 static int akm8963_i2c_txdata(
109 struct i2c_client *i2c,
110 unsigned char *txData,
113 struct i2c_msg msg[] = {
119 .scl_rate = 200*1000,
122 if (i2c_transfer(i2c->adapter, msg, 1) < 0) {
123 dev_err(&i2c->dev, "%s: transfer failed.", __func__);
127 dev_vdbg(&i2c->dev, "TxData: len=%02x, addr=%02x data=%02x",
128 length, txData[0], txData[1]);
132 static int akm8963_i2c_check_device(
133 struct i2c_client *client)
135 unsigned char buffer[2];
138 /* Set measure mode */
139 buffer[0] = AK8963_REG_WIA;
140 err = akm8963_i2c_rxdata(client, buffer, 1);
142 dev_err(&client->dev,
143 "%s: Can not read WIA.", __func__);
146 /* Check read data */
147 if (buffer[0] != 0x48) {
148 dev_err(&client->dev,
149 "%s: The device is not AK8963.", __func__);
153 //printk("========[%x] ,[%x]" , buffer[0],buffer[1]);
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);
163 static struct file_operations AKECS_fops = {
164 .owner = THIS_MODULE,
166 .release = AKECS_Release,
167 .unlocked_ioctl = AKECS_ioctl,
170 static struct miscdevice akm8963_dev = {
171 .minor = MISC_DYNAMIC_MINOR,
172 .name = "akm8963_dev",
176 static int AKECS_Set_CNTL1(
177 struct akm8963_data *akm,
180 unsigned char buffer[2];
184 if (atomic_cmpxchg(&akm->is_busy, 0, 1) != 0) {
185 dev_err(&akm->i2c->dev, "%s: device is busy.", __func__);
190 atomic_set(&akm->drdy, 0);
192 /* Set measure mode */
193 buffer[0] = AK8963_REG_CNTL1;
195 err = akm8963_i2c_txdata(akm->i2c, buffer, 2);
197 dev_err(&akm->i2c->dev, "%s: Can not set CNTL.", __func__);
198 atomic_set(&akm->is_busy, 0);
200 dev_dbg(&akm->i2c->dev, "Mode is set to (%d).", mode);
206 static int AKECS_Set_PowerDown(
207 struct akm8963_data *akm)
209 unsigned char buffer[2];
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);
217 dev_err(&akm->i2c->dev,
218 "%s: Can not set to measurement mode.", __func__);
219 atomic_set(&akm->is_busy, 0);
221 dev_dbg(&akm->i2c->dev, "Powerdown mode is set.");
224 /* Set to initial status. */
225 atomic_set(&akm->is_busy, 0);
226 atomic_set(&akm->drdy, 0);
231 static int AKECS_Reset(
232 struct akm8963_data *akm,
235 unsigned char buffer[2];
239 gpio_set_value(akm->rstn, 0);
241 gpio_set_value(akm->rstn, 1);
243 /* Set measure mode */
244 buffer[0] = AK8963_REG_CNTL2;
246 err = akm8963_i2c_txdata(akm->i2c, buffer, 2);
248 dev_err(&akm->i2c->dev,
249 "%s: Can not set SRST bit.", __func__);
251 dev_dbg(&akm->i2c->dev, "Soft reset is done.");
255 /* Device will be accessible 100 us after */
261 static int AKECS_SetMode(
262 struct akm8963_data *akm,
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(
275 usecs_to_jiffies(AK8963_MEASUREMENT_TIME_US));
278 case AK8963_MODE_POWERDOWN:
279 err = AKECS_Set_PowerDown(akm);
282 dev_err(&akm->i2c->dev,
283 "%s: Unknown mode(%d).", __func__, mode);
287 /* wait at least 100us after changing mode */
293 /* This function will block a process until the latest measurement
296 static int AKECS_GetData(
297 struct akm8963_data *akm,
302 err = wait_event_interruptible_timeout(
304 atomic_read(&akm->drdy),
305 AKM8963_DRDY_TIMEOUT);
308 dev_err(&akm->i2c->dev,
309 "%s: wait_event failed (%d).", __func__, err);
312 if (!atomic_read(&akm->drdy)) {
313 dev_err(&akm->i2c->dev,
314 "%s: DRDY is not set.", __func__);
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);
326 static void AKECS_SetYPR(
327 struct akm8963_data *akm,
331 dev_vdbg(&akm->i2c->dev, "AKM8963 %s: flag =0x%X", __func__,
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]);
340 /* No events are reported */
342 dev_dbg(&akm->i2c->dev, "Don't waste a time.");
346 mutex_lock(&akm->val_mutex);
347 ready = (akm->enable_flag & (uint32_t)rbuf[0]);
348 mutex_unlock(&akm->val_mutex);
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]);
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]);
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]);
372 input_sync(akm->input);
375 static int AKECS_GetOpenStatus(
376 struct akm8963_data *akm)
378 return wait_event_interruptible(
379 akm->open_wq, (atomic_read(&akm->active) != 0));
382 static int AKECS_GetCloseStatus(
383 struct akm8963_data *akm)
385 return wait_event_interruptible(
386 akm->open_wq, (atomic_read(&akm->active) <= 0));
389 static int AKECS_Open(struct inode *inode, struct file *file)
391 file->private_data = s_akm;
392 return nonseekable_open(inode, file);
395 static int AKECS_Release(struct inode *inode, struct file *file)
401 AKECS_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
403 void __user *argp = (void __user *)arg;
404 struct akm8963_data *akm = file->private_data;
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. */
420 case ECS_IOCTL_WRITE:
422 dev_err(&akm->i2c->dev, "invalid argument.");
425 if (copy_from_user(&i2c_buf, argp, sizeof(i2c_buf))) {
426 dev_err(&akm->i2c->dev, "copy_from_user failed.");
430 case ECS_IOCTL_SET_MODE:
432 dev_err(&akm->i2c->dev, "invalid argument.");
435 if (copy_from_user(&mode, argp, sizeof(mode))) {
436 dev_err(&akm->i2c->dev, "copy_from_user failed.");
440 case ECS_IOCTL_SET_YPR:
442 dev_err(&akm->i2c->dev, "invalid argument.");
445 if (copy_from_user(&ypr_buf, argp, sizeof(ypr_buf))) {
446 dev_err(&akm->i2c->dev, "copy_from_user failed.");
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 */
458 dev_err(&akm->i2c->dev, "invalid argument.");
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.");
474 ret = akm8963_i2c_rxdata(akm->i2c, &i2c_buf[1], i2c_buf[0]);
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.");
484 ret = akm8963_i2c_txdata(akm->i2c, &i2c_buf[1], i2c_buf[0]);
488 case ECS_IOCTL_SET_MODE:
489 dev_vdbg(&akm->i2c->dev, "IOCTL_SET_MODE called.");
490 ret = AKECS_SetMode(akm, mode);
494 case ECS_IOCTL_GETDATA:
495 dev_vdbg(&akm->i2c->dev, "IOCTL_GETDATA called.");
496 ret = AKECS_GetData(akm, sensor_buf, SENSOR_DATA_SIZE);
500 case ECS_IOCTL_SET_YPR:
501 dev_vdbg(&akm->i2c->dev, "IOCTL_SET_YPR called.");
502 AKECS_SetYPR(akm, ypr_buf);
504 case ECS_IOCTL_GET_OPEN_STATUS:
505 dev_vdbg(&akm->i2c->dev, "IOCTL_GET_OPEN_STATUS called.");
506 ret = AKECS_GetOpenStatus(akm);
508 dev_err(&akm->i2c->dev,
509 "Get Open returns error (%d).", ret);
512 case ECS_IOCTL_GET_CLOSE_STATUS:
513 dev_vdbg(&akm->i2c->dev, "IOCTL_GET_CLOSE_STATUS called.");
514 ret = AKECS_GetCloseStatus(akm);
516 dev_err(&akm->i2c->dev,
517 "Get Close returns error (%d).", ret);
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);
528 case ECS_IOCTL_GET_LAYOUT:
529 dev_vdbg(&akm->i2c->dev, "IOCTL_GET_LAYOUT called.");
530 layout = akm->layout;
532 case ECS_IOCTL_GET_OUTBIT:
533 dev_vdbg(&akm->i2c->dev, "IOCTL_GET_OUTBIT called.");
534 outbit = akm->outbit;
536 case ECS_IOCTL_RESET:
537 ret = AKECS_Reset(akm, akm->rstn);
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);
555 if (copy_to_user(argp, &i2c_buf, i2c_buf[0]+1)) {
556 dev_err(&akm->i2c->dev, "copy_to_user failed.");
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.");
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.");
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.");
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.");
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.");
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.");
605 /***** akm sysfs functions ******************************************/
606 static int create_device_attributes(
608 struct device_attribute *attrs)
613 for (i = 0 ; NULL != attrs[i].attr.name ; ++i) {
614 err = device_create_file(dev, &attrs[i]);
621 device_remove_file(dev, &attrs[i]);
627 static void remove_device_attributes(
629 struct device_attribute *attrs)
633 for (i = 0 ; NULL != attrs[i].attr.name ; ++i)
634 device_remove_file(dev, &attrs[i]);
637 static int create_device_binary_attributes(
638 struct kobject *kobj,
639 struct bin_attribute *attrs)
646 for (i = 0 ; NULL != attrs[i].attr.name ; ++i) {
647 err = sysfs_create_bin_file(kobj, &attrs[i]);
654 sysfs_remove_bin_file(kobj, &attrs[i]);
660 static void remove_device_binary_attributes(
661 struct kobject *kobj,
662 struct bin_attribute *attrs)
666 for (i = 0 ; NULL != attrs[i].attr.name ; ++i)
667 sysfs_remove_bin_file(kobj, &attrs[i]);
670 static bool get_value_as_int(char const *buf, size_t size, int *value)
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))
685 if (0 != strict_strtol(buf, 8, &tmp))
690 if (0 != strict_strtol(buf, 10, &tmp))
702 static bool get_value_as_int64(char const *buf, size_t size, long long *value)
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))
717 if (0 != strict_strtoll(buf, 8, &tmp))
722 if (0 != strict_strtoll(buf, 10, &tmp))
734 /*********************************************************************
736 * SysFS attribute functions
738 * directory : /sys/class/compass/akm8963/
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
749 * - mode [w] [t] : AK8963's mode
750 * - bdata [r] [t] : raw data
751 * - asa [r] [t] : FUSEROM data
753 * [b] = binary format
757 /***** sysfs enable *************************************************/
758 static void akm8963_sysfs_update_active_status(
759 struct akm8963_data *akm)
762 mutex_lock(&akm->val_mutex);
763 en = akm->enable_flag;
764 mutex_unlock(&akm->val_mutex);
767 if (atomic_cmpxchg(&akm->active, 1, 0) == 1) {
768 wake_up(&akm->open_wq);
769 dev_dbg(akm->class_dev, "Deactivated");
772 if (atomic_cmpxchg(&akm->active, 0, 1) == 0) {
773 wake_up(&akm->open_wq);
774 dev_dbg(akm->class_dev, "Activated");
777 dev_dbg(&akm->i2c->dev,
778 "Status updated: enable=0x%X, active=%d",
779 en, atomic_read(&akm->active));
782 static ssize_t akm8963_sysfs_enable_show(
783 struct akm8963_data *akm, char *buf, int pos)
787 mutex_lock(&akm->val_mutex);
788 flag = ((akm->enable_flag >> pos) & 1);
789 mutex_unlock(&akm->val_mutex);
791 return sprintf(buf, "%d\n", flag);
794 static ssize_t akm8963_sysfs_enable_store(
795 struct akm8963_data *akm, char const *buf, size_t count, int pos)
805 if (false == get_value_as_int(buf, count, &en))
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);
815 akm8963_sysfs_update_active_status(akm);
820 /***** Acceleration ***/
821 static ssize_t akm8963_enable_acc_show(
822 struct device *dev, struct device_attribute *attr, char *buf)
824 return akm8963_sysfs_enable_show(
825 dev_get_drvdata(dev), buf, ACC_DATA_FLAG);
827 static ssize_t akm8963_enable_acc_store(
828 struct device *dev, struct device_attribute *attr,
829 char const *buf, size_t count)
831 return akm8963_sysfs_enable_store(
832 dev_get_drvdata(dev), buf, count, ACC_DATA_FLAG);
835 /***** Magnetic field ***/
836 static ssize_t akm8963_enable_mag_show(
837 struct device *dev, struct device_attribute *attr, char *buf)
839 return akm8963_sysfs_enable_show(
840 dev_get_drvdata(dev), buf, MAG_DATA_FLAG);
842 static ssize_t akm8963_enable_mag_store(
843 struct device *dev, struct device_attribute *attr,
844 char const *buf, size_t count)
846 return akm8963_sysfs_enable_store(
847 dev_get_drvdata(dev), buf, count, MAG_DATA_FLAG);
850 /***** Orientation ***/
851 static ssize_t akm8963_enable_ori_show(
852 struct device *dev, struct device_attribute *attr, char *buf)
854 return akm8963_sysfs_enable_show(
855 dev_get_drvdata(dev), buf, ORI_DATA_FLAG);
857 static ssize_t akm8963_enable_ori_store(
858 struct device *dev, struct device_attribute *attr,
859 char const *buf, size_t count)
861 return akm8963_sysfs_enable_store(
862 dev_get_drvdata(dev), buf, count, ORI_DATA_FLAG);
865 /***** sysfs delay **************************************************/
866 static ssize_t akm8963_sysfs_delay_show(
867 struct akm8963_data *akm, char *buf, int pos)
871 mutex_lock(&akm->val_mutex);
872 val = akm->delay[pos];
873 mutex_unlock(&akm->val_mutex);
875 return sprintf(buf, "%lld\n", val);
878 static ssize_t akm8963_sysfs_delay_store(
879 struct akm8963_data *akm, char const *buf, size_t count, int pos)
889 if (false == get_value_as_int64(buf, count, &val))
892 mutex_lock(&akm->val_mutex);
893 akm->delay[pos] = val;
894 mutex_unlock(&akm->val_mutex);
899 /***** Accelerometer ***/
900 static ssize_t akm8963_delay_acc_show(
901 struct device *dev, struct device_attribute *attr, char *buf)
903 return akm8963_sysfs_delay_show(
904 dev_get_drvdata(dev), buf, ACC_DATA_FLAG);
906 static ssize_t akm8963_delay_acc_store(
907 struct device *dev, struct device_attribute *attr,
908 char const *buf, size_t count)
910 return akm8963_sysfs_delay_store(
911 dev_get_drvdata(dev), buf, count, ACC_DATA_FLAG);
914 /***** Magnetic field ***/
915 static ssize_t akm8963_delay_mag_show(
916 struct device *dev, struct device_attribute *attr, char *buf)
918 return akm8963_sysfs_delay_show(
919 dev_get_drvdata(dev), buf, MAG_DATA_FLAG);
921 static ssize_t akm8963_delay_mag_store(
922 struct device *dev, struct device_attribute *attr,
923 char const *buf, size_t count)
925 return akm8963_sysfs_delay_store(
926 dev_get_drvdata(dev), buf, count, MAG_DATA_FLAG);
929 /***** Orientation ***/
930 static ssize_t akm8963_delay_ori_show(
931 struct device *dev, struct device_attribute *attr, char *buf)
933 return akm8963_sysfs_delay_show(
934 dev_get_drvdata(dev), buf, ORI_DATA_FLAG);
936 static ssize_t akm8963_delay_ori_store(
937 struct device *dev, struct device_attribute *attr,
938 char const *buf, size_t count)
940 return akm8963_sysfs_delay_store(
941 dev_get_drvdata(dev), buf, count, ORI_DATA_FLAG);
945 /***** accel (binary) ***/
946 static ssize_t akm8963_bin_accel_write(
948 struct kobject *kobj,
949 struct bin_attribute *attr,
954 struct device *dev = container_of(kobj, struct device, kobj);
955 struct akm8963_data *akm = dev_get_drvdata(dev);
961 accel_data = (int16_t*)buf;
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);
969 dev_vdbg(&akm->i2c->dev, "accel:%d,%d,%d\n",
970 accel_data[0], accel_data[1], accel_data[2]);
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)
981 struct akm8963_data *akm = dev_get_drvdata(dev);
990 if (false == get_value_as_int(buf, count, &mode))
993 if (AKECS_SetMode(akm, mode) < 0)
999 static ssize_t akm8963_bdata_show(
1000 struct device *dev, struct device_attribute *attr, char *buf)
1002 struct akm8963_data *akm = dev_get_drvdata(dev);
1003 char rbuf[SENSOR_DATA_SIZE];
1005 mutex_lock(&akm->sensor_mutex);
1006 memcpy(&rbuf, akm->sense_data, sizeof(rbuf));
1007 mutex_unlock(&akm->sensor_mutex);
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]);
1016 static ssize_t akm8963_asa_show(
1017 struct device *dev, struct device_attribute *attr, char *buf)
1019 struct akm8963_data *akm = dev_get_drvdata(dev);
1021 unsigned char asa[3];
1023 err = AKECS_SetMode(akm, AK8963_MODE_FUSE_ACCESS);
1027 asa[0] = AK8963_FUSE_ASAX;
1028 err = akm8963_i2c_rxdata(akm->i2c, asa, 3);
1032 err = AKECS_SetMode(akm, AK8963_MODE_POWERDOWN);
1036 return sprintf(buf, "0x%02X,0x%02X,0x%02X\n",
1037 asa[0], asa[1], asa[2]);
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),
1056 #define __BIN_ATTR(name_, mode_, size_, private_, read_, write_) \
1058 .attr = { .name = __stringify(name_), .mode = mode_ }, \
1060 .private = private_, \
1065 #define __BIN_ATTR_NULL \
1067 .attr = { .name = NULL }, \
1070 static struct bin_attribute akm8963_bin_attributes[] = {
1071 __BIN_ATTR(accel, 0220, 6, NULL,
1072 NULL, akm8963_bin_accel_write),
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);
1081 static int create_sysfs_interfaces(struct akm8963_data *akm)
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;
1096 akm->class_dev = device_create(
1099 akm8963_device_dev_t,
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;
1107 err = sysfs_create_link(
1108 &akm->class_dev->kobj,
1109 &akm->i2c->dev.kobj,
1112 goto exit_sysfs_create_link_failed;
1114 err = create_device_attributes(
1116 akm8963_attributes);
1118 goto exit_device_attributes_create_failed;
1120 err = create_device_binary_attributes(
1121 &akm->class_dev->kobj,
1122 akm8963_bin_attributes);
1124 goto exit_device_binary_attributes_create_failed;
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;
1142 static void remove_sysfs_interfaces(struct akm8963_data *akm)
1147 if (NULL != akm->class_dev) {
1148 remove_device_binary_attributes(
1149 &akm->class_dev->kobj,
1150 akm8963_bin_attributes);
1151 remove_device_attributes(
1153 akm8963_attributes);
1155 &akm->class_dev->kobj,
1157 akm->class_dev = NULL;
1159 if (NULL != akm->compass) {
1162 akm8963_device_dev_t);
1163 class_destroy(akm->compass);
1164 akm->compass = NULL;
1169 /***** akm input device functions ***********************************/
1170 static int akm8963_input_init(
1171 struct input_dev **input)
1175 /* Declare input device */
1176 *input = input_allocate_device();
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,
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,
1200 /* Orientation (yaw:0,360 pitch:-180,180 roll:-90,90) */
1201 input_set_abs_params(*input, ABS_HAT0X,
1203 input_set_abs_params(*input, ABS_HAT0Y,
1204 -11520, 11520, 0, 0);
1205 input_set_abs_params(*input, ABS_HAT1X,
1207 input_set_abs_params(*input, ABS_HAT1Y,
1211 (*input)->name = "compass";
1214 err = input_register_device(*input);
1216 input_free_device(*input);
1223 /***** akm functions ************************************************/
1225 static irqreturn_t akm8963_irq(int irq, void *handle)
1227 struct akm8963_data *akm = handle;
1228 char buffer[SENSOR_DATA_SIZE];
1231 memset(buffer, 0, sizeof(buffer));
1232 buffer[0] = AK8963_REG_ST1;
1233 err = akm8963_i2c_rxdata(akm->i2c, buffer, SENSOR_DATA_SIZE);
1235 dev_err(&akm->i2c->dev, "%s failed.", __func__);
1239 if ((buffer[0] & 0x01) != 0x01) {
1240 dev_err(&akm->i2c->dev, "%s ST is not set.", __func__);
1244 mutex_lock(&akm->sensor_mutex);
1245 memcpy(akm->sense_data, buffer, SENSOR_DATA_SIZE);
1246 mutex_unlock(&akm->sensor_mutex);
1248 atomic_set(&akm->drdy, 1);
1249 atomic_set(&akm->is_busy, 0);
1250 wake_up(&akm->drdy_wq);
1256 static void akm8963_delayed_work(struct work_struct *work)
1258 struct akm8963_data *akm = container_of(
1259 work, struct akm8963_data, work.work);
1261 akm8963_irq(akm->irq, akm);
1264 static int akm8963_suspend(struct device *dev)
1266 struct akm8963_data *akm = dev_get_drvdata(dev);
1267 dev_dbg(&akm->i2c->dev, "suspended\n");
1272 static int akm8963_resume(struct device *dev)
1274 struct akm8963_data *akm = dev_get_drvdata(dev);
1275 dev_dbg(&akm->i2c->dev, "resumed\n");
1280 int akm8963_probe(struct i2c_client *client, const struct i2c_device_id *id)
1282 struct akm8963_platform_data *pdata;
1286 dev_dbg(&client->dev, "start probing.");
1288 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
1289 dev_err(&client->dev, "%s: check_functionality failed.", __func__);
1294 /* Allocate memory for driver data */
1295 s_akm = kzalloc(sizeof(struct akm8963_data), GFP_KERNEL);
1297 dev_err(&client->dev, "%s: memory allocation failed.", __func__);
1302 /***** Set layout information *****/
1303 pdata = client->dev.platform_data;
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;
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__);
1318 /***** I2C initialization *****/
1319 s_akm->i2c = client;
1320 /* check connection */
1321 err = akm8963_i2c_check_device(client);
1324 /* set client data */
1325 i2c_set_clientdata(client, s_akm);
1329 err = akm8963_input_init(&s_akm->input);
1331 dev_err(&client->dev,
1332 "%s: input_dev register failed", __func__);
1335 input_set_drvdata(s_akm->input, s_akm);
1338 /**** initialize variables in akm8963_data *****/
1339 init_waitqueue_head(&s_akm->drdy_wq);
1340 init_waitqueue_head(&s_akm->open_wq);
1342 mutex_init(&s_akm->sensor_mutex);
1343 mutex_init(&s_akm->accel_mutex);
1344 mutex_init(&s_akm->val_mutex);
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);
1351 s_akm->enable_flag = 0;
1352 for (i=0; i<AKM_NUM_SENSORS; i++)
1353 s_akm->delay[i] = -1;
1356 /***** IRQ setup *****/
1357 s_akm->irq = client->irq;
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);
1365 err = request_threaded_irq(
1369 IRQF_TRIGGER_HIGH|IRQF_ONESHOT,
1370 dev_name(&client->dev),
1373 dev_err(&client->dev,
1374 "%s: request irq failed.", __func__);
1380 err = misc_register(&akm8963_dev);
1382 dev_err(&client->dev,
1383 "%s: akm8963_dev register failed", __func__);
1388 err = create_sysfs_interfaces(s_akm);
1390 dev_err(&client->dev,
1391 "%s: create sysfs failed.", __func__);
1395 dev_info(&client->dev, "successfully probed.");
1399 misc_deregister(&akm8963_dev);
1402 free_irq(s_akm->irq, s_akm);
1404 input_unregister_device(s_akm->input);
1413 static int akm8963_remove(struct i2c_client *client)
1415 struct akm8963_data *akm = i2c_get_clientdata(client);
1417 remove_sysfs_interfaces(akm);
1418 if (misc_deregister(&akm8963_dev) < 0)
1419 dev_err(&client->dev, "misc deregister failed.");
1421 free_irq(akm->irq, akm);
1422 input_unregister_device(akm->input);
1424 dev_info(&client->dev, "successfully removed.");
1428 static const struct i2c_device_id akm8963_id[] = {
1429 {AKM8963_I2C_NAME, 0 },
1433 static const struct dev_pm_ops akm8963_pm_ops = {
1434 .suspend = akm8963_suspend,
1435 .resume = akm8963_resume,
1438 static struct i2c_driver akm8963_driver = {
1439 .probe = akm8963_probe,
1440 .remove = akm8963_remove,
1441 .id_table = akm8963_id,
1443 .name = AKM8963_I2C_NAME,
1444 .pm = &akm8963_pm_ops,
1448 static int __init akm8963_init(void)
1450 printk(KERN_INFO "AKM8963 compass driver: initialize.");
1451 return i2c_add_driver(&akm8963_driver);
1454 static void __exit akm8963_exit(void)
1456 printk(KERN_INFO "AKM8963 compass driver: release.");
1457 i2c_del_driver(&akm8963_driver);
1460 module_init(akm8963_init);
1461 module_exit(akm8963_exit);
1463 MODULE_AUTHOR("viral wang <viral_wang@htc.com>");
1464 MODULE_DESCRIPTION("AKM8963 compass driver");
1465 MODULE_LICENSE("GPL");