drivers/staging/iio/accel/kxsd9.c

   1 /*
   2  * kxsd9.c      simple support for the Kionix KXSD9 3D
   3  *              accelerometer.
   4  *
   5  * Copyright (c) 2008-2009 Jonathan Cameron <jic23@cam.ac.uk>
   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 version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  * The i2c interface is very similar, so shouldn't be a problem once
  12  * I have a suitable wire made up.
  13  *
  14  * TODO:        Support the motion detector
  15  *              Uses register address incrementing so could have a
  16  *              heavily optimized ring buffer access function.
  17  */
  18
  19 #include <linux/device.h>
  20 #include <linux/kernel.h>
  21 #include <linux/spi/spi.h>
  22 #include <linux/sysfs.h>
  23 #include <linux/slab.h>
  24 #include <linux/module.h>
  25
  26 #include "../iio.h"
  27 #include "../sysfs.h"
  28
  29 #define KXSD9_REG_X             0x00
  30 #define KXSD9_REG_Y             0x02
  31 #define KXSD9_REG_Z             0x04
  32 #define KXSD9_REG_AUX           0x06
  33 #define KXSD9_REG_RESET         0x0a
  34 #define KXSD9_REG_CTRL_C        0x0c
  35
  36 #define KXSD9_FS_MASK           0x03
  37
  38 #define KXSD9_REG_CTRL_B        0x0d
  39 #define KXSD9_REG_CTRL_A        0x0e
  40
  41 #define KXSD9_READ(a) (0x80 | (a))
  42 #define KXSD9_WRITE(a) (a)
  43
  44 #define KXSD9_STATE_RX_SIZE 2
  45 #define KXSD9_STATE_TX_SIZE 2
  46 /**
  47  * struct kxsd9_state - device related storage
  48  * @buf_lock:   protect the rx and tx buffers.
  49  * @us:         spi device
  50  * @rx:         single rx buffer storage
  51  * @tx:         single tx buffer storage
  52  **/
  53 struct kxsd9_state {
  54         struct mutex buf_lock;
  55         struct spi_device *us;
  56         u8 rx[KXSD9_STATE_RX_SIZE] ____cacheline_aligned;
  57         u8 tx[KXSD9_STATE_TX_SIZE];
  58 };
  59
  60 #define KXSD9_SCALE_2G "0.011978"
  61 #define KXSD9_SCALE_4G "0.023927"
  62 #define KXSD9_SCALE_6G "0.035934"
  63 #define KXSD9_SCALE_8G "0.047853"
  64
  65 /* reverse order */
  66 static const int kxsd9_micro_scales[4] = { 47853, 35934, 23927, 11978 };
  67
  68 static int kxsd9_write_scale(struct iio_dev *indio_dev, int micro)
  69 {
  70         int ret, i;
  71         struct kxsd9_state *st = iio_priv(indio_dev);
  72         bool foundit = false;
  73
  74         for (i = 0; i < 4; i++)
  75                 if (micro == kxsd9_micro_scales[i]) {
  76                         foundit = true;
  77                         break;
  78                 }
  79         if (!foundit)
  80                 return -EINVAL;
  81
  82         mutex_lock(&st->buf_lock);
  83         ret = spi_w8r8(st->us, KXSD9_READ(KXSD9_REG_CTRL_C));
  84         if (ret)
  85                 goto error_ret;
  86         st->tx[0] = KXSD9_WRITE(KXSD9_REG_CTRL_C);
  87         st->tx[1] = (ret & ~KXSD9_FS_MASK) | i;
  88
  89         ret = spi_write(st->us, st->tx, 2);
  90 error_ret:
  91         mutex_unlock(&st->buf_lock);
  92         return ret;
  93 }
  94
  95 static int kxsd9_read(struct iio_dev *indio_dev, u8 address)
  96 {
  97         struct spi_message msg;
  98         int ret;
  99         struct kxsd9_state *st = iio_priv(indio_dev);
 100         struct spi_transfer xfers[] = {
 101                 {
 102                         .bits_per_word = 8,
 103                         .len = 1,
 104                         .delay_usecs = 200,
 105                         .tx_buf = st->tx,
 106                 }, {
 107                         .bits_per_word = 8,
 108                         .len = 2,
 109                         .rx_buf = st->rx,
 110                 },
 111         };
 112
 113         mutex_lock(&st->buf_lock);
 114         st->tx[0] = KXSD9_READ(address);
 115         spi_message_init(&msg);
 116         spi_message_add_tail(&xfers[0], &msg);
 117         spi_message_add_tail(&xfers[1], &msg);
 118         ret = spi_sync(st->us, &msg);
 119         if (ret)
 120                 return ret;
 121         return (((u16)(st->rx[0])) << 8) | (st->rx[1] & 0xF0);
 122 }
 123
 124 static IIO_CONST_ATTR(accel_scale_available,
 125                 KXSD9_SCALE_2G " "
 126                 KXSD9_SCALE_4G " "
 127                 KXSD9_SCALE_6G " "
 128                 KXSD9_SCALE_8G);
 129
 130 static struct attribute *kxsd9_attributes[] = {
 131         &iio_const_attr_accel_scale_available.dev_attr.attr,
 132         NULL,
 133 };
 134
 135 static int kxsd9_write_raw(struct iio_dev *indio_dev,
 136                            struct iio_chan_spec const *chan,
 137                            int val,
 138                            int val2,
 139                            long mask)
 140 {
 141         int ret = -EINVAL;
 142
 143         if (mask == (1 << IIO_CHAN_INFO_SCALE_SHARED)) {
 144                 /* Check no integer component */
 145                 if (val)
 146                         return -EINVAL;
 147                 ret = kxsd9_write_scale(indio_dev, val2);
 148         }
 149
 150         return ret;
 151 }
 152
 153 static int kxsd9_read_raw(struct iio_dev *indio_dev,
 154                           struct iio_chan_spec const *chan,
 155                           int *val, int *val2, long mask)
 156 {
 157         int ret = -EINVAL;
 158         struct kxsd9_state *st = iio_priv(indio_dev);
 159
 160         switch (mask) {
 161         case 0:
 162                 ret = kxsd9_read(indio_dev, chan->address);
 163                 if (ret < 0)
 164                         goto error_ret;
 165                 *val = ret;
 166                 break;
 167         case (1 << IIO_CHAN_INFO_SCALE_SHARED):
 168                 ret = spi_w8r8(st->us, KXSD9_READ(KXSD9_REG_CTRL_C));
 169                 if (ret)
 170                         goto error_ret;
 171                 *val2 = kxsd9_micro_scales[ret & KXSD9_FS_MASK];
 172                 ret = IIO_VAL_INT_PLUS_MICRO;
 173                 break;
 174         };
 175
 176 error_ret:
 177         return ret;
 178 };
 179 #define KXSD9_ACCEL_CHAN(axis)                                          \
 180         {                                                               \
 181                 .type = IIO_ACCEL,                                      \
 182                 .modified = 1,                                          \
 183                 .channel2 = IIO_MOD_##axis,                             \
 184                 .info_mask = 1 << IIO_CHAN_INFO_SCALE_SHARED,           \
 185                 .address = KXSD9_REG_##axis,                            \
 186         }
 187
 188 static struct iio_chan_spec kxsd9_channels[] = {
 189         KXSD9_ACCEL_CHAN(X), KXSD9_ACCEL_CHAN(Y), KXSD9_ACCEL_CHAN(Z),
 190         {
 191                 .type = IIO_VOLTAGE,
 192                 .indexed = 1,
 193                 .address = KXSD9_REG_AUX,
 194         }
 195 };
 196
 197 static const struct attribute_group kxsd9_attribute_group = {
 198         .attrs = kxsd9_attributes,
 199 };
 200
 201 static int __devinit kxsd9_power_up(struct kxsd9_state *st)
 202 {
 203         int ret;
 204
 205         st->tx[0] = 0x0d;
 206         st->tx[1] = 0x40;
 207         ret = spi_write(st->us, st->tx, 2);
 208         if (ret)
 209                 return ret;
 210
 211         st->tx[0] = 0x0c;
 212         st->tx[1] = 0x9b;
 213         return spi_write(st->us, st->tx, 2);
 214 };
 215
 216 static const struct iio_info kxsd9_info = {
 217         .read_raw = &kxsd9_read_raw,
 218         .write_raw = &kxsd9_write_raw,
 219         .attrs = &kxsd9_attribute_group,
 220         .driver_module = THIS_MODULE,
 221 };
 222
 223 static int __devinit kxsd9_probe(struct spi_device *spi)
 224 {
 225         struct iio_dev *indio_dev;
 226         struct kxsd9_state *st;
 227         int ret = 0;
 228
 229         indio_dev = iio_allocate_device(sizeof(*st));
 230         if (indio_dev == NULL) {
 231                 ret = -ENOMEM;
 232                 goto error_ret;
 233         }
 234         st = iio_priv(indio_dev);
 235         spi_set_drvdata(spi, indio_dev);
 236
 237         st->us = spi;
 238         mutex_init(&st->buf_lock);
 239         indio_dev->channels = kxsd9_channels;
 240         indio_dev->num_channels = ARRAY_SIZE(kxsd9_channels);
 241         indio_dev->name = spi_get_device_id(spi)->name;
 242         indio_dev->dev.parent = &spi->dev;
 243         indio_dev->info = &kxsd9_info;
 244         indio_dev->modes = INDIO_DIRECT_MODE;
 245
 246         ret = iio_device_register(indio_dev);
 247         if (ret)
 248                 goto error_free_dev;
 249
 250         spi->mode = SPI_MODE_0;
 251         spi_setup(spi);
 252         kxsd9_power_up(st);
 253
 254         return 0;
 255
 256 error_free_dev:
 257         iio_free_device(indio_dev);
 258 error_ret:
 259         return ret;
 260 }
 261
 262 static int __devexit kxsd9_remove(struct spi_device *spi)
 263 {
 264         iio_device_unregister(spi_get_drvdata(spi));
 265         iio_free_device(spi_get_drvdata(spi));
 266
 267         return 0;
 268 }
 269
 270 static const struct spi_device_id kxsd9_id[] = {
 271         {"kxsd9", 0}
 272 };
 273
 274 static struct spi_driver kxsd9_driver = {
 275         .driver = {
 276                 .name = "kxsd9",
 277                 .owner = THIS_MODULE,
 278         },
 279         .probe = kxsd9_probe,
 280         .remove = __devexit_p(kxsd9_remove),
 281         .id_table = kxsd9_id,
 282 };
 283
 284 static __init int kxsd9_spi_init(void)
 285 {
 286         return spi_register_driver(&kxsd9_driver);
 287 }
 288 module_init(kxsd9_spi_init);
 289
 290 static __exit void kxsd9_spi_exit(void)
 291 {
 292         spi_unregister_driver(&kxsd9_driver);
 293 }
 294 module_exit(kxsd9_spi_exit);
 295
 296 MODULE_AUTHOR("Jonathan Cameron <jic23@cam.ac.uk>");
 297 MODULE_DESCRIPTION("Kionix KXSD9 SPI driver");
 298 MODULE_LICENSE("GPL v2");