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;
  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         retval = 1;
 107
 108         if (data < 255)
 109                 byte_data = data;
 110         else
 111                 byte_data = 255;
 112
 113         if (put_user(byte_data, buf))
 114                 retval = -EFAULT;
 115
 116         return retval;
 117 }
 118
 119 static int smo8800_misc_open(struct inode *inode, struct file *file)
 120 {
 121         struct smo8800_device *smo8800 = container_of(file->private_data,
 122                                          struct smo8800_device, miscdev);
 123
 124         if (test_and_set_bit(0, &smo8800->misc_opened))
 125                 return -EBUSY; /* already open */
 126
 127         atomic_set(&smo8800->counter, 0);
 128         return 0;
 129 }
 130
 131 static int smo8800_misc_release(struct inode *inode, struct file *file)
 132 {
 133         struct smo8800_device *smo8800 = container_of(file->private_data,
 134                                          struct smo8800_device, miscdev);
 135
 136         clear_bit(0, &smo8800->misc_opened); /* release the device */
 137         return 0;
 138 }
 139
 140 static const struct file_operations smo8800_misc_fops = {
 141         .owner = THIS_MODULE,
 142         .read = smo8800_misc_read,
 143         .open = smo8800_misc_open,
 144         .release = smo8800_misc_release,
 145 };
 146
 147 static int smo8800_add(struct acpi_device *device)
 148 {
 149         int err;
 150         struct smo8800_device *smo8800;
 151
 152         smo8800 = devm_kzalloc(&device->dev, sizeof(*smo8800), GFP_KERNEL);
 153         if (!smo8800) {
 154                 dev_err(&device->dev, "failed to allocate device data\n");
 155                 return -ENOMEM;
 156         }
 157
 158         smo8800->dev = &device->dev;
 159         smo8800->miscdev.minor = MISC_DYNAMIC_MINOR;
 160         smo8800->miscdev.name = "freefall";
 161         smo8800->miscdev.fops = &smo8800_misc_fops;
 162
 163         init_waitqueue_head(&smo8800->misc_wait);
 164
 165         err = misc_register(&smo8800->miscdev);
 166         if (err) {
 167                 dev_err(&device->dev, "failed to register misc dev: %d\n", err);
 168                 return err;
 169         }
 170
 171         device->driver_data = smo8800;
 172
 173         smo8800->irq = smo8800_get_irq(device);
 174         if (!smo8800->irq) {
 175                 dev_err(&device->dev, "failed to obtain IRQ\n");
 176                 err = -EINVAL;
 177                 goto error;
 178         }
 179
 180         err = request_threaded_irq(smo8800->irq, smo8800_interrupt_quick,
 181                                    smo8800_interrupt_thread,
 182                                    IRQF_TRIGGER_RISING | IRQF_ONESHOT,
 183                                    DRIVER_NAME, smo8800);
 184         if (err) {
 185                 dev_err(&device->dev,
 186                         "failed to request thread for IRQ %d: %d\n",
 187                         smo8800->irq, err);
 188                 goto error;
 189         }
 190
 191         dev_dbg(&device->dev, "device /dev/freefall registered with IRQ %d\n",
 192                  smo8800->irq);
 193         return 0;
 194
 195 error:
 196         misc_deregister(&smo8800->miscdev);
 197         return err;
 198 }
 199
 200 static int smo8800_remove(struct acpi_device *device)
 201 {
 202         struct smo8800_device *smo8800 = device->driver_data;
 203
 204         free_irq(smo8800->irq, smo8800);
 205         misc_deregister(&smo8800->miscdev);
 206         dev_dbg(&device->dev, "device /dev/freefall unregistered\n");
 207         return 0;
 208 }
 209
 210 static const struct acpi_device_id smo8800_ids[] = {
 211         { "SMO8800", 0 },
 212         { "SMO8801", 0 },
 213         { "SMO8810", 0 },
 214         { "SMO8811", 0 },
 215         { "SMO8820", 0 },
 216         { "SMO8821", 0 },
 217         { "SMO8830", 0 },
 218         { "SMO8831", 0 },
 219         { "", 0 },
 220 };
 221
 222 MODULE_DEVICE_TABLE(acpi, smo8800_ids);
 223
 224 static struct acpi_driver smo8800_driver = {
 225         .name = DRIVER_NAME,
 226         .class = "Latitude",
 227         .ids = smo8800_ids,
 228         .ops = {
 229                 .add = smo8800_add,
 230                 .remove = smo8800_remove,
 231         },
 232         .owner = THIS_MODULE,
 233 };
 234
 235 module_acpi_driver(smo8800_driver);
 236
 237 MODULE_DESCRIPTION("Dell Latitude freefall driver (ACPI SMO88XX)");
 238 MODULE_LICENSE("GPL");
 239 MODULE_AUTHOR("Sonal Santan, Pali Rohár");