projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
import PULS_20160108
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / arm / mach-mt8127 / tpw8127_tb_c_l / magnetometer / akm09911.c
1 /* akm09911.c - akm09911 compass driver
2 *
3 *
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.
7 *
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.
12 *
13 */
14
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>
28
29 #include <linux/hwmsensor.h>
30 #include <linux/hwmsen_dev.h>
31 #include <linux/sensors_io.h>
32 #include <linux/proc_fs.h>
33
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>
38
39
40 #define POWER_NONE_MACRO MT65XX_POWER_NONE
41
42 #include <cust_mag.h>
43 #include "akm09911.h"
44 #include <linux/hwmsen_helper.h>
45
46 /*----------------------------------------------------------------------------*/
47 #define DEBUG 0
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
58
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
61
62
63 #if AKM09911_DEBUG_MSG
64 #define AKMDBG(format, ...) printk(KERN_ERR "AKM09911 " format "\n", ## __VA_ARGS__)
65 #else
66 #define AKMDBG(format, ...)
67 #endif
68
69 #if AKM09911_DEBUG_FUNC
70 #define AKMFUNC(func) printk(KERN_INFO "AKM09911 " func " is called\n")
71 #else
72 #define AKMFUNC(func)
73 #endif
74
75 static struct i2c_client *this_client = NULL;
76
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);
85
86 static short akmd_delay = AKM09911_DEFAULT_DELAY;
87
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);
91
92 static int factory_mode=0;
93 static int ecompass_status = 0;
94
95 static int mEnabled=0;
96
97 static struct proc_dir_entry *akm09911_ecompass_status_proc = NULL;
98
99
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);
114
115
116 /*----------------------------------------------------------------------------*/
117 typedef enum {
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,
123 } AMK_TRC;
124
125
126 /*----------------------------------------------------------------------------*/
127 struct akm09911_i2c_data {
128 struct i2c_client *client;
129 struct mag_hw *hw;
130 atomic_t layout;
131 atomic_t trace;
132 struct hwmsen_convert cvt;
133 #if defined(CONFIG_HAS_EARLYSUSPEND)
134 struct early_suspend early_drv;
135 #endif
136 };
137 /*----------------------------------------------------------------------------*/
138 static struct i2c_driver akm09911_i2c_driver = {
139 .driver = {
140 // .owner = THIS_MODULE,
141 .name = AKM09911_DEV_NAME,
142 },
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,
149 #endif
150 .id_table = akm09911_i2c_id,
151 // .address_data = &akm09911_addr_data,
152 };
153
154 /*----------------------------------------------------------------------------*/
155 static struct platform_driver akm_sensor_driver = {
156 .probe = akm_probe,
157 .remove = akm_remove,
158 .driver = {
159 .name = "msensor",
160 .owner = THIS_MODULE,
161 }
162 };
163
164
165 /*----------------------------------------------------------------------------*/
166 static atomic_t dev_open_count;
167 /*----------------------------------------------------------------------------*/
168 static void akm09911_power(struct mag_hw *hw, unsigned int on)
169 {
170 static unsigned int power_on = 0;
171
172 if(hw->power_id != POWER_NONE_MACRO)
173 {
174 AKMDBG("power %s\n", on ? "on" : "off");
175 if(power_on == on)
176 {
177 AKMDBG("ignore power control: %d\n", on);
178 }
179 else if(on)
180 {
181 if(!hwPowerOn(hw->power_id, hw->power_vol, "akm09911"))
182 {
183 printk(KERN_ERR "power on fails!!\n");
184 }
185 }
186 else
187 {
188 if(!hwPowerDown(hw->power_id, "akm09911"))
189 {
190 printk(KERN_ERR "power off fail!!\n");
191 }
192 }
193 }
194 power_on = on;
195 }
196 static long AKI2C_RxData(char *rxData, int length)
197 {
198 uint8_t loop_i;
199
200 #if DEBUG
201 int i;
202 struct i2c_client *client = this_client;
203 struct akm09911_i2c_data *data = i2c_get_clientdata(client);
204 char addr = rxData[0];
205 #endif
206
207
208 /* Caller should check parameter validity.*/
209 if((rxData == NULL) || (length < 1))
210 {
211 return -EINVAL;
212 }
213
214 for(loop_i = 0; loop_i < AKM09911_RETRY_COUNT; loop_i++)
215 {
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)))
219 {
220 break;
221 }
222 mdelay(10);
223 }
224
225 if(loop_i >= AKM09911_RETRY_COUNT)
226 {
227 printk(KERN_ERR "%s retry over %d\n", __func__, AKM09911_RETRY_COUNT);
228 return -EIO;
229 }
230 #if DEBUG
231 if(atomic_read(&data->trace) & AMK_I2C_DEBUG)
232 {
233 printk(KERN_INFO "RxData: len=%02x, addr=%02x\n data=", length, addr);
234 for(i = 0; i < length; i++)
235 {
236 printk(KERN_INFO " %02x", rxData[i]);
237 }
238 printk(KERN_INFO "\n");
239 }
240 #endif
241 return 0;
242 }
243
244 static long AKI2C_TxData(char *txData, int length)
245 {
246 uint8_t loop_i;
247
248 #if DEBUG
249 int i;
250 struct i2c_client *client = this_client;
251 struct akm09911_i2c_data *data = i2c_get_clientdata(client);
252 #endif
253
254 /* Caller should check parameter validity.*/
255 if ((txData == NULL) || (length < 2))
256 {
257 return -EINVAL;
258 }
259
260 this_client->addr = this_client->addr & I2C_MASK_FLAG;
261 for(loop_i = 0; loop_i < AKM09911_RETRY_COUNT; loop_i++)
262 {
263 if(i2c_master_send(this_client, (const char*)txData, length) > 0)
264 {
265 break;
266 }
267 mdelay(10);
268 }
269
270 if(loop_i >= AKM09911_RETRY_COUNT)
271 {
272 printk(KERN_ERR "%s retry over %d\n", __func__, AKM09911_RETRY_COUNT);
273 return -EIO;
274 }
275 #if DEBUG
276 if(atomic_read(&data->trace) & AMK_I2C_DEBUG)
277 {
278 printk(KERN_INFO "TxData: len=%02x, addr=%02x\n data=", length, txData[0]);
279 for(i = 0; i < (length-1); i++)
280 {
281 printk(KERN_INFO " %02x", txData[i + 1]);
282 }
283 printk(KERN_INFO "\n");
284 }
285 #endif
286 return 0;
287 }
288
289 /*
290 static long AKECS_Set_CNTL1(unsigned char mode)
291 {
292 unsigned char buffer[2];
293 //int err;
294
295 //Set measure mode
296 buffer[0] = AK09911_REG_CNTL1;
297 buffer[1] = mode;
298
299 return AKI2C_TxData(buffer, 2);;
300 }
301 */
302
303
304 static long AKECS_SetMode_SngMeasure(void)
305 {
306 char buffer[2];
307 #ifdef AKM_Device_AK8963
308
309 buffer[0] = AK8963_REG_CNTL1;
310 buffer[1] = AK8963_MODE_SNG_MEASURE;
311
312 #else
313 /* Set measure mode */
314 buffer[0] = AK09911_REG_CNTL2;
315 buffer[1] = AK09911_MODE_SNG_MEASURE;
316 #endif
317
318 /* Set data */
319 return AKI2C_TxData(buffer, 2);
320 }
321
322 static long AKECS_SetMode_SelfTest(void)
323 {
324 char buffer[2];
325 #ifdef AKM_Device_AK8963
326
327 buffer[0] = AK8963_REG_CNTL1;
328 buffer[1] = AK8963_MODE_SELF_TEST;
329
330 #else
331
332 /* Set measure mode */
333 buffer[0] = AK09911_REG_CNTL2;
334 buffer[1] = AK09911_MODE_SELF_TEST;
335 /* Set data */
336 #endif
337 return AKI2C_TxData(buffer, 2);
338 }
339 static long AKECS_SetMode_FUSEAccess(void)
340 {
341 char buffer[2];
342
343 #ifdef AKM_Device_AK8963
344 buffer[0] = AK8963_REG_CNTL1;
345 buffer[1] = AK8963_MODE_FUSE_ACCESS;
346 #else
347 /* Set measure mode */
348 buffer[0] = AK09911_REG_CNTL2;
349 buffer[1] = AK09911_MODE_FUSE_ACCESS;
350 /* Set data */
351 #endif
352 return AKI2C_TxData(buffer, 2);
353 }
354 static int AKECS_SetMode_PowerDown(void)
355 {
356 char buffer[2];
357 #ifdef AKM_Device_AK8963
358 buffer[0] = AK8963_REG_CNTL1;
359 buffer[1] = AK8963_MODE_POWERDOWN;
360 #else
361 /* Set powerdown mode */
362 buffer[0] = AK09911_REG_CNTL2;
363 buffer[1] = AK09911_MODE_POWERDOWN;
364 /* Set data */
365 #endif
366 return AKI2C_TxData(buffer, 2);
367 }
368
369 static long AKECS_Reset(int hard)
370 {
371 unsigned char buffer[2];
372 long err = 0;
373
374 if (hard != 0) {
375 //TODO change to board setting
376 //gpio_set_value(akm->rstn, 0);
377 udelay(5);
378 //gpio_set_value(akm->rstn, 1);
379 } else {
380 /* Set measure mode */
381 #ifdef AKM_Device_AK8963
382 buffer[0] = AK8963_REG_CNTL2;
383 buffer[1] = 0x01;
384 #else
385 buffer[0] = AK09911_REG_CNTL3;
386 buffer[1] = 0x01;
387 #endif
388 err = AKI2C_TxData(buffer, 2);
389 if (err < 0) {
390 AKMDBG("%s: Can not set SRST bit.", __func__);
391 } else {
392 AKMDBG("Soft reset is done.");
393 }
394 }
395
396 /* Device will be accessible 300 us after */
397 udelay(300); // 100
398
399 return err;
400 }
401
402 static long AKECS_SetMode(char mode)
403 {
404 long ret;
405
406 switch (mode & 0x1F){
407
408
409 case AK09911_MODE_SNG_MEASURE:
410 ret = AKECS_SetMode_SngMeasure();
411 break;
412
413 case AK09911_MODE_SELF_TEST:
414 case AK8963_MODE_SELF_TEST:
415 ret = AKECS_SetMode_SelfTest();
416 break;
417
418 case AK09911_MODE_FUSE_ACCESS:
419 case AK8963_MODE_FUSE_ACCESS:
420 ret = AKECS_SetMode_FUSEAccess();
421 break;
422
423 case AK09911_MODE_POWERDOWN:
424 ret = AKECS_SetMode_PowerDown();
425 break;
426
427 default:
428 AKMDBG("%s: Unknown mode(%d)", __func__, mode);
429 return -EINVAL;
430 }
431
432 /* wait at least 100us after changing mode */
433 udelay(100);
434
435 return ret;
436 }
437
438 static int AKECS_CheckDevice(void)
439 {
440 char buffer[2];
441 int ret;
442 AKMDBG(" AKM check device id");
443 /* Set measure mode */
444 #ifdef AKM_Device_AK8963
445 buffer[0] = AK8963_REG_WIA;
446 #else
447 buffer[0] = AK09911_REG_WIA1;
448 #endif
449
450
451
452 /* Read data */
453 ret = AKI2C_RxData(buffer, 1);
454 AKMDBG(" AKM check device id = %x",buffer[0]);
455 AKMDBG("ret = %d",ret);
456 if(ret < 0)
457 {
458 return ret;
459 }
460 /* Check read data */
461 if(buffer[0] != 0x48)
462 {
463 return -ENXIO;
464 }
465
466 return 0;
467 }
468
469 // Daemon application save the data
470 static void AKECS_SaveData(int *buf)
471 {
472 #if DEBUG
473 struct i2c_client *client = this_client;
474 struct akm09911_i2c_data *data = i2c_get_clientdata(client);
475 #endif
476
477 mutex_lock(&sensor_data_mutex);
478 memcpy(sensor_data, buf, sizeof(sensor_data));
479 mutex_unlock(&sensor_data_mutex);
480
481 #if DEBUG
482 if(atomic_read(&data->trace) & AMK_HWM_DEBUG)
483 {
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]);
492 }
493 #endif
494
495 }
496
497 // M-sensor daemon application have set the sng mode
498 static long AKECS_GetData(char *rbuf, int size)
499 {
500 char temp;
501 int loop_i,ret;
502 #if DEBUG
503 struct i2c_client *client = this_client;
504 struct akm09911_i2c_data *data = i2c_get_clientdata(client);
505 #endif
506
507 if(size < SENSOR_DATA_SIZE)
508 {
509 printk(KERN_ERR "buff size is too small %d!\n", size);
510 return -1;
511 }
512
513 memset(rbuf, 0, SENSOR_DATA_SIZE);
514 #ifdef AKM_Device_AK8963
515 rbuf[0] = AK8963_REG_ST1;
516 #else
517 rbuf[0] = AK09911_REG_ST1;
518 #endif
519
520 for(loop_i = 0; loop_i < AKM09911_RETRY_COUNT; loop_i++)
521 {
522 if((ret = AKI2C_RxData(rbuf, 1)))
523 {
524 printk(KERN_ERR "read ST1 resigster failed!\n");
525 return -1;
526 }
527
528 if((rbuf[0] & 0x01) == 0x01)
529 {
530 break;
531 }
532 msleep(2);
533 #ifdef AKM_Device_AK8963
534 rbuf[0] = AK8963_REG_ST1;
535 #else
536 rbuf[0] = AK09911_REG_ST1;
537 #endif
538 }
539
540 if(loop_i >= AKM09911_RETRY_COUNT)
541 {
542 printk(KERN_ERR "Data read retry larger the max count!\n");
543 if(0 ==factory_mode)
544 {
545 return -1;//if return we can not get data at factory mode
546 }
547 }
548
549 temp = rbuf[0];
550 #ifdef AKM_Device_AK8963
551 rbuf[1]= AK8963_REG_HXL;
552 ret = AKI2C_RxData(&rbuf[1], SENSOR_DATA_SIZE -2);
553 #else
554 rbuf[1]= AK09911_REG_HXL;
555 ret = AKI2C_RxData(&rbuf[1], SENSOR_DATA_SIZE -1);
556 #endif
557 if(ret < 0)
558 {
559 printk(KERN_ERR "AKM8975 akm8975_work_func: I2C failed\n");
560 return -1;
561 }
562 rbuf[0] = temp;
563 #ifdef AKM_Device_AK8963
564 rbuf[8]=rbuf[7];
565 rbuf[7]=0;
566 #endif
567 mutex_lock(&sense_data_mutex);
568 memcpy(sense_data, rbuf, sizeof(sense_data));
569 mutex_unlock(&sense_data_mutex);
570
571 #if DEBUG
572 if(atomic_read(&data->trace) & AMK_DATA_DEBUG)
573 {
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]);
577 }
578 #endif
579
580 return 0;
581 }
582
583 // Get Msensor Raw data
584 static int AKECS_GetRawData(char *rbuf, int size)
585 {
586 char strbuf[SENSOR_DATA_SIZE];
587 s16 data[3];
588 if((atomic_read(&open_flag) == 0) || (factory_mode == 1))
589 {
590 AKECS_SetMode_SngMeasure();
591 msleep(10);
592 }
593
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));
598
599 sprintf(rbuf, "%x %x %x", data[0], data[1], data[2]);
600
601 return 0;
602
603 }
604
605
606
607 static int AKECS_GetOpenStatus(void)
608 {
609 wait_event_interruptible(open_wq, (atomic_read(&open_flag) != 0));
610 return atomic_read(&open_flag);
611 }
612
613 static int AKECS_GetCloseStatus(void)
614 {
615 wait_event_interruptible(open_wq, (atomic_read(&open_flag) <= 0));
616 return atomic_read(&open_flag);
617 }
618
619
620
621
622 /*----------------------------------------------------------------------------*/
623 static int akm09911_ReadChipInfo(char *buf, int bufsize)
624 {
625 if((!buf)||(bufsize <= AKM09911_BUFSIZE -1))
626 {
627 return -1;
628 }
629 if(!this_client)
630 {
631 *buf = 0;
632 return -2;
633 }
634
635 sprintf(buf, "akm09911 Chip");
636 return 0;
637 }
638
639 /*----------------------------shipment test------------------------------------------------*/
640 /*!
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
649 */
650 int
651 TEST_DATA(const char testno[],
652 const char testname[],
653 const int testdata,
654 const int lolimit,
655 const int hilimit,
656 int * pf_total)
657 {
658 int pf; //Pass;1, Fail;-1
659
660 if ((testno == NULL) && (strncmp(testname, "START", 5) == 0)) {
661 // Display header
662 AKMDBG("--------------------------------------------------------------------\n");
663 AKMDBG(" Test No. Test Name Fail Test Data [ Low High]\n");
664 AKMDBG("--------------------------------------------------------------------\n");
665
666 pf = 1;
667 } else if ((testno == NULL) && (strncmp(testname, "END", 3) == 0)) {
668 // Display result
669 AKMDBG("--------------------------------------------------------------------\n");
670 if (*pf_total == 1) {
671 AKMDBG("Factory shipment test was passed.\n\n");
672 } else {
673 AKMDBG("Factory shipment test was failed.\n\n");
674 }
675
676 pf = 1;
677 } else {
678 if ((lolimit <= testdata) && (testdata <= hilimit)) {
679 //Pass
680 pf = 1;
681 } else {
682 //Fail
683 pf = -1;
684 }
685
686 //display result
687 AKMDBG(" %7s %-10s %c %9d [%9d %9d]\n",
688 testno, testname, ((pf == 1) ? ('.') : ('F')), testdata,
689 lolimit, hilimit);
690 }
691
692 //Pass/Fail check
693 if (*pf_total != 0) {
694 if ((*pf_total == 1) && (pf == 1)) {
695 *pf_total = 1; //Pass
696 } else {
697 *pf_total = -1; //Fail
698 }
699 }
700 return pf;
701 }
702 int FST_AK8963(void)
703 {
704 int pf_total; //p/f flag for this subtest
705 char i2cData[16];
706 int hdata[3];
707 int asax;
708 int asay;
709 int asaz;
710
711 //***********************************************
712 // Reset Test Result
713 //***********************************************
714 pf_total = 1;
715
716 //***********************************************
717 // Step1
718 //***********************************************
719
720 // Set to PowerDown mode
721 //if (AKECS_SetMode(AK8963_MODE_POWERDOWN) < 0) {
722 // AKMDBG("%s:%d Error.\n", __FUNCTION__, __LINE__);
723 // return 0;
724 //}
725 AKECS_Reset(0);
726 msleep(1);
727
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;
732 i2cData[1] = 0x1B;
733 if (AKI2C_TxData(i2cData, 2) < 0) {
734 AKMDBG("%s:%d Error.\n", __FUNCTION__, __LINE__);
735 return 0;
736 }
737 }
738
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__);
743 return 0;
744 }
745
746 // TEST
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__);
758 return 0;
759 }
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);
766
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__);
771 return 0;
772 }
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);
775 }else{
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);
777 }
778
779 // Set to FUSE ROM access mode
780 if (AKECS_SetMode(AK8963_MODE_FUSE_ACCESS) < 0) {
781 AKMDBG("%s:%d Error.\n", __FUNCTION__, __LINE__);
782 return 0;
783 }
784
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__);
789 return 0;
790 }
791 asax = (int)i2cData[0];
792 asay = (int)i2cData[1];
793 asaz = (int)i2cData[2];
794
795 // TEST
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);
799
800 // Read values. CNTL
801 i2cData[0] = AK8963_REG_CNTL1;
802 if (AKI2C_RxData(i2cData, 1)< 0) {
803 AKMDBG("%s:%d Error.\n", __FUNCTION__, __LINE__);
804 return 0;
805 }
806
807 // Set to PowerDown mode
808 if (AKECS_SetMode(AK8963_MODE_POWERDOWN) < 0) {
809 AKMDBG("%s:%d Error.\n", __FUNCTION__, __LINE__);
810 return 0;
811 }
812
813 // TEST
814 TEST_DATA(TLIMIT_NO_WR_CNTL, TLIMIT_TN_WR_CNTL, (int)i2cData[0], TLIMIT_LO_WR_CNTL, TLIMIT_HI_WR_CNTL, &pf_total);
815
816
817 //***********************************************
818 // Step2
819 //***********************************************
820
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__);
824 return 0;
825 }
826
827 // Wait for DRDY pin changes to HIGH.
828 msleep(10);
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__);
834 return 0;
835 }
836
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));
840 // AK8963 @ 14 BIT
841 hdata[0] <<= 2;
842 hdata[1] <<= 2;
843 hdata[2] <<= 2;
844
845
846 // TEST
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);
852
853 // Generate magnetic field for self-test (Set ASTC register)
854 i2cData[0] = AK8963_REG_ASTC;
855 i2cData[1] = 0x40;
856 if (AKI2C_TxData(i2cData, 2) < 0) {
857 AKMDBG("%s:%d Error.\n", __FUNCTION__, __LINE__);
858 return 0;
859 }
860
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__);
864 return 0;
865 }
866
867 // Wait for DRDY pin changes to HIGH.
868 msleep(10);
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__);
874 return 0;
875 }
876
877 // TEST
878 TEST_DATA(TLIMIT_NO_SLF_ST1, TLIMIT_TN_SLF_ST1, (int)i2cData[0], TLIMIT_LO_SLF_ST1, TLIMIT_HI_SLF_ST1, &pf_total);
879
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));
883
884 // AK8963 @ 14 BIT
885 hdata[0] <<= 2;
886 hdata[1] <<= 2;
887 hdata[2] <<= 2;
888
889 AKMDBG("hdata[0] = %d\n",hdata[0] );
890 AKMDBG("asax = %d\n",asax );
891 TEST_DATA(
892 TLIMIT_NO_SLF_RVHX,
893 TLIMIT_TN_SLF_RVHX,
894 (hdata[0])*((asax - 128)/2/128 + 1),
895 TLIMIT_LO_SLF_RVHX,
896 TLIMIT_HI_SLF_RVHX,
897 &pf_total
898 );
899
900 TEST_DATA(
901 TLIMIT_NO_SLF_RVHY,
902 TLIMIT_TN_SLF_RVHY,
903 (hdata[1])*((asay - 128)/2/128 + 1),
904 TLIMIT_LO_SLF_RVHY,
905 TLIMIT_HI_SLF_RVHY,
906 &pf_total
907 );
908
909 TEST_DATA(
910 TLIMIT_NO_SLF_RVHZ,
911 TLIMIT_TN_SLF_RVHZ,
912 (hdata[2])*((asaz - 128)/2/128 + 1),
913 TLIMIT_LO_SLF_RVHZ,
914 TLIMIT_HI_SLF_RVHZ,
915 &pf_total
916 );
917 // TEST
918 TEST_DATA(TLIMIT_NO_SLF_ST2, TLIMIT_TN_SLF_ST2, (int)i2cData[8], TLIMIT_LO_SLF_ST2, TLIMIT_HI_SLF_ST2, &pf_total);
919
920 // Set to Normal mode for self-test.
921 i2cData[0] = AK8963_REG_ASTC;
922 i2cData[1] = 0x00;
923 if (AKI2C_TxData(i2cData, 2) < 0) {
924 AKMDBG("%s:%d Error.\n", __FUNCTION__, __LINE__);
925 return 0;
926 }
927 AKMDBG("pf_total = %d\n",pf_total );
928 return pf_total;
929 }
930
931
932
933 /*!
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.
938 */
939 int FST_AK09911(void)
940 {
941 int pf_total; //p/f flag for this subtest
942 char i2cData[16];
943 int hdata[3];
944 int asax;
945 int asay;
946 int asaz;
947
948 //***********************************************
949 // Reset Test Result
950 //***********************************************
951 pf_total = 1;
952
953 //***********************************************
954 // Step1
955 //***********************************************
956
957 // Reset device.
958 if (AKECS_Reset(0) < 0) {
959 AKMDBG("%s:%d Error.\n", __FUNCTION__, __LINE__);
960 return 0;
961 }
962
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__);
967 return 0;
968 }
969
970 // TEST
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);
973
974 // Set to FUSE ROM access mode
975 if (AKECS_SetMode(AK09911_MODE_FUSE_ACCESS) < 0) {
976 AKMDBG("%s:%d Error.\n", __FUNCTION__, __LINE__);
977 return 0;
978 }
979
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__);
984 return 0;
985 }
986 asax = (int)i2cData[0];
987 asay = (int)i2cData[1];
988 asaz = (int)i2cData[2];
989
990 // TEST
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);
994
995 // Set to PowerDown mode
996 if (AKECS_SetMode(AK09911_MODE_POWERDOWN) < 0) {
997 AKMDBG("%s:%d Error.\n", __FUNCTION__, __LINE__);
998 return 0;
999 }
1000
1001 //***********************************************
1002 // Step2
1003 //***********************************************
1004
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__);
1008 return 0;
1009 }
1010
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__);
1019 return 0;
1020 }
1021
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]));
1025
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));
1029
1030 // TEST
1031 i2cData[0] &= 0x7F;
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);
1033
1034 // TEST
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);
1039
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__);
1043 return 0;
1044 }
1045
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__);
1054 return 0;
1055 }
1056
1057 // TEST
1058 i2cData[0] &= 0x7F;
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);
1060
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]));
1064
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));
1068
1069 // TEST
1070 TEST_DATA(
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,
1076 &pf_total
1077 );
1078
1079 TEST_DATA(
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,
1085 &pf_total
1086 );
1087
1088 TEST_DATA(
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,
1094 &pf_total
1095 );
1096
1097 TEST_DATA(
1098 TLIMIT_NO_SLF_ST2_09911,
1099 TLIMIT_TN_SLF_ST2_09911,
1100 (int)i2cData[8],
1101 TLIMIT_LO_SLF_ST2_09911,
1102 TLIMIT_HI_SLF_ST2_09911,
1103 &pf_total
1104 );
1105
1106 return pf_total;
1107 }
1108
1109 /*!
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.
1114 */
1115 int FctShipmntTestProcess_Body(void)
1116 {
1117 int pf_total = 1;
1118
1119 //***********************************************
1120 // Reset Test Result
1121 //***********************************************
1122 TEST_DATA(NULL, "START", 0, 0, 0, &pf_total);
1123
1124 //***********************************************
1125 // Step 1 to 2
1126 //***********************************************
1127 #ifdef AKM_Device_AK8963
1128 pf_total = FST_AK8963();
1129 #else
1130 pf_total = FST_AK09911();
1131 #endif
1132
1133 //***********************************************
1134 // Judge Test Result
1135 //***********************************************
1136 TEST_DATA(NULL, "END", 0, 0, 0, &pf_total);
1137
1138 return pf_total;
1139 }
1140
1141 static ssize_t store_shipment_test(struct device_driver * ddri,const char * buf, size_t count)
1142 {
1143 //struct i2c_client *client = this_client;
1144 //struct akm09911_i2c_data *data = i2c_get_clientdata(client);
1145 //int layout = 0;
1146
1147
1148 return count;
1149 }
1150
1151 static ssize_t show_shipment_test(struct device_driver *ddri, char *buf)
1152 {
1153 char result[10];
1154 int res = 0;
1155 res = FctShipmntTestProcess_Body();
1156 if(1 == res)
1157 {
1158 AKMDBG("shipment_test pass\n");
1159 strcpy(result,"y");
1160 }
1161 else if(-1 == res)
1162 {
1163 AKMDBG("shipment_test fail\n");
1164 strcpy(result,"n");
1165 }
1166 else
1167 {
1168 AKMDBG("shipment_test NaN\n");
1169 strcpy(result,"NaN");
1170 }
1171
1172 return sprintf(buf, "%s\n", result);
1173 }
1174
1175 static ssize_t show_daemon_name(struct device_driver *ddri, char *buf)
1176 {
1177 char strbuf[AKM09911_BUFSIZE];
1178 sprintf(strbuf, "akmd09911");
1179 return sprintf(buf, "%s", strbuf);
1180 }
1181
1182 static ssize_t show_chipinfo_value(struct device_driver *ddri, char *buf)
1183 {
1184 char strbuf[AKM09911_BUFSIZE];
1185 akm09911_ReadChipInfo(strbuf, AKM09911_BUFSIZE);
1186 return sprintf(buf, "%s\n", strbuf);
1187 }
1188 /*----------------------------------------------------------------------------*/
1189 static ssize_t show_sensordata_value(struct device_driver *ddri, char *buf)
1190 {
1191
1192 char sensordata[SENSOR_DATA_SIZE];
1193 char strbuf[AKM09911_BUFSIZE];
1194 if(atomic_read(&open_flag) == 0)
1195 {
1196 AKECS_SetMode_SngMeasure();
1197 msleep(10);
1198 AKECS_GetData(sensordata, SENSOR_DATA_SIZE);
1199 }
1200 else
1201 {
1202 mutex_lock(&sense_data_mutex);
1203 memcpy(sensordata, sense_data, sizeof(sensordata));
1204 mutex_unlock(&sense_data_mutex);
1205 }
1206
1207
1208
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]);
1211
1212 return sprintf(buf, "%s\n", strbuf);
1213 }
1214 /*----------------------------------------------------------------------------*/
1215 static ssize_t show_posturedata_value(struct device_driver *ddri, char *buf)
1216 {
1217 short tmp[3];
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]);
1223
1224 return sprintf(buf, "%s\n", strbuf);;
1225 }
1226
1227 /*----------------------------------------------------------------------------*/
1228 static ssize_t show_layout_value(struct device_driver *ddri, char *buf)
1229 {
1230 struct i2c_client *client = this_client;
1231 struct akm09911_i2c_data *data = i2c_get_clientdata(client);
1232
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]);
1236 }
1237 /*----------------------------------------------------------------------------*/
1238 static ssize_t store_layout_value(struct device_driver *ddri, const char *buf, size_t count)
1239 {
1240 struct i2c_client *client = this_client;
1241 struct akm09911_i2c_data *data = i2c_get_clientdata(client);
1242 int layout = 0;
1243
1244 if(1 == sscanf(buf, "%d", &layout))
1245 {
1246 atomic_set(&data->layout, layout);
1247 if(!hwmsen_get_convert(layout, &data->cvt))
1248 {
1249 printk(KERN_ERR "HWMSEN_GET_CONVERT function error!\r\n");
1250 }
1251 else if(!hwmsen_get_convert(data->hw->direction, &data->cvt))
1252 {
1253 printk(KERN_ERR "invalid layout: %d, restore to %d\n", layout, data->hw->direction);
1254 }
1255 else
1256 {
1257 printk(KERN_ERR "invalid layout: (%d, %d)\n", layout, data->hw->direction);
1258 hwmsen_get_convert(0, &data->cvt);
1259 }
1260 }
1261 else
1262 {
1263 printk(KERN_ERR "invalid format = '%s'\n", buf);
1264 }
1265
1266 return count;
1267 }
1268 /*----------------------------------------------------------------------------*/
1269 static ssize_t show_status_value(struct device_driver *ddri, char *buf)
1270 {
1271 struct i2c_client *client = this_client;
1272 struct akm09911_i2c_data *data = i2c_get_clientdata(client);
1273 ssize_t len = 0;
1274
1275 if(data->hw)
1276 {
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);
1279 }
1280 else
1281 {
1282 len += snprintf(buf+len, PAGE_SIZE-len, "CUST: NULL\n");
1283 }
1284
1285 len += snprintf(buf+len, PAGE_SIZE-len, "OPEN: %d\n", atomic_read(&dev_open_count));
1286 return len;
1287 }
1288 /*----------------------------------------------------------------------------*/
1289 static ssize_t show_trace_value(struct device_driver *ddri, char *buf)
1290 {
1291 ssize_t res;
1292 struct akm09911_i2c_data *obj = i2c_get_clientdata(this_client);
1293 if(NULL == obj)
1294 {
1295 printk(KERN_ERR "akm09911_i2c_data is null!!\n");
1296 return 0;
1297 }
1298
1299 res = snprintf(buf, PAGE_SIZE, "0x%04X\n", atomic_read(&obj->trace));
1300 return res;
1301 }
1302 /*----------------------------------------------------------------------------*/
1303 static ssize_t store_trace_value(struct device_driver *ddri, const char *buf, size_t count)
1304 {
1305 struct akm09911_i2c_data *obj = i2c_get_clientdata(this_client);
1306 int trace;
1307 if(NULL == obj)
1308 {
1309 printk(KERN_ERR "akm09911_i2c_data is null!!\n");
1310 return 0;
1311 }
1312
1313 if(1 == sscanf(buf, "0x%x", &trace))
1314 {
1315 atomic_set(&obj->trace, trace);
1316 }
1317 else
1318 {
1319 printk(KERN_ERR "invalid content: '%s', length = %d\n", buf, count);
1320 }
1321
1322 return count;
1323 }
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,
1342 &driver_attr_trace,
1343 };
1344 /*----------------------------------------------------------------------------*/
1345 static int akm09911_create_attr(struct device_driver *driver)
1346 {
1347 int idx, err = 0;
1348 int num = (int)(sizeof(akm09911_attr_list)/sizeof(akm09911_attr_list[0]));
1349 if (driver == NULL)
1350 {
1351 return -EINVAL;
1352 }
1353
1354 for(idx = 0; idx < num; idx++)
1355 {
1356 if((err = driver_create_file(driver, akm09911_attr_list[idx])))
1357 {
1358 printk(KERN_ERR "driver_create_file (%s) = %d\n", akm09911_attr_list[idx]->attr.name, err);
1359 break;
1360 }
1361 }
1362 return err;
1363 }
1364 /*----------------------------------------------------------------------------*/
1365 static int akm09911_delete_attr(struct device_driver *driver)
1366 {
1367 int idx ,err = 0;
1368 int num = (int)(sizeof(akm09911_attr_list)/sizeof(akm09911_attr_list[0]));
1369
1370 if(driver == NULL)
1371 {
1372 return -EINVAL;
1373 }
1374
1375
1376 for(idx = 0; idx < num; idx++)
1377 {
1378 driver_remove_file(driver, akm09911_attr_list[idx]);
1379 }
1380
1381
1382 return err;
1383 }
1384
1385
1386 /*----------------------------------------------------------------------------*/
1387 static int akm09911_open(struct inode *inode, struct file *file)
1388 {
1389 struct akm09911_i2c_data *obj = i2c_get_clientdata(this_client);
1390 int ret = -1;
1391
1392 if(atomic_read(&obj->trace) & AMK_CTR_DEBUG)
1393 {
1394 AKMDBG("Open device node:akm09911\n");
1395 }
1396 ret = nonseekable_open(inode, file);
1397
1398 return ret;
1399 }
1400 /*----------------------------------------------------------------------------*/
1401 static int akm09911_release(struct inode *inode, struct file *file)
1402 {
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)
1406 {
1407 AKMDBG("Release device node:akm09911\n");
1408 }
1409 return 0;
1410 }
1411
1412
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)
1416 {
1417 void __user *argp = (void __user *)arg;
1418
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. */
1428 int layout;
1429 struct i2c_client *client = this_client;
1430 struct akm09911_i2c_data *data = i2c_get_clientdata(client);
1431 hwm_sensor_data* osensor_data;
1432 uint32_t enable;
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];
1437
1438 // printk(KERN_ERR"akm09911 cmd:0x%x\n", cmd);
1439 switch (cmd)
1440 {
1441 case ECS_IOCTL_WRITE:
1442 //AKMFUNC("ECS_IOCTL_WRITE");
1443 if(argp == NULL)
1444 {
1445 AKMDBG("invalid argument.");
1446 return -EINVAL;
1447 }
1448 if(copy_from_user(rwbuf, argp, sizeof(rwbuf)))
1449 {
1450 AKMDBG("copy_from_user failed.");
1451 return -EFAULT;
1452 }
1453
1454 if((rwbuf[0] < 2) || (rwbuf[0] > (RWBUF_SIZE-1)))
1455 {
1456 AKMDBG("invalid argument.");
1457 return -EINVAL;
1458 }
1459 ret = AKI2C_TxData(&rwbuf[1], rwbuf[0]);
1460 if(ret < 0)
1461 {
1462 return ret;
1463 }
1464 break;
1465 case ECS_IOCTL_RESET:
1466 ret = AKECS_Reset(0); // sw: 0, hw: 1
1467 if (ret < 0)
1468 return ret;
1469 break;
1470 case ECS_IOCTL_READ:
1471 //AKMFUNC("ECS_IOCTL_READ");
1472 if(argp == NULL)
1473 {
1474 AKMDBG("invalid argument.");
1475 return -EINVAL;
1476 }
1477
1478 if(copy_from_user(rwbuf, argp, sizeof(rwbuf)))
1479 {
1480 AKMDBG("copy_from_user failed.");
1481 return -EFAULT;
1482 }
1483
1484 if((rwbuf[0] < 1) || (rwbuf[0] > (RWBUF_SIZE-1)))
1485 {
1486 AKMDBG("invalid argument.");
1487 return -EINVAL;
1488 }
1489 ret = AKI2C_RxData(&rwbuf[1], rwbuf[0]);
1490 if (ret < 0)
1491 {
1492 return ret;
1493 }
1494 if(copy_to_user(argp, rwbuf, rwbuf[0]+1))
1495 {
1496 AKMDBG("copy_to_user failed.");
1497 return -EFAULT;
1498 }
1499 break;
1500 case ECS_IOCTL_GET_INFO:
1501
1502 #ifdef AKM_Device_AK8963
1503 sense_info[0] = AK8963_REG_WIA;
1504 #else
1505 sense_info[0] = AK09911_REG_WIA1;
1506 #endif
1507
1508 ret = AKI2C_RxData(sense_info, AKM_SENSOR_INFO_SIZE);
1509 if (ret < 0)
1510 {
1511 return ret;
1512 }
1513 if(copy_to_user(argp, sense_info, AKM_SENSOR_INFO_SIZE))
1514 {
1515 AKMDBG("copy_to_user failed.");
1516 return -EFAULT;
1517 }
1518 break;
1519 case ECS_IOCTL_GET_CONF:
1520 /* Set FUSE access mode */
1521 #ifdef AKM_Device_AK8963
1522 ret = AKECS_SetMode(AK8963_MODE_FUSE_ACCESS);
1523 #else
1524 ret = AKECS_SetMode(AK09911_MODE_FUSE_ACCESS);
1525 #endif
1526 if (ret < 0)
1527 return ret;
1528 #ifdef AKM_Device_AK8963
1529 sense_conf[0] = AK8963_FUSE_ASAX;
1530 #else
1531 sense_conf[0] = AK09911_FUSE_ASAX;
1532 #endif
1533
1534 ret = AKI2C_RxData(sense_conf, AKM_SENSOR_CONF_SIZE);
1535 if (ret < 0)
1536 {
1537 return ret;
1538 }
1539 if(copy_to_user(argp, sense_conf, AKM_SENSOR_CONF_SIZE))
1540 {
1541 AKMDBG("copy_to_user failed.");
1542 return -EFAULT;
1543 }
1544 #ifdef AKM_Device_AK8963
1545 ret = AKECS_SetMode(AK8963_MODE_POWERDOWN);
1546 #else
1547 ret = AKECS_SetMode(AK09911_MODE_POWERDOWN);
1548 #endif
1549 if (ret < 0)
1550 return ret;
1551
1552 break;
1553
1554 case ECS_IOCTL_SET_MODE:
1555 //AKMFUNC("ECS_IOCTL_SET_MODE");
1556 if(argp == NULL)
1557 {
1558 AKMDBG("invalid argument.");
1559 return -EINVAL;
1560 }
1561 if(copy_from_user(&mode, argp, sizeof(mode)))
1562 {
1563 AKMDBG("copy_from_user failed.");
1564 return -EFAULT;
1565 }
1566 ret = AKECS_SetMode(mode); // MATCH command from AKMD PART
1567 if(ret < 0)
1568 {
1569 return ret;
1570 }
1571 break;
1572
1573 case ECS_IOCTL_GETDATA:
1574 //AKMFUNC("ECS_IOCTL_GETDATA");
1575 ret = AKECS_GetData(sData, SENSOR_DATA_SIZE);
1576 if(ret < 0)
1577 {
1578 return ret;
1579 }
1580
1581 if(copy_to_user(argp, sData, sizeof(sData)))
1582 {
1583 AKMDBG("copy_to_user failed.");
1584 return -EFAULT;
1585 }
1586 break;
1587
1588 case ECS_IOCTL_SET_YPR_09911:
1589 //AKMFUNC("ECS_IOCTL_SET_YPR");
1590 if(argp == NULL)
1591 {
1592 AKMDBG("invalid argument.");
1593 return -EINVAL;
1594 }
1595 if(copy_from_user(value, argp, sizeof(value)))
1596 {
1597 AKMDBG("copy_from_user failed.");
1598 return -EFAULT;
1599 }
1600 AKECS_SaveData(value);
1601 break;
1602
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)))
1608 {
1609 AKMDBG("copy_to_user failed.");
1610 return -EFAULT;
1611 }
1612 break;
1613
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)))
1619 {
1620 AKMDBG("copy_to_user failed.");
1621 return -EFAULT;
1622 }
1623 break;
1624
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)))
1629 {
1630 AKMDBG("copy_to_user failed.");
1631 return -EFAULT;
1632 }
1633 break;
1634
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)))
1641 {
1642 AKMDBG("copy_to_user failed.");
1643 return -EFAULT;
1644 }
1645 break;
1646
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)))
1651 {
1652 AKMDBG("copy_to_user failed.");
1653 return -EFAULT;
1654 }
1655 break;
1656
1657 case MSENSOR_IOCTL_READ_CHIPINFO:
1658 if(argp == NULL)
1659 {
1660 printk(KERN_ERR "IO parameter pointer is NULL!\r\n");
1661 break;
1662 }
1663
1664 akm09911_ReadChipInfo(buff, AKM09911_BUFSIZE);
1665 if(copy_to_user(argp, buff, strlen(buff)+1))
1666 {
1667 return -EFAULT;
1668 }
1669 break;
1670
1671 case MSENSOR_IOCTL_READ_SENSORDATA:
1672 if(argp == NULL)
1673 {
1674 printk(KERN_ERR "IO parameter pointer is NULL!\r\n");
1675 break;
1676 }
1677
1678 AKECS_GetRawData(buff, AKM09911_BUFSIZE);
1679
1680 if(copy_to_user(argp, buff, strlen(buff)+1))
1681 {
1682 return -EFAULT;
1683 }
1684 break;
1685
1686 case MSENSOR_IOCTL_SENSOR_ENABLE:
1687
1688 if(argp == NULL)
1689 {
1690 printk(KERN_ERR "IO parameter pointer is NULL!\r\n");
1691 break;
1692 }
1693 if(copy_from_user(&enable, argp, sizeof(enable)))
1694 {
1695 AKMDBG("copy_from_user failed.");
1696 return -EFAULT;
1697 }
1698 else
1699 {
1700 printk( "MSENSOR_IOCTL_SENSOR_ENABLE enable=%d!\r\n",enable);
1701 factory_mode = 1;
1702 if(1 == enable)
1703 {
1704 atomic_set(&o_flag, 1);
1705 atomic_set(&open_flag, 1);
1706 }
1707 else
1708 {
1709 atomic_set(&o_flag, 0);
1710 if(atomic_read(&m_flag) == 0)
1711 {
1712 atomic_set(&open_flag, 0);
1713 }
1714 }
1715 wake_up(&open_wq);
1716
1717 }
1718
1719 break;
1720
1721 case MSENSOR_IOCTL_READ_FACTORY_SENSORDATA:
1722 if(argp == NULL)
1723 {
1724 printk(KERN_ERR "IO parameter pointer is NULL!\r\n");
1725 break;
1726 }
1727
1728 //AKECS_GetRawData(buff, AKM09911_BUFSIZE);
1729 osensor_data = (hwm_sensor_data *)buff;
1730 mutex_lock(&sensor_data_mutex);
1731
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;
1737
1738 mutex_unlock(&sensor_data_mutex);
1739
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))
1743 {
1744 return -EFAULT;
1745 }
1746
1747 break;
1748
1749 default:
1750 printk(KERN_ERR "%s not supported = 0x%04x", __FUNCTION__, cmd);
1751 return -ENOIOCTLCMD;
1752 break;
1753 }
1754
1755 return 0;
1756 }
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,
1764 };
1765 /*----------------------------------------------------------------------------*/
1766 static struct miscdevice akm09911_device = {
1767 .minor = MISC_DYNAMIC_MINOR,
1768 .name = "msensor",
1769 .fops = &akm09911_fops,
1770 };
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)
1774 {
1775 int err = 0;
1776 int value;
1777 hwm_sensor_data* msensor_data;
1778
1779 #if DEBUG
1780 struct i2c_client *client = this_client;
1781 struct akm09911_i2c_data *data = i2c_get_clientdata(client);
1782 #endif
1783
1784 #if DEBUG
1785 if(atomic_read(&data->trace) & AMK_FUN_DEBUG)
1786 {
1787 AKMFUNC("akm09911_operate");
1788 }
1789 #endif
1790 switch (command)
1791 {
1792 case SENSOR_DELAY:
1793 if((buff_in == NULL) || (size_in < sizeof(int)))
1794 {
1795 printk(KERN_ERR "Set delay parameter error!\n");
1796 err = -EINVAL;
1797 }
1798 else
1799 {
1800 value = *(int *)buff_in;
1801 if(value <= 10)
1802 {
1803 value = 10;
1804 }
1805 akmd_delay = value;
1806 }
1807 break;
1808
1809 case SENSOR_ENABLE:
1810 if((buff_in == NULL) || (size_in < sizeof(int)))
1811 {
1812 printk(KERN_ERR "Enable sensor parameter error!\n");
1813 err = -EINVAL;
1814 }
1815 else
1816 {
1817
1818 value = *(int *)buff_in;
1819
1820 if(value == 1)
1821 {
1822 atomic_set(&m_flag, 1);
1823 atomic_set(&open_flag, 1);
1824 }
1825 else
1826 {
1827 atomic_set(&m_flag, 0);
1828 if(atomic_read(&o_flag) == 0)
1829 {
1830 // atomic_set(&m_flag, 0); // if gyro, rv,la ,gravity open , then m flag open
1831 atomic_set(&open_flag, 0);
1832 }
1833 }
1834 wake_up(&open_wq);
1835
1836 // TODO: turn device into standby or normal mode
1837 }
1838 break;
1839
1840 case SENSOR_GET_DATA:
1841 if((buff_out == NULL) || (size_out< sizeof(hwm_sensor_data)))
1842 {
1843 printk(KERN_ERR "get sensor data parameter error!\n");
1844 err = -EINVAL;
1845 }
1846 else
1847 {
1848 msensor_data = (hwm_sensor_data *)buff_out;
1849 mutex_lock(&sensor_data_mutex);
1850
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;
1856
1857 mutex_unlock(&sensor_data_mutex);
1858 #if DEBUG
1859 if(atomic_read(&data->trace) & AMK_HWM_DEBUG)
1860 {
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);
1864 }
1865 #endif
1866 }
1867 break;
1868 default:
1869 printk(KERN_ERR "msensor operate function no this parameter %d!\n", command);
1870 err = -1;
1871 break;
1872 }
1873
1874 return err;
1875 }
1876
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)
1880 {
1881 int err = 0;
1882 int value;
1883 hwm_sensor_data* osensor_data;
1884 #if DEBUG
1885 struct i2c_client *client = this_client;
1886 struct akm09911_i2c_data *data = i2c_get_clientdata(client);
1887 #endif
1888
1889 #if DEBUG
1890 if(atomic_read(&data->trace) & AMK_FUN_DEBUG)
1891 {
1892 AKMFUNC("akm09911_orientation_operate");
1893 }
1894 #endif
1895
1896 switch (command)
1897 {
1898 case SENSOR_DELAY:
1899 if((buff_in == NULL) || (size_in < sizeof(int)))
1900 {
1901 printk(KERN_ERR "Set delay parameter error!\n");
1902 err = -EINVAL;
1903 }
1904 else
1905 {
1906 value = *(int *)buff_in;
1907 if(value <= 10)
1908 {
1909 value = 10;
1910 }
1911 akmd_delay = value;
1912 }
1913 break;
1914
1915 case SENSOR_ENABLE:
1916
1917 if((buff_in == NULL) || (size_in < sizeof(int)))
1918 {
1919 printk(KERN_ERR "Enable sensor parameter error!\n");
1920 err = -EINVAL;
1921 }
1922 else
1923 {
1924
1925 value = *(int *)buff_in;
1926 // printk(KERN_ERR "akm09911_orientation_operate SENSOR_ENABLE=%d mEnabled=%d\n",value,mEnabled);
1927
1928 if (mEnabled <= 0) {
1929 if(value == 1)
1930 {
1931 atomic_set(&o_flag, 1);
1932 atomic_set(&open_flag, 1);
1933 }
1934 }
1935 else if (mEnabled == 1){
1936 if (!value )
1937 {
1938 atomic_set(&o_flag, 0);
1939 if(atomic_read(&m_flag) == 0)
1940 {
1941 atomic_set(&open_flag, 0);
1942 }
1943 }
1944 }
1945
1946 if (value ) {
1947 mEnabled++;
1948 if (mEnabled > 32767) mEnabled = 32767;
1949 } else {
1950 mEnabled--;
1951 if (mEnabled < 0) mEnabled = 0;
1952 }
1953 wake_up(&open_wq);
1954 }
1955
1956 break;
1957
1958 case SENSOR_GET_DATA:
1959 if((buff_out == NULL) || (size_out< sizeof(hwm_sensor_data)))
1960 {
1961 printk(KERN_ERR "get sensor data parameter error!\n");
1962 err = -EINVAL;
1963 }
1964 else
1965 {
1966 osensor_data = (hwm_sensor_data *)buff_out;
1967 mutex_lock(&sensor_data_mutex);
1968
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;
1974
1975 mutex_unlock(&sensor_data_mutex);
1976 #if DEBUG
1977 if(atomic_read(&data->trace) & AMK_HWM_DEBUG)
1978 {
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);
1982 }
1983 #endif
1984 }
1985 break;
1986 default:
1987 printk(KERN_ERR "gsensor operate function no this parameter %d!\n", command);
1988 err = -1;
1989 break;
1990 }
1991
1992 return err;
1993 }
1994
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)
2000 {
2001 int err = 0;
2002 int value;
2003 hwm_sensor_data* gyrosensor_data;
2004 #if DEBUG
2005 struct i2c_client *client = this_client;
2006 struct akm09911_i2c_data *data = i2c_get_clientdata(client);
2007 #endif
2008
2009 #if DEBUG
2010 if(atomic_read(&data->trace) & AMK_FUN_DEBUG)
2011 {
2012 AKMFUNC("akm09911_gyroscope_operate");
2013 }
2014 #endif
2015
2016 switch (command)
2017 {
2018 case SENSOR_DELAY:
2019 if((buff_in == NULL) || (size_in < sizeof(int)))
2020 {
2021 printk(KERN_ERR "Set delay parameter error!\n");
2022 err = -EINVAL;
2023 }
2024 else
2025 {
2026 value = *(int *)buff_in;
2027
2028 akmd_delay = 10; // fix to 100Hz
2029 }
2030 break;
2031
2032 case SENSOR_ENABLE:
2033 if((buff_in == NULL) || (size_in < sizeof(int)))
2034 {
2035 printk(KERN_ERR "Enable sensor parameter error!\n");
2036 err = -EINVAL;
2037 }
2038 else
2039 {
2040
2041 value = *(int *)buff_in;
2042 // printk(KERN_ERR "akm09911_gyroscope_operate SENSOR_ENABLE=%d mEnabled=%d\n",value,mEnabled);
2043 if (mEnabled <= 0) {
2044 if(value == 1)
2045 {
2046 atomic_set(&o_flag, 1);
2047 atomic_set(&open_flag, 1);
2048 }
2049 }
2050 else if (mEnabled == 1){
2051 if (!value )
2052 {
2053 atomic_set(&o_flag, 0);
2054 if(atomic_read(&m_flag) == 0)
2055 {
2056 atomic_set(&open_flag, 0);
2057 }
2058 }
2059 }
2060
2061 if (value ) {
2062 mEnabled++;
2063 if (mEnabled > 32767) mEnabled = 32767;
2064 } else {
2065 mEnabled--;
2066 if (mEnabled < 0) mEnabled = 0;
2067 }
2068
2069 wake_up(&open_wq);
2070 }
2071
2072 break;
2073
2074 case SENSOR_GET_DATA:
2075 if((buff_out == NULL) || (size_out< sizeof(hwm_sensor_data)))
2076 {
2077 printk(KERN_ERR "get sensor data parameter error!\n");
2078 err = -EINVAL;
2079 }
2080 else
2081 {
2082 gyrosensor_data = (hwm_sensor_data *)buff_out;
2083 mutex_lock(&sensor_data_mutex);
2084
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;
2090
2091 mutex_unlock(&sensor_data_mutex);
2092 #if DEBUG
2093 if(atomic_read(&data->trace) & AMK_HWM_DEBUG)
2094 {
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);
2098 }
2099 #endif
2100 }
2101 break;
2102 default:
2103 printk(KERN_ERR "gyrosensor operate function no this parameter %d!\n", command);
2104 err = -1;
2105 break;
2106 }
2107
2108 return err;
2109 }
2110
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)
2114 {
2115 int err = 0;
2116 int value;
2117 hwm_sensor_data* RV_data;
2118 #if DEBUG
2119 struct i2c_client *client = this_client;
2120 struct akm09911_i2c_data *data = i2c_get_clientdata(client);
2121 #endif
2122
2123 #if DEBUG
2124 if(atomic_read(&data->trace) & AMK_FUN_DEBUG)
2125 {
2126 AKMFUNC("akm09911_rotation_vector_operate");
2127 }
2128 #endif
2129
2130 switch (command)
2131 {
2132 case SENSOR_DELAY:
2133 if((buff_in == NULL) || (size_in < sizeof(int)))
2134 {
2135 printk(KERN_ERR "Set delay parameter error!\n");
2136 err = -EINVAL;
2137 }
2138 else
2139 {
2140 value = *(int *)buff_in;
2141 akmd_delay = 10; // fix to 100Hz
2142 }
2143 break;
2144
2145 case SENSOR_ENABLE:
2146 if((buff_in == NULL) || (size_in < sizeof(int)))
2147 {
2148 printk(KERN_ERR "Enable sensor parameter error!\n");
2149 err = -EINVAL;
2150 }
2151 else
2152 {
2153
2154 value = *(int *)buff_in;
2155
2156 if (mEnabled <= 0) {
2157 if(value == 1)
2158 {
2159 atomic_set(&o_flag, 1);
2160 atomic_set(&open_flag, 1);
2161 }
2162 }
2163 else if (mEnabled == 1){
2164 if (!value )
2165 {
2166 atomic_set(&o_flag, 0);
2167 if(atomic_read(&m_flag) == 0)
2168 {
2169 atomic_set(&open_flag, 0);
2170 }
2171 }
2172 }
2173
2174 if (value ) {
2175 mEnabled++;
2176 if (mEnabled > 32767) mEnabled = 32767;
2177 } else {
2178 mEnabled--;
2179 if (mEnabled < 0) mEnabled = 0;
2180 }
2181 wake_up(&open_wq);
2182 }
2183
2184 break;
2185
2186 case SENSOR_GET_DATA:
2187 if((buff_out == NULL) || (size_out< sizeof(hwm_sensor_data)))
2188 {
2189 printk(KERN_ERR "get sensor data parameter error!\n");
2190 err = -EINVAL;
2191 }
2192 else
2193 {
2194 RV_data = (hwm_sensor_data *)buff_out;
2195 mutex_lock(&sensor_data_mutex);
2196
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;
2202
2203 mutex_unlock(&sensor_data_mutex);
2204 #if DEBUG
2205 if(atomic_read(&data->trace) & AMK_HWM_DEBUG)
2206 {
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);
2210 }
2211 #endif
2212 }
2213 break;
2214 default:
2215 printk(KERN_ERR "RV operate function no this parameter %d!\n", command);
2216 err = -1;
2217 break;
2218 }
2219
2220 return err;
2221 }
2222
2223
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)
2227 {
2228 int err = 0;
2229 int value;
2230 hwm_sensor_data* gravity_data;
2231 #if DEBUG
2232 struct i2c_client *client = this_client;
2233 struct akm09911_i2c_data *data = i2c_get_clientdata(client);
2234 #endif
2235
2236 #if DEBUG
2237 if(atomic_read(&data->trace) & AMK_FUN_DEBUG)
2238 {
2239 AKMFUNC("akm09911_gravity_operate");
2240 }
2241 #endif
2242
2243 switch (command)
2244 {
2245 case SENSOR_DELAY:
2246 if((buff_in == NULL) || (size_in < sizeof(int)))
2247 {
2248 printk(KERN_ERR "Set delay parameter error!\n");
2249 err = -EINVAL;
2250 }
2251 else
2252 {
2253 value = *(int *)buff_in;
2254 if(value <= 10)
2255 {
2256 value = 10;
2257 }
2258 akmd_delay = value;
2259 }
2260 break;
2261
2262 case SENSOR_ENABLE:
2263 if((buff_in == NULL) || (size_in < sizeof(int)))
2264 {
2265 printk(KERN_ERR "Enable sensor parameter error!\n");
2266 err = -EINVAL;
2267 }
2268 else
2269 {
2270
2271 value = *(int *)buff_in;
2272
2273 if (mEnabled <= 0) {
2274 if(value == 1)
2275 {
2276 atomic_set(&o_flag, 1);
2277 atomic_set(&open_flag, 1);
2278 }
2279 }
2280 else if (mEnabled == 1){
2281 if (!value )
2282 {
2283 atomic_set(&o_flag, 0);
2284 if(atomic_read(&m_flag) == 0)
2285 {
2286 atomic_set(&open_flag, 0);
2287 }
2288 }
2289 }
2290
2291 if (value ) {
2292 mEnabled++;
2293 if (mEnabled > 32767) mEnabled = 32767;
2294 } else {
2295 mEnabled--;
2296 if (mEnabled < 0) mEnabled = 0;
2297 }
2298 wake_up(&open_wq);
2299 }
2300
2301 break;
2302
2303 case SENSOR_GET_DATA:
2304 if((buff_out == NULL) || (size_out< sizeof(hwm_sensor_data)))
2305 {
2306 printk(KERN_ERR "get sensor data parameter error!\n");
2307 err = -EINVAL;
2308 }
2309 else
2310 {
2311 gravity_data = (hwm_sensor_data *)buff_out;
2312 mutex_lock(&sensor_data_mutex);
2313
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;
2319
2320 mutex_unlock(&sensor_data_mutex);
2321 #if DEBUG
2322 if(atomic_read(&data->trace) & AMK_HWM_DEBUG)
2323 {
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);
2327 }
2328 #endif
2329 }
2330 break;
2331 default:
2332 printk(KERN_ERR "gravity operate function no this parameter %d!\n", command);
2333 err = -1;
2334 break;
2335 }
2336
2337 return err;
2338 }
2339
2340
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)
2344 {
2345 int err = 0;
2346 int value;
2347 hwm_sensor_data* LA_data;
2348 #if DEBUG
2349 struct i2c_client *client = this_client;
2350 struct akm09911_i2c_data *data = i2c_get_clientdata(client);
2351 #endif
2352
2353 #if DEBUG
2354 if(atomic_read(&data->trace) & AMK_FUN_DEBUG)
2355 {
2356 AKMFUNC("akm09911_linear_accelration_operate");
2357 }
2358 #endif
2359
2360 switch (command)
2361 {
2362 case SENSOR_DELAY:
2363 if((buff_in == NULL) || (size_in < sizeof(int)))
2364 {
2365 printk(KERN_ERR "Set delay parameter error!\n");
2366 err = -EINVAL;
2367 }
2368 else
2369 {
2370 value = *(int *)buff_in;
2371 if(value <= 10)
2372 {
2373 value = 10;
2374 }
2375 akmd_delay = value;
2376 }
2377 break;
2378
2379 case SENSOR_ENABLE:
2380 if((buff_in == NULL) || (size_in < sizeof(int)))
2381 {
2382 printk(KERN_ERR "Enable sensor parameter error!\n");
2383 err = -EINVAL;
2384 }
2385 else
2386 {
2387
2388 value = *(int *)buff_in;
2389
2390 if (mEnabled <= 0) {
2391 if(value == 1)
2392 {
2393 atomic_set(&o_flag, 1);
2394 atomic_set(&open_flag, 1);
2395 }
2396 }
2397 else if (mEnabled == 1){
2398 if (!value )
2399 {
2400 atomic_set(&o_flag, 0);
2401 if(atomic_read(&m_flag) == 0)
2402 {
2403 atomic_set(&open_flag, 0);
2404 }
2405 }
2406 }
2407
2408 if (value ) {
2409 mEnabled++;
2410 if (mEnabled > 32767) mEnabled = 32767;
2411 } else {
2412 mEnabled--;
2413 if (mEnabled < 0) mEnabled = 0;
2414 }
2415 wake_up(&open_wq);
2416 }
2417
2418 break;
2419
2420 case SENSOR_GET_DATA:
2421 if((buff_out == NULL) || (size_out< sizeof(hwm_sensor_data)))
2422 {
2423 printk(KERN_ERR "get sensor data parameter error!\n");
2424 err = -EINVAL;
2425 }
2426 else
2427 {
2428 LA_data = (hwm_sensor_data *)buff_out;
2429 mutex_lock(&sensor_data_mutex);
2430
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;
2436
2437 mutex_unlock(&sensor_data_mutex);
2438 #if DEBUG
2439 if(atomic_read(&data->trace) & AMK_HWM_DEBUG)
2440 {
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);
2444 }
2445 #endif
2446 }
2447 break;
2448 default:
2449 printk(KERN_ERR "linear_accelration operate function no this parameter %d!\n", command);
2450 err = -1;
2451 break;
2452 }
2453
2454 return err;
2455 }
2456
2457 #endif
2458
2459 #ifndef CONFIG_HAS_EARLYSUSPEND
2460 /*----------------------------------------------------------------------------*/
2461 static int akm09911_suspend(struct i2c_client *client, pm_message_t msg)
2462 {
2463 int err;
2464 struct akm09911_i2c_data *obj = i2c_get_clientdata(client)
2465
2466
2467 if(msg.event == PM_EVENT_SUSPEND)
2468 {
2469 akm09911_power(obj->hw, 0);
2470 }
2471 return 0;
2472 }
2473 /*----------------------------------------------------------------------------*/
2474 static int akm09911_resume(struct i2c_client *client)
2475 {
2476 int err;
2477 struct akm09911_i2c_data *obj = i2c_get_clientdata(client)
2478
2479
2480 akm09911_power(obj->hw, 1);
2481
2482
2483 return 0;
2484 }
2485 /*----------------------------------------------------------------------------*/
2486 #else /*CONFIG_HAS_EARLY_SUSPEND is defined*/
2487 /*----------------------------------------------------------------------------*/
2488 static void akm09911_early_suspend(struct early_suspend *h)
2489 {
2490 struct akm09911_i2c_data *obj = container_of(h, struct akm09911_i2c_data, early_drv);
2491 int err = 0;
2492
2493 if(NULL == obj)
2494 {
2495 printk(KERN_ERR "null pointer!!\n");
2496 return;
2497 }
2498 if ((err = AKECS_SetMode(AK09911_MODE_POWERDOWN)) < 0) {
2499 AKMDBG("%s:%d Error.\n", __FUNCTION__, __LINE__);
2500 return;
2501 }
2502
2503 akm09911_power(obj->hw, 0);
2504 }
2505 /*----------------------------------------------------------------------------*/
2506 static void akm09911_late_resume(struct early_suspend *h)
2507 {
2508 struct akm09911_i2c_data *obj = container_of(h, struct akm09911_i2c_data, early_drv);
2509 int err;
2510
2511
2512 if(NULL == obj)
2513 {
2514 printk(KERN_ERR "null pointer!!\n");
2515 return;
2516 }
2517 akm09911_power(obj->hw, 1);
2518
2519 if ((err = AKECS_SetMode(AK09911_MODE_SNG_MEASURE)) < 0) {
2520 AKMDBG("%s:%d Error.\n", __FUNCTION__, __LINE__);
2521 return;
2522 }
2523 }
2524 /*----------------------------------------------------------------------------*/
2525 #endif /*CONFIG_HAS_EARLYSUSPEND*/
2526 /*----------------------------------------------------------------------------*/
2527 static int akm09911_i2c_detect(struct i2c_client *client, struct i2c_board_info *info)
2528 {
2529 strcpy(info->type, AKM09911_DEV_NAME);
2530 return 0;
2531 }
2532
2533 static int ecompass_status_read_proc(struct file *file, char *buffer, size_t count, loff_t *ppos)
2534 {
2535 char *page = NULL;
2536 char *ptr = NULL;
2537 int len = 0;
2538 int err = -1;
2539
2540 page = kmalloc(PAGE_SIZE, GFP_KERNEL);
2541 if (!page)
2542 {
2543 kfree(page);
2544 return -ENOMEM;
2545 }
2546 ptr = page;
2547
2548 ptr += sprintf(ptr, "%d\n", ecompass_status);
2549
2550 len = ptr - page;
2551 if(*ppos >= len)
2552 {
2553 kfree(page);
2554 return 0;
2555 }
2556 err = copy_to_user(buffer,(char *)page,len);
2557 *ppos += len;
2558 if(err)
2559 {
2560 kfree(page);
2561 return err;
2562 }
2563 kfree(page);
2564 return len;
2565 }
2566
2567 static const struct file_operations akm09911_ecompass_status_proc_fops = {
2568 .read = ecompass_status_read_proc
2569 };
2570
2571
2572 /*----------------------------------------------------------------------------*/
2573 static int akm09911_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
2574 {
2575 struct i2c_client *new_client;
2576 struct akm09911_i2c_data *data;
2577 int err = 0;
2578 struct hwmsen_object sobj_m, sobj_o;
2579 struct hwmsen_object sobj_gyro, sobj_rv;
2580 struct hwmsen_object sobj_gravity, sobj_la;
2581
2582 if(!(data = kmalloc(sizeof(struct akm09911_i2c_data), GFP_KERNEL)))
2583 {
2584 err = -ENOMEM;
2585 goto exit;
2586 }
2587 memset(data, 0, sizeof(struct akm09911_i2c_data));
2588 data->hw = get_cust_mag_hw();
2589
2590 atomic_set(&data->layout, data->hw->direction);
2591 atomic_set(&data->trace, 0);
2592
2593 mutex_init(&sense_data_mutex);
2594 mutex_init(&sensor_data_mutex);
2595
2596 init_waitqueue_head(&data_ready_wq);
2597 init_waitqueue_head(&open_wq);
2598
2599 data->client = client;
2600 new_client = data->client;
2601 i2c_set_clientdata(new_client, data);
2602
2603 this_client = new_client;
2604
2605 printk(KERN_ERR " AKM09911 akm09911_probe: befor init prob \n");
2606 /* Check connection */
2607 err = AKECS_CheckDevice();
2608 if(err < 0)
2609 {
2610 printk(KERN_ERR "AKM09911 akm09911_probe: check device connect error\n");
2611 goto exit_init_failed;
2612 }
2613
2614
2615 /* Register sysfs attribute */
2616 if((err = akm09911_create_attr(&akm_sensor_driver.driver)))
2617 {
2618 printk(KERN_ERR "create attribute err = %d\n", err);
2619 goto exit_sysfs_create_group_failed;
2620 }
2621
2622
2623 if((err = misc_register(&akm09911_device)))
2624 {
2625 printk(KERN_ERR "akm09911_device register failed\n");
2626 goto exit_misc_device_register_failed; }
2627
2628 sobj_m.self = data;
2629 sobj_m.polling = 1;
2630 sobj_m.sensor_operate = akm09911_operate;
2631 if((err = hwmsen_attach(ID_MAGNETIC, &sobj_m)))
2632 {
2633 printk(KERN_ERR "attach fail = %d\n", err);
2634 goto exit_kfree;
2635 }
2636
2637 sobj_o.self = data;
2638 sobj_o.polling = 1;
2639 sobj_o.sensor_operate = akm09911_orientation_operate;
2640 if((err = hwmsen_attach(ID_ORIENTATION, &sobj_o)))
2641 {
2642 printk(KERN_ERR "attach fail = %d\n", err);
2643 goto exit_kfree;
2644 }
2645
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))
2652 {
2653 printk(KERN_ERR "attach fail = %d\n", err);
2654 goto exit_kfree;
2655 }
2656
2657 //rotation vector sensor
2658
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))
2663 {
2664 printk(KERN_ERR "attach fail = %d\n", err);
2665 goto exit_kfree;
2666 }
2667
2668 //Gravity sensor
2669
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))
2674 {
2675 printk(KERN_ERR "attach fail = %d\n", err);
2676 goto exit_kfree;
2677 }
2678
2679 //LINEAR_ACCELERATION sensor
2680
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))
2685 {
2686 // printk(KERN_ERR "attach fail = %d\n", err);
2687 goto exit_kfree;
2688 }
2689
2690 #endif
2691
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);
2697 #endif
2698
2699 AKMDBG("%s: OK\n", __func__);
2700 ecompass_status = 1;
2701 return 0;
2702
2703 exit_sysfs_create_group_failed:
2704 exit_init_failed:
2705 exit_misc_device_register_failed:
2706 exit_kfree:
2707 kfree(data);
2708 exit:
2709 printk(KERN_ERR "%s: err = %d\n", __func__, err);
2710 ecompass_status = 0;
2711 return err;
2712 }
2713 /*----------------------------------------------------------------------------*/
2714 static int akm09911_i2c_remove(struct i2c_client *client)
2715 {
2716 int err;
2717
2718 if((err = akm09911_delete_attr(&akm_sensor_driver.driver)))
2719 {
2720 printk(KERN_ERR "akm09911_delete_attr fail: %d\n", err);
2721 }
2722
2723 this_client = NULL;
2724 i2c_unregister_device(client);
2725 kfree(i2c_get_clientdata(client));
2726 misc_deregister(&akm09911_device);
2727 return 0;
2728 }
2729 /*----------------------------------------------------------------------------*/
2730 static int akm_probe(struct platform_device *pdev)
2731 {
2732 struct mag_hw *hw = get_cust_mag_hw();
2733
2734 akm09911_power(hw, 1);
2735
2736 atomic_set(&dev_open_count, 0);
2737 //akm09911_force[0] = hw->i2c_num;
2738
2739 if(i2c_add_driver(&akm09911_i2c_driver))
2740 {
2741 printk(KERN_ERR "add driver error\n");
2742 return -1;
2743 }
2744 return 0;
2745 }
2746 /*----------------------------------------------------------------------------*/
2747 static int akm_remove(struct platform_device *pdev)
2748 {
2749 struct mag_hw *hw = get_cust_mag_hw();
2750
2751 akm09911_power(hw, 0);
2752 atomic_set(&dev_open_count, 0);
2753 i2c_del_driver(&akm09911_i2c_driver);
2754 return 0;
2755 }
2756 /*----------------------------------------------------------------------------*/
2757 static int __init akm09911_init(void)
2758 {
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)
2764 {
2765 printk(KERN_ERR "create_proc_entry ecompass_status failed");
2766 }
2767
2768 i2c_register_board_info(hw->i2c_num, &i2c_akm09911, 1);
2769 if(platform_driver_register(&akm_sensor_driver))
2770 {
2771 printk(KERN_ERR "failed to register driver");
2772 return -ENODEV;
2773 }
2774 return 0;
2775 }
2776 /*----------------------------------------------------------------------------*/
2777 static void __exit akm09911_exit(void)
2778 {
2779 platform_driver_unregister(&akm_sensor_driver);
2780 }
2781 /*----------------------------------------------------------------------------*/
2782 module_init(akm09911_init);
2783 module_exit(akm09911_exit);
2784
2785 MODULE_AUTHOR("viral wang <viral_wang@htc.com>");
2786 MODULE_DESCRIPTION("AKM09911 compass driver");
2787 MODULE_LICENSE("GPL");
2788 MODULE_VERSION(DRIVER_VERSION);
kernel source for telekom puls (alcatel/mediatek)