drivers/macintosh/ams/ams-core.c

   1 /*
   2  * Apple Motion Sensor driver
   3  *
   4  * Copyright (C) 2005 Stelian Pop (stelian@popies.net)
   5  * Copyright (C) 2006 Michael Hanselmann (linux-kernel@hansmi.ch)
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  */
  21
  22 #include <linux/module.h>
  23 #include <linux/types.h>
  24 #include <linux/errno.h>
  25 #include <linux/init.h>
  26 #include <linux/of_platform.h>
  27 #include <asm/pmac_pfunc.h>
  28
  29 #include "ams.h"
  30
  31 /* There is only one motion sensor per machine */
  32 struct ams ams_info;
  33
  34 static bool verbose;
  35 module_param(verbose, bool, 0644);
  36 MODULE_PARM_DESC(verbose, "Show free falls and shocks in kernel output");
  37
  38 /* Call with ams_info.lock held! */
  39 void ams_sensors(s8 *x, s8 *y, s8 *z)
  40 {
  41         u32 orient = ams_info.vflag? ams_info.orient1 : ams_info.orient2;
  42
  43         if (orient & 0x80)
  44                 /* X and Y swapped */
  45                 ams_info.get_xyz(y, x, z);
  46         else
  47                 ams_info.get_xyz(x, y, z);
  48
  49         if (orient & 0x04)
  50                 *z = ~(*z);
  51         if (orient & 0x02)
  52                 *y = ~(*y);
  53         if (orient & 0x01)
  54                 *x = ~(*x);
  55 }
  56
  57 static ssize_t ams_show_current(struct device *dev,
  58         struct device_attribute *attr, char *buf)
  59 {
  60         s8 x, y, z;
  61
  62         mutex_lock(&ams_info.lock);
  63         ams_sensors(&x, &y, &z);
  64         mutex_unlock(&ams_info.lock);
  65
  66         return snprintf(buf, PAGE_SIZE, "%d %d %d\n", x, y, z);
  67 }
  68
  69 static DEVICE_ATTR(current, S_IRUGO, ams_show_current, NULL);
  70
  71 static void ams_handle_irq(void *data)
  72 {
  73         enum ams_irq irq = *((enum ams_irq *)data);
  74
  75         spin_lock(&ams_info.irq_lock);
  76
  77         ams_info.worker_irqs |= irq;
  78         schedule_work(&ams_info.worker);
  79
  80         spin_unlock(&ams_info.irq_lock);
  81 }
  82
  83 static enum ams_irq ams_freefall_irq_data = AMS_IRQ_FREEFALL;
  84 static struct pmf_irq_client ams_freefall_client = {
  85         .owner = THIS_MODULE,
  86         .handler = ams_handle_irq,
  87         .data = &ams_freefall_irq_data,
  88 };
  89
  90 static enum ams_irq ams_shock_irq_data = AMS_IRQ_SHOCK;
  91 static struct pmf_irq_client ams_shock_client = {
  92         .owner = THIS_MODULE,
  93         .handler = ams_handle_irq,
  94         .data = &ams_shock_irq_data,
  95 };
  96
  97 /* Once hard disk parking is implemented in the kernel, this function can
  98  * trigger it.
  99  */
 100 static void ams_worker(struct work_struct *work)
 101 {
 102         unsigned long flags;
 103         u8 irqs_to_clear;
 104
 105         mutex_lock(&ams_info.lock);
 106
 107         spin_lock_irqsave(&ams_info.irq_lock, flags);
 108         irqs_to_clear = ams_info.worker_irqs;
 109
 110         if (ams_info.worker_irqs & AMS_IRQ_FREEFALL) {
 111                 if (verbose)
 112                         printk(KERN_INFO "ams: freefall detected!\n");
 113
 114                 ams_info.worker_irqs &= ~AMS_IRQ_FREEFALL;
 115         }
 116
 117         if (ams_info.worker_irqs & AMS_IRQ_SHOCK) {
 118                 if (verbose)
 119                         printk(KERN_INFO "ams: shock detected!\n");
 120
 121                 ams_info.worker_irqs &= ~AMS_IRQ_SHOCK;
 122         }
 123
 124         spin_unlock_irqrestore(&ams_info.irq_lock, flags);
 125
 126         ams_info.clear_irq(irqs_to_clear);
 127
 128         mutex_unlock(&ams_info.lock);
 129 }
 130
 131 /* Call with ams_info.lock held! */
 132 int ams_sensor_attach(void)
 133 {
 134         int result;
 135         const u32 *prop;
 136
 137         /* Get orientation */
 138         prop = of_get_property(ams_info.of_node, "orientation", NULL);
 139         if (!prop)
 140                 return -ENODEV;
 141         ams_info.orient1 = *prop;
 142         ams_info.orient2 = *(prop + 1);
 143
 144         /* Register freefall interrupt handler */
 145         result = pmf_register_irq_client(ams_info.of_node,
 146                         "accel-int-1",
 147                         &ams_freefall_client);
 148         if (result < 0)
 149                 return -ENODEV;
 150
 151         /* Reset saved irqs */
 152         ams_info.worker_irqs = 0;
 153
 154         /* Register shock interrupt handler */
 155         result = pmf_register_irq_client(ams_info.of_node,
 156                         "accel-int-2",
 157                         &ams_shock_client);
 158         if (result < 0)
 159                 goto release_freefall;
 160
 161         /* Create device */
 162         ams_info.of_dev = of_platform_device_create(ams_info.of_node, "ams", NULL);
 163         if (!ams_info.of_dev) {
 164                 result = -ENODEV;
 165                 goto release_shock;
 166         }
 167
 168         /* Create attributes */
 169         result = device_create_file(&ams_info.of_dev->dev, &dev_attr_current);
 170         if (result)
 171                 goto release_of;
 172
 173         ams_info.vflag = !!(ams_info.get_vendor() & 0x10);
 174
 175         /* Init input device */
 176         result = ams_input_init();
 177         if (result)
 178                 goto release_device_file;
 179
 180         return result;
 181 release_device_file:
 182         device_remove_file(&ams_info.of_dev->dev, &dev_attr_current);
 183 release_of:
 184         of_device_unregister(ams_info.of_dev);
 185 release_shock:
 186         pmf_unregister_irq_client(&ams_shock_client);
 187 release_freefall:
 188         pmf_unregister_irq_client(&ams_freefall_client);
 189         return result;
 190 }
 191
 192 int __init ams_init(void)
 193 {
 194         struct device_node *np;
 195
 196         spin_lock_init(&ams_info.irq_lock);
 197         mutex_init(&ams_info.lock);
 198         INIT_WORK(&ams_info.worker, ams_worker);
 199
 200 #ifdef CONFIG_SENSORS_AMS_I2C
 201         np = of_find_node_by_name(NULL, "accelerometer");
 202         if (np && of_device_is_compatible(np, "AAPL,accelerometer_1"))
 203                 /* Found I2C motion sensor */
 204                 return ams_i2c_init(np);
 205 #endif
 206
 207 #ifdef CONFIG_SENSORS_AMS_PMU
 208         np = of_find_node_by_name(NULL, "sms");
 209         if (np && of_device_is_compatible(np, "sms"))
 210                 /* Found PMU motion sensor */
 211                 return ams_pmu_init(np);
 212 #endif
 213         return -ENODEV;
 214 }
 215
 216 void ams_sensor_detach(void)
 217 {
 218         /* Remove input device */
 219         ams_input_exit();
 220
 221         /* Remove attributes */
 222         device_remove_file(&ams_info.of_dev->dev, &dev_attr_current);
 223
 224         /* Flush interrupt worker
 225          *
 226          * We do this after ams_info.exit(), because an interrupt might
 227          * have arrived before disabling them.
 228          */
 229         flush_work_sync(&ams_info.worker);
 230
 231         /* Remove device */
 232         of_device_unregister(ams_info.of_dev);
 233
 234         /* Remove handler */
 235         pmf_unregister_irq_client(&ams_shock_client);
 236         pmf_unregister_irq_client(&ams_freefall_client);
 237 }
 238
 239 static void __exit ams_exit(void)
 240 {
 241         /* Shut down implementation */
 242         ams_info.exit();
 243 }
 244
 245 MODULE_AUTHOR("Stelian Pop, Michael Hanselmann");
 246 MODULE_DESCRIPTION("Apple Motion Sensor driver");
 247 MODULE_LICENSE("GPL");
 248
 249 module_init(ams_init);
 250 module_exit(ams_exit);