1 /* akm09911.c - akm09911 compass driver
4 * This software is licensed under the terms of the GNU General Public
5 * License version 2, as published by the Free Software Foundation, and
6 * may be copied, distributed, and modified under those terms.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
15 #include <linux/interrupt.h>
16 #include <linux/i2c.h>
17 #include <linux/slab.h>
18 #include <linux/irq.h>
19 #include <linux/miscdevice.h>
20 #include <asm/uaccess.h>
21 #include <asm/atomic.h>
22 #include <linux/delay.h>
23 #include <linux/input.h>
24 #include <linux/workqueue.h>
25 #include <linux/kobject.h>
26 #include <linux/platform_device.h>
27 #include <linux/earlysuspend.h>
29 #include <linux/hwmsensor.h>
30 #include <linux/hwmsen_dev.h>
31 #include <linux/sensors_io.h>
32 #include <linux/proc_fs.h>
34 //#include <mach/mt_devs.h>
35 #include <mach/mt_typedefs.h>
36 #include <mach/mt_gpio.h>
37 #include <mach/mt_pm_ldo.h>
40 #define POWER_NONE_MACRO MT65XX_POWER_NONE
44 #include <linux/hwmsen_helper.h>
46 /*----------------------------------------------------------------------------*/
48 #define AKM09911_DEV_NAME "akm09911"
49 #define DRIVER_VERSION "1.0.1"
50 /*----------------------------------------------------------------------------*/
51 #define AKM09911_DEBUG 1
52 #define AKM09911_DEBUG_MSG 0
53 #define AKM09911_DEBUG_FUNC 0
54 #define AKM09911_DEBUG_DATA 1
55 #define MAX_FAILURE_COUNT 3
56 #define AKM09911_RETRY_COUNT 10
57 #define AKM09911_DEFAULT_DELAY 100
59 //#define AKM_Pseudogyro // enable this if you need use 6D gyro
60 //#define AKM_Device_AK8963 //if use AK09911 code to compatible AK8963C, need define this
63 #if AKM09911_DEBUG_MSG
64 #define AKMDBG(format, ...) printk(KERN_ERR "AKM09911 " format "\n", ## __VA_ARGS__)
66 #define AKMDBG(format, ...)
69 #if AKM09911_DEBUG_FUNC
70 #define AKMFUNC(func) printk(KERN_INFO "AKM09911 " func " is called\n")
75 static struct i2c_client
*this_client
= NULL
;
77 /* Addresses to scan -- protected by sense_data_mutex */
78 static char sense_data
[SENSOR_DATA_SIZE
];
79 static struct mutex sense_data_mutex
;
80 // calibration msensor and orientation data
81 static int sensor_data
[CALIBRATION_DATA_SIZE
];
82 static struct mutex sensor_data_mutex
;
83 static DECLARE_WAIT_QUEUE_HEAD(data_ready_wq
);
84 static DECLARE_WAIT_QUEUE_HEAD(open_wq
);
86 static short akmd_delay
= AKM09911_DEFAULT_DELAY
;
88 static atomic_t open_flag
= ATOMIC_INIT(0);
89 static atomic_t m_flag
= ATOMIC_INIT(0);
90 static atomic_t o_flag
= ATOMIC_INIT(0);
92 static int factory_mode
=0;
93 static int ecompass_status
= 0;
95 static int mEnabled
=0;
97 static struct proc_dir_entry
*akm09911_ecompass_status_proc
= NULL
;
100 /*----------------------------------------------------------------------------*/
101 /*----------------------------------------------------------------------------*/
102 static const struct i2c_device_id akm09911_i2c_id
[] = {{AKM09911_DEV_NAME
,0},{}};
103 static struct i2c_board_info __initdata i2c_akm09911
={ I2C_BOARD_INFO("akm09911", (AKM09911_I2C_ADDRESS
>>1))};
104 /*the adapter id will be available in customization*/
105 //static unsigned short akm09911_force[] = {0x00, AKM09911_I2C_ADDRESS, I2C_CLIENT_END, I2C_CLIENT_END};
106 //static const unsigned short *const akm09911_forces[] = { akm09911_force, NULL };
107 //static struct i2c_client_address_data akm09911_addr_data = { .forces = akm09911_forces,};
108 /*----------------------------------------------------------------------------*/
109 static int akm09911_i2c_probe(struct i2c_client
*client
, const struct i2c_device_id
*id
);
110 static int akm09911_i2c_remove(struct i2c_client
*client
);
111 static int akm09911_i2c_detect(struct i2c_client
*client
, struct i2c_board_info
*info
);
112 static int akm_probe(struct platform_device
*pdev
);
113 static int akm_remove(struct platform_device
*pdev
);
116 /*----------------------------------------------------------------------------*/
118 AMK_FUN_DEBUG
= 0x01,
119 AMK_DATA_DEBUG
= 0X02,
120 AMK_HWM_DEBUG
= 0X04,
121 AMK_CTR_DEBUG
= 0X08,
122 AMK_I2C_DEBUG
= 0x10,
126 /*----------------------------------------------------------------------------*/
127 struct akm09911_i2c_data
{
128 struct i2c_client
*client
;
132 struct hwmsen_convert cvt
;
133 #if defined(CONFIG_HAS_EARLYSUSPEND)
134 struct early_suspend early_drv
;
137 /*----------------------------------------------------------------------------*/
138 static struct i2c_driver akm09911_i2c_driver
= {
140 // .owner = THIS_MODULE,
141 .name
= AKM09911_DEV_NAME
,
143 .probe
= akm09911_i2c_probe
,
144 .remove
= akm09911_i2c_remove
,
145 .detect
= akm09911_i2c_detect
,
146 #if !defined(CONFIG_HAS_EARLYSUSPEND)
147 .suspend
= akm09911_suspend
,
148 .resume
= akm09911_resume
,
150 .id_table
= akm09911_i2c_id
,
151 // .address_data = &akm09911_addr_data,
154 /*----------------------------------------------------------------------------*/
155 static struct platform_driver akm_sensor_driver
= {
157 .remove
= akm_remove
,
160 .owner
= THIS_MODULE
,
165 /*----------------------------------------------------------------------------*/
166 static atomic_t dev_open_count
;
167 /*----------------------------------------------------------------------------*/
168 static void akm09911_power(struct mag_hw
*hw
, unsigned int on
)
170 static unsigned int power_on
= 0;
172 if(hw
->power_id
!= POWER_NONE_MACRO
)
174 AKMDBG("power %s\n", on
? "on" : "off");
177 AKMDBG("ignore power control: %d\n", on
);
181 if(!hwPowerOn(hw
->power_id
, hw
->power_vol
, "akm09911"))
183 printk(KERN_ERR
"power on fails!!\n");
188 if(!hwPowerDown(hw
->power_id
, "akm09911"))
190 printk(KERN_ERR
"power off fail!!\n");
196 static long AKI2C_RxData(char *rxData
, int length
)
202 struct i2c_client
*client
= this_client
;
203 struct akm09911_i2c_data
*data
= i2c_get_clientdata(client
);
204 char addr
= rxData
[0];
208 /* Caller should check parameter validity.*/
209 if((rxData
== NULL
) || (length
< 1))
214 for(loop_i
= 0; loop_i
< AKM09911_RETRY_COUNT
; loop_i
++)
216 this_client
->addr
= this_client
->addr
& I2C_MASK_FLAG
;
217 this_client
->addr
= this_client
->addr
| I2C_WR_FLAG
;
218 if(i2c_master_send(this_client
, (const char*)rxData
, ((length
<<0X08) | 0X01)))
225 if(loop_i
>= AKM09911_RETRY_COUNT
)
227 printk(KERN_ERR
"%s retry over %d\n", __func__
, AKM09911_RETRY_COUNT
);
231 if(atomic_read(&data
->trace
) & AMK_I2C_DEBUG
)
233 printk(KERN_INFO
"RxData: len=%02x, addr=%02x\n data=", length
, addr
);
234 for(i
= 0; i
< length
; i
++)
236 printk(KERN_INFO
" %02x", rxData
[i
]);
238 printk(KERN_INFO
"\n");
244 static long AKI2C_TxData(char *txData
, int length
)
250 struct i2c_client
*client
= this_client
;
251 struct akm09911_i2c_data
*data
= i2c_get_clientdata(client
);
254 /* Caller should check parameter validity.*/
255 if ((txData
== NULL
) || (length
< 2))
260 this_client
->addr
= this_client
->addr
& I2C_MASK_FLAG
;
261 for(loop_i
= 0; loop_i
< AKM09911_RETRY_COUNT
; loop_i
++)
263 if(i2c_master_send(this_client
, (const char*)txData
, length
) > 0)
270 if(loop_i
>= AKM09911_RETRY_COUNT
)
272 printk(KERN_ERR
"%s retry over %d\n", __func__
, AKM09911_RETRY_COUNT
);
276 if(atomic_read(&data
->trace
) & AMK_I2C_DEBUG
)
278 printk(KERN_INFO
"TxData: len=%02x, addr=%02x\n data=", length
, txData
[0]);
279 for(i
= 0; i
< (length
-1); i
++)
281 printk(KERN_INFO
" %02x", txData
[i
+ 1]);
283 printk(KERN_INFO
"\n");
290 static long AKECS_Set_CNTL1(unsigned char mode)
292 unsigned char buffer[2];
296 buffer[0] = AK09911_REG_CNTL1;
299 return AKI2C_TxData(buffer, 2);;
304 static long AKECS_SetMode_SngMeasure(void)
307 #ifdef AKM_Device_AK8963
309 buffer
[0] = AK8963_REG_CNTL1
;
310 buffer
[1] = AK8963_MODE_SNG_MEASURE
;
313 /* Set measure mode */
314 buffer
[0] = AK09911_REG_CNTL2
;
315 buffer
[1] = AK09911_MODE_SNG_MEASURE
;
319 return AKI2C_TxData(buffer
, 2);
322 static long AKECS_SetMode_SelfTest(void)
325 #ifdef AKM_Device_AK8963
327 buffer
[0] = AK8963_REG_CNTL1
;
328 buffer
[1] = AK8963_MODE_SELF_TEST
;
332 /* Set measure mode */
333 buffer
[0] = AK09911_REG_CNTL2
;
334 buffer
[1] = AK09911_MODE_SELF_TEST
;
337 return AKI2C_TxData(buffer
, 2);
339 static long AKECS_SetMode_FUSEAccess(void)
343 #ifdef AKM_Device_AK8963
344 buffer
[0] = AK8963_REG_CNTL1
;
345 buffer
[1] = AK8963_MODE_FUSE_ACCESS
;
347 /* Set measure mode */
348 buffer
[0] = AK09911_REG_CNTL2
;
349 buffer
[1] = AK09911_MODE_FUSE_ACCESS
;
352 return AKI2C_TxData(buffer
, 2);
354 static int AKECS_SetMode_PowerDown(void)
357 #ifdef AKM_Device_AK8963
358 buffer
[0] = AK8963_REG_CNTL1
;
359 buffer
[1] = AK8963_MODE_POWERDOWN
;
361 /* Set powerdown mode */
362 buffer
[0] = AK09911_REG_CNTL2
;
363 buffer
[1] = AK09911_MODE_POWERDOWN
;
366 return AKI2C_TxData(buffer
, 2);
369 static long AKECS_Reset(int hard
)
371 unsigned char buffer
[2];
375 //TODO change to board setting
376 //gpio_set_value(akm->rstn, 0);
378 //gpio_set_value(akm->rstn, 1);
380 /* Set measure mode */
381 #ifdef AKM_Device_AK8963
382 buffer
[0] = AK8963_REG_CNTL2
;
385 buffer
[0] = AK09911_REG_CNTL3
;
388 err
= AKI2C_TxData(buffer
, 2);
390 AKMDBG("%s: Can not set SRST bit.", __func__
);
392 AKMDBG("Soft reset is done.");
396 /* Device will be accessible 300 us after */
402 static long AKECS_SetMode(char mode
)
406 switch (mode
& 0x1F){
409 case AK09911_MODE_SNG_MEASURE
:
410 ret
= AKECS_SetMode_SngMeasure();
413 case AK09911_MODE_SELF_TEST
:
414 case AK8963_MODE_SELF_TEST
:
415 ret
= AKECS_SetMode_SelfTest();
418 case AK09911_MODE_FUSE_ACCESS
:
419 case AK8963_MODE_FUSE_ACCESS
:
420 ret
= AKECS_SetMode_FUSEAccess();
423 case AK09911_MODE_POWERDOWN
:
424 ret
= AKECS_SetMode_PowerDown();
428 AKMDBG("%s: Unknown mode(%d)", __func__
, mode
);
432 /* wait at least 100us after changing mode */
438 static int AKECS_CheckDevice(void)
442 AKMDBG(" AKM check device id");
443 /* Set measure mode */
444 #ifdef AKM_Device_AK8963
445 buffer
[0] = AK8963_REG_WIA
;
447 buffer
[0] = AK09911_REG_WIA1
;
453 ret
= AKI2C_RxData(buffer
, 1);
454 AKMDBG(" AKM check device id = %x",buffer
[0]);
455 AKMDBG("ret = %d",ret
);
460 /* Check read data */
461 if(buffer
[0] != 0x48)
469 // Daemon application save the data
470 static void AKECS_SaveData(int *buf
)
473 struct i2c_client
*client
= this_client
;
474 struct akm09911_i2c_data
*data
= i2c_get_clientdata(client
);
477 mutex_lock(&sensor_data_mutex
);
478 memcpy(sensor_data
, buf
, sizeof(sensor_data
));
479 mutex_unlock(&sensor_data_mutex
);
482 if(atomic_read(&data
->trace
) & AMK_HWM_DEBUG
)
484 AKMDBG("Get daemon data: %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d!\n",
485 sensor_data
[0],sensor_data
[1],sensor_data
[2],sensor_data
[3],
486 sensor_data
[4],sensor_data
[5],sensor_data
[6],sensor_data
[7],
487 sensor_data
[8],sensor_data
[9],sensor_data
[10],sensor_data
[11],
488 sensor_data
[12],sensor_data
[13],sensor_data
[14],sensor_data
[15],
489 sensor_data
[16],sensor_data
[17],sensor_data
[18],sensor_data
[19],
490 sensor_data
[20],sensor_data
[21],sensor_data
[22],sensor_data
[23],
491 sensor_data
[24],sensor_data
[25]);
497 // M-sensor daemon application have set the sng mode
498 static long AKECS_GetData(char *rbuf
, int size
)
503 struct i2c_client
*client
= this_client
;
504 struct akm09911_i2c_data
*data
= i2c_get_clientdata(client
);
507 if(size
< SENSOR_DATA_SIZE
)
509 printk(KERN_ERR
"buff size is too small %d!\n", size
);
513 memset(rbuf
, 0, SENSOR_DATA_SIZE
);
514 #ifdef AKM_Device_AK8963
515 rbuf
[0] = AK8963_REG_ST1
;
517 rbuf
[0] = AK09911_REG_ST1
;
520 for(loop_i
= 0; loop_i
< AKM09911_RETRY_COUNT
; loop_i
++)
522 if((ret
= AKI2C_RxData(rbuf
, 1)))
524 printk(KERN_ERR
"read ST1 resigster failed!\n");
528 if((rbuf
[0] & 0x01) == 0x01)
533 #ifdef AKM_Device_AK8963
534 rbuf
[0] = AK8963_REG_ST1
;
536 rbuf
[0] = AK09911_REG_ST1
;
540 if(loop_i
>= AKM09911_RETRY_COUNT
)
542 printk(KERN_ERR
"Data read retry larger the max count!\n");
545 return -1;//if return we can not get data at factory mode
550 #ifdef AKM_Device_AK8963
551 rbuf
[1]= AK8963_REG_HXL
;
552 ret
= AKI2C_RxData(&rbuf
[1], SENSOR_DATA_SIZE
-2);
554 rbuf
[1]= AK09911_REG_HXL
;
555 ret
= AKI2C_RxData(&rbuf
[1], SENSOR_DATA_SIZE
-1);
559 printk(KERN_ERR
"AKM8975 akm8975_work_func: I2C failed\n");
563 #ifdef AKM_Device_AK8963
567 mutex_lock(&sense_data_mutex
);
568 memcpy(sense_data
, rbuf
, sizeof(sense_data
));
569 mutex_unlock(&sense_data_mutex
);
572 if(atomic_read(&data
->trace
) & AMK_DATA_DEBUG
)
574 AKMDBG("Get device data: %d, %d, %d, %d , %d, %d, %d, %d!\n",
575 sense_data
[0],sense_data
[1],sense_data
[2],sense_data
[3],
576 sense_data
[4],sense_data
[5],sense_data
[6],sense_data
[7]);
583 // Get Msensor Raw data
584 static int AKECS_GetRawData(char *rbuf
, int size
)
586 char strbuf
[SENSOR_DATA_SIZE
];
588 if((atomic_read(&open_flag
) == 0) || (factory_mode
== 1))
590 AKECS_SetMode_SngMeasure();
594 AKECS_GetData(strbuf
, SENSOR_DATA_SIZE
);
595 data
[0] = (s16
)(strbuf
[1] | (strbuf
[2] << 8));
596 data
[1] = (s16
)(strbuf
[3] | (strbuf
[4] << 8));
597 data
[2] = (s16
)(strbuf
[5] | (strbuf
[6] << 8));
599 sprintf(rbuf
, "%x %x %x", data
[0], data
[1], data
[2]);
607 static int AKECS_GetOpenStatus(void)
609 wait_event_interruptible(open_wq
, (atomic_read(&open_flag
) != 0));
610 return atomic_read(&open_flag
);
613 static int AKECS_GetCloseStatus(void)
615 wait_event_interruptible(open_wq
, (atomic_read(&open_flag
) <= 0));
616 return atomic_read(&open_flag
);
622 /*----------------------------------------------------------------------------*/
623 static int akm09911_ReadChipInfo(char *buf
, int bufsize
)
625 if((!buf
)||(bufsize
<= AKM09911_BUFSIZE
-1))
635 sprintf(buf
, "akm09911 Chip");
639 /*----------------------------shipment test------------------------------------------------*/
641 @return If @a testdata is in the range of between @a lolimit and @a hilimit,
642 the return value is 1, otherwise -1.
643 @param[in] testno A pointer to a text string.
644 @param[in] testname A pointer to a text string.
645 @param[in] testdata A data to be tested.
646 @param[in] lolimit The maximum allowable value of @a testdata.
647 @param[in] hilimit The minimum allowable value of @a testdata.
648 @param[in,out] pf_total
651 TEST_DATA(const char testno
[],
652 const char testname
[],
658 int pf
; //Pass;1, Fail;-1
660 if ((testno
== NULL
) && (strncmp(testname
, "START", 5) == 0)) {
662 AKMDBG("--------------------------------------------------------------------\n");
663 AKMDBG(" Test No. Test Name Fail Test Data [ Low High]\n");
664 AKMDBG("--------------------------------------------------------------------\n");
667 } else if ((testno
== NULL
) && (strncmp(testname
, "END", 3) == 0)) {
669 AKMDBG("--------------------------------------------------------------------\n");
670 if (*pf_total
== 1) {
671 AKMDBG("Factory shipment test was passed.\n\n");
673 AKMDBG("Factory shipment test was failed.\n\n");
678 if ((lolimit
<= testdata
) && (testdata
<= hilimit
)) {
687 AKMDBG(" %7s %-10s %c %9d [%9d %9d]\n",
688 testno
, testname
, ((pf
== 1) ? ('.') : ('F')), testdata
,
693 if (*pf_total
!= 0) {
694 if ((*pf_total
== 1) && (pf
== 1)) {
695 *pf_total
= 1; //Pass
697 *pf_total
= -1; //Fail
704 int pf_total
; //p/f flag for this subtest
711 //***********************************************
713 //***********************************************
716 //***********************************************
718 //***********************************************
720 // Set to PowerDown mode
721 //if (AKECS_SetMode(AK8963_MODE_POWERDOWN) < 0) {
722 // AKMDBG("%s:%d Error.\n", __FUNCTION__, __LINE__);
728 // When the serial interface is SPI,
729 // write "00011011" to I2CDIS register(to disable I2C,).
730 if(CSPEC_SPI_USE
== 1){
731 i2cData
[0] = AK8963_REG_I2CDIS
;
733 if (AKI2C_TxData(i2cData
, 2) < 0) {
734 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
739 // Read values from WIA to ASTC.
740 i2cData
[0] = AK8963_REG_WIA
;
741 if (AKI2C_RxData(i2cData
, 7) < 0) {
742 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
747 TEST_DATA(TLIMIT_NO_RST_WIA
, TLIMIT_TN_RST_WIA
, (int)i2cData
[0], TLIMIT_LO_RST_WIA
, TLIMIT_HI_RST_WIA
, &pf_total
);
748 TEST_DATA(TLIMIT_NO_RST_INFO
, TLIMIT_TN_RST_INFO
, (int)i2cData
[1], TLIMIT_LO_RST_INFO
, TLIMIT_HI_RST_INFO
, &pf_total
);
749 TEST_DATA(TLIMIT_NO_RST_ST1
, TLIMIT_TN_RST_ST1
, (int)i2cData
[2], TLIMIT_LO_RST_ST1
, TLIMIT_HI_RST_ST1
, &pf_total
);
750 TEST_DATA(TLIMIT_NO_RST_HXL
, TLIMIT_TN_RST_HXL
, (int)i2cData
[3], TLIMIT_LO_RST_HXL
, TLIMIT_HI_RST_HXL
, &pf_total
);
751 TEST_DATA(TLIMIT_NO_RST_HXH
, TLIMIT_TN_RST_HXH
, (int)i2cData
[4], TLIMIT_LO_RST_HXH
, TLIMIT_HI_RST_HXH
, &pf_total
);
752 TEST_DATA(TLIMIT_NO_RST_HYL
, TLIMIT_TN_RST_HYL
, (int)i2cData
[5], TLIMIT_LO_RST_HYL
, TLIMIT_HI_RST_HYL
, &pf_total
);
753 TEST_DATA(TLIMIT_NO_RST_HYH
, TLIMIT_TN_RST_HYH
, (int)i2cData
[6], TLIMIT_LO_RST_HYH
, TLIMIT_HI_RST_HYH
, &pf_total
);
754 // our i2c only most can read 8 byte at one time ,
755 i2cData
[7]= AK8963_REG_HZL
;
756 if (AKI2C_RxData((i2cData
+7), 6) < 0) {
757 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
760 TEST_DATA(TLIMIT_NO_RST_HZL
, TLIMIT_TN_RST_HZL
, (int)i2cData
[7], TLIMIT_LO_RST_HZL
, TLIMIT_HI_RST_HZL
, &pf_total
);
761 TEST_DATA(TLIMIT_NO_RST_HZH
, TLIMIT_TN_RST_HZH
, (int)i2cData
[8], TLIMIT_LO_RST_HZH
, TLIMIT_HI_RST_HZH
, &pf_total
);
762 TEST_DATA(TLIMIT_NO_RST_ST2
, TLIMIT_TN_RST_ST2
, (int)i2cData
[9], TLIMIT_LO_RST_ST2
, TLIMIT_HI_RST_ST2
, &pf_total
);
763 TEST_DATA(TLIMIT_NO_RST_CNTL
, TLIMIT_TN_RST_CNTL
, (int)i2cData
[10], TLIMIT_LO_RST_CNTL
, TLIMIT_HI_RST_CNTL
, &pf_total
);
764 // i2cData[11] is BLANK.
765 TEST_DATA(TLIMIT_NO_RST_ASTC
, TLIMIT_TN_RST_ASTC
, (int)i2cData
[12], TLIMIT_LO_RST_ASTC
, TLIMIT_HI_RST_ASTC
, &pf_total
);
767 // Read values from I2CDIS.
768 i2cData
[0] = AK8963_REG_I2CDIS
;
769 if (AKI2C_RxData(i2cData
, 1) < 0 ) {
770 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
773 if(CSPEC_SPI_USE
== 1){
774 TEST_DATA(TLIMIT_NO_RST_I2CDIS
, TLIMIT_TN_RST_I2CDIS
, (int)i2cData
[0], TLIMIT_LO_RST_I2CDIS_USESPI
, TLIMIT_HI_RST_I2CDIS_USESPI
, &pf_total
);
776 TEST_DATA(TLIMIT_NO_RST_I2CDIS
, TLIMIT_TN_RST_I2CDIS
, (int)i2cData
[0], TLIMIT_LO_RST_I2CDIS_USEI2C
, TLIMIT_HI_RST_I2CDIS_USEI2C
, &pf_total
);
779 // Set to FUSE ROM access mode
780 if (AKECS_SetMode(AK8963_MODE_FUSE_ACCESS
) < 0) {
781 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
785 // Read values from ASAX to ASAZ
786 i2cData
[0] = AK8963_FUSE_ASAX
;
787 if (AKI2C_RxData(i2cData
, 3) < 0) {
788 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
791 asax
= (int)i2cData
[0];
792 asay
= (int)i2cData
[1];
793 asaz
= (int)i2cData
[2];
796 TEST_DATA(TLIMIT_NO_ASAX
, TLIMIT_TN_ASAX
, asax
, TLIMIT_LO_ASAX
, TLIMIT_HI_ASAX
, &pf_total
);
797 TEST_DATA(TLIMIT_NO_ASAY
, TLIMIT_TN_ASAY
, asay
, TLIMIT_LO_ASAY
, TLIMIT_HI_ASAY
, &pf_total
);
798 TEST_DATA(TLIMIT_NO_ASAZ
, TLIMIT_TN_ASAZ
, asaz
, TLIMIT_LO_ASAZ
, TLIMIT_HI_ASAZ
, &pf_total
);
801 i2cData
[0] = AK8963_REG_CNTL1
;
802 if (AKI2C_RxData(i2cData
, 1)< 0) {
803 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
807 // Set to PowerDown mode
808 if (AKECS_SetMode(AK8963_MODE_POWERDOWN
) < 0) {
809 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
814 TEST_DATA(TLIMIT_NO_WR_CNTL
, TLIMIT_TN_WR_CNTL
, (int)i2cData
[0], TLIMIT_LO_WR_CNTL
, TLIMIT_HI_WR_CNTL
, &pf_total
);
817 //***********************************************
819 //***********************************************
821 // Set to SNG measurement pattern (Set CNTL register)
822 if (AKECS_SetMode(AK8963_MODE_SNG_MEASURE
) < 0) {
823 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
827 // Wait for DRDY pin changes to HIGH.
829 // Get measurement data from AK8963
830 // ST1 + (HXL + HXH) + (HYL + HYH) + (HZL + HZH) + ST2
831 // = 1 + (1 + 1) + (1 + 1) + (1 + 1) + 1 = 8 bytes
832 if (AKECS_GetData(i2cData
,SENSOR_DATA_SIZE
) < 0) {
833 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
837 hdata
[0] = (s16
)(i2cData
[1] | (i2cData
[2] << 8));
838 hdata
[1] = (s16
)(i2cData
[3] | (i2cData
[4] << 8));
839 hdata
[2] = (s16
)(i2cData
[5] | (i2cData
[6] << 8));
847 TEST_DATA(TLIMIT_NO_SNG_ST1
, TLIMIT_TN_SNG_ST1
, (int)i2cData
[0], TLIMIT_LO_SNG_ST1
, TLIMIT_HI_SNG_ST1
, &pf_total
);
848 TEST_DATA(TLIMIT_NO_SNG_HX
, TLIMIT_TN_SNG_HX
, hdata
[0], TLIMIT_LO_SNG_HX
, TLIMIT_HI_SNG_HX
, &pf_total
);
849 TEST_DATA(TLIMIT_NO_SNG_HY
, TLIMIT_TN_SNG_HY
, hdata
[1], TLIMIT_LO_SNG_HY
, TLIMIT_HI_SNG_HY
, &pf_total
);
850 TEST_DATA(TLIMIT_NO_SNG_HZ
, TLIMIT_TN_SNG_HZ
, hdata
[2], TLIMIT_LO_SNG_HZ
, TLIMIT_HI_SNG_HZ
, &pf_total
);
851 TEST_DATA(TLIMIT_NO_SNG_ST2
, TLIMIT_TN_SNG_ST2
, (int)i2cData
[8], TLIMIT_LO_SNG_ST2
, TLIMIT_HI_SNG_ST2
, &pf_total
);
853 // Generate magnetic field for self-test (Set ASTC register)
854 i2cData
[0] = AK8963_REG_ASTC
;
856 if (AKI2C_TxData(i2cData
, 2) < 0) {
857 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
861 // Set to Self-test mode (Set CNTL register)
862 if (AKECS_SetMode(AK8963_MODE_SELF_TEST
) < 0) {
863 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
867 // Wait for DRDY pin changes to HIGH.
869 // Get measurement data from AK8963
870 // ST1 + (HXL + HXH) + (HYL + HYH) + (HZL + HZH) + ST2
871 // = 1 + (1 + 1) + (1 + 1) + (1 + 1) + 1 = 8Byte
872 if (AKECS_GetData(i2cData
,SENSOR_DATA_SIZE
) < 0) {
873 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
878 TEST_DATA(TLIMIT_NO_SLF_ST1
, TLIMIT_TN_SLF_ST1
, (int)i2cData
[0], TLIMIT_LO_SLF_ST1
, TLIMIT_HI_SLF_ST1
, &pf_total
);
880 hdata
[0] = (s16
)(i2cData
[1] | (i2cData
[2] << 8));
881 hdata
[1] = (s16
)(i2cData
[3] | (i2cData
[4] << 8));
882 hdata
[2] = (s16
)(i2cData
[5] | (i2cData
[6] << 8));
889 AKMDBG("hdata[0] = %d\n",hdata
[0] );
890 AKMDBG("asax = %d\n",asax
);
894 (hdata
[0])*((asax
- 128)/2/128 + 1),
903 (hdata
[1])*((asay
- 128)/2/128 + 1),
912 (hdata
[2])*((asaz
- 128)/2/128 + 1),
918 TEST_DATA(TLIMIT_NO_SLF_ST2
, TLIMIT_TN_SLF_ST2
, (int)i2cData
[8], TLIMIT_LO_SLF_ST2
, TLIMIT_HI_SLF_ST2
, &pf_total
);
920 // Set to Normal mode for self-test.
921 i2cData
[0] = AK8963_REG_ASTC
;
923 if (AKI2C_TxData(i2cData
, 2) < 0) {
924 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
927 AKMDBG("pf_total = %d\n",pf_total
);
934 Execute "Onboard Function Test" (NOT includes "START" and "END" command).
935 @retval 1 The test is passed successfully.
936 @retval -1 The test is failed.
937 @retval 0 The test is aborted by kind of system error.
939 int FST_AK09911(void)
941 int pf_total
; //p/f flag for this subtest
948 //***********************************************
950 //***********************************************
953 //***********************************************
955 //***********************************************
958 if (AKECS_Reset(0) < 0) {
959 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
963 // Read values from WIA.
964 i2cData
[0] = AK09911_REG_WIA1
;
965 if (AKI2C_RxData(i2cData
, 2) < 0) {
966 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
971 TEST_DATA(TLIMIT_NO_RST_WIA1_09911
, TLIMIT_TN_RST_WIA1_09911
, (int)i2cData
[0], TLIMIT_LO_RST_WIA1_09911
, TLIMIT_HI_RST_WIA1_09911
, &pf_total
);
972 TEST_DATA(TLIMIT_NO_RST_WIA2_09911
, TLIMIT_TN_RST_WIA2_09911
, (int)i2cData
[1], TLIMIT_LO_RST_WIA2_09911
, TLIMIT_HI_RST_WIA2_09911
, &pf_total
);
974 // Set to FUSE ROM access mode
975 if (AKECS_SetMode(AK09911_MODE_FUSE_ACCESS
) < 0) {
976 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
980 // Read values from ASAX to ASAZ
981 i2cData
[0] = AK09911_FUSE_ASAX
;
982 if (AKI2C_RxData(i2cData
, 3) < 0) {
983 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
986 asax
= (int)i2cData
[0];
987 asay
= (int)i2cData
[1];
988 asaz
= (int)i2cData
[2];
991 TEST_DATA(TLIMIT_NO_ASAX_09911
, TLIMIT_TN_ASAX_09911
, asax
, TLIMIT_LO_ASAX_09911
, TLIMIT_HI_ASAX_09911
, &pf_total
);
992 TEST_DATA(TLIMIT_NO_ASAY_09911
, TLIMIT_TN_ASAY_09911
, asay
, TLIMIT_LO_ASAY_09911
, TLIMIT_HI_ASAY_09911
, &pf_total
);
993 TEST_DATA(TLIMIT_NO_ASAZ_09911
, TLIMIT_TN_ASAZ_09911
, asaz
, TLIMIT_LO_ASAZ_09911
, TLIMIT_HI_ASAZ_09911
, &pf_total
);
995 // Set to PowerDown mode
996 if (AKECS_SetMode(AK09911_MODE_POWERDOWN
) < 0) {
997 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
1001 //***********************************************
1003 //***********************************************
1005 // Set to SNG measurement pattern (Set CNTL register)
1006 if (AKECS_SetMode(AK09911_MODE_SNG_MEASURE
) < 0) {
1007 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
1011 // Wait for DRDY pin changes to HIGH.
1012 //usleep(AKM_MEASURE_TIME_US);
1013 // Get measurement data from AK09911
1014 // ST1 + (HXL + HXH) + (HYL + HYH) + (HZL + HZH) + TEMP + ST2
1015 // = 1 + (1 + 1) + (1 + 1) + (1 + 1) + 1 + 1 = 9yte
1016 //if (AKD_GetMagneticData(i2cData) != AKD_SUCCESS) {
1017 if (AKECS_GetData(i2cData
,SENSOR_DATA_SIZE
) < 0) {
1018 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
1022 //hdata[0] = (int)((((uint)(i2cData[2]))<<8)+(uint)(i2cData[1]));
1023 //hdata[1] = (int)((((uint)(i2cData[4]))<<8)+(uint)(i2cData[3]));
1024 //hdata[2] = (int)((((uint)(i2cData[6]))<<8)+(uint)(i2cData[5]));
1026 hdata
[0] = (s16
)(i2cData
[1] | (i2cData
[2] << 8));
1027 hdata
[1] = (s16
)(i2cData
[3] | (i2cData
[4] << 8));
1028 hdata
[2] = (s16
)(i2cData
[5] | (i2cData
[6] << 8));
1032 TEST_DATA(TLIMIT_NO_SNG_ST1_09911
, TLIMIT_TN_SNG_ST1_09911
, (int)i2cData
[0], TLIMIT_LO_SNG_ST1_09911
, TLIMIT_HI_SNG_ST1_09911
, &pf_total
);
1035 TEST_DATA(TLIMIT_NO_SNG_HX_09911
, TLIMIT_TN_SNG_HX_09911
, hdata
[0], TLIMIT_LO_SNG_HX_09911
, TLIMIT_HI_SNG_HX_09911
, &pf_total
);
1036 TEST_DATA(TLIMIT_NO_SNG_HY_09911
, TLIMIT_TN_SNG_HY_09911
, hdata
[1], TLIMIT_LO_SNG_HY_09911
, TLIMIT_HI_SNG_HY_09911
, &pf_total
);
1037 TEST_DATA(TLIMIT_NO_SNG_HZ_09911
, TLIMIT_TN_SNG_HZ_09911
, hdata
[2], TLIMIT_LO_SNG_HZ_09911
, TLIMIT_HI_SNG_HZ_09911
, &pf_total
);
1038 TEST_DATA(TLIMIT_NO_SNG_ST2_09911
, TLIMIT_TN_SNG_ST2_09911
, (int)i2cData
[8], TLIMIT_LO_SNG_ST2_09911
, TLIMIT_HI_SNG_ST2_09911
, &pf_total
);
1040 // Set to Self-test mode (Set CNTL register)
1041 if (AKECS_SetMode(AK09911_MODE_SELF_TEST
) < 0) {
1042 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
1046 // Wait for DRDY pin changes to HIGH.
1047 //usleep(AKM_MEASURE_TIME_US);
1048 // Get measurement data from AK09911
1049 // ST1 + (HXL + HXH) + (HYL + HYH) + (HZL + HZH) + TEMP + ST2
1050 // = 1 + (1 + 1) + (1 + 1) + (1 + 1) + 1 + 1 = 9byte
1051 //if (AKD_GetMagneticData(i2cData) != AKD_SUCCESS) {
1052 if (AKECS_GetData(i2cData
,SENSOR_DATA_SIZE
) < 0) {
1053 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
1059 TEST_DATA(TLIMIT_NO_SLF_ST1_09911
, TLIMIT_TN_SLF_ST1_09911
, (int)i2cData
[0], TLIMIT_LO_SLF_ST1_09911
, TLIMIT_HI_SLF_ST1_09911
, &pf_total
);
1061 //hdata[0] = (int)((((uint)(i2cData[2]))<<8)+(uint)(i2cData[1]));
1062 //hdata[1] = (int)((((uint)(i2cData[4]))<<8)+(uint)(i2cData[3]));
1063 //hdata[2] = (int)((((uint)(i2cData[6]))<<8)+(uint)(i2cData[5]));
1065 hdata
[0] = (s16
)(i2cData
[1] | (i2cData
[2] << 8));
1066 hdata
[1] = (s16
)(i2cData
[3] | (i2cData
[4] << 8));
1067 hdata
[2] = (s16
)(i2cData
[5] | (i2cData
[6] << 8));
1071 TLIMIT_NO_SLF_RVHX_09911
,
1072 TLIMIT_TN_SLF_RVHX_09911
,
1073 (hdata
[0])*(asax
/128 + 1),
1074 TLIMIT_LO_SLF_RVHX_09911
,
1075 TLIMIT_HI_SLF_RVHX_09911
,
1080 TLIMIT_NO_SLF_RVHY_09911
,
1081 TLIMIT_TN_SLF_RVHY_09911
,
1082 (hdata
[1])*(asay
/128 + 1),
1083 TLIMIT_LO_SLF_RVHY_09911
,
1084 TLIMIT_HI_SLF_RVHY_09911
,
1089 TLIMIT_NO_SLF_RVHZ_09911
,
1090 TLIMIT_TN_SLF_RVHZ_09911
,
1091 (hdata
[2])*(asaz
/128 + 1),
1092 TLIMIT_LO_SLF_RVHZ_09911
,
1093 TLIMIT_HI_SLF_RVHZ_09911
,
1098 TLIMIT_NO_SLF_ST2_09911
,
1099 TLIMIT_TN_SLF_ST2_09911
,
1101 TLIMIT_LO_SLF_ST2_09911
,
1102 TLIMIT_HI_SLF_ST2_09911
,
1110 Execute "Onboard Function Test" (includes "START" and "END" command).
1111 @retval 1 The test is passed successfully.
1112 @retval -1 The test is failed.
1113 @retval 0 The test is aborted by kind of system error.
1115 int FctShipmntTestProcess_Body(void)
1119 //***********************************************
1120 // Reset Test Result
1121 //***********************************************
1122 TEST_DATA(NULL
, "START", 0, 0, 0, &pf_total
);
1124 //***********************************************
1126 //***********************************************
1127 #ifdef AKM_Device_AK8963
1128 pf_total
= FST_AK8963();
1130 pf_total
= FST_AK09911();
1133 //***********************************************
1134 // Judge Test Result
1135 //***********************************************
1136 TEST_DATA(NULL
, "END", 0, 0, 0, &pf_total
);
1141 static ssize_t
store_shipment_test(struct device_driver
* ddri
,const char * buf
, size_t count
)
1143 //struct i2c_client *client = this_client;
1144 //struct akm09911_i2c_data *data = i2c_get_clientdata(client);
1151 static ssize_t
show_shipment_test(struct device_driver
*ddri
, char *buf
)
1155 res
= FctShipmntTestProcess_Body();
1158 AKMDBG("shipment_test pass\n");
1163 AKMDBG("shipment_test fail\n");
1168 AKMDBG("shipment_test NaN\n");
1169 strcpy(result
,"NaN");
1172 return sprintf(buf
, "%s\n", result
);
1175 static ssize_t
show_daemon_name(struct device_driver
*ddri
, char *buf
)
1177 char strbuf
[AKM09911_BUFSIZE
];
1178 sprintf(strbuf
, "akmd09911");
1179 return sprintf(buf
, "%s", strbuf
);
1182 static ssize_t
show_chipinfo_value(struct device_driver
*ddri
, char *buf
)
1184 char strbuf
[AKM09911_BUFSIZE
];
1185 akm09911_ReadChipInfo(strbuf
, AKM09911_BUFSIZE
);
1186 return sprintf(buf
, "%s\n", strbuf
);
1188 /*----------------------------------------------------------------------------*/
1189 static ssize_t
show_sensordata_value(struct device_driver
*ddri
, char *buf
)
1192 char sensordata
[SENSOR_DATA_SIZE
];
1193 char strbuf
[AKM09911_BUFSIZE
];
1194 if(atomic_read(&open_flag
) == 0)
1196 AKECS_SetMode_SngMeasure();
1198 AKECS_GetData(sensordata
, SENSOR_DATA_SIZE
);
1202 mutex_lock(&sense_data_mutex
);
1203 memcpy(sensordata
, sense_data
, sizeof(sensordata
));
1204 mutex_unlock(&sense_data_mutex
);
1209 sprintf(strbuf
, "%d %d %d %d %d %d %d %d %d\n", sensordata
[0],sensordata
[1],sensordata
[2],
1210 sensordata
[3],sensordata
[4],sensordata
[5],sensordata
[6],sensordata
[7],sensordata
[8]);
1212 return sprintf(buf
, "%s\n", strbuf
);
1214 /*----------------------------------------------------------------------------*/
1215 static ssize_t
show_posturedata_value(struct device_driver
*ddri
, char *buf
)
1218 char strbuf
[AKM09911_BUFSIZE
];
1219 tmp
[0] = sensor_data
[13] * CONVERT_O
/ CONVERT_O_DIV
;
1220 tmp
[1] = sensor_data
[14] * CONVERT_O
/ CONVERT_O_DIV
;
1221 tmp
[2] = sensor_data
[15] * CONVERT_O
/ CONVERT_O_DIV
;
1222 sprintf(strbuf
, "%d, %d, %d\n", tmp
[0],tmp
[1], tmp
[2]);
1224 return sprintf(buf
, "%s\n", strbuf
);;
1227 /*----------------------------------------------------------------------------*/
1228 static ssize_t
show_layout_value(struct device_driver
*ddri
, char *buf
)
1230 struct i2c_client
*client
= this_client
;
1231 struct akm09911_i2c_data
*data
= i2c_get_clientdata(client
);
1233 return sprintf(buf
, "(%d, %d)\n[%+2d %+2d %+2d]\n[%+2d %+2d %+2d]\n",
1234 data
->hw
->direction
,atomic_read(&data
->layout
), data
->cvt
.sign
[0], data
->cvt
.sign
[1],
1235 data
->cvt
.sign
[2],data
->cvt
.map
[0], data
->cvt
.map
[1], data
->cvt
.map
[2]);
1237 /*----------------------------------------------------------------------------*/
1238 static ssize_t
store_layout_value(struct device_driver
*ddri
, const char *buf
, size_t count
)
1240 struct i2c_client
*client
= this_client
;
1241 struct akm09911_i2c_data
*data
= i2c_get_clientdata(client
);
1244 if(1 == sscanf(buf
, "%d", &layout
))
1246 atomic_set(&data
->layout
, layout
);
1247 if(!hwmsen_get_convert(layout
, &data
->cvt
))
1249 printk(KERN_ERR
"HWMSEN_GET_CONVERT function error!\r\n");
1251 else if(!hwmsen_get_convert(data
->hw
->direction
, &data
->cvt
))
1253 printk(KERN_ERR
"invalid layout: %d, restore to %d\n", layout
, data
->hw
->direction
);
1257 printk(KERN_ERR
"invalid layout: (%d, %d)\n", layout
, data
->hw
->direction
);
1258 hwmsen_get_convert(0, &data
->cvt
);
1263 printk(KERN_ERR
"invalid format = '%s'\n", buf
);
1268 /*----------------------------------------------------------------------------*/
1269 static ssize_t
show_status_value(struct device_driver
*ddri
, char *buf
)
1271 struct i2c_client
*client
= this_client
;
1272 struct akm09911_i2c_data
*data
= i2c_get_clientdata(client
);
1277 len
+= snprintf(buf
+len
, PAGE_SIZE
-len
, "CUST: %d %d (%d %d)\n",
1278 data
->hw
->i2c_num
, data
->hw
->direction
, data
->hw
->power_id
, data
->hw
->power_vol
);
1282 len
+= snprintf(buf
+len
, PAGE_SIZE
-len
, "CUST: NULL\n");
1285 len
+= snprintf(buf
+len
, PAGE_SIZE
-len
, "OPEN: %d\n", atomic_read(&dev_open_count
));
1288 /*----------------------------------------------------------------------------*/
1289 static ssize_t
show_trace_value(struct device_driver
*ddri
, char *buf
)
1292 struct akm09911_i2c_data
*obj
= i2c_get_clientdata(this_client
);
1295 printk(KERN_ERR
"akm09911_i2c_data is null!!\n");
1299 res
= snprintf(buf
, PAGE_SIZE
, "0x%04X\n", atomic_read(&obj
->trace
));
1302 /*----------------------------------------------------------------------------*/
1303 static ssize_t
store_trace_value(struct device_driver
*ddri
, const char *buf
, size_t count
)
1305 struct akm09911_i2c_data
*obj
= i2c_get_clientdata(this_client
);
1309 printk(KERN_ERR
"akm09911_i2c_data is null!!\n");
1313 if(1 == sscanf(buf
, "0x%x", &trace
))
1315 atomic_set(&obj
->trace
, trace
);
1319 printk(KERN_ERR
"invalid content: '%s', length = %d\n", buf
, count
);
1324 /*----------------------------------------------------------------------------*/
1325 static DRIVER_ATTR(daemon
, S_IRUGO
, show_daemon_name
, NULL
);
1326 static DRIVER_ATTR(shipmenttest
,S_IRUGO
| S_IWUSR
, show_shipment_test
, store_shipment_test
);
1327 static DRIVER_ATTR(chipinfo
, S_IRUGO
, show_chipinfo_value
, NULL
);
1328 static DRIVER_ATTR(sensordata
, S_IRUGO
, show_sensordata_value
, NULL
);
1329 static DRIVER_ATTR(posturedata
, S_IRUGO
, show_posturedata_value
, NULL
);
1330 static DRIVER_ATTR(layout
, S_IRUGO
| S_IWUSR
, show_layout_value
, store_layout_value
);
1331 static DRIVER_ATTR(status
, S_IRUGO
, show_status_value
, NULL
);
1332 static DRIVER_ATTR(trace
, S_IRUGO
| S_IWUSR
, show_trace_value
, store_trace_value
);
1333 /*----------------------------------------------------------------------------*/
1334 static struct driver_attribute
*akm09911_attr_list
[] = {
1335 &driver_attr_daemon
,
1336 &driver_attr_shipmenttest
,
1337 &driver_attr_chipinfo
,
1338 &driver_attr_sensordata
,
1339 &driver_attr_posturedata
,
1340 &driver_attr_layout
,
1341 &driver_attr_status
,
1344 /*----------------------------------------------------------------------------*/
1345 static int akm09911_create_attr(struct device_driver
*driver
)
1348 int num
= (int)(sizeof(akm09911_attr_list
)/sizeof(akm09911_attr_list
[0]));
1354 for(idx
= 0; idx
< num
; idx
++)
1356 if((err
= driver_create_file(driver
, akm09911_attr_list
[idx
])))
1358 printk(KERN_ERR
"driver_create_file (%s) = %d\n", akm09911_attr_list
[idx
]->attr
.name
, err
);
1364 /*----------------------------------------------------------------------------*/
1365 static int akm09911_delete_attr(struct device_driver
*driver
)
1368 int num
= (int)(sizeof(akm09911_attr_list
)/sizeof(akm09911_attr_list
[0]));
1376 for(idx
= 0; idx
< num
; idx
++)
1378 driver_remove_file(driver
, akm09911_attr_list
[idx
]);
1386 /*----------------------------------------------------------------------------*/
1387 static int akm09911_open(struct inode
*inode
, struct file
*file
)
1389 struct akm09911_i2c_data
*obj
= i2c_get_clientdata(this_client
);
1392 if(atomic_read(&obj
->trace
) & AMK_CTR_DEBUG
)
1394 AKMDBG("Open device node:akm09911\n");
1396 ret
= nonseekable_open(inode
, file
);
1400 /*----------------------------------------------------------------------------*/
1401 static int akm09911_release(struct inode
*inode
, struct file
*file
)
1403 struct akm09911_i2c_data
*obj
= i2c_get_clientdata(this_client
);
1404 atomic_dec(&dev_open_count
);
1405 if(atomic_read(&obj
->trace
) & AMK_CTR_DEBUG
)
1407 AKMDBG("Release device node:akm09911\n");
1413 /*----------------------------------------------------------------------------*/
1414 //static int akm09911_ioctl(struct inode *inode, struct file *file, unsigned int cmd,unsigned long arg)
1415 static long akm09911_unlocked_ioctl(struct file
*file
, unsigned int cmd
,unsigned long arg
)
1417 void __user
*argp
= (void __user
*)arg
;
1419 /* NOTE: In this function the size of "char" should be 1-byte. */
1420 char sData
[SENSOR_DATA_SIZE
];/* for GETDATA */
1421 char rwbuf
[RWBUF_SIZE
]; /* for READ/WRITE */
1422 char buff
[AKM09911_BUFSIZE
]; /* for chip information */
1423 char mode
; /* for SET_MODE*/
1424 int value
[26]; /* for SET_YPR */
1425 int64_t delay
[3]; /* for GET_DELAY */
1426 int status
; /* for OPEN/CLOSE_STATUS */
1427 long ret
= -1; /* Return value. */
1429 struct i2c_client
*client
= this_client
;
1430 struct akm09911_i2c_data
*data
= i2c_get_clientdata(client
);
1431 hwm_sensor_data
* osensor_data
;
1433 /* These two buffers are initialized at start up.
1434 After that, the value is not changed */
1435 unsigned char sense_info
[AKM_SENSOR_INFO_SIZE
];
1436 unsigned char sense_conf
[AKM_SENSOR_CONF_SIZE
];
1438 // printk(KERN_ERR"akm09911 cmd:0x%x\n", cmd);
1441 case ECS_IOCTL_WRITE
:
1442 //AKMFUNC("ECS_IOCTL_WRITE");
1445 AKMDBG("invalid argument.");
1448 if(copy_from_user(rwbuf
, argp
, sizeof(rwbuf
)))
1450 AKMDBG("copy_from_user failed.");
1454 if((rwbuf
[0] < 2) || (rwbuf
[0] > (RWBUF_SIZE
-1)))
1456 AKMDBG("invalid argument.");
1459 ret
= AKI2C_TxData(&rwbuf
[1], rwbuf
[0]);
1465 case ECS_IOCTL_RESET
:
1466 ret
= AKECS_Reset(0); // sw: 0, hw: 1
1470 case ECS_IOCTL_READ
:
1471 //AKMFUNC("ECS_IOCTL_READ");
1474 AKMDBG("invalid argument.");
1478 if(copy_from_user(rwbuf
, argp
, sizeof(rwbuf
)))
1480 AKMDBG("copy_from_user failed.");
1484 if((rwbuf
[0] < 1) || (rwbuf
[0] > (RWBUF_SIZE
-1)))
1486 AKMDBG("invalid argument.");
1489 ret
= AKI2C_RxData(&rwbuf
[1], rwbuf
[0]);
1494 if(copy_to_user(argp
, rwbuf
, rwbuf
[0]+1))
1496 AKMDBG("copy_to_user failed.");
1500 case ECS_IOCTL_GET_INFO
:
1502 #ifdef AKM_Device_AK8963
1503 sense_info
[0] = AK8963_REG_WIA
;
1505 sense_info
[0] = AK09911_REG_WIA1
;
1508 ret
= AKI2C_RxData(sense_info
, AKM_SENSOR_INFO_SIZE
);
1513 if(copy_to_user(argp
, sense_info
, AKM_SENSOR_INFO_SIZE
))
1515 AKMDBG("copy_to_user failed.");
1519 case ECS_IOCTL_GET_CONF
:
1520 /* Set FUSE access mode */
1521 #ifdef AKM_Device_AK8963
1522 ret
= AKECS_SetMode(AK8963_MODE_FUSE_ACCESS
);
1524 ret
= AKECS_SetMode(AK09911_MODE_FUSE_ACCESS
);
1528 #ifdef AKM_Device_AK8963
1529 sense_conf
[0] = AK8963_FUSE_ASAX
;
1531 sense_conf
[0] = AK09911_FUSE_ASAX
;
1534 ret
= AKI2C_RxData(sense_conf
, AKM_SENSOR_CONF_SIZE
);
1539 if(copy_to_user(argp
, sense_conf
, AKM_SENSOR_CONF_SIZE
))
1541 AKMDBG("copy_to_user failed.");
1544 #ifdef AKM_Device_AK8963
1545 ret
= AKECS_SetMode(AK8963_MODE_POWERDOWN
);
1547 ret
= AKECS_SetMode(AK09911_MODE_POWERDOWN
);
1554 case ECS_IOCTL_SET_MODE
:
1555 //AKMFUNC("ECS_IOCTL_SET_MODE");
1558 AKMDBG("invalid argument.");
1561 if(copy_from_user(&mode
, argp
, sizeof(mode
)))
1563 AKMDBG("copy_from_user failed.");
1566 ret
= AKECS_SetMode(mode
); // MATCH command from AKMD PART
1573 case ECS_IOCTL_GETDATA
:
1574 //AKMFUNC("ECS_IOCTL_GETDATA");
1575 ret
= AKECS_GetData(sData
, SENSOR_DATA_SIZE
);
1581 if(copy_to_user(argp
, sData
, sizeof(sData
)))
1583 AKMDBG("copy_to_user failed.");
1588 case ECS_IOCTL_SET_YPR_09911
:
1589 //AKMFUNC("ECS_IOCTL_SET_YPR");
1592 AKMDBG("invalid argument.");
1595 if(copy_from_user(value
, argp
, sizeof(value
)))
1597 AKMDBG("copy_from_user failed.");
1600 AKECS_SaveData(value
);
1603 case ECS_IOCTL_GET_OPEN_STATUS
:
1604 //AKMFUNC("IOCTL_GET_OPEN_STATUS");
1605 status
= AKECS_GetOpenStatus();
1606 //AKMDBG("AKECS_GetOpenStatus returned (%d)", status);
1607 if(copy_to_user(argp
, &status
, sizeof(status
)))
1609 AKMDBG("copy_to_user failed.");
1614 case ECS_IOCTL_GET_CLOSE_STATUS
:
1615 //AKMFUNC("IOCTL_GET_CLOSE_STATUS");
1616 status
= AKECS_GetCloseStatus();
1617 //AKMDBG("AKECS_GetCloseStatus returned (%d)", status);
1618 if(copy_to_user(argp
, &status
, sizeof(status
)))
1620 AKMDBG("copy_to_user failed.");
1625 case ECS_IOCTL_GET_OSENSOR_STATUS
:
1626 //AKMFUNC("ECS_IOCTL_GET_OSENSOR_STATUS");
1627 status
= atomic_read(&o_flag
);
1628 if(copy_to_user(argp
, &status
, sizeof(status
)))
1630 AKMDBG("copy_to_user failed.");
1635 case ECS_IOCTL_GET_DELAY_09911
:
1636 //AKMFUNC("IOCTL_GET_DELAY");
1637 delay
[0] = (int)akmd_delay
* 1000000;
1638 delay
[1] = (int)akmd_delay
* 1000000;
1639 delay
[2] = (int)akmd_delay
* 1000000;
1640 if(copy_to_user(argp
, delay
, sizeof(delay
)))
1642 AKMDBG("copy_to_user failed.");
1647 case ECS_IOCTL_GET_LAYOUT_09911
:
1648 layout
= atomic_read(&data
->layout
);
1649 printk(KERN_ERR
"layout=%d\r\n",layout
);
1650 if(copy_to_user(argp
, &layout
, sizeof(layout
)))
1652 AKMDBG("copy_to_user failed.");
1657 case MSENSOR_IOCTL_READ_CHIPINFO
:
1660 printk(KERN_ERR
"IO parameter pointer is NULL!\r\n");
1664 akm09911_ReadChipInfo(buff
, AKM09911_BUFSIZE
);
1665 if(copy_to_user(argp
, buff
, strlen(buff
)+1))
1671 case MSENSOR_IOCTL_READ_SENSORDATA
:
1674 printk(KERN_ERR
"IO parameter pointer is NULL!\r\n");
1678 AKECS_GetRawData(buff
, AKM09911_BUFSIZE
);
1680 if(copy_to_user(argp
, buff
, strlen(buff
)+1))
1686 case MSENSOR_IOCTL_SENSOR_ENABLE
:
1690 printk(KERN_ERR
"IO parameter pointer is NULL!\r\n");
1693 if(copy_from_user(&enable
, argp
, sizeof(enable
)))
1695 AKMDBG("copy_from_user failed.");
1700 printk( "MSENSOR_IOCTL_SENSOR_ENABLE enable=%d!\r\n",enable
);
1704 atomic_set(&o_flag
, 1);
1705 atomic_set(&open_flag
, 1);
1709 atomic_set(&o_flag
, 0);
1710 if(atomic_read(&m_flag
) == 0)
1712 atomic_set(&open_flag
, 0);
1721 case MSENSOR_IOCTL_READ_FACTORY_SENSORDATA
:
1724 printk(KERN_ERR
"IO parameter pointer is NULL!\r\n");
1728 //AKECS_GetRawData(buff, AKM09911_BUFSIZE);
1729 osensor_data
= (hwm_sensor_data
*)buff
;
1730 mutex_lock(&sensor_data_mutex
);
1732 osensor_data
->values
[0] = sensor_data
[13] * CONVERT_O
;
1733 osensor_data
->values
[1] = sensor_data
[14] * CONVERT_O
;
1734 osensor_data
->values
[2] = sensor_data
[15] * CONVERT_O
;
1735 osensor_data
->status
= sensor_data
[8];
1736 osensor_data
->value_divide
= CONVERT_O_DIV
;
1738 mutex_unlock(&sensor_data_mutex
);
1740 sprintf(buff
, "%x %x %x %x %x", osensor_data
->values
[0], osensor_data
->values
[1],
1741 osensor_data
->values
[2],osensor_data
->status
,osensor_data
->value_divide
);
1742 if(copy_to_user(argp
, buff
, strlen(buff
)+1))
1750 printk(KERN_ERR
"%s not supported = 0x%04x", __FUNCTION__
, cmd
);
1751 return -ENOIOCTLCMD
;
1757 /*----------------------------------------------------------------------------*/
1758 static struct file_operations akm09911_fops
= {
1759 .owner
= THIS_MODULE
,
1760 .open
= akm09911_open
,
1761 .release
= akm09911_release
,
1762 //.unlocked_ioctl = akm09911_ioctl,
1763 .unlocked_ioctl
= akm09911_unlocked_ioctl
,
1765 /*----------------------------------------------------------------------------*/
1766 static struct miscdevice akm09911_device
= {
1767 .minor
= MISC_DYNAMIC_MINOR
,
1769 .fops
= &akm09911_fops
,
1771 /*----------------------------------------------------------------------------*/
1772 int akm09911_operate(void* self
, uint32_t command
, void* buff_in
, int size_in
,
1773 void* buff_out
, int size_out
, int* actualout
)
1777 hwm_sensor_data
* msensor_data
;
1780 struct i2c_client
*client
= this_client
;
1781 struct akm09911_i2c_data
*data
= i2c_get_clientdata(client
);
1785 if(atomic_read(&data
->trace
) & AMK_FUN_DEBUG
)
1787 AKMFUNC("akm09911_operate");
1793 if((buff_in
== NULL
) || (size_in
< sizeof(int)))
1795 printk(KERN_ERR
"Set delay parameter error!\n");
1800 value
= *(int *)buff_in
;
1810 if((buff_in
== NULL
) || (size_in
< sizeof(int)))
1812 printk(KERN_ERR
"Enable sensor parameter error!\n");
1818 value
= *(int *)buff_in
;
1822 atomic_set(&m_flag
, 1);
1823 atomic_set(&open_flag
, 1);
1827 atomic_set(&m_flag
, 0);
1828 if(atomic_read(&o_flag
) == 0)
1830 // atomic_set(&m_flag, 0); // if gyro, rv,la ,gravity open , then m flag open
1831 atomic_set(&open_flag
, 0);
1836 // TODO: turn device into standby or normal mode
1840 case SENSOR_GET_DATA
:
1841 if((buff_out
== NULL
) || (size_out
< sizeof(hwm_sensor_data
)))
1843 printk(KERN_ERR
"get sensor data parameter error!\n");
1848 msensor_data
= (hwm_sensor_data
*)buff_out
;
1849 mutex_lock(&sensor_data_mutex
);
1851 msensor_data
->values
[0] = sensor_data
[5] * CONVERT_M
;
1852 msensor_data
->values
[1] = sensor_data
[6] * CONVERT_M
;
1853 msensor_data
->values
[2] = sensor_data
[7] * CONVERT_M
;
1854 msensor_data
->status
= sensor_data
[8];
1855 msensor_data
->value_divide
= CONVERT_M_DIV
;
1857 mutex_unlock(&sensor_data_mutex
);
1859 if(atomic_read(&data
->trace
) & AMK_HWM_DEBUG
)
1861 AKMDBG("Hwm get m-sensor data: %d, %d, %d. divide %d, status %d!\n",
1862 msensor_data
->values
[0],msensor_data
->values
[1],msensor_data
->values
[2],
1863 msensor_data
->value_divide
,msensor_data
->status
);
1869 printk(KERN_ERR
"msensor operate function no this parameter %d!\n", command
);
1877 /*----------------------------------------------------------------------------*/
1878 int akm09911_orientation_operate(void* self
, uint32_t command
, void* buff_in
, int size_in
,
1879 void* buff_out
, int size_out
, int* actualout
)
1883 hwm_sensor_data
* osensor_data
;
1885 struct i2c_client
*client
= this_client
;
1886 struct akm09911_i2c_data
*data
= i2c_get_clientdata(client
);
1890 if(atomic_read(&data
->trace
) & AMK_FUN_DEBUG
)
1892 AKMFUNC("akm09911_orientation_operate");
1899 if((buff_in
== NULL
) || (size_in
< sizeof(int)))
1901 printk(KERN_ERR
"Set delay parameter error!\n");
1906 value
= *(int *)buff_in
;
1917 if((buff_in
== NULL
) || (size_in
< sizeof(int)))
1919 printk(KERN_ERR
"Enable sensor parameter error!\n");
1925 value
= *(int *)buff_in
;
1926 // printk(KERN_ERR "akm09911_orientation_operate SENSOR_ENABLE=%d mEnabled=%d\n",value,mEnabled);
1928 if (mEnabled
<= 0) {
1931 atomic_set(&o_flag
, 1);
1932 atomic_set(&open_flag
, 1);
1935 else if (mEnabled
== 1){
1938 atomic_set(&o_flag
, 0);
1939 if(atomic_read(&m_flag
) == 0)
1941 atomic_set(&open_flag
, 0);
1948 if (mEnabled
> 32767) mEnabled
= 32767;
1951 if (mEnabled
< 0) mEnabled
= 0;
1958 case SENSOR_GET_DATA
:
1959 if((buff_out
== NULL
) || (size_out
< sizeof(hwm_sensor_data
)))
1961 printk(KERN_ERR
"get sensor data parameter error!\n");
1966 osensor_data
= (hwm_sensor_data
*)buff_out
;
1967 mutex_lock(&sensor_data_mutex
);
1969 osensor_data
->values
[0] = sensor_data
[13] * CONVERT_O
;
1970 osensor_data
->values
[1] = sensor_data
[14] * CONVERT_O
;
1971 osensor_data
->values
[2] = sensor_data
[15] * CONVERT_O
;
1972 osensor_data
->status
= sensor_data
[8];
1973 osensor_data
->value_divide
= CONVERT_O_DIV
;
1975 mutex_unlock(&sensor_data_mutex
);
1977 if(atomic_read(&data
->trace
) & AMK_HWM_DEBUG
)
1979 AKMDBG("Hwm get o-sensor data: %d, %d, %d. divide %d, status %d!\n",
1980 osensor_data
->values
[0],osensor_data
->values
[1],osensor_data
->values
[2],
1981 osensor_data
->value_divide
,osensor_data
->status
);
1987 printk(KERN_ERR
"gsensor operate function no this parameter %d!\n", command
);
1995 #ifdef AKM_Pseudogyro
1996 /*----------------------------------------------------------------------------*/
1997 /*----------------------------------------------------------------------------*/
1998 int akm09911_gyroscope_operate(void* self
, uint32_t command
, void* buff_in
, int size_in
,
1999 void* buff_out
, int size_out
, int* actualout
)
2003 hwm_sensor_data
* gyrosensor_data
;
2005 struct i2c_client
*client
= this_client
;
2006 struct akm09911_i2c_data
*data
= i2c_get_clientdata(client
);
2010 if(atomic_read(&data
->trace
) & AMK_FUN_DEBUG
)
2012 AKMFUNC("akm09911_gyroscope_operate");
2019 if((buff_in
== NULL
) || (size_in
< sizeof(int)))
2021 printk(KERN_ERR
"Set delay parameter error!\n");
2026 value
= *(int *)buff_in
;
2028 akmd_delay
= 10; // fix to 100Hz
2033 if((buff_in
== NULL
) || (size_in
< sizeof(int)))
2035 printk(KERN_ERR
"Enable sensor parameter error!\n");
2041 value
= *(int *)buff_in
;
2042 // printk(KERN_ERR "akm09911_gyroscope_operate SENSOR_ENABLE=%d mEnabled=%d\n",value,mEnabled);
2043 if (mEnabled
<= 0) {
2046 atomic_set(&o_flag
, 1);
2047 atomic_set(&open_flag
, 1);
2050 else if (mEnabled
== 1){
2053 atomic_set(&o_flag
, 0);
2054 if(atomic_read(&m_flag
) == 0)
2056 atomic_set(&open_flag
, 0);
2063 if (mEnabled
> 32767) mEnabled
= 32767;
2066 if (mEnabled
< 0) mEnabled
= 0;
2074 case SENSOR_GET_DATA
:
2075 if((buff_out
== NULL
) || (size_out
< sizeof(hwm_sensor_data
)))
2077 printk(KERN_ERR
"get sensor data parameter error!\n");
2082 gyrosensor_data
= (hwm_sensor_data
*)buff_out
;
2083 mutex_lock(&sensor_data_mutex
);
2085 gyrosensor_data
->values
[0] = sensor_data
[9] * CONVERT_Q16
;
2086 gyrosensor_data
->values
[1] = sensor_data
[10] * CONVERT_Q16
;
2087 gyrosensor_data
->values
[2] = sensor_data
[11] * CONVERT_Q16
;
2088 gyrosensor_data
->status
= sensor_data
[12];
2089 gyrosensor_data
->value_divide
= CONVERT_Q16_DIV
;
2091 mutex_unlock(&sensor_data_mutex
);
2093 if(atomic_read(&data
->trace
) & AMK_HWM_DEBUG
)
2095 AKMDBG("Hwm get gyro-sensor data: %d, %d, %d. divide %d, status %d!\n",
2096 gyrosensor_data
->values
[0],gyrosensor_data
->values
[1],gyrosensor_data
->values
[2],
2097 gyrosensor_data
->value_divide
,gyrosensor_data
->status
);
2103 printk(KERN_ERR
"gyrosensor operate function no this parameter %d!\n", command
);
2111 /*----------------------------------------------------------------------------*/
2112 int akm09911_rotation_vector_operate(void* self
, uint32_t command
, void* buff_in
, int size_in
,
2113 void* buff_out
, int size_out
, int* actualout
)
2117 hwm_sensor_data
* RV_data
;
2119 struct i2c_client
*client
= this_client
;
2120 struct akm09911_i2c_data
*data
= i2c_get_clientdata(client
);
2124 if(atomic_read(&data
->trace
) & AMK_FUN_DEBUG
)
2126 AKMFUNC("akm09911_rotation_vector_operate");
2133 if((buff_in
== NULL
) || (size_in
< sizeof(int)))
2135 printk(KERN_ERR
"Set delay parameter error!\n");
2140 value
= *(int *)buff_in
;
2141 akmd_delay
= 10; // fix to 100Hz
2146 if((buff_in
== NULL
) || (size_in
< sizeof(int)))
2148 printk(KERN_ERR
"Enable sensor parameter error!\n");
2154 value
= *(int *)buff_in
;
2156 if (mEnabled
<= 0) {
2159 atomic_set(&o_flag
, 1);
2160 atomic_set(&open_flag
, 1);
2163 else if (mEnabled
== 1){
2166 atomic_set(&o_flag
, 0);
2167 if(atomic_read(&m_flag
) == 0)
2169 atomic_set(&open_flag
, 0);
2176 if (mEnabled
> 32767) mEnabled
= 32767;
2179 if (mEnabled
< 0) mEnabled
= 0;
2186 case SENSOR_GET_DATA
:
2187 if((buff_out
== NULL
) || (size_out
< sizeof(hwm_sensor_data
)))
2189 printk(KERN_ERR
"get sensor data parameter error!\n");
2194 RV_data
= (hwm_sensor_data
*)buff_out
;
2195 mutex_lock(&sensor_data_mutex
);
2197 RV_data
->values
[0] = sensor_data
[22] * CONVERT_Q16
;
2198 RV_data
->values
[1] = sensor_data
[23] * CONVERT_Q16
;
2199 RV_data
->values
[2] = sensor_data
[24] * CONVERT_Q16
;
2200 RV_data
->status
= 0 ; //sensor_data[19]; fix w-> 0 w
2201 RV_data
->value_divide
= CONVERT_Q16_DIV
;
2203 mutex_unlock(&sensor_data_mutex
);
2205 if(atomic_read(&data
->trace
) & AMK_HWM_DEBUG
)
2207 AKMDBG("Hwm get rv-sensor data: %d, %d, %d. divide %d, status %d!\n",
2208 RV_data
->values
[0],RV_data
->values
[1],RV_data
->values
[2],
2209 RV_data
->value_divide
,RV_data
->status
);
2215 printk(KERN_ERR
"RV operate function no this parameter %d!\n", command
);
2224 /*----------------------------------------------------------------------------*/
2225 int akm09911_gravity_operate(void* self
, uint32_t command
, void* buff_in
, int size_in
,
2226 void* buff_out
, int size_out
, int* actualout
)
2230 hwm_sensor_data
* gravity_data
;
2232 struct i2c_client
*client
= this_client
;
2233 struct akm09911_i2c_data
*data
= i2c_get_clientdata(client
);
2237 if(atomic_read(&data
->trace
) & AMK_FUN_DEBUG
)
2239 AKMFUNC("akm09911_gravity_operate");
2246 if((buff_in
== NULL
) || (size_in
< sizeof(int)))
2248 printk(KERN_ERR
"Set delay parameter error!\n");
2253 value
= *(int *)buff_in
;
2263 if((buff_in
== NULL
) || (size_in
< sizeof(int)))
2265 printk(KERN_ERR
"Enable sensor parameter error!\n");
2271 value
= *(int *)buff_in
;
2273 if (mEnabled
<= 0) {
2276 atomic_set(&o_flag
, 1);
2277 atomic_set(&open_flag
, 1);
2280 else if (mEnabled
== 1){
2283 atomic_set(&o_flag
, 0);
2284 if(atomic_read(&m_flag
) == 0)
2286 atomic_set(&open_flag
, 0);
2293 if (mEnabled
> 32767) mEnabled
= 32767;
2296 if (mEnabled
< 0) mEnabled
= 0;
2303 case SENSOR_GET_DATA
:
2304 if((buff_out
== NULL
) || (size_out
< sizeof(hwm_sensor_data
)))
2306 printk(KERN_ERR
"get sensor data parameter error!\n");
2311 gravity_data
= (hwm_sensor_data
*)buff_out
;
2312 mutex_lock(&sensor_data_mutex
);
2314 gravity_data
->values
[0] = sensor_data
[16] * CONVERT_Q16
;
2315 gravity_data
->values
[1] = sensor_data
[17] * CONVERT_Q16
;
2316 gravity_data
->values
[2] = sensor_data
[18] * CONVERT_Q16
;
2317 gravity_data
->status
= sensor_data
[4];
2318 gravity_data
->value_divide
= CONVERT_Q16_DIV
;
2320 mutex_unlock(&sensor_data_mutex
);
2322 if(atomic_read(&data
->trace
) & AMK_HWM_DEBUG
)
2324 AKMDBG("Hwm get gravity-sensor data: %d, %d, %d. divide %d, status %d!\n",
2325 gravity_data
->values
[0],gravity_data
->values
[1],gravity_data
->values
[2],
2326 gravity_data
->value_divide
,gravity_data
->status
);
2332 printk(KERN_ERR
"gravity operate function no this parameter %d!\n", command
);
2341 /*----------------------------------------------------------------------------*/
2342 int akm09911_linear_accelration_operate(void* self
, uint32_t command
, void* buff_in
, int size_in
,
2343 void* buff_out
, int size_out
, int* actualout
)
2347 hwm_sensor_data
* LA_data
;
2349 struct i2c_client
*client
= this_client
;
2350 struct akm09911_i2c_data
*data
= i2c_get_clientdata(client
);
2354 if(atomic_read(&data
->trace
) & AMK_FUN_DEBUG
)
2356 AKMFUNC("akm09911_linear_accelration_operate");
2363 if((buff_in
== NULL
) || (size_in
< sizeof(int)))
2365 printk(KERN_ERR
"Set delay parameter error!\n");
2370 value
= *(int *)buff_in
;
2380 if((buff_in
== NULL
) || (size_in
< sizeof(int)))
2382 printk(KERN_ERR
"Enable sensor parameter error!\n");
2388 value
= *(int *)buff_in
;
2390 if (mEnabled
<= 0) {
2393 atomic_set(&o_flag
, 1);
2394 atomic_set(&open_flag
, 1);
2397 else if (mEnabled
== 1){
2400 atomic_set(&o_flag
, 0);
2401 if(atomic_read(&m_flag
) == 0)
2403 atomic_set(&open_flag
, 0);
2410 if (mEnabled
> 32767) mEnabled
= 32767;
2413 if (mEnabled
< 0) mEnabled
= 0;
2420 case SENSOR_GET_DATA
:
2421 if((buff_out
== NULL
) || (size_out
< sizeof(hwm_sensor_data
)))
2423 printk(KERN_ERR
"get sensor data parameter error!\n");
2428 LA_data
= (hwm_sensor_data
*)buff_out
;
2429 mutex_lock(&sensor_data_mutex
);
2431 LA_data
->values
[0] = sensor_data
[19] * CONVERT_Q16
;
2432 LA_data
->values
[1] = sensor_data
[20] * CONVERT_Q16
;
2433 LA_data
->values
[2] = sensor_data
[21] * CONVERT_Q16
;
2434 LA_data
->status
= sensor_data
[4];
2435 LA_data
->value_divide
= CONVERT_Q16_DIV
;
2437 mutex_unlock(&sensor_data_mutex
);
2439 if(atomic_read(&data
->trace
) & AMK_HWM_DEBUG
)
2441 AKMDBG("Hwm get LA-sensor data: %d, %d, %d. divide %d, status %d!\n",
2442 LA_data
->values
[0],LA_data
->values
[1],LA_data
->values
[2],
2443 LA_data
->value_divide
,LA_data
->status
);
2449 printk(KERN_ERR
"linear_accelration operate function no this parameter %d!\n", command
);
2459 #ifndef CONFIG_HAS_EARLYSUSPEND
2460 /*----------------------------------------------------------------------------*/
2461 static int akm09911_suspend(struct i2c_client
*client
, pm_message_t msg
)
2464 struct akm09911_i2c_data
*obj
= i2c_get_clientdata(client
)
2467 if(msg
.event
== PM_EVENT_SUSPEND
)
2469 akm09911_power(obj
->hw
, 0);
2473 /*----------------------------------------------------------------------------*/
2474 static int akm09911_resume(struct i2c_client
*client
)
2477 struct akm09911_i2c_data
*obj
= i2c_get_clientdata(client
)
2480 akm09911_power(obj
->hw
, 1);
2485 /*----------------------------------------------------------------------------*/
2486 #else /*CONFIG_HAS_EARLY_SUSPEND is defined*/
2487 /*----------------------------------------------------------------------------*/
2488 static void akm09911_early_suspend(struct early_suspend
*h
)
2490 struct akm09911_i2c_data
*obj
= container_of(h
, struct akm09911_i2c_data
, early_drv
);
2495 printk(KERN_ERR
"null pointer!!\n");
2498 if ((err
= AKECS_SetMode(AK09911_MODE_POWERDOWN
)) < 0) {
2499 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
2503 akm09911_power(obj
->hw
, 0);
2505 /*----------------------------------------------------------------------------*/
2506 static void akm09911_late_resume(struct early_suspend
*h
)
2508 struct akm09911_i2c_data
*obj
= container_of(h
, struct akm09911_i2c_data
, early_drv
);
2514 printk(KERN_ERR
"null pointer!!\n");
2517 akm09911_power(obj
->hw
, 1);
2519 if ((err
= AKECS_SetMode(AK09911_MODE_SNG_MEASURE
)) < 0) {
2520 AKMDBG("%s:%d Error.\n", __FUNCTION__
, __LINE__
);
2524 /*----------------------------------------------------------------------------*/
2525 #endif /*CONFIG_HAS_EARLYSUSPEND*/
2526 /*----------------------------------------------------------------------------*/
2527 static int akm09911_i2c_detect(struct i2c_client
*client
, struct i2c_board_info
*info
)
2529 strcpy(info
->type
, AKM09911_DEV_NAME
);
2533 static int ecompass_status_read_proc(struct file
*file
, char *buffer
, size_t count
, loff_t
*ppos
)
2540 page
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
2548 ptr
+= sprintf(ptr
, "%d\n", ecompass_status
);
2556 err
= copy_to_user(buffer
,(char *)page
,len
);
2567 static const struct file_operations akm09911_ecompass_status_proc_fops
= {
2568 .read
= ecompass_status_read_proc
2572 /*----------------------------------------------------------------------------*/
2573 static int akm09911_i2c_probe(struct i2c_client
*client
, const struct i2c_device_id
*id
)
2575 struct i2c_client
*new_client
;
2576 struct akm09911_i2c_data
*data
;
2578 struct hwmsen_object sobj_m
, sobj_o
;
2579 struct hwmsen_object sobj_gyro
, sobj_rv
;
2580 struct hwmsen_object sobj_gravity
, sobj_la
;
2582 if(!(data
= kmalloc(sizeof(struct akm09911_i2c_data
), GFP_KERNEL
)))
2587 memset(data
, 0, sizeof(struct akm09911_i2c_data
));
2588 data
->hw
= get_cust_mag_hw();
2590 atomic_set(&data
->layout
, data
->hw
->direction
);
2591 atomic_set(&data
->trace
, 0);
2593 mutex_init(&sense_data_mutex
);
2594 mutex_init(&sensor_data_mutex
);
2596 init_waitqueue_head(&data_ready_wq
);
2597 init_waitqueue_head(&open_wq
);
2599 data
->client
= client
;
2600 new_client
= data
->client
;
2601 i2c_set_clientdata(new_client
, data
);
2603 this_client
= new_client
;
2605 printk(KERN_ERR
" AKM09911 akm09911_probe: befor init prob \n");
2606 /* Check connection */
2607 err
= AKECS_CheckDevice();
2610 printk(KERN_ERR
"AKM09911 akm09911_probe: check device connect error\n");
2611 goto exit_init_failed
;
2615 /* Register sysfs attribute */
2616 if((err
= akm09911_create_attr(&akm_sensor_driver
.driver
)))
2618 printk(KERN_ERR
"create attribute err = %d\n", err
);
2619 goto exit_sysfs_create_group_failed
;
2623 if((err
= misc_register(&akm09911_device
)))
2625 printk(KERN_ERR
"akm09911_device register failed\n");
2626 goto exit_misc_device_register_failed
; }
2630 sobj_m
.sensor_operate
= akm09911_operate
;
2631 if((err
= hwmsen_attach(ID_MAGNETIC
, &sobj_m
)))
2633 printk(KERN_ERR
"attach fail = %d\n", err
);
2639 sobj_o
.sensor_operate
= akm09911_orientation_operate
;
2640 if((err
= hwmsen_attach(ID_ORIENTATION
, &sobj_o
)))
2642 printk(KERN_ERR
"attach fail = %d\n", err
);
2646 #ifdef AKM_Pseudogyro
2647 //pseudo gyro sensor
2648 sobj_gyro
.self
= data
;
2649 sobj_gyro
.polling
= 1;
2650 sobj_gyro
.sensor_operate
= akm09911_gyroscope_operate
;
2651 if(err
= hwmsen_attach(ID_GYROSCOPE
, &sobj_gyro
))
2653 printk(KERN_ERR
"attach fail = %d\n", err
);
2657 //rotation vector sensor
2659 sobj_rv
.self
= data
;
2660 sobj_rv
.polling
= 1;
2661 sobj_rv
.sensor_operate
= akm09911_rotation_vector_operate
;
2662 if(err
= hwmsen_attach(ID_ROTATION_VECTOR
, &sobj_rv
))
2664 printk(KERN_ERR
"attach fail = %d\n", err
);
2670 sobj_gravity
.self
= data
;
2671 sobj_gravity
.polling
= 1;
2672 sobj_gravity
.sensor_operate
= akm09911_gravity_operate
;
2673 if(err
= hwmsen_attach( ID_GRAVITY
, &sobj_gravity
))
2675 printk(KERN_ERR
"attach fail = %d\n", err
);
2679 //LINEAR_ACCELERATION sensor
2681 sobj_la
.self
= data
;
2682 sobj_la
.polling
= 1;
2683 sobj_la
.sensor_operate
= akm09911_linear_accelration_operate
;
2684 if(err
= hwmsen_attach( ID_LINEAR_ACCELERATION
, &sobj_la
))
2686 // printk(KERN_ERR "attach fail = %d\n", err);
2692 #if CONFIG_HAS_EARLYSUSPEND
2693 data
->early_drv
.level
= EARLY_SUSPEND_LEVEL_STOP_DRAWING
- 2,
2694 data
->early_drv
.suspend
= akm09911_early_suspend
,
2695 data
->early_drv
.resume
= akm09911_late_resume
,
2696 register_early_suspend(&data
->early_drv
);
2699 AKMDBG("%s: OK\n", __func__
);
2700 ecompass_status
= 1;
2703 exit_sysfs_create_group_failed
:
2705 exit_misc_device_register_failed
:
2709 printk(KERN_ERR
"%s: err = %d\n", __func__
, err
);
2710 ecompass_status
= 0;
2713 /*----------------------------------------------------------------------------*/
2714 static int akm09911_i2c_remove(struct i2c_client
*client
)
2718 if((err
= akm09911_delete_attr(&akm_sensor_driver
.driver
)))
2720 printk(KERN_ERR
"akm09911_delete_attr fail: %d\n", err
);
2724 i2c_unregister_device(client
);
2725 kfree(i2c_get_clientdata(client
));
2726 misc_deregister(&akm09911_device
);
2729 /*----------------------------------------------------------------------------*/
2730 static int akm_probe(struct platform_device
*pdev
)
2732 struct mag_hw
*hw
= get_cust_mag_hw();
2734 akm09911_power(hw
, 1);
2736 atomic_set(&dev_open_count
, 0);
2737 //akm09911_force[0] = hw->i2c_num;
2739 if(i2c_add_driver(&akm09911_i2c_driver
))
2741 printk(KERN_ERR
"add driver error\n");
2746 /*----------------------------------------------------------------------------*/
2747 static int akm_remove(struct platform_device
*pdev
)
2749 struct mag_hw
*hw
= get_cust_mag_hw();
2751 akm09911_power(hw
, 0);
2752 atomic_set(&dev_open_count
, 0);
2753 i2c_del_driver(&akm09911_i2c_driver
);
2756 /*----------------------------------------------------------------------------*/
2757 static int __init
akm09911_init(void)
2759 struct mag_hw
*hw
= get_cust_mag_hw();
2760 printk("akm09911: i2c_number=%d\n",hw
->i2c_num
);
2761 // register cat /proc/ecompass_status
2762 akm09911_ecompass_status_proc
= proc_create("ecompass_status", 0, NULL
, &akm09911_ecompass_status_proc_fops
);
2763 if (akm09911_ecompass_status_proc
== NULL
)
2765 printk(KERN_ERR
"create_proc_entry ecompass_status failed");
2768 i2c_register_board_info(hw
->i2c_num
, &i2c_akm09911
, 1);
2769 if(platform_driver_register(&akm_sensor_driver
))
2771 printk(KERN_ERR
"failed to register driver");
2776 /*----------------------------------------------------------------------------*/
2777 static void __exit
akm09911_exit(void)
2779 platform_driver_unregister(&akm_sensor_driver
);
2781 /*----------------------------------------------------------------------------*/
2782 module_init(akm09911_init
);
2783 module_exit(akm09911_exit
);
2785 MODULE_AUTHOR("viral wang <viral_wang@htc.com>");
2786 MODULE_DESCRIPTION("AKM09911 compass driver");
2787 MODULE_LICENSE("GPL");
2788 MODULE_VERSION(DRIVER_VERSION
);