GNU Linux-libre 4.9.328-gnu1
[releases.git] / drivers / platform / x86 / dell-smo8800.c
1 /*
2  *  dell-smo8800.c - Dell Latitude ACPI SMO88XX freefall sensor driver
3  *
4  *  Copyright (C) 2012 Sonal Santan <sonal.santan@gmail.com>
5  *  Copyright (C) 2014 Pali Rohár <pali.rohar@gmail.com>
6  *
7  *  This is loosely based on lis3lv02d driver.
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; either version 2 of the License, or
12  *  (at your option) any later version.
13  *
14  *  This program is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *  GNU General Public License for more details.
18  */
19
20 #define DRIVER_NAME "smo8800"
21
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/acpi.h>
25 #include <linux/interrupt.h>
26 #include <linux/miscdevice.h>
27 #include <linux/uaccess.h>
28
29 struct smo8800_device {
30         u32 irq;                     /* acpi device irq */
31         atomic_t counter;            /* count after last read */
32         struct miscdevice miscdev;   /* for /dev/freefall */
33         unsigned long misc_opened;   /* whether the device is open */
34         wait_queue_head_t misc_wait; /* Wait queue for the misc dev */
35         struct device *dev;          /* acpi device */
36 };
37
38 static irqreturn_t smo8800_interrupt_quick(int irq, void *data)
39 {
40         struct smo8800_device *smo8800 = data;
41
42         atomic_inc(&smo8800->counter);
43         wake_up_interruptible(&smo8800->misc_wait);
44         return IRQ_WAKE_THREAD;
45 }
46
47 static irqreturn_t smo8800_interrupt_thread(int irq, void *data)
48 {
49         struct smo8800_device *smo8800 = data;
50
51         dev_info(smo8800->dev, "detected free fall\n");
52         return IRQ_HANDLED;
53 }
54
55 static acpi_status smo8800_get_resource(struct acpi_resource *resource,
56                                         void *context)
57 {
58         struct acpi_resource_extended_irq *irq;
59
60         if (resource->type != ACPI_RESOURCE_TYPE_EXTENDED_IRQ)
61                 return AE_OK;
62
63         irq = &resource->data.extended_irq;
64         if (!irq || !irq->interrupt_count)
65                 return AE_OK;
66
67         *((u32 *)context) = irq->interrupts[0];
68         return AE_CTRL_TERMINATE;
69 }
70
71 static u32 smo8800_get_irq(struct acpi_device *device)
72 {
73         u32 irq = 0;
74         acpi_status status;
75
76         status = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
77                                      smo8800_get_resource, &irq);
78         if (ACPI_FAILURE(status)) {
79                 dev_err(&device->dev, "acpi_walk_resources failed\n");
80                 return 0;
81         }
82
83         return irq;
84 }
85
86 static ssize_t smo8800_misc_read(struct file *file, char __user *buf,
87                                  size_t count, loff_t *pos)
88 {
89         struct smo8800_device *smo8800 = container_of(file->private_data,
90                                          struct smo8800_device, miscdev);
91
92         u32 data = 0;
93         unsigned char byte_data = 0;
94         ssize_t retval = 1;
95
96         if (count < 1)
97                 return -EINVAL;
98
99         atomic_set(&smo8800->counter, 0);
100         retval = wait_event_interruptible(smo8800->misc_wait,
101                                 (data = atomic_xchg(&smo8800->counter, 0)));
102
103         if (retval)
104                 return retval;
105
106         byte_data = 1;
107         retval = 1;
108
109         if (data < 255)
110                 byte_data = data;
111         else
112                 byte_data = 255;
113
114         if (put_user(byte_data, buf))
115                 retval = -EFAULT;
116
117         return retval;
118 }
119
120 static int smo8800_misc_open(struct inode *inode, struct file *file)
121 {
122         struct smo8800_device *smo8800 = container_of(file->private_data,
123                                          struct smo8800_device, miscdev);
124
125         if (test_and_set_bit(0, &smo8800->misc_opened))
126                 return -EBUSY; /* already open */
127
128         atomic_set(&smo8800->counter, 0);
129         return 0;
130 }
131
132 static int smo8800_misc_release(struct inode *inode, struct file *file)
133 {
134         struct smo8800_device *smo8800 = container_of(file->private_data,
135                                          struct smo8800_device, miscdev);
136
137         clear_bit(0, &smo8800->misc_opened); /* release the device */
138         return 0;
139 }
140
141 static const struct file_operations smo8800_misc_fops = {
142         .owner = THIS_MODULE,
143         .read = smo8800_misc_read,
144         .open = smo8800_misc_open,
145         .release = smo8800_misc_release,
146 };
147
148 static int smo8800_add(struct acpi_device *device)
149 {
150         int err;
151         struct smo8800_device *smo8800;
152
153         smo8800 = devm_kzalloc(&device->dev, sizeof(*smo8800), GFP_KERNEL);
154         if (!smo8800) {
155                 dev_err(&device->dev, "failed to allocate device data\n");
156                 return -ENOMEM;
157         }
158
159         smo8800->dev = &device->dev;
160         smo8800->miscdev.minor = MISC_DYNAMIC_MINOR;
161         smo8800->miscdev.name = "freefall";
162         smo8800->miscdev.fops = &smo8800_misc_fops;
163
164         init_waitqueue_head(&smo8800->misc_wait);
165
166         err = misc_register(&smo8800->miscdev);
167         if (err) {
168                 dev_err(&device->dev, "failed to register misc dev: %d\n", err);
169                 return err;
170         }
171
172         device->driver_data = smo8800;
173
174         smo8800->irq = smo8800_get_irq(device);
175         if (!smo8800->irq) {
176                 dev_err(&device->dev, "failed to obtain IRQ\n");
177                 err = -EINVAL;
178                 goto error;
179         }
180
181         err = request_threaded_irq(smo8800->irq, smo8800_interrupt_quick,
182                                    smo8800_interrupt_thread,
183                                    IRQF_TRIGGER_RISING | IRQF_ONESHOT,
184                                    DRIVER_NAME, smo8800);
185         if (err) {
186                 dev_err(&device->dev,
187                         "failed to request thread for IRQ %d: %d\n",
188                         smo8800->irq, err);
189                 goto error;
190         }
191
192         dev_dbg(&device->dev, "device /dev/freefall registered with IRQ %d\n",
193                  smo8800->irq);
194         return 0;
195
196 error:
197         misc_deregister(&smo8800->miscdev);
198         return err;
199 }
200
201 static int smo8800_remove(struct acpi_device *device)
202 {
203         struct smo8800_device *smo8800 = device->driver_data;
204
205         free_irq(smo8800->irq, smo8800);
206         misc_deregister(&smo8800->miscdev);
207         dev_dbg(&device->dev, "device /dev/freefall unregistered\n");
208         return 0;
209 }
210
211 static const struct acpi_device_id smo8800_ids[] = {
212         { "SMO8800", 0 },
213         { "SMO8801", 0 },
214         { "SMO8810", 0 },
215         { "SMO8811", 0 },
216         { "SMO8820", 0 },
217         { "SMO8821", 0 },
218         { "SMO8830", 0 },
219         { "SMO8831", 0 },
220         { "", 0 },
221 };
222
223 MODULE_DEVICE_TABLE(acpi, smo8800_ids);
224
225 static struct acpi_driver smo8800_driver = {
226         .name = DRIVER_NAME,
227         .class = "Latitude",
228         .ids = smo8800_ids,
229         .ops = {
230                 .add = smo8800_add,
231                 .remove = smo8800_remove,
232         },
233         .owner = THIS_MODULE,
234 };
235
236 module_acpi_driver(smo8800_driver);
237
238 MODULE_DESCRIPTION("Dell Latitude freefall driver (ACPI SMO88XX)");
239 MODULE_LICENSE("GPL");
240 MODULE_AUTHOR("Sonal Santan, Pali Rohár");