drivers/hwmon/ams/ams-i2c.c

   1 /*
   2  * Apple Motion Sensor driver (I2C variant)
   3  *
   4  * Copyright (C) 2005 Stelian Pop (stelian@popies.net)
   5  * Copyright (C) 2006 Michael Hanselmann (linux-kernel@hansmi.ch)
   6  *
   7  * Clean room implementation based on the reverse engineered Mac OS X driver by
   8  * Johannes Berg <johannes@sipsolutions.net>, documentation available at
   9  * http://johannes.sipsolutions.net/PowerBook/Apple_Motion_Sensor_Specification
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  */
  16
  17 #include <linux/module.h>
  18 #include <linux/types.h>
  19 #include <linux/errno.h>
  20 #include <linux/init.h>
  21 #include <linux/delay.h>
  22
  23 #include "ams.h"
  24
  25 /* AMS registers */
  26 #define AMS_COMMAND     0x00    /* command register */
  27 #define AMS_STATUS      0x01    /* status register */
  28 #define AMS_CTRL1       0x02    /* read control 1 (number of values) */
  29 #define AMS_CTRL2       0x03    /* read control 2 (offset?) */
  30 #define AMS_CTRL3       0x04    /* read control 3 (size of each value?) */
  31 #define AMS_DATA1       0x05    /* read data 1 */
  32 #define AMS_DATA2       0x06    /* read data 2 */
  33 #define AMS_DATA3       0x07    /* read data 3 */
  34 #define AMS_DATA4       0x08    /* read data 4 */
  35 #define AMS_DATAX       0x20    /* data X */
  36 #define AMS_DATAY       0x21    /* data Y */
  37 #define AMS_DATAZ       0x22    /* data Z */
  38 #define AMS_FREEFALL    0x24    /* freefall int control */
  39 #define AMS_SHOCK       0x25    /* shock int control */
  40 #define AMS_SENSLOW     0x26    /* sensitivity low limit */
  41 #define AMS_SENSHIGH    0x27    /* sensitivity high limit */
  42 #define AMS_CTRLX       0x28    /* control X */
  43 #define AMS_CTRLY       0x29    /* control Y */
  44 #define AMS_CTRLZ       0x2A    /* control Z */
  45 #define AMS_UNKNOWN1    0x2B    /* unknown 1 */
  46 #define AMS_UNKNOWN2    0x2C    /* unknown 2 */
  47 #define AMS_UNKNOWN3    0x2D    /* unknown 3 */
  48 #define AMS_VENDOR      0x2E    /* vendor */
  49
  50 /* AMS commands - use with the AMS_COMMAND register */
  51 enum ams_i2c_cmd {
  52         AMS_CMD_NOOP = 0,
  53         AMS_CMD_VERSION,
  54         AMS_CMD_READMEM,
  55         AMS_CMD_WRITEMEM,
  56         AMS_CMD_ERASEMEM,
  57         AMS_CMD_READEE,
  58         AMS_CMD_WRITEEE,
  59         AMS_CMD_RESET,
  60         AMS_CMD_START,
  61 };
  62
  63 static int ams_i2c_attach(struct i2c_adapter *adapter);
  64 static int ams_i2c_detach(struct i2c_adapter *adapter);
  65
  66 static struct i2c_driver ams_i2c_driver = {
  67         .driver = {
  68                 .name   = "ams",
  69                 .owner  = THIS_MODULE,
  70         },
  71         .attach_adapter = ams_i2c_attach,
  72         .detach_adapter = ams_i2c_detach,
  73 };
  74
  75 static s32 ams_i2c_read(u8 reg)
  76 {
  77         return i2c_smbus_read_byte_data(&ams_info.i2c_client, reg);
  78 }
  79
  80 static int ams_i2c_write(u8 reg, u8 value)
  81 {
  82         return i2c_smbus_write_byte_data(&ams_info.i2c_client, reg, value);
  83 }
  84
  85 static int ams_i2c_cmd(enum ams_i2c_cmd cmd)
  86 {
  87         s32 result;
  88         int remaining = HZ / 20;
  89
  90         ams_i2c_write(AMS_COMMAND, cmd);
  91         mdelay(5);
  92
  93         while (remaining) {
  94                 result = ams_i2c_read(AMS_COMMAND);
  95                 if (result == 0 || result & 0x80)
  96                         return 0;
  97
  98                 remaining = schedule_timeout(remaining);
  99         }
 100
 101         return -1;
 102 }
 103
 104 static void ams_i2c_set_irq(enum ams_irq reg, char enable)
 105 {
 106         if (reg & AMS_IRQ_FREEFALL) {
 107                 u8 val = ams_i2c_read(AMS_CTRLX);
 108                 if (enable)
 109                         val |= 0x80;
 110                 else
 111                         val &= ~0x80;
 112                 ams_i2c_write(AMS_CTRLX, val);
 113         }
 114
 115         if (reg & AMS_IRQ_SHOCK) {
 116                 u8 val = ams_i2c_read(AMS_CTRLY);
 117                 if (enable)
 118                         val |= 0x80;
 119                 else
 120                         val &= ~0x80;
 121                 ams_i2c_write(AMS_CTRLY, val);
 122         }
 123
 124         if (reg & AMS_IRQ_GLOBAL) {
 125                 u8 val = ams_i2c_read(AMS_CTRLZ);
 126                 if (enable)
 127                         val |= 0x80;
 128                 else
 129                         val &= ~0x80;
 130                 ams_i2c_write(AMS_CTRLZ, val);
 131         }
 132 }
 133
 134 static void ams_i2c_clear_irq(enum ams_irq reg)
 135 {
 136         if (reg & AMS_IRQ_FREEFALL)
 137                 ams_i2c_write(AMS_FREEFALL, 0);
 138
 139         if (reg & AMS_IRQ_SHOCK)
 140                 ams_i2c_write(AMS_SHOCK, 0);
 141 }
 142
 143 static u8 ams_i2c_get_vendor(void)
 144 {
 145         return ams_i2c_read(AMS_VENDOR);
 146 }
 147
 148 static void ams_i2c_get_xyz(s8 *x, s8 *y, s8 *z)
 149 {
 150         *x = ams_i2c_read(AMS_DATAX);
 151         *y = ams_i2c_read(AMS_DATAY);
 152         *z = ams_i2c_read(AMS_DATAZ);
 153 }
 154
 155 static int ams_i2c_attach(struct i2c_adapter *adapter)
 156 {
 157         unsigned long bus;
 158         int vmaj, vmin;
 159         int result;
 160
 161         /* There can be only one */
 162         if (unlikely(ams_info.has_device))
 163                 return -ENODEV;
 164
 165         if (strncmp(adapter->name, "uni-n", 5))
 166                 return -ENODEV;
 167
 168         bus = simple_strtoul(adapter->name + 6, NULL, 10);
 169         if (bus != ams_info.i2c_bus)
 170                 return -ENODEV;
 171
 172         ams_info.i2c_client.addr = ams_info.i2c_address;
 173         ams_info.i2c_client.adapter = adapter;
 174         ams_info.i2c_client.driver = &ams_i2c_driver;
 175         strcpy(ams_info.i2c_client.name, "Apple Motion Sensor");
 176
 177         if (ams_i2c_cmd(AMS_CMD_RESET)) {
 178                 printk(KERN_INFO "ams: Failed to reset the device\n");
 179                 return -ENODEV;
 180         }
 181
 182         if (ams_i2c_cmd(AMS_CMD_START)) {
 183                 printk(KERN_INFO "ams: Failed to start the device\n");
 184                 return -ENODEV;
 185         }
 186
 187         /* get version/vendor information */
 188         ams_i2c_write(AMS_CTRL1, 0x02);
 189         ams_i2c_write(AMS_CTRL2, 0x85);
 190         ams_i2c_write(AMS_CTRL3, 0x01);
 191
 192         ams_i2c_cmd(AMS_CMD_READMEM);
 193
 194         vmaj = ams_i2c_read(AMS_DATA1);
 195         vmin = ams_i2c_read(AMS_DATA2);
 196         if (vmaj != 1 || vmin != 52) {
 197                 printk(KERN_INFO "ams: Incorrect device version (%d.%d)\n",
 198                         vmaj, vmin);
 199                 return -ENODEV;
 200         }
 201
 202         ams_i2c_cmd(AMS_CMD_VERSION);
 203
 204         vmaj = ams_i2c_read(AMS_DATA1);
 205         vmin = ams_i2c_read(AMS_DATA2);
 206         if (vmaj != 0 || vmin != 1) {
 207                 printk(KERN_INFO "ams: Incorrect firmware version (%d.%d)\n",
 208                         vmaj, vmin);
 209                 return -ENODEV;
 210         }
 211
 212         /* Disable interrupts */
 213         ams_i2c_set_irq(AMS_IRQ_ALL, 0);
 214
 215         result = ams_sensor_attach();
 216         if (result < 0)
 217                 return result;
 218
 219         /* Set default values */
 220         ams_i2c_write(AMS_SENSLOW, 0x15);
 221         ams_i2c_write(AMS_SENSHIGH, 0x60);
 222         ams_i2c_write(AMS_CTRLX, 0x08);
 223         ams_i2c_write(AMS_CTRLY, 0x0F);
 224         ams_i2c_write(AMS_CTRLZ, 0x4F);
 225         ams_i2c_write(AMS_UNKNOWN1, 0x14);
 226
 227         /* Clear interrupts */
 228         ams_i2c_clear_irq(AMS_IRQ_ALL);
 229
 230         ams_info.has_device = 1;
 231
 232         /* Enable interrupts */
 233         ams_i2c_set_irq(AMS_IRQ_ALL, 1);
 234
 235         printk(KERN_INFO "ams: Found I2C based motion sensor\n");
 236
 237         return 0;
 238 }
 239
 240 static int ams_i2c_detach(struct i2c_adapter *adapter)
 241 {
 242         if (ams_info.has_device) {
 243                 /* Disable interrupts */
 244                 ams_i2c_set_irq(AMS_IRQ_ALL, 0);
 245
 246                 /* Clear interrupts */
 247                 ams_i2c_clear_irq(AMS_IRQ_ALL);
 248
 249                 printk(KERN_INFO "ams: Unloading\n");
 250
 251                 ams_info.has_device = 0;
 252         }
 253
 254         return 0;
 255 }
 256
 257 static void ams_i2c_exit(void)
 258 {
 259         i2c_del_driver(&ams_i2c_driver);
 260 }
 261
 262 int __init ams_i2c_init(struct device_node *np)
 263 {
 264         char *tmp_bus;
 265         int result;
 266         u32 *prop;
 267
 268         mutex_lock(&ams_info.lock);
 269
 270         /* Set implementation stuff */
 271         ams_info.of_node = np;
 272         ams_info.exit = ams_i2c_exit;
 273         ams_info.get_vendor = ams_i2c_get_vendor;
 274         ams_info.get_xyz = ams_i2c_get_xyz;
 275         ams_info.clear_irq = ams_i2c_clear_irq;
 276         ams_info.bustype = BUS_I2C;
 277
 278         /* look for bus either using "reg" or by path */
 279         prop = (u32*)get_property(ams_info.of_node, "reg", NULL);
 280         if (!prop) {
 281                 result = -ENODEV;
 282
 283                 goto exit;
 284         }
 285
 286         tmp_bus = strstr(ams_info.of_node->full_name, "/i2c-bus@");
 287         if (tmp_bus)
 288                 ams_info.i2c_bus = *(tmp_bus + 9) - '0';
 289         else
 290                 ams_info.i2c_bus = ((*prop) >> 8) & 0x0f;
 291         ams_info.i2c_address = ((*prop) & 0xff) >> 1;
 292
 293         result = i2c_add_driver(&ams_i2c_driver);
 294
 295 exit:
 296         mutex_unlock(&ams_info.lock);
 297
 298         return result;
 299 }