1 /*
2 * Copyright (C) 2015-2017 Alibaba Group Holding Limited
3 ***** only for 1422a ,not for 1422 ***********
4 * Edit wanjiang-yan 2018-6-26
5 */
6
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #include "aos/kernel.h"
11 #include "sensor_drv_api.h"
12 #include "sensor_hal.h"
13
14 // ********** ADDR = L ,addr=0x0E,ADDR = H,addr=0x0f ************
15 //#define ADDR_HIGH 1
16 #ifdef ADDR_HIGH
17 #define BM1422AGMV_I2C_ADDR1 0x0F //ADDR=H
18 #else
19 #define BM1422AGMV_I2C_ADDR1 0x0E //ADDR=L
20 #endif
21
22 #define BM1422AGMV_I2C_ADDR_TRANS(n) ((n)<<1)
23 #define BM1422AGMV_I2C_ADDR BM1422AGMV_I2C_ADDR_TRANS(BM1422AGMV_I2C_ADDR1)
24 #define BM1422AGMV_BIT(x) (x)
25
26 #define I_AM_BM1422AGMV 0x41
27
28 #define BM1422AGMV_MAG_INFO1_REG 0x0D
29 #define BM1422AGMV_MAG_INFO2_REG 0x0E
30 #define BM1422AGMV_MAG_WHO_AM_I_REG 0x0F
31 #define BM1422AGMV_MAG_OUTX_L 0x10
32 #define BM1422AGMV_MAG_OUTX_H 0x11
33 #define BM1422AGMV_MAG_OUTY_L 0x12
34 #define BM1422AGMV_MAG_OUTY_H 0x13
35 #define BM1422AGMV_MAG_OUTZ_L 0x14
36 #define BM1422AGMV_MAG_OUTZ_H 0x15
37 #define BM1422AGMV_MAG_STATUS_REG 0x18
38 #define BM1422AGMV_MAG_CNTL1_REG 0x1B
39 #define BM1422AGMV_MAG_CNTL2_REG 0x1C
40 #define BM1422AGMV_MAG_CNTL3_REG 0x1D
41 #define BM1422AGMV_MAG_PRET_REG 0x30
42 #define BM1422AGMV_MAG_AVE_A_REG 0x40
43 #define BM1422AGMV_MAG_CNTL4_REG 0x5C
44 #define BM1422AGMV_MAG_CNTL4_REG2 0x5D
45 #define BM1422AGMV_MAG_TEMP_OUT_L 0x60
46 #define BM1422AGMV_MAG_TEMP_OUT_H 0x61
47 #define BM1422AGMV_MAG_OFF_X_L 0x6C
48 #define BM1422AGMV_MAG_OFF_X_H 0x6D
49 #define BM1422AGMV_MAG_OFF_Y_L 0x72
50 #define BM1422AGMV_MAG_OFF_Y_H 0x73
51 #define BM1422AGMV_MAG_OFF_Z_L 0x78
52 #define BM1422AGMV_MAG_OFF_Z_H 0x79
53
54 #define BM1422AGMV_MAG_FINE_OUT_X_L 0x90
55 #define BM1422AGMV_MAG_FINE_OUT_X_H 0x91
56 #define BM1422AGMV_MAG_FINE_OUT_Y_L 0x92
57 #define BM1422AGMV_MAG_FINE_OUT_Y_H 0x93
58 #define BM1422AGMV_MAG_FINE_OUT_Z_L 0x94
59 #define BM1422AGMV_MAG_FINE_OUT_Z_H 0x95
60
61 #define BM1422AGMV_MAG_GAIN_PARA_X_L 0x9C
62 #define BM1422AGMV_MAG_GAIN_PARA_X_H 0x9D
63 #define BM1422AGMV_MAG_GAIN_PARA_Y_L 0x9E
64 #define BM1422AGMV_MAG_GAIN_PARA_Y_H 0x9F
65 #define BM1422AGMV_MAG_GAIN_PARA_Z_L 0xA0
66 #define BM1422AGMV_MAG_GAIN_PARA_Z_H 0xA1
67
68 #define INFORMATION_BM1422AGMV 0x0101
69
70 #define I_AM_BM1422AGMV 0x41
71
72
73 //0X18 STA1 BIT 6
74 #define BM1422AGMV_MAG_STATUS_RD_DRDY_BIT 0x40
75
76 //CNTL1 0X1B
77 #define BM1422AGMV_MAG_CNTL1_ODR_BIT BM1422AGMV_BIT(0x18)
78 #define BM1422AGMV_MAG_CNTL1_ODR_10_HZ 0x00
79 #define BM1422AGMV_MAG_CNTL1_ODR_20_HZ 0x10
80 #define BM1422AGMV_MAG_CNTL1_ODR_100_HZ 0x08
81 #define BM1422AGMV_MAG_CNTL1_ODR_1000_HZ 0x18
82
83 #define BM1422AGMV_MAG_CNTL1_FS1_BIT BM1422AGMV_BIT(0x02)
84 #define BM1422AGMV_MAG_CNTL1_FS1_CONTINUOUS 0x00
85 #define BM1422AGMV_MAG_CNTL1_FS1_SINGLE 0x02
86
87 #define BM1422AGMV_MAG_CNTL1_PC1_BIT BM1422AGMV_BIT(0x80)
88 #define BM1422AGMV_MAG_CNTL1_PC1_POWERDOWN 0x00
89 #define BM1422AGMV_MAG_CNTL1_PC1_ACTIVE 0x80
90 #define BM1422AGMV_MAG_CNTL1_OUT_BIT BM1422AGMV_BIT(0x40)
91 #define BM1422AGMV_MAG_CNTL1_OUT12_BIT 0x40
92 #define BM1422AGMV_MAG_CNTL1_OUT14_BIT 0x00
93
94
95 #define BM1422AGMV_MAG_CNTL1_RST_LV_BIT BM1422AGMV_BIT(0x20)
96
97
98
99 //CNTL2 0X1C
100 #define BM1422AGMV_MAG_CNTL2_DRP_BIT BM1422AGMV_BIT(0x04)
101 #define BM1422AGMV_MAG_CNTL2_DREN_BIT BM1422AGMV_BIT(0x08)
102
103 //CNTL3 0X1D
104 #define BM1422AGMV_MAG_CNTL3_FORCE_BIT BM1422AGMV_BIT(0x40)
105
106 //PRET 0X30
107 #define BM1422AGMV_MAG_PRET_PS_BIT BM1422AGMV_BIT(0x01)
108
109 //AVE 0X40
110 #define BM1422AGMV_MAG_AVE_A_BIT BM1422AGMV_BIT(0x1C)
111
112 //CNTL4 0X5D
113 #define BM1422AGMV_MAG_CNTL4_RSTB_LV_BIT BM1422AGMV_BIT(0x3F)
114
115 #define DEV_POWER_ON 1
116 #define DEV_POWER_OFF 0
117
118
119
120 i2c_dev_t bm1422a_ctx = {
121 .port = 3,
122 .config.address_width = 8,
123 .config.freq = 400000,
124 .config.dev_addr = BM1422AGMV_I2C_ADDR,
125 };
126 uint16_t offx_dat,offy_dat,offz_dat;
127
128
drv_mag_rohm_bm1422a_soft_reset(i2c_dev_t * drv)129 static int drv_mag_rohm_bm1422a_soft_reset(i2c_dev_t* drv)
130 {
131 int ret = 0;
132 uint8_t value = BM1422AGMV_MAG_CNTL1_PC1_ACTIVE;
133 ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
134 if(unlikely(ret)){
135 return -1;
136 }
137 return 0;
138 }
139
drv_mag_rohm_bm1422a_selftest(i2c_dev_t * drv)140 UNUSED static int drv_mag_rohm_bm1422a_selftest(i2c_dev_t* drv)
141 {
142 /*
143 int ret = 0;
144 ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CTRL_REG1, LMS303C_MAG_SELFTEST_ENABLE, I2C_DATA_LEN, I2C_OP_RETRIES);
145 if(unlikely(ret)){
146 return -1;
147 }
148 */
149 return 0;
150 }
151
drv_mag_rohm_bm1422a_reboot(i2c_dev_t * drv)152 UNUSED static int drv_mag_rohm_bm1422a_reboot(i2c_dev_t* drv)
153 {
154 /*
155 int ret = 0;
156 ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL2_REG, BM1422AGMV_MAG_REBOOT_ENABLE, I2C_DATA_LEN, I2C_OP_RETRIES);
157 if(unlikely(ret)){
158 return -1;
159 }*/
160 return 0;
161 }
162
drv_mag_rohm_bm1422a_validate_id(i2c_dev_t * drv,uint8_t id_value)163 static int drv_mag_rohm_bm1422a_validate_id(i2c_dev_t* drv, uint8_t id_value)
164 {
165 uint8_t value = 0x00;
166 int ret = 0;
167
168 if(drv == NULL){
169 return -1;
170 }
171
172 ret = sensor_i2c_read(drv, BM1422AGMV_MAG_WHO_AM_I_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
173 if(unlikely(ret)){
174 return ret;
175 }
176
177 if (id_value != value){
178 return -1;
179 }
180 //ok
181 return 0;
182 }
183
184 //
drv_mag_rohm_bm1422a_set_power_mode(i2c_dev_t * drv,dev_power_mode_e mode)185 static int drv_mag_rohm_bm1422a_set_power_mode(i2c_dev_t* drv, dev_power_mode_e mode)
186 {
187 uint8_t value = 0x00;
188 int ret = 0;
189
190 ret = sensor_i2c_read(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
191 if(unlikely(ret)){
192 return ret;
193 }
194
195 if (mode == DEV_POWER_ON)
196 {
197 value &= ~BM1422AGMV_MAG_CNTL1_PC1_BIT;
198 value |= BM1422AGMV_MAG_CNTL1_PC1_ACTIVE;
199 }
200 else{
201 value &= ~BM1422AGMV_MAG_CNTL1_PC1_BIT;
202 value |= BM1422AGMV_MAG_CNTL1_PC1_POWERDOWN;
203 }
204
205 ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
206 if(unlikely(ret)){
207 return ret;
208 }
209
210 return 0;
211 }
212
213 //
drv_mag_rohm_bm1422a_set_odr(i2c_dev_t * drv,uint8_t odr)214 static int drv_mag_rohm_bm1422a_set_odr(i2c_dev_t* drv, uint8_t odr)
215 {
216 uint8_t value = 0x00;
217 int ret = 0;
218
219 ret = sensor_i2c_read(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
220 if(unlikely(ret)){
221 return ret;
222 }
223 value &= ~BM1422AGMV_MAG_CNTL1_ODR_BIT;
224 value |= (uint8_t)odr;
225 ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
226 if(unlikely(ret)){
227 return ret;
228 }
229 return 0;
230 }
231
232 //single mode or continuous mode
drv_mag_rohm_bm1422a_set_mode(i2c_dev_t * drv,uint8_t mode)233 UNUSED static int drv_mag_rohm_bm1422a_set_mode(i2c_dev_t* drv, uint8_t mode)
234 {
235 uint8_t value = 0x00;
236 int ret = 0;
237
238 ret = sensor_i2c_read(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
239 if(unlikely(ret)){
240 return ret;
241 }
242 value &= ~BM1422AGMV_MAG_CNTL1_FS1_BIT;
243 value |= (uint8_t)mode;
244 ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
245 if(unlikely(ret)){
246 return ret;
247 }
248 return 0;
249 }
250
251 //Output bit 12bit 14bit
drv_mag_rohm_bm1422a_set_outmode(i2c_dev_t * drv,uint8_t bit_wide)252 UNUSED static int drv_mag_rohm_bm1422a_set_outmode(i2c_dev_t* drv, uint8_t bit_wide)
253 {
254 uint8_t value = 0x00;
255 int ret = 0;
256
257 ret = sensor_i2c_read(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
258 if(unlikely(ret)){
259 return ret;
260 }
261 value &= ~BM1422AGMV_MAG_CNTL1_OUT_BIT;
262 value |= (uint8_t)bit_wide;
263 ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
264 if(unlikely(ret)){
265 return ret;
266 }
267 return 0;
268 }
269
270 //
drv_mag_rohm_bm1422a_set_cntl1(i2c_dev_t * drv,uint8_t value)271 static int drv_mag_rohm_bm1422a_set_cntl1(i2c_dev_t* drv, uint8_t value)
272 {
273 int ret = 0;
274
275 ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL1_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
276 if(unlikely(ret)){
277 return ret;
278 }
279 return 0;
280 }
281
282
drv_mag_rohm_bm1422a_set_step1(i2c_dev_t * drv,uint16_t value)283 static int drv_mag_rohm_bm1422a_set_step1(i2c_dev_t* drv, uint16_t value)
284 {
285 //uint8_t value = 0x00;
286 int ret = 0;
287
288 //5C //5D
289 //value = 0X00;
290 ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL4_REG, (uint8_t*)&value, 2, I2C_OP_RETRIES);
291 if(unlikely(ret)){
292 return ret;
293 }
294
295
296 return 0;
297
298
299 }
300
drv_mag_rohm_bm1422a_set_step2(i2c_dev_t * drv,uint8_t value)301 static int drv_mag_rohm_bm1422a_set_step2(i2c_dev_t* drv, uint8_t value)
302 {
303 //uint8_t value = 0x00;
304 int ret = 0;
305
306 //value = BM1422AGMV_MAG_CNTL2_DRP_BIT | BM1422AGMV_MAG_CNTL2_DREN_BIT;
307 ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL2_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
308 if(unlikely(ret)){
309 return ret;
310 }
311 return 0;
312
313 }
314
drv_mag_rohm_bm1422a_set_step4(i2c_dev_t * drv,uint8_t value)315 static int drv_mag_rohm_bm1422a_set_step4(i2c_dev_t* drv, uint8_t value)
316 {
317 //uint8_t value = 0x00;
318 int ret = 0;
319
320 //value = BM1422AGMV_MAG_CNTL3_FORCE_BIT;
321 ret = sensor_i2c_write(drv, BM1422AGMV_MAG_CNTL3_REG, &value, I2C_DATA_LEN, I2C_OP_RETRIES);
322 if(unlikely(ret)){
323 return ret;
324 }
325 return 0;
326
327 }
328
329
330 // offset x,y,z step 3
drv_mag_rohm_bm1422a_set_x_offset(i2c_dev_t * drv,uint16_t value)331 static int drv_mag_rohm_bm1422a_set_x_offset(i2c_dev_t* drv, uint16_t value)
332 {
333 //uint8_t value = 0x00;
334 int ret = 0;
335
336 ret = sensor_i2c_write(drv, BM1422AGMV_MAG_OFF_X_L, (uint8_t*)&value, 2, I2C_OP_RETRIES);
337 if(unlikely(ret)){
338 return ret;
339 }
340 return 0;
341 }
342
drv_mag_rohm_bm1422a_set_y_offset(i2c_dev_t * drv,uint16_t value)343 static int drv_mag_rohm_bm1422a_set_y_offset(i2c_dev_t* drv, uint16_t value)
344 {
345 //uint8_t value = 0x00;
346 int ret = 0;
347
348 ret = sensor_i2c_write(drv, BM1422AGMV_MAG_OFF_Y_L, (uint8_t*)&value, 2, I2C_OP_RETRIES);
349 if(unlikely(ret)){
350 return ret;
351 }
352 return 0;
353 }
354
drv_mag_rohm_bm1422a_set_z_offset(i2c_dev_t * drv,uint16_t value)355 static int drv_mag_rohm_bm1422a_set_z_offset(i2c_dev_t* drv, uint16_t value)
356 {
357 //uint8_t value = 0x00;
358 int ret = 0;
359
360 ret = sensor_i2c_write(drv, BM1422AGMV_MAG_OFF_Z_L, (uint8_t*)&value, 2, I2C_OP_RETRIES);
361 if(unlikely(ret)){
362 return ret;
363 }
364 return 0;
365 }
366
367 //select x,y,z
drv_mag_rohm_bm1422a_offset_adjustment(i2c_dev_t * drv,uint8_t xyz_wide)368 UNUSED static int drv_mag_rohm_bm1422a_offset_adjustment(i2c_dev_t* drv, uint8_t xyz_wide)
369 {
370 int ret = 0;
371 // int diff_x = 9999;
372 uint8_t wk_dat = 1,off_dat=1,drdy=0,buffer[2];
373 uint16_t data_temp,diff_x=9999;
374
375 drv_mag_rohm_bm1422a_set_step1(drv,0x82);
376 drv_mag_rohm_bm1422a_set_step2(drv,0x0C);
377 switch(xyz_wide)
378 {
379 case 1:
380 while(wk_dat<96)
381 {
382 drv_mag_rohm_bm1422a_set_x_offset(drv,wk_dat);
383 drv_mag_rohm_bm1422a_set_step4(drv,0x40);
384 do
385 {
386
387 ret = sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_STATUS_REG, &drdy, I2C_DATA_LEN, I2C_OP_RETRIES);
388
389 }while((drdy & BM1422AGMV_MAG_STATUS_RD_DRDY_BIT) != BM1422AGMV_MAG_STATUS_RD_DRDY_BIT);
390
391 // read x,y,z data
392 ret = sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTX_L , buffer, 2, I2C_OP_RETRIES);
393 if(unlikely(ret)){
394 return -1;
395 }
396 data_temp=((((uint16_t)buffer[1]) << 8) | (uint16_t)buffer[0]);
397 if(diff_x > abs(data_temp))
398 {
399 off_dat = wk_dat;
400 diff_x = abs(data_temp);
401 offx_dat = off_dat;
402 }
403 wk_dat ++;
404 }
405 drv_mag_rohm_bm1422a_set_x_offset(drv,off_dat);
406 break;
407 case 2:
408 while(wk_dat<96)
409 {
410 drv_mag_rohm_bm1422a_set_y_offset(drv,wk_dat);
411 drv_mag_rohm_bm1422a_set_step4(drv,0x40);
412 do
413 {
414
415 ret = sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_STATUS_REG, &drdy, I2C_DATA_LEN, I2C_OP_RETRIES);
416
417 }while((drdy & BM1422AGMV_MAG_STATUS_RD_DRDY_BIT) != BM1422AGMV_MAG_STATUS_RD_DRDY_BIT);
418
419 // read x,y,z data
420 ret = sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTY_L, buffer, 2, I2C_OP_RETRIES);
421 data_temp=((((uint16_t)buffer[1]) << 8) | (uint16_t)buffer[0]);
422 if(diff_x > abs(data_temp))
423 {
424 off_dat = wk_dat;
425 diff_x = abs(data_temp);
426 offy_dat = off_dat;
427 }
428 wk_dat ++;
429 }
430 drv_mag_rohm_bm1422a_set_y_offset(drv,off_dat);
431 break;
432 case 3:
433 while(wk_dat<96)
434 {
435 drv_mag_rohm_bm1422a_set_z_offset(drv,wk_dat);
436 drv_mag_rohm_bm1422a_set_step4(drv,0x40);
437 do
438 {
439
440 ret = sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_STATUS_REG, &drdy, I2C_DATA_LEN, I2C_OP_RETRIES);
441
442 }while((drdy & BM1422AGMV_MAG_STATUS_RD_DRDY_BIT) != BM1422AGMV_MAG_STATUS_RD_DRDY_BIT);
443 // read x,y,z data
444
445 ret = sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTZ_L, buffer, 2, I2C_OP_RETRIES);
446 data_temp=((((uint16_t)buffer[1]) << 8) | (uint16_t)buffer[0]);
447 if(diff_x > abs(data_temp))
448 {
449 off_dat = wk_dat;
450 diff_x = abs(data_temp);
451 offz_dat = off_dat;
452 }
453 wk_dat ++;
454 }
455 drv_mag_rohm_bm1422a_set_z_offset(drv,off_dat);
456 break;
457 default:
458 break;
459 }
460
461 return 0;
462 }
463
464
drv_mag_rohm_bm1422a_set_default_config(i2c_dev_t * drv)465 static int drv_mag_rohm_bm1422a_set_default_config(i2c_dev_t* drv)
466 {
467 /*
468 uint8_t value = 0x00;
469 ret = drv_mag_rohm_bm1422a_set_power_mode(drv, DEV_POWER_ON);
470 if(unlikely(ret)){
471 return ret;
472 }
473 ret = drv_mag_rohm_bm1422a_set_odr(drv, BM1422AGMV_MAG_CNTL1_ODR_10_HZ);
474 if(unlikely(ret)){
475 return ret;
476 }
477 //single or connutional
478 ret = drv_mag_rohm_bm1422a_set_mode(drv, BM1422AGMV_MAG_CNTL1_FS1_CONTINUOUS);
479 if(unlikely(ret)){
480 return ret;
481 }
482
483 //single or connutional
484 ret = drv_mag_rohm_bm1422a_set_mode(drv, BM1422AGMV_MAG_CNTL1_FS1_CONTINUOUS);
485 if(unlikely(ret)){
486 return ret;
487 }
488
489 ret = drv_mag_rohm_bm1422a_set_outmode(drv, BM1422AGMV_MAG_CNTL1_OUT12_BIT);
490 if(unlikely(ret)){
491 return ret;
492 }
493 */
494 //step 1
495 drv_mag_rohm_bm1422a_set_cntl1(drv,0x80);
496 drv_mag_rohm_bm1422a_set_step1(drv,0x0000);
497 aos_msleep(10);
498 //step 2
499 drv_mag_rohm_bm1422a_set_step2(drv,0x0c);
500 aos_msleep(10);
501 //step 3
502
503 //step 4
504 drv_mag_rohm_bm1422a_set_step4(drv,0x40);
505 aos_msleep(10);
506 return 0;
507 }
508
drv_mag_rohm_bm1422a_irq_handle(void)509 static void drv_mag_rohm_bm1422a_irq_handle(void)
510 {
511 /* no handle so far */
512 }
513
drv_mag_rohm_bm1422a_open(void)514 static int drv_mag_rohm_bm1422a_open(void)
515 {
516 int ret = 0;
517 ret = drv_mag_rohm_bm1422a_set_power_mode(&bm1422a_ctx, DEV_POWER_ON);
518 if(unlikely(ret)){
519 return -1;
520 }
521 return 0;
522
523 }
524
drv_mag_rohm_bm1422a_close(void)525 static int drv_mag_rohm_bm1422a_close(void)
526 {
527 int ret = 0;
528 ret = drv_mag_rohm_bm1422a_set_power_mode(&bm1422a_ctx, DEV_POWER_OFF);
529 if(unlikely(ret)){
530 return -1;
531 }
532 return 0;
533 }
534
535
536 ///////////////////////////////////////////
537
drv_mag_rohm_bm1422a_read(void * buf,size_t len)538 static int drv_mag_rohm_bm1422a_read(void* buf, size_t len)
539 {
540 int ret = 0;
541 size_t size;
542 int16_t data_temp[3];
543 uint8_t drdy= 0;
544 uint8_t buffer[6];
545 uint8_t i = 0;
546
547 mag_data_t* pdata = (mag_data_t*)buf;
548 if(buf == NULL){
549 return -1;
550 }
551
552 size = sizeof(mag_data_t);
553 if(len < size){
554 return -1;
555 }
556
557 drdy = 0;
558 do{
559
560 ret = sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_STATUS_REG, &drdy, I2C_DATA_LEN, I2C_OP_RETRIES);
561
562 }while(drdy == 0);
563
564 ret = 0;
565 ret |= sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTX_L, &buffer[0], 1, I2C_OP_RETRIES);
566 ret |= sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTX_H, &buffer[1], 1, I2C_OP_RETRIES);
567 ret |= sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTY_L, &buffer[2], 1, I2C_OP_RETRIES);
568 ret |= sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTY_H, &buffer[3], 1, I2C_OP_RETRIES);
569 ret |= sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTZ_L, &buffer[4], 1, I2C_OP_RETRIES);
570 ret |= sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTZ_H, &buffer[5], 1, I2C_OP_RETRIES);
571
572 if(unlikely(ret)){
573 return -1;
574 }
575 //ret = sensor_i2c_read(&bm1422a_ctx, BM1422AGMV_MAG_OUTX_L, buffer, 6, I2C_OP_RETRIES);
576
577
578 for(i=0; i<3; i++)
579 {
580 data_temp[i]=(((buffer[2*i+1]) << 8) | buffer[2*i]);
581 }
582
583 //check x,y,z value is ok
584 //
585 for(i=0; i<3; i++)
586 {
587 //pdata->data[i] = ((data_temp[i] * sensitivity) >> 10);
588 pdata->data[i] = data_temp[i] /6000;
589 }
590 pdata->timestamp = aos_now_ms();
591
592 return (int)size;
593 }
594
595
drv_mag_rohm_bm1422a_ioctl(int cmd,unsigned long arg)596 static int drv_mag_rohm_bm1422a_ioctl(int cmd, unsigned long arg)
597 {
598 int ret = 0;
599
600 switch(cmd){
601 case SENSOR_IOCTL_ODR_SET:{
602 ret = drv_mag_rohm_bm1422a_set_odr(&bm1422a_ctx, arg);
603 if(unlikely(ret)){
604 return -1;
605 }
606 }break;
607 /*
608 case SENSOR_IOCTL_RANGE_SET:{
609 ret = drv_mag_rohm_bm1422a_set_range(&bm1422a_ctx, arg);
610 if(unlikely(ret)){
611 return -1;
612 }
613 }break;
614 */
615 case SENSOR_IOCTL_SET_POWER:{
616 ret = drv_mag_rohm_bm1422a_set_power_mode(&bm1422a_ctx, arg);
617 if(unlikely(ret)){
618 return -1;
619 }
620 }break;
621 case SENSOR_IOCTL_GET_INFO:{
622 /* fill the dev info here */
623 dev_sensor_info_t *info = (dev_sensor_info_t *)arg;
624 info->model = "BM1422AGMV";
625 info->range_max = 8191;
626 info->range_min = -8192;
627 info->unit = mGauss;
628 }break;
629
630 default:break;
631 }
632
633 return 0;
634 }
635
drv_mag_rohm_bm1422a_init(void)636 int drv_mag_rohm_bm1422a_init(void){
637 int ret = 0;
638 sensor_obj_t sensor;
639 memset(&sensor, 0, sizeof(sensor));
640 /* fill the sensor obj parameters here */
641 sensor.io_port = I2C_PORT;
642 sensor.tag = TAG_DEV_MAG;
643 sensor.path = dev_mag_path;
644 sensor.open = drv_mag_rohm_bm1422a_open;
645 sensor.close = drv_mag_rohm_bm1422a_close;
646 sensor.read = drv_mag_rohm_bm1422a_read;
647 sensor.write = NULL;
648 sensor.ioctl = drv_mag_rohm_bm1422a_ioctl;
649 sensor.irq_handle = drv_mag_rohm_bm1422a_irq_handle;
650
651 ret = sensor_create_obj(&sensor);
652 if(unlikely(ret)){
653 return -1;
654 }
655
656 ret = drv_mag_rohm_bm1422a_validate_id(&bm1422a_ctx, I_AM_BM1422AGMV);
657 if(unlikely(ret)){
658 return -1;
659 }
660
661 ret = drv_mag_rohm_bm1422a_soft_reset(&bm1422a_ctx);
662 if(unlikely(ret)){
663 return -1;
664 }
665
666 ret = drv_mag_rohm_bm1422a_set_default_config(&bm1422a_ctx);
667 if(unlikely(ret)){
668 return -1;
669 }
670
671 /* update the phy sensor info to sensor hal */
672 LOG("%s %s successfully \n", SENSOR_STR, __func__);
673 return 0;
674 }
675
676 SENSOR_DRV_ADD(drv_mag_rohm_bm1422a_init);
677
678
679