1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * kernel/drivers/input/sensors/compass/akm09918.c
4 *
5 * Copyright (C) 2020 Rockchip Co.,Ltd.
6 * Author: Wang Jie <dave.wang@rock-chips.com>
7 */
8
9 #include <linux/interrupt.h>
10 #include <linux/i2c.h>
11 #include <linux/slab.h>
12 #include <linux/irq.h>
13 #include <linux/miscdevice.h>
14 #include <linux/gpio.h>
15 #include <linux/uaccess.h>
16 #include <linux/atomic.h>
17 #include <linux/delay.h>
18 #include <linux/input.h>
19 #include <linux/workqueue.h>
20 #include <linux/freezer.h>
21 #include <linux/of_gpio.h>
22 #ifdef CONFIG_HAS_EARLYSUSPEND
23 #include <linux/earlysuspend.h>
24 #endif
25 #include <linux/sensor-dev.h>
26
27 #define SENSOR_DATA_SIZE 9
28 #define YPR_DATA_SIZE 16
29 #define RWBUF_SIZE 16
30
31 #define ACC_DATA_FLAG 0
32 #define MAG_DATA_FLAG 1
33 #define ORI_DATA_FLAG 2
34 #define AKM_NUM_SENSORS 3
35
36 #define ACC_DATA_READY (1 << (ACC_DATA_FLAG))
37 #define MAG_DATA_READY (1 << (MAG_DATA_FLAG))
38 #define ORI_DATA_READY (1 << (ORI_DATA_FLAG))
39
40 /*Constant definitions of the AK09918.*/
41 #define AK09918_MEASUREMENT_TIME_US 10000
42 #define AK09918_MODE_SNG_MEASURE 0x01
43 #define AK09918_MODE_SELF_TEST 0x10
44 #define AK09918_MODE_FUSE_ACCESS 0x1F
45 #define AK09918_MODE_POWERDOWN 0x00
46 #define AK09918_RESET_DATA 0x01
47
48 /* Device specific constant values */
49 #define AK09918_REG_WIA1 0x00
50 #define AK09918_REG_WIA2 0x01
51 #define AK09918_REG_INFO1 0x02
52 #define AK09918_REG_INFO2 0x03
53 #define AK09918_REG_ST1 0x10
54 #define AK09918_REG_HXL 0x11
55 #define AK09918_REG_HXH 0x12
56 #define AK09918_REG_HYL 0x13
57 #define AK09918_REG_HYH 0x14
58 #define AK09918_REG_HZL 0x15
59 #define AK09918_REG_HZH 0x16
60 #define AK09918_REG_TMPS 0x17
61 #define AK09918_REG_ST2 0x18
62 #define AK09918_REG_CNTL1 0x30
63 #define AK09918_REG_CNTL2 0x31
64 #define AK09918_REG_CNTL3 0x32
65
66 #define AK09918_FUSE_ASAX 0x60
67 #define AK09918_FUSE_ASAY 0x61
68 #define AK09918_FUSE_ASAZ 0x62
69
70 #define AK09918_INFO_SIZE 2
71 #define AK09918_CONF_SIZE 3
72
73 #define COMPASS_IOCTL_MAGIC 'c'
74
75 /* IOCTLs for AKM library */
76 #define ECS_IOCTL_WRITE _IOW(COMPASS_IOCTL_MAGIC, 0x01, char*)
77 #define ECS_IOCTL_READ _IOWR(COMPASS_IOCTL_MAGIC, 0x02, char*)
78 #define ECS_IOCTL_RESET _IO(COMPASS_IOCTL_MAGIC, 0x03)
79 #define ECS_IOCTL_SET_MODE _IOW(COMPASS_IOCTL_MAGIC, 0x04, short)
80 #define ECS_IOCTL_GETDATA _IOR(COMPASS_IOCTL_MAGIC, 0x05, char[8])
81 #define ECS_IOCTL_SET_YPR _IOW(COMPASS_IOCTL_MAGIC, 0x06, short[12])
82 #define ECS_IOCTL_GET_OPEN_STATUS _IOR(COMPASS_IOCTL_MAGIC, 0x07, int)
83 #define ECS_IOCTL_GET_CLOSE_STATUS _IOR(COMPASS_IOCTL_MAGIC, 0x08, int)
84 #define ECS_IOCTL_GET_LAYOUT _IOR(COMPASS_IOCTL_MAGIC, 0x09, char)
85 #define ECS_IOCTL_GET_ACCEL _IOR(COMPASS_IOCTL_MAGIC, 0x0A, short[3])
86 #define ECS_IOCTL_GET_OUTBIT _IOR(COMPASS_IOCTL_MAGIC, 0x0B, char)
87 #define ECS_IOCTL_GET_INFO _IOR(COMPASS_IOCTL_MAGIC, 0x27, unsigned char[AK09918_INFO_SIZE])
88 #define ECS_IOCTL_GET_CONF _IOR(COMPASS_IOCTL_MAGIC, 0x28, unsigned char[AK09918_CONF_SIZE])
89 #define ECS_IOCTL_GET_PLATFORM_DATA _IOR(COMPASS_IOCTL_MAGIC, 0x0E, struct akm_platform_data)
90 #define ECS_IOCTL_GET_DELAY _IOR(COMPASS_IOCTL_MAGIC, 0x30, short)
91 #define AK09918_DEVICE_ID 0x0c
92
93 static struct i2c_client *this_client;
94 static struct miscdevice compass_dev_device;
95
96 static int g_akm_rbuf_ready;
97 static int g_akm_rbuf[12];
98 static char g_sensor_info[AK09918_INFO_SIZE];
99 static char g_sensor_conf[AK09918_CONF_SIZE];
100
101 /****************operate according to sensor chip:start************/
sensor_active(struct i2c_client * client,int enable,int rate)102 static int sensor_active(struct i2c_client *client, int enable, int rate)
103 {
104 struct sensor_private_data *sensor =
105 (struct sensor_private_data *) i2c_get_clientdata(client);
106 int result = 0;
107
108 if (enable)
109 sensor->ops->ctrl_data = AK09918_MODE_SNG_MEASURE;
110 else
111 sensor->ops->ctrl_data = AK09918_MODE_POWERDOWN;
112
113 result = sensor_write_reg(client,
114 sensor->ops->ctrl_reg, sensor->ops->ctrl_data);
115 if (result)
116 dev_err(&client->dev,
117 "%s: fail to active sensor(%d)\n", __func__, result);
118
119 return result;
120 }
121
sensor_init(struct i2c_client * client)122 static int sensor_init(struct i2c_client *client)
123 {
124 struct sensor_private_data *sensor =
125 (struct sensor_private_data *) i2c_get_clientdata(client);
126 int result = 0;
127
128 this_client = client;
129
130 result = sensor->ops->active(client, 0, 0);
131 if (result) {
132 dev_err(&client->dev, "%s: line= %d, result = %d\n",
133 __func__, __LINE__, result);
134 return result;
135 }
136
137 sensor->status_cur = SENSOR_OFF;
138
139 result = misc_register(&compass_dev_device);
140 if (result < 0) {
141 dev_err(&client->dev,
142 "%s:fail to register misc device %s(%d)\n",
143 __func__, compass_dev_device.name, result);
144 result = -1;
145 }
146
147 g_sensor_info[0] = AK09918_REG_WIA1;
148 result = sensor_rx_data(client, g_sensor_info, AK09918_INFO_SIZE);
149 if (result) {
150 dev_err(&client->dev, "%s: line= %d, error(%d)\n",
151 __func__, __LINE__, result);
152 return result;
153 }
154
155 g_sensor_conf[0] = AK09918_FUSE_ASAX;
156 result = sensor_rx_data(client, g_sensor_conf, AK09918_CONF_SIZE);
157 if (result) {
158 dev_err(&client->dev, "%s: line= %d, error(%d)\n",
159 __func__, __LINE__, result);
160 return result;
161 }
162
163 return result;
164 }
165
compass_report_value(void)166 static void compass_report_value(void)
167 {
168 struct sensor_private_data *sensor =
169 (struct sensor_private_data *) i2c_get_clientdata(this_client);
170 static int flag;
171
172 if (!g_akm_rbuf_ready) {
173 dev_err(&this_client->dev, "g_akm_rbuf not ready\n");
174 return;
175 }
176
177 /* Report magnetic vector information */
178 if (atomic_read(&sensor->flags.mv_flag) && (g_akm_rbuf[0] & MAG_DATA_READY)) {
179 /*
180 *input dev will ignore report data if data value is the same with last_value,
181 *sample rate will not enough by this way, so just avoid this case
182 */
183 if ((sensor->axis.x == g_akm_rbuf[5]) &&
184 (sensor->axis.y == g_akm_rbuf[6]) && (sensor->axis.z == g_akm_rbuf[7])) {
185 if (flag) {
186 flag = 0;
187 sensor->axis.x += 1;
188 sensor->axis.y += 1;
189 sensor->axis.z += 1;
190 } else {
191 flag = 1;
192 sensor->axis.x -= 1;
193 sensor->axis.y -= 1;
194 sensor->axis.z -= 1;
195 }
196 } else {
197 sensor->axis.x = g_akm_rbuf[5];
198 sensor->axis.y = g_akm_rbuf[6];
199 sensor->axis.z = g_akm_rbuf[7];
200 }
201 input_report_abs(sensor->input_dev, ABS_HAT0X, sensor->axis.x);
202 input_report_abs(sensor->input_dev, ABS_HAT0Y, sensor->axis.y);
203 input_report_abs(sensor->input_dev, ABS_BRAKE, sensor->axis.z);
204 input_report_abs(sensor->input_dev, ABS_HAT1X, g_akm_rbuf[8]);
205 }
206 input_sync(sensor->input_dev);
207 }
208
sensor_report_value(struct i2c_client * client)209 static int sensor_report_value(struct i2c_client *client)
210 {
211 struct sensor_private_data *sensor =
212 (struct sensor_private_data *) i2c_get_clientdata(client);
213 char buffer[SENSOR_DATA_SIZE] = {0};
214 unsigned char *stat;
215 unsigned char *stat2;
216 int ret = 0;
217 char value = 0;
218
219 mutex_lock(&sensor->data_mutex);
220 compass_report_value();
221 mutex_unlock(&sensor->data_mutex);
222
223 if (sensor->ops->read_len < SENSOR_DATA_SIZE) {
224 dev_err(&client->dev, "%s: length is error,len = %d\n",
225 __func__, sensor->ops->read_len);
226 return -EINVAL;
227 }
228
229 /* Data bytes from hardware xL, xH, yL, yH, zL, zH */
230 *buffer = sensor->ops->read_reg;
231 ret = sensor_rx_data(client, buffer, sensor->ops->read_len);
232 if (ret < 0) {
233 dev_err(&client->dev,
234 "%s: read data error(%d)\n", __func__, ret);
235 return ret;
236 }
237
238 stat = &buffer[0];
239 stat2 = &buffer[7];
240
241 /*
242 * ST : data ready -
243 * Measurement has been completed and data is ready to be read.
244 */
245 if ((*stat & 0x01) != 0x01) {
246 dev_err(&client->dev,
247 "%s: ST is not set, stat = 0x%x\n", __func__, *stat);
248 return -EINVAL;
249 }
250
251 mutex_lock(&sensor->data_mutex);
252 memcpy(sensor->sensor_data, buffer, sensor->ops->read_len);
253 mutex_unlock(&sensor->data_mutex);
254
255 if ((sensor->pdata->irq_enable) && (sensor->ops->int_status_reg >= 0))
256 value = sensor_read_reg(client, sensor->ops->int_status_reg);
257
258 /* trigger next measurement */
259 ret = sensor_write_reg(client, sensor->ops->ctrl_reg, sensor->ops->ctrl_data);
260 if (ret) {
261 dev_err(&client->dev,
262 "%s: fail to set ctrl_data(%d)\n", __func__, ret);
263 return ret;
264 }
265
266 return ret;
267 }
268
compass_set_YPR(int * rbuf)269 static void compass_set_YPR(int *rbuf)
270 {
271 /* No events are reported */
272 if (!rbuf[0]) {
273 pr_err("%s: Don't waste a time.", __func__);
274 return;
275 }
276
277 g_akm_rbuf_ready = 1;
278 memcpy(g_akm_rbuf, rbuf, 12 * sizeof(int));
279 }
280
compass_dev_open(struct inode * inode,struct file * file)281 static int compass_dev_open(struct inode *inode, struct file *file)
282 {
283 return 0;
284 }
285
compass_dev_release(struct inode * inode,struct file * file)286 static int compass_dev_release(struct inode *inode, struct file *file)
287 {
288 return 0;
289 }
290
compass_akm_set_mode(struct i2c_client * client,char mode)291 static int compass_akm_set_mode(struct i2c_client *client, char mode)
292 {
293 struct sensor_private_data *sensor =
294 (struct sensor_private_data *) i2c_get_clientdata(this_client);
295 int result = 0;
296
297 switch (mode & 0x1f) {
298 case AK09918_MODE_SNG_MEASURE:
299 case AK09918_MODE_SELF_TEST:
300 case AK09918_MODE_FUSE_ACCESS:
301 if (sensor->status_cur == SENSOR_OFF) {
302 sensor->stop_work = 0;
303 sensor->status_cur = SENSOR_ON;
304 dev_info(&client->dev, "compass AK09918 start measure\n");
305 schedule_delayed_work(&sensor->delaywork, 0);
306 }
307 break;
308
309 case AK09918_MODE_POWERDOWN:
310 if (sensor->status_cur == SENSOR_ON) {
311 sensor->stop_work = 1;
312 cancel_delayed_work_sync(&sensor->delaywork);
313 dev_err(&client->dev, "compass AK09918 stop measure\n");
314 g_akm_rbuf_ready = 0;
315 sensor->status_cur = SENSOR_OFF;
316 }
317 break;
318 }
319
320 switch (mode & 0x1f) {
321 case AK09918_MODE_SNG_MEASURE:
322 result = sensor_write_reg(client, sensor->ops->ctrl_reg, AK09918_MODE_SNG_MEASURE);
323 if (result)
324 dev_err(&client->dev,
325 "%s: i2c error,mode = %d \n", __func__, mode);
326 break;
327 case AK09918_MODE_SELF_TEST:
328 result = sensor_write_reg(client, sensor->ops->ctrl_reg, AK09918_MODE_SELF_TEST);
329 if (result)
330 dev_err(&client->dev,
331 "%s: i2c error,mode = %d\n", __func__, mode);
332 break;
333 case AK09918_MODE_FUSE_ACCESS:
334 result = sensor_write_reg(client, sensor->ops->ctrl_reg, AK09918_MODE_FUSE_ACCESS);
335 if (result)
336 dev_err(&client->dev,
337 "%s: i2c error,mode = %d\n", __func__, mode);
338 break;
339 case AK09918_MODE_POWERDOWN:
340 /* Set powerdown mode */
341 result = sensor_write_reg(client, sensor->ops->ctrl_reg, AK09918_MODE_POWERDOWN);
342 if (result)
343 dev_err(&client->dev,
344 "%s: i2c error, mode= %d \n", __func__, mode);
345 udelay(100);
346 break;
347 default:
348 dev_err(&client->dev, "%s: Unknown mode(%d)", __func__, mode);
349 result = -EINVAL;
350 break;
351 }
352 return result;
353 }
354
compass_akm_reset(struct i2c_client * client)355 static int compass_akm_reset(struct i2c_client *client)
356 {
357 struct sensor_private_data *sensor =
358 (struct sensor_private_data *) i2c_get_clientdata(this_client);
359 int result = 0;
360
361 if (sensor->pdata->reset_pin > 0) {
362 gpio_direction_output(sensor->pdata->reset_pin, GPIO_LOW);
363 udelay(10);
364 gpio_direction_output(sensor->pdata->reset_pin, GPIO_HIGH);
365 } else {
366 /* Set measure mode */
367 result = sensor_write_reg(client, sensor->ops->ctrl_reg, AK09918_MODE_SNG_MEASURE);
368 if (result)
369 dev_err(&client->dev,
370 "%s: fail to Set measure mode(%d)\n", __func__, result);
371 }
372
373 udelay(100);
374
375 return result;
376 }
377
compass_akm_get_openstatus(void)378 static int compass_akm_get_openstatus(void)
379 {
380 struct sensor_private_data *sensor =
381 (struct sensor_private_data *) i2c_get_clientdata(this_client);
382
383 wait_event_interruptible(sensor->flags.open_wq, (atomic_read(&sensor->flags.open_flag) != 0));
384
385 return atomic_read(&sensor->flags.open_flag);
386 }
387
compass_akm_get_closestatus(void)388 static int compass_akm_get_closestatus(void)
389 {
390 struct sensor_private_data *sensor =
391 (struct sensor_private_data *) i2c_get_clientdata(this_client);
392
393 wait_event_interruptible(sensor->flags.open_wq, (atomic_read(&sensor->flags.open_flag) <= 0));
394
395 return atomic_read(&sensor->flags.open_flag);
396 }
397
398 /* ioctl - I/O control */
compass_dev_ioctl(struct file * file,unsigned int cmd,unsigned long arg)399 static long compass_dev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
400 {
401 struct sensor_private_data *sensor = (struct sensor_private_data *)i2c_get_clientdata(this_client);
402 struct i2c_client *client = this_client;
403 void __user *argp = (void __user *)arg;
404 int result = 0;
405 struct akm_platform_data compass;
406
407 /* NOTE: In this function the size of "char" should be 1-byte. */
408 char compass_data[SENSOR_DATA_SIZE]; /* for GETDATA */
409 char rwbuf[RWBUF_SIZE]; /* for READ/WRITE */
410 char mode; /* for SET_MODE*/
411 int value[YPR_DATA_SIZE]; /* for SET_YPR */
412 int status; /* for OPEN/CLOSE_STATUS */
413 int ret = -1; /* Return value. */
414
415 int16_t acc_buf[3]; /* for GET_ACCEL */
416 int64_t delay[AKM_NUM_SENSORS]; /* for GET_DELAY */
417 char layout; /* for GET_LAYOUT */
418 char outbit; /* for GET_OUTBIT */
419
420 switch (cmd) {
421 case ECS_IOCTL_WRITE:
422 case ECS_IOCTL_READ:
423 if (!argp)
424 return -EINVAL;
425 if (copy_from_user(&rwbuf, argp, sizeof(rwbuf)))
426 return -EFAULT;
427 break;
428 case ECS_IOCTL_SET_MODE:
429 if (!argp)
430 return -EINVAL;
431 if (copy_from_user(&mode, argp, sizeof(mode)))
432 return -EFAULT;
433 break;
434 case ECS_IOCTL_SET_YPR:
435 if (!argp)
436 return -EINVAL;
437 if (copy_from_user(&value, argp, sizeof(value)))
438 return -EFAULT;
439 break;
440 case ECS_IOCTL_GETDATA:
441 case ECS_IOCTL_GET_OPEN_STATUS:
442 case ECS_IOCTL_GET_CLOSE_STATUS:
443 case ECS_IOCTL_GET_DELAY:
444 case ECS_IOCTL_GET_LAYOUT:
445 case ECS_IOCTL_GET_OUTBIT:
446 case ECS_IOCTL_GET_ACCEL:
447 case ECS_IOCTL_GET_INFO:
448 case ECS_IOCTL_GET_CONF:
449 /* Just check buffer pointer */
450 if (!argp) {
451 dev_err(&client->dev,
452 "%s: invalid argument\n", __func__);
453 return -EINVAL;
454 }
455 break;
456 default:
457 break;
458 }
459
460 switch (cmd) {
461 case ECS_IOCTL_WRITE:
462 mutex_lock(&sensor->operation_mutex);
463 if ((rwbuf[0] < 2) || (rwbuf[0] > (RWBUF_SIZE - 1))) {
464 mutex_unlock(&sensor->operation_mutex);
465 return -EINVAL;
466 }
467 ret = sensor_tx_data(client, &rwbuf[1], rwbuf[0]);
468 if (ret < 0) {
469 mutex_unlock(&sensor->operation_mutex);
470 dev_err(&client->dev,
471 "%s: line = %d, fail to tx data(%d)\n",
472 __func__, __LINE__, ret);
473 return ret;
474 }
475 mutex_unlock(&sensor->operation_mutex);
476 break;
477 case ECS_IOCTL_READ:
478 mutex_lock(&sensor->operation_mutex);
479 if ((rwbuf[0] < 1) || (rwbuf[0] > (RWBUF_SIZE - 1))) {
480 mutex_unlock(&sensor->operation_mutex);
481 dev_err(&client->dev,
482 "%s: data is error\n", __func__);
483 return -EINVAL;
484 }
485 ret = sensor_rx_data(client, &rwbuf[1], rwbuf[0]);
486 if (ret < 0) {
487 mutex_unlock(&sensor->operation_mutex);
488 dev_err(&client->dev,
489 "%s: line = %d, fail to rx data(%d)\n",
490 __func__, __LINE__, ret);
491 return ret;
492 }
493 mutex_unlock(&sensor->operation_mutex);
494 break;
495 case ECS_IOCTL_SET_MODE:
496 mutex_lock(&sensor->operation_mutex);
497 if (sensor->ops->ctrl_data != mode) {
498 ret = compass_akm_set_mode(client, mode);
499 if (ret < 0) {
500 dev_err(&client->dev,
501 "%s: fail to set mode(%d)\n",
502 __func__, ret);
503 mutex_unlock(&sensor->operation_mutex);
504 return ret;
505 }
506
507 sensor->ops->ctrl_data = mode;
508 }
509 mutex_unlock(&sensor->operation_mutex);
510 break;
511 case ECS_IOCTL_GETDATA:
512 mutex_lock(&sensor->data_mutex);
513 memcpy(compass_data, sensor->sensor_data, SENSOR_DATA_SIZE);
514 mutex_unlock(&sensor->data_mutex);
515 break;
516 case ECS_IOCTL_SET_YPR:
517 mutex_lock(&sensor->data_mutex);
518 compass_set_YPR(value);
519 mutex_unlock(&sensor->data_mutex);
520 break;
521 case ECS_IOCTL_GET_OPEN_STATUS:
522 status = compass_akm_get_openstatus();
523 break;
524 case ECS_IOCTL_GET_CLOSE_STATUS:
525 status = compass_akm_get_closestatus();
526 break;
527 case ECS_IOCTL_GET_DELAY:
528 mutex_lock(&sensor->operation_mutex);
529 delay[0] = sensor->flags.delay;
530 delay[1] = sensor->flags.delay;
531 delay[2] = sensor->flags.delay;
532 mutex_unlock(&sensor->operation_mutex);
533 break;
534
535 case ECS_IOCTL_GET_PLATFORM_DATA:
536 ret = copy_to_user(argp, &compass, sizeof(compass));
537 if (ret < 0) {
538 dev_err(&client->dev, "%s: line = %d, ret = %d\n",
539 __func__, __LINE__, ret);
540 return ret;
541 }
542 break;
543 case ECS_IOCTL_GET_LAYOUT:
544 if ((sensor->pdata->layout >= 1) && (sensor->pdata->layout <= 8))
545 layout = sensor->pdata->layout;
546 else
547 layout = 1;
548 break;
549 case ECS_IOCTL_GET_OUTBIT:
550 outbit = 1;
551 break;
552 case ECS_IOCTL_RESET:
553 ret = compass_akm_reset(client);
554 if (ret < 0)
555 return ret;
556 break;
557 case ECS_IOCTL_GET_ACCEL:
558 break;
559 case ECS_IOCTL_GET_INFO:
560 ret = copy_to_user(argp, g_sensor_info, sizeof(g_sensor_info));
561 if (ret < 0) {
562 dev_err(&client->dev, "%s: line = %d, ret = %d\n",
563 __func__, __LINE__, ret);
564 return ret;
565 }
566 break;
567 case ECS_IOCTL_GET_CONF:
568 ret = copy_to_user(argp, g_sensor_conf, sizeof(g_sensor_conf));
569 if (ret < 0) {
570 dev_err(&client->dev, "%s: line = %d, ret = %d\n",
571 __func__, __LINE__, ret);
572 return ret;
573 }
574 break;
575
576 default:
577 return -ENOTTY;
578 }
579
580 switch (cmd) {
581 case ECS_IOCTL_READ:
582 if (copy_to_user(argp, &rwbuf, rwbuf[0] + 1))
583 return -EFAULT;
584 break;
585 case ECS_IOCTL_GETDATA:
586 if (copy_to_user(argp, &compass_data, sizeof(compass_data)))
587 return -EFAULT;
588 break;
589 case ECS_IOCTL_GET_OPEN_STATUS:
590 case ECS_IOCTL_GET_CLOSE_STATUS:
591 if (copy_to_user(argp, &status, sizeof(status)))
592 return -EFAULT;
593 break;
594 case ECS_IOCTL_GET_DELAY:
595 if (copy_to_user(argp, &delay, sizeof(delay)))
596 return -EFAULT;
597 break;
598 case ECS_IOCTL_GET_LAYOUT:
599 if (copy_to_user(argp, &layout, sizeof(layout))) {
600 dev_err(&client->dev, "%s: line = %d, ret = %d\n",
601 __func__, __LINE__, ret);
602 return -EFAULT;
603 }
604 break;
605 case ECS_IOCTL_GET_OUTBIT:
606 if (copy_to_user(argp, &outbit, sizeof(outbit))) {
607 dev_err(&client->dev, "%s: line = %d, ret = %d\n",
608 __func__, __LINE__, ret);
609 return -EFAULT;
610 }
611 break;
612 case ECS_IOCTL_GET_ACCEL:
613 if (copy_to_user(argp, &acc_buf, sizeof(acc_buf))) {
614 dev_err(&client->dev, "%s: line = %d, ret = %d\n",
615 __func__, __LINE__, ret);
616 return -EFAULT;
617 }
618 break;
619 default:
620 break;
621 }
622
623 return result;
624 }
625
626 static const struct file_operations compass_dev_fops = {
627 .owner = THIS_MODULE,
628 .open = compass_dev_open,
629 .release = compass_dev_release,
630 .unlocked_ioctl = compass_dev_ioctl,
631 };
632
633 static struct miscdevice compass_dev_device = {
634 .minor = MISC_DYNAMIC_MINOR,
635 .name = "akm8963_dev",
636 .fops = &compass_dev_fops,
637 };
638
639 static struct sensor_operate compass_akm09918_ops = {
640 .name = "akm09918",
641 .type = SENSOR_TYPE_COMPASS,
642 .id_i2c = COMPASS_ID_AK09918,
643 .read_reg = AK09918_REG_ST1,
644 .read_len = SENSOR_DATA_SIZE,
645 .id_reg = AK09918_REG_WIA2,
646 .id_data = AK09918_DEVICE_ID,
647 .precision = 8,
648 .ctrl_reg = AK09918_REG_CNTL2,
649 .int_status_reg = SENSOR_UNKNOW_DATA,
650 .range = {-0xffff, 0xffff},
651 .trig = IRQF_TRIGGER_RISING,
652 .active = sensor_active,
653 .init = sensor_init,
654 .report = sensor_report_value,
655 .misc_dev = NULL,
656 };
657
658 /****************operate according to sensor chip:end************/
compass_akm09918_probe(struct i2c_client * client,const struct i2c_device_id * devid)659 static int compass_akm09918_probe(struct i2c_client *client,
660 const struct i2c_device_id *devid)
661 {
662 return sensor_register_device(client, NULL, devid, &compass_akm09918_ops);
663 }
664
compass_akm09918_remove(struct i2c_client * client)665 static int compass_akm09918_remove(struct i2c_client *client)
666 {
667 return sensor_unregister_device(client, NULL, &compass_akm09918_ops);
668 }
669
670 static const struct i2c_device_id compass_akm09918_id[] = {
671 {"ak09918", COMPASS_ID_AK09918},
672 {}
673 };
674
675 static struct i2c_driver compass_akm09918_driver = {
676 .probe = compass_akm09918_probe,
677 .remove = compass_akm09918_remove,
678 .shutdown = sensor_shutdown,
679 .id_table = compass_akm09918_id,
680 .driver = {
681 .name = "compass_akm09918",
682 #ifdef CONFIG_PM
683 .pm = &sensor_pm_ops,
684 #endif
685 },
686 };
687
688 module_i2c_driver(compass_akm09918_driver);
689
690 MODULE_AUTHOR("Wang Jie <dave.wang@rock-chips.com>");
691 MODULE_DESCRIPTION("akm09918 3-Axis compasss driver");
692 MODULE_LICENSE("GPL");
693