drivers: misc: therm_est: Add of_match_table
[linux-2.6.git] / drivers / misc / akm8975.c
1 /* drivers/misc/akm8975.c - akm8975 compass driver
2  *
3  * Copyright (C) 2007-2008 HTC Corporation.
4  * Author: Hou-Kun Chen <houkun.chen@gmail.com>
5  *
6  * This software is licensed under the terms of the GNU General Public
7  * License version 2, as published by the Free Software Foundation, and
8  * may be copied, distributed, and modified under those terms.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  */
16
17 /*
18  * Revised by AKM 2009/04/02
19  * Revised by Motorola 2010/05/27
20  *
21  */
22
23 #include <linux/interrupt.h>
24 #include <linux/i2c.h>
25 #include <linux/slab.h>
26 #include <linux/irq.h>
27 #include <linux/miscdevice.h>
28 #include <linux/gpio.h>
29 #include <linux/uaccess.h>
30 #include <linux/delay.h>
31 #include <linux/input.h>
32 #include <linux/workqueue.h>
33 #include <linux/freezer.h>
34 #include <linux/akm8975.h>
35 #include <linux/earlysuspend.h>
36
37 #define AK8975DRV_CALL_DBG 0
38 #if AK8975DRV_CALL_DBG
39 #define FUNCDBG(msg)    pr_err("%s:%s\n", __func__, msg);
40 #else
41 #define FUNCDBG(msg)
42 #endif
43
44 #define AK8975DRV_DATA_DBG 0
45 #define MAX_FAILURE_COUNT 10
46
47 struct akm8975_data {
48         struct i2c_client *this_client;
49         struct akm8975_platform_data *pdata;
50         struct input_dev *input_dev;
51         struct work_struct work;
52         struct mutex flags_lock;
53 };
54
55 /*
56 * Because misc devices can not carry a pointer from driver register to
57 * open, we keep this global. This limits the driver to a single instance.
58 */
59 struct akm8975_data *akmd_data;
60
61 static DECLARE_WAIT_QUEUE_HEAD(open_wq);
62
63 static atomic_t open_flag;
64
65 static short m_flag;
66 static short a_flag;
67 static short t_flag;
68 static short mv_flag;
69
70 static short akmd_delay;
71
72 static ssize_t akm8975_show(struct device *dev, struct device_attribute *attr,
73                                  char *buf)
74 {
75         struct i2c_client *client = to_i2c_client(dev);
76         return sprintf(buf, "%u\n", i2c_smbus_read_byte_data(client,
77                                                              AK8975_REG_CNTL));
78 }
79 static ssize_t akm8975_store(struct device *dev, struct device_attribute *attr,
80                             const char *buf, size_t count)
81 {
82         struct i2c_client *client = to_i2c_client(dev);
83         unsigned long val;
84         strict_strtoul(buf, 10, &val);
85         if (val > 0xff)
86                 return -EINVAL;
87         i2c_smbus_write_byte_data(client, AK8975_REG_CNTL, val);
88         return count;
89 }
90 static DEVICE_ATTR(akm_ms1, S_IWUSR | S_IRUGO, akm8975_show, akm8975_store);
91
92 static int akm8975_i2c_rxdata(struct akm8975_data *akm, char *buf, int length)
93 {
94         struct i2c_msg msgs[] = {
95                 {
96                         .addr = akm->this_client->addr,
97                         .flags = 0,
98                         .len = 1,
99                         .buf = buf,
100                 },
101                 {
102                         .addr = akm->this_client->addr,
103                         .flags = I2C_M_RD,
104                         .len = length,
105                         .buf = buf,
106                 },
107         };
108
109         FUNCDBG("called");
110
111         if (i2c_transfer(akm->this_client->adapter, msgs, 2) < 0) {
112                 pr_err("akm8975_i2c_rxdata: transfer error\n");
113                 return EIO;
114         } else
115                 return 0;
116 }
117
118 static int akm8975_i2c_txdata(struct akm8975_data *akm, char *buf, int length)
119 {
120         struct i2c_msg msgs[] = {
121                 {
122                         .addr = akm->this_client->addr,
123                         .flags = 0,
124                         .len = length,
125                         .buf = buf,
126                 },
127         };
128
129         FUNCDBG("called");
130
131         if (i2c_transfer(akm->this_client->adapter, msgs, 1) < 0) {
132                 pr_err("akm8975_i2c_txdata: transfer error\n");
133                 return -EIO;
134         } else
135                 return 0;
136 }
137
138 static void akm8975_ecs_report_value(struct akm8975_data *akm, short *rbuf)
139 {
140         struct akm8975_data *data = i2c_get_clientdata(akm->this_client);
141
142         FUNCDBG("called");
143
144 #if AK8975DRV_DATA_DBG
145         pr_info("akm8975_ecs_report_value: yaw = %d, pitch = %d, roll = %d\n",
146                                  rbuf[0], rbuf[1], rbuf[2]);
147         pr_info("tmp = %d, m_stat= %d, g_stat=%d\n", rbuf[3], rbuf[4], rbuf[5]);
148         pr_info("Acceleration:   x = %d LSB, y = %d LSB, z = %d LSB\n",
149                                  rbuf[6], rbuf[7], rbuf[8]);
150         pr_info("Magnetic:       x = %d LSB, y = %d LSB, z = %d LSB\n\n",
151                                  rbuf[9], rbuf[10], rbuf[11]);
152 #endif
153         mutex_lock(&akm->flags_lock);
154         /* Report magnetic sensor information */
155         if (m_flag) {
156                 input_report_abs(data->input_dev, ABS_RX, rbuf[0]);
157                 input_report_abs(data->input_dev, ABS_RY, rbuf[1]);
158                 input_report_abs(data->input_dev, ABS_RZ, rbuf[2]);
159                 input_report_abs(data->input_dev, ABS_RUDDER, rbuf[4]);
160         }
161
162         /* Report acceleration sensor information */
163         if (a_flag) {
164                 input_report_abs(data->input_dev, ABS_X, rbuf[6]);
165                 input_report_abs(data->input_dev, ABS_Y, rbuf[7]);
166                 input_report_abs(data->input_dev, ABS_Z, rbuf[8]);
167                 input_report_abs(data->input_dev, ABS_WHEEL, rbuf[5]);
168         }
169
170         /* Report temperature information */
171         if (t_flag)
172                 input_report_abs(data->input_dev, ABS_THROTTLE, rbuf[3]);
173
174         if (mv_flag) {
175                 input_report_abs(data->input_dev, ABS_HAT0X, rbuf[9]);
176                 input_report_abs(data->input_dev, ABS_HAT0Y, rbuf[10]);
177                 input_report_abs(data->input_dev, ABS_BRAKE, rbuf[11]);
178         }
179         mutex_unlock(&akm->flags_lock);
180
181         input_sync(data->input_dev);
182 }
183
184 static void akm8975_ecs_close_done(struct akm8975_data *akm)
185 {
186         FUNCDBG("called");
187         mutex_lock(&akm->flags_lock);
188         m_flag = 1;
189         a_flag = 1;
190         t_flag = 1;
191         mv_flag = 1;
192         mutex_unlock(&akm->flags_lock);
193 }
194
195 static int akm_aot_open(struct inode *inode, struct file *file)
196 {
197         int ret = -1;
198
199         FUNCDBG("called");
200         if (atomic_cmpxchg(&open_flag, 0, 1) == 0) {
201                 wake_up(&open_wq);
202                 ret = 0;
203         }
204
205         ret = nonseekable_open(inode, file);
206         if (ret)
207                 return ret;
208
209         file->private_data = akmd_data;
210
211         return ret;
212 }
213
214 static int akm_aot_release(struct inode *inode, struct file *file)
215 {
216         FUNCDBG("called");
217         atomic_set(&open_flag, 0);
218         wake_up(&open_wq);
219         return 0;
220 }
221
222 static int akm_aot_ioctl(struct inode *inode, struct file *file,
223               unsigned int cmd, unsigned long arg)
224 {
225         void __user *argp = (void __user *) arg;
226         short flag;
227         struct akm8975_data *akm = file->private_data;
228
229         FUNCDBG("called");
230
231         switch (cmd) {
232         case ECS_IOCTL_APP_SET_MFLAG:
233         case ECS_IOCTL_APP_SET_AFLAG:
234         case ECS_IOCTL_APP_SET_MVFLAG:
235                 if (copy_from_user(&flag, argp, sizeof(flag)))
236                         return -EFAULT;
237                 if (flag < 0 || flag > 1)
238                         return -EINVAL;
239                 break;
240         case ECS_IOCTL_APP_SET_DELAY:
241                 if (copy_from_user(&flag, argp, sizeof(flag)))
242                         return -EFAULT;
243                 break;
244         default:
245                 break;
246         }
247
248         mutex_lock(&akm->flags_lock);
249         switch (cmd) {
250         case ECS_IOCTL_APP_SET_MFLAG:
251           m_flag = flag;
252                 break;
253         case ECS_IOCTL_APP_GET_MFLAG:
254                 flag = m_flag;
255                 break;
256         case ECS_IOCTL_APP_SET_AFLAG:
257                 a_flag = flag;
258                 break;
259         case ECS_IOCTL_APP_GET_AFLAG:
260                 flag = a_flag;
261                 break;
262         case ECS_IOCTL_APP_SET_MVFLAG:
263                 mv_flag = flag;
264                 break;
265         case ECS_IOCTL_APP_GET_MVFLAG:
266                 flag = mv_flag;
267                 break;
268         case ECS_IOCTL_APP_SET_DELAY:
269                 akmd_delay = flag;
270                 break;
271         case ECS_IOCTL_APP_GET_DELAY:
272                 flag = akmd_delay;
273                 break;
274         default:
275                 return -ENOTTY;
276         }
277         mutex_unlock(&akm->flags_lock);
278
279         switch (cmd) {
280         case ECS_IOCTL_APP_GET_MFLAG:
281         case ECS_IOCTL_APP_GET_AFLAG:
282         case ECS_IOCTL_APP_GET_MVFLAG:
283         case ECS_IOCTL_APP_GET_DELAY:
284                 if (copy_to_user(argp, &flag, sizeof(flag)))
285                         return -EFAULT;
286                 break;
287         default:
288                 break;
289         }
290
291         return 0;
292 }
293
294 static int akmd_open(struct inode *inode, struct file *file)
295 {
296         int err = 0;
297
298         FUNCDBG("called");
299         err = nonseekable_open(inode, file);
300         if (err)
301                 return err;
302
303         file->private_data = akmd_data;
304         return 0;
305 }
306
307 static int akmd_release(struct inode *inode, struct file *file)
308 {
309         struct akm8975_data *akm = file->private_data;
310
311         FUNCDBG("called");
312         akm8975_ecs_close_done(akm);
313         return 0;
314 }
315
316 static int akmd_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
317                       unsigned long arg)
318 {
319         void __user *argp = (void __user *) arg;
320
321         char rwbuf[16];
322         int ret = -1;
323         int status;
324         short value[12];
325         short delay;
326         struct akm8975_data *akm = file->private_data;
327
328         FUNCDBG("called");
329
330         switch (cmd) {
331         case ECS_IOCTL_READ:
332         case ECS_IOCTL_WRITE:
333                 if (copy_from_user(&rwbuf, argp, sizeof(rwbuf)))
334                         return -EFAULT;
335                 break;
336
337         case ECS_IOCTL_SET_YPR:
338                 if (copy_from_user(&value, argp, sizeof(value)))
339                         return -EFAULT;
340                 break;
341
342         default:
343                 break;
344         }
345
346         switch (cmd) {
347         case ECS_IOCTL_READ:
348                 if (rwbuf[0] < 1)
349                         return -EINVAL;
350
351                 ret = akm8975_i2c_rxdata(akm, &rwbuf[1], rwbuf[0]);
352                 if (ret < 0)
353                         return ret;
354                 break;
355
356         case ECS_IOCTL_WRITE:
357                 if (rwbuf[0] < 2)
358                         return -EINVAL;
359
360                 ret = akm8975_i2c_txdata(akm, &rwbuf[1], rwbuf[0]);
361                 if (ret < 0)
362                         return ret;
363                 break;
364         case ECS_IOCTL_SET_YPR:
365                 akm8975_ecs_report_value(akm, value);
366                 break;
367
368         case ECS_IOCTL_GET_OPEN_STATUS:
369                 wait_event_interruptible(open_wq,
370                                          (atomic_read(&open_flag) != 0));
371                 status = atomic_read(&open_flag);
372                 break;
373         case ECS_IOCTL_GET_CLOSE_STATUS:
374                 wait_event_interruptible(open_wq,
375                                          (atomic_read(&open_flag) == 0));
376                 status = atomic_read(&open_flag);
377                 break;
378
379         case ECS_IOCTL_GET_DELAY:
380                 delay = akmd_delay;
381                 break;
382
383         default:
384                 FUNCDBG("Unknown cmd\n");
385                 return -ENOTTY;
386         }
387
388         switch (cmd) {
389         case ECS_IOCTL_READ:
390                 if (copy_to_user(argp, &rwbuf, sizeof(rwbuf)))
391                         return -EFAULT;
392                 break;
393         case ECS_IOCTL_GET_OPEN_STATUS:
394         case ECS_IOCTL_GET_CLOSE_STATUS:
395                 if (copy_to_user(argp, &status, sizeof(status)))
396                         return -EFAULT;
397                 break;
398         case ECS_IOCTL_GET_DELAY:
399                 if (copy_to_user(argp, &delay, sizeof(delay)))
400                         return -EFAULT;
401                 break;
402         default:
403                 break;
404         }
405
406         return 0;
407 }
408
409 /* needed to clear the int. pin */
410 static void akm_work_func(struct work_struct *work)
411 {
412         struct akm8975_data *akm =
413             container_of(work, struct akm8975_data, work);
414
415         FUNCDBG("called");
416         enable_irq(akm->this_client->irq);
417 }
418
419 static irqreturn_t akm8975_interrupt(int irq, void *dev_id)
420 {
421         struct akm8975_data *akm = dev_id;
422         FUNCDBG("called");
423
424         disable_irq_nosync(akm->this_client->irq);
425         schedule_work(&akm->work);
426         return IRQ_HANDLED;
427 }
428
429 static int akm8975_power_off(struct akm8975_data *akm)
430 {
431 #if AK8975DRV_CALL_DBG
432         pr_info("%s\n", __func__);
433 #endif
434         if (akm->pdata->power_off)
435                 akm->pdata->power_off();
436
437         return 0;
438 }
439
440 static int akm8975_power_on(struct akm8975_data *akm)
441 {
442         int err;
443
444 #if AK8975DRV_CALL_DBG
445         pr_info("%s\n", __func__);
446 #endif
447         if (akm->pdata->power_on) {
448                 err = akm->pdata->power_on();
449                 if (err < 0)
450                         return err;
451         }
452         return 0;
453 }
454
455 #ifdef CONFIG_PM
456 static int akm8975_suspend(struct i2c_client *client, pm_message_t mesg)
457 {
458         struct akm8975_data *akm = i2c_get_clientdata(client);
459
460 #if AK8975DRV_CALL_DBG
461         pr_info("%s\n", __func__);
462 #endif
463         /* TO DO: might need more work after power mgmt
464            is enabled */
465         return akm8975_power_off(akm);
466 }
467
468 static int akm8975_resume(struct i2c_client *client)
469 {
470         struct akm8975_data *akm = i2c_get_clientdata(client);
471
472 #if AK8975DRV_CALL_DBG
473         pr_info("%s\n", __func__);
474 #endif
475         /* TO DO: might need more work after power mgmt
476            is enabled */
477         return akm8975_power_on(akm);
478 }
479 #endif
480
481 static int akm8975_init_client(struct i2c_client *client)
482 {
483         struct akm8975_data *data;
484         int ret;
485
486         data = i2c_get_clientdata(client);
487
488         ret = request_irq(client->irq, akm8975_interrupt, IRQF_TRIGGER_RISING,
489                                 "akm8975", data);
490
491         if (ret < 0) {
492                 pr_err("akm8975_init_client: request irq failed\n");
493                 goto err;
494         }
495
496         init_waitqueue_head(&open_wq);
497
498         mutex_lock(&data->flags_lock);
499         m_flag = 1;
500         a_flag = 1;
501         t_flag = 1;
502         mv_flag = 1;
503         mutex_unlock(&data->flags_lock);
504
505         return 0;
506 err:
507   return ret;
508 }
509
510 static const struct file_operations akmd_fops = {
511         .owner = THIS_MODULE,
512         .open = akmd_open,
513         .release = akmd_release,
514         .unlocked_ioctl = akmd_ioctl,
515 };
516
517 static const struct file_operations akm_aot_fops = {
518         .owner = THIS_MODULE,
519         .open = akm_aot_open,
520         .release = akm_aot_release,
521         .unlocked_ioctl = akm_aot_ioctl,
522 };
523
524 static struct miscdevice akm_aot_device = {
525         .minor = MISC_DYNAMIC_MINOR,
526         .name = "akm8975_aot",
527         .fops = &akm_aot_fops,
528 };
529
530 static struct miscdevice akmd_device = {
531         .minor = MISC_DYNAMIC_MINOR,
532         .name = "akm8975_dev",
533         .fops = &akmd_fops,
534 };
535
536 int akm8975_probe(struct i2c_client *client,
537                   const struct i2c_device_id *devid)
538 {
539         struct akm8975_data *akm;
540         int err;
541         FUNCDBG("called");
542
543         if (client->dev.platform_data == NULL) {
544                 dev_err(&client->dev, "platform data is NULL. exiting.\n");
545                 err = -ENODEV;
546                 goto exit_platform_data_null;
547         }
548
549         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
550                 dev_err(&client->dev, "platform data is NULL. exiting.\n");
551                 err = -ENODEV;
552                 goto exit_check_functionality_failed;
553         }
554
555         akm = kzalloc(sizeof(struct akm8975_data), GFP_KERNEL);
556         if (!akm) {
557                 dev_err(&client->dev,
558                         "failed to allocate memory for module data\n");
559                 err = -ENOMEM;
560                 goto exit_alloc_data_failed;
561         }
562
563         akm->pdata = client->dev.platform_data;
564
565         mutex_init(&akm->flags_lock);
566         INIT_WORK(&akm->work, akm_work_func);
567         i2c_set_clientdata(client, akm);
568
569         err = akm8975_power_on(akm);
570         if (err < 0)
571                 goto exit_power_on_failed;
572
573         akm8975_init_client(client);
574         akm->this_client = client;
575         akmd_data = akm;
576
577         akm->input_dev = input_allocate_device();
578         if (!akm->input_dev) {
579                 err = -ENOMEM;
580                 dev_err(&akm->this_client->dev,
581                         "input device allocate failed\n");
582                 goto exit_input_dev_alloc_failed;
583         }
584
585         set_bit(EV_ABS, akm->input_dev->evbit);
586
587         /* yaw */
588         input_set_abs_params(akm->input_dev, ABS_RX, 0, 23040, 0, 0);
589         /* pitch */
590         input_set_abs_params(akm->input_dev, ABS_RY, -11520, 11520, 0, 0);
591         /* roll */
592         input_set_abs_params(akm->input_dev, ABS_RZ, -5760, 5760, 0, 0);
593         /* x-axis acceleration */
594         input_set_abs_params(akm->input_dev, ABS_X, -5760, 5760, 0, 0);
595         /* y-axis acceleration */
596         input_set_abs_params(akm->input_dev, ABS_Y, -5760, 5760, 0, 0);
597         /* z-axis acceleration */
598         input_set_abs_params(akm->input_dev, ABS_Z, -5760, 5760, 0, 0);
599         /* temparature */
600         input_set_abs_params(akm->input_dev, ABS_THROTTLE, -30, 85, 0, 0);
601         /* status of magnetic sensor */
602         input_set_abs_params(akm->input_dev, ABS_RUDDER, 0, 3, 0, 0);
603         /* status of acceleration sensor */
604         input_set_abs_params(akm->input_dev, ABS_WHEEL, 0, 3, 0, 0);
605         /* x-axis of raw magnetic vector */
606         input_set_abs_params(akm->input_dev, ABS_HAT0X, -20480, 20479, 0, 0);
607         /* y-axis of raw magnetic vector */
608         input_set_abs_params(akm->input_dev, ABS_HAT0Y, -20480, 20479, 0, 0);
609         /* z-axis of raw magnetic vector */
610         input_set_abs_params(akm->input_dev, ABS_BRAKE, -20480, 20479, 0, 0);
611
612         akm->input_dev->name = "compass";
613
614         err = input_register_device(akm->input_dev);
615         if (err) {
616                 pr_err("akm8975_probe: Unable to register input device: %s\n",
617                                          akm->input_dev->name);
618                 goto exit_input_register_device_failed;
619         }
620
621         err = misc_register(&akmd_device);
622         if (err) {
623                 pr_err("akm8975_probe: akmd_device register failed\n");
624                 goto exit_misc_device_register_failed;
625         }
626
627         err = misc_register(&akm_aot_device);
628         if (err) {
629                 pr_err("akm8975_probe: akm_aot_device register failed\n");
630                 goto exit_misc_device_register_failed;
631         }
632
633         err = device_create_file(&client->dev, &dev_attr_akm_ms1);
634
635         return 0;
636
637 exit_misc_device_register_failed:
638 exit_input_register_device_failed:
639         input_free_device(akm->input_dev);
640 exit_input_dev_alloc_failed:
641         akm8975_power_off(akm);
642 exit_power_on_failed:
643         kfree(akm);
644 exit_alloc_data_failed:
645 exit_check_functionality_failed:
646 exit_platform_data_null:
647         return err;
648 }
649
650 static int __devexit akm8975_remove(struct i2c_client *client)
651 {
652         struct akm8975_data *akm = i2c_get_clientdata(client);
653         FUNCDBG("called");
654         free_irq(client->irq, NULL);
655         input_unregister_device(akm->input_dev);
656         misc_deregister(&akmd_device);
657         misc_deregister(&akm_aot_device);
658         akm8975_power_off(akm);
659         kfree(akm);
660         return 0;
661 }
662
663 static const struct i2c_device_id akm8975_id[] = {
664         { "akm8975", 0 },
665         { }
666 };
667
668 MODULE_DEVICE_TABLE(i2c, akm8975_id);
669
670 static struct i2c_driver akm8975_driver = {
671         .probe = akm8975_probe,
672         .remove = akm8975_remove,
673 #ifdef CONFIG_PM
674         .resume = akm8975_resume,
675         .suspend = akm8975_suspend,
676 #endif
677         .id_table = akm8975_id,
678         .driver = {
679                 .name = "akm8975",
680         },
681 };
682
683 static int __init akm8975_init(void)
684 {
685         pr_info("AK8975 compass driver: init\n");
686         FUNCDBG("AK8975 compass driver: init\n");
687         return i2c_add_driver(&akm8975_driver);
688 }
689
690 static void __exit akm8975_exit(void)
691 {
692         FUNCDBG("AK8975 compass driver: exit\n");
693         i2c_del_driver(&akm8975_driver);
694 }
695
696 module_init(akm8975_init);
697 module_exit(akm8975_exit);
698
699 MODULE_AUTHOR("Hou-Kun Chen <hk_chen@htc.com>");
700 MODULE_DESCRIPTION("AK8975 compass driver");
701 MODULE_LICENSE("GPL");