drivers/staging/iio/accel/lis3l02dq_core.c

   1 /*
   2  * lis3l02dq.c  support STMicroelectronics LISD02DQ
   3  *              3d 2g Linear Accelerometers via SPI
   4  *
   5  * Copyright (c) 2007 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  * Settings:
  12  * 16 bit left justified mode used.
  13  */
  14
  15 #include <linux/interrupt.h>
  16 #include <linux/irq.h>
  17 #include <linux/gpio.h>
  18 #include <linux/workqueue.h>
  19 #include <linux/mutex.h>
  20 #include <linux/device.h>
  21 #include <linux/kernel.h>
  22 #include <linux/spi/spi.h>
  23 #include <linux/slab.h>
  24
  25 #include <linux/sysfs.h>
  26 #include <linux/list.h>
  27
  28 #include "../iio.h"
  29 #include "../sysfs.h"
  30 #include "accel.h"
  31
  32 #include "lis3l02dq.h"
  33
  34 /* At the moment the spi framework doesn't allow global setting of cs_change.
  35  * It's in the likely to be added comment at the top of spi.h.
  36  * This means that use cannot be made of spi_write etc.
  37  */
  38
  39 /**
  40  * lis3l02dq_spi_read_reg_8() - read single byte from a single register
  41  * @dev: device asosciated with child of actual device (iio_dev or iio_trig)
  42  * @reg_address: the address of the register to be read
  43  * @val: pass back the resulting value
  44  **/
  45 int lis3l02dq_spi_read_reg_8(struct device *dev, u8 reg_address, u8 *val)
  46 {
  47         int ret;
  48         struct spi_message msg;
  49         struct iio_dev *indio_dev = dev_get_drvdata(dev);
  50         struct lis3l02dq_state *st = iio_dev_get_devdata(indio_dev);
  51         struct spi_transfer xfer = {
  52                 .tx_buf = st->tx,
  53                 .rx_buf = st->rx,
  54                 .bits_per_word = 8,
  55                 .len = 2,
  56                 .cs_change = 1,
  57         };
  58
  59         mutex_lock(&st->buf_lock);
  60         st->tx[0] = LIS3L02DQ_READ_REG(reg_address);
  61         st->tx[1] = 0;
  62
  63         spi_message_init(&msg);
  64         spi_message_add_tail(&xfer, &msg);
  65         ret = spi_sync(st->us, &msg);
  66         *val = st->rx[1];
  67         mutex_unlock(&st->buf_lock);
  68
  69         return ret;
  70 }
  71
  72 /**
  73  * lis3l02dq_spi_write_reg_8() - write single byte to a register
  74  * @dev: device associated with child of actual device (iio_dev or iio_trig)
  75  * @reg_address: the address of the register to be writen
  76  * @val: the value to write
  77  **/
  78 int lis3l02dq_spi_write_reg_8(struct device *dev,
  79                               u8 reg_address,
  80                               u8 *val)
  81 {
  82         int ret;
  83         struct spi_message msg;
  84         struct iio_dev *indio_dev = dev_get_drvdata(dev);
  85         struct lis3l02dq_state *st = iio_dev_get_devdata(indio_dev);
  86         struct spi_transfer xfer = {
  87                 .tx_buf = st->tx,
  88                 .bits_per_word = 8,
  89                 .len = 2,
  90                 .cs_change = 1,
  91         };
  92
  93         mutex_lock(&st->buf_lock);
  94         st->tx[0] = LIS3L02DQ_WRITE_REG(reg_address);
  95         st->tx[1] = *val;
  96
  97         spi_message_init(&msg);
  98         spi_message_add_tail(&xfer, &msg);
  99         ret = spi_sync(st->us, &msg);
 100         mutex_unlock(&st->buf_lock);
 101
 102         return ret;
 103 }
 104
 105 /**
 106  * lisl302dq_spi_write_reg_s16() - write 2 bytes to a pair of registers
 107  * @dev: device associated with child of actual device (iio_dev or iio_trig)
 108  * @reg_address: the address of the lower of the two registers. Second register
 109  *               is assumed to have address one greater.
 110  * @val: value to be written
 111  **/
 112 static int lis3l02dq_spi_write_reg_s16(struct device *dev,
 113                                        u8 lower_reg_address,
 114                                        s16 value)
 115 {
 116         int ret;
 117         struct spi_message msg;
 118         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 119         struct lis3l02dq_state *st = iio_dev_get_devdata(indio_dev);
 120         struct spi_transfer xfers[] = { {
 121                         .tx_buf = st->tx,
 122                         .bits_per_word = 8,
 123                         .len = 2,
 124                         .cs_change = 1,
 125                 }, {
 126                         .tx_buf = st->tx + 2,
 127                         .bits_per_word = 8,
 128                         .len = 2,
 129                         .cs_change = 1,
 130                 },
 131         };
 132
 133         mutex_lock(&st->buf_lock);
 134         st->tx[0] = LIS3L02DQ_WRITE_REG(lower_reg_address);
 135         st->tx[1] = value & 0xFF;
 136         st->tx[2] = LIS3L02DQ_WRITE_REG(lower_reg_address + 1);
 137         st->tx[3] = (value >> 8) & 0xFF;
 138
 139         spi_message_init(&msg);
 140         spi_message_add_tail(&xfers[0], &msg);
 141         spi_message_add_tail(&xfers[1], &msg);
 142         ret = spi_sync(st->us, &msg);
 143         mutex_unlock(&st->buf_lock);
 144
 145         return ret;
 146 }
 147
 148 /**
 149  * lisl302dq_spi_read_reg_s16() - write 2 bytes to a pair of registers
 150  * @dev: device associated with child of actual device (iio_dev or iio_trig)
 151  * @reg_address: the address of the lower of the two registers. Second register
 152  *               is assumed to have address one greater.
 153  * @val: somewhere to pass back the value read
 154  **/
 155 static int lis3l02dq_spi_read_reg_s16(struct device *dev,
 156                                       u8 lower_reg_address,
 157                                       s16 *val)
 158 {
 159         struct spi_message msg;
 160         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 161         struct lis3l02dq_state *st = iio_dev_get_devdata(indio_dev);
 162         int ret;
 163         struct spi_transfer xfers[] = { {
 164                         .tx_buf = st->tx,
 165                         .rx_buf = st->rx,
 166                         .bits_per_word = 8,
 167                         .len = 2,
 168                         .cs_change = 1,
 169                 }, {
 170                         .tx_buf = st->tx + 2,
 171                         .rx_buf = st->rx + 2,
 172                         .bits_per_word = 8,
 173                         .len = 2,
 174                         .cs_change = 1,
 175
 176                 },
 177         };
 178
 179         mutex_lock(&st->buf_lock);
 180         st->tx[0] = LIS3L02DQ_READ_REG(lower_reg_address);
 181         st->tx[1] = 0;
 182         st->tx[2] = LIS3L02DQ_READ_REG(lower_reg_address+1);
 183         st->tx[3] = 0;
 184
 185         spi_message_init(&msg);
 186         spi_message_add_tail(&xfers[0], &msg);
 187         spi_message_add_tail(&xfers[1], &msg);
 188         ret = spi_sync(st->us, &msg);
 189         if (ret) {
 190                 dev_err(&st->us->dev, "problem when reading 16 bit register");
 191                 goto error_ret;
 192         }
 193         *val = (s16)(st->rx[1]) | ((s16)(st->rx[3]) << 8);
 194
 195 error_ret:
 196         mutex_unlock(&st->buf_lock);
 197         return ret;
 198 }
 199
 200 /**
 201  * lis3l02dq_read_signed() - attribute function used for 8 bit signed values
 202  * @dev: the child device associated with the iio_dev or iio_trigger
 203  * @attr: the attribute being processed
 204  * @buf: buffer into which put the output string
 205  **/
 206 static ssize_t lis3l02dq_read_signed(struct device *dev,
 207                                      struct device_attribute *attr,
 208                                      char *buf)
 209 {
 210         int ret;
 211         s8 val;
 212         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 213
 214         ret = lis3l02dq_spi_read_reg_8(dev, this_attr->address, (u8 *)&val);
 215
 216         return ret ? ret : sprintf(buf, "%d\n", val);
 217 }
 218
 219 static ssize_t lis3l02dq_read_unsigned(struct device *dev,
 220                                        struct device_attribute *attr,
 221                                        char *buf)
 222 {
 223         int ret;
 224         u8 val;
 225         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 226
 227         ret = lis3l02dq_spi_read_reg_8(dev, this_attr->address, &val);
 228
 229         return ret ? ret : sprintf(buf, "%d\n", val);
 230 }
 231
 232 static ssize_t lis3l02dq_write_signed(struct device *dev,
 233                                       struct device_attribute *attr,
 234                                       const char *buf,
 235                                       size_t len)
 236 {
 237         long valin;
 238         s8 val;
 239         int ret;
 240         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 241
 242         ret = strict_strtol(buf, 10, &valin);
 243         if (ret)
 244                 goto error_ret;
 245         val = valin;
 246         ret = lis3l02dq_spi_write_reg_8(dev, this_attr->address, (u8 *)&val);
 247
 248 error_ret:
 249         return ret ? ret : len;
 250 }
 251
 252 static ssize_t lis3l02dq_write_unsigned(struct device *dev,
 253                                         struct device_attribute *attr,
 254                                         const char *buf,
 255                                         size_t len)
 256 {
 257         int ret;
 258         ulong valin;
 259         u8 val;
 260         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 261
 262         ret = strict_strtoul(buf, 10, &valin);
 263         if (ret)
 264                 goto err_ret;
 265         val = valin;
 266         ret = lis3l02dq_spi_write_reg_8(dev, this_attr->address, &val);
 267
 268 err_ret:
 269         return ret ? ret : len;
 270 }
 271
 272 static ssize_t lis3l02dq_read_16bit_signed(struct device *dev,
 273                                            struct device_attribute *attr,
 274                                            char *buf)
 275 {
 276         int ret;
 277         s16 val = 0;
 278         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 279
 280         ret = lis3l02dq_spi_read_reg_s16(dev, this_attr->address, &val);
 281
 282         if (ret)
 283                 return ret;
 284
 285         return sprintf(buf, "%d\n", val);
 286 }
 287
 288 static ssize_t lis3l02dq_read_accel(struct device *dev,
 289                                     struct device_attribute *attr,
 290                                     char *buf)
 291 {
 292         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 293         ssize_t ret;
 294
 295         /* Take the iio_dev status lock */
 296         mutex_lock(&indio_dev->mlock);
 297         if (indio_dev->currentmode == INDIO_RING_TRIGGERED)
 298                 ret = lis3l02dq_read_accel_from_ring(dev, attr, buf);
 299         else
 300                 ret =  lis3l02dq_read_16bit_signed(dev, attr, buf);
 301         mutex_unlock(&indio_dev->mlock);
 302
 303         return ret;
 304 }
 305
 306 static ssize_t lis3l02dq_write_16bit_signed(struct device *dev,
 307                                             struct device_attribute *attr,
 308                                             const char *buf,
 309                                             size_t len)
 310 {
 311         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 312         int ret;
 313         long val;
 314
 315         ret = strict_strtol(buf, 10, &val);
 316         if (ret)
 317                 goto error_ret;
 318         ret = lis3l02dq_spi_write_reg_s16(dev, this_attr->address, val);
 319
 320 error_ret:
 321         return ret ? ret : len;
 322 }
 323
 324 static ssize_t lis3l02dq_read_frequency(struct device *dev,
 325                                         struct device_attribute *attr,
 326                                         char *buf)
 327 {
 328         int ret, len = 0;
 329         s8 t;
 330         ret = lis3l02dq_spi_read_reg_8(dev,
 331                                        LIS3L02DQ_REG_CTRL_1_ADDR,
 332                                        (u8 *)&t);
 333         if (ret)
 334                 return ret;
 335         t &= LIS3L02DQ_DEC_MASK;
 336         switch (t) {
 337         case LIS3L02DQ_REG_CTRL_1_DF_128:
 338                 len = sprintf(buf, "280\n");
 339                 break;
 340         case LIS3L02DQ_REG_CTRL_1_DF_64:
 341                 len = sprintf(buf, "560\n");
 342                 break;
 343         case LIS3L02DQ_REG_CTRL_1_DF_32:
 344                 len = sprintf(buf, "1120\n");
 345                 break;
 346         case LIS3L02DQ_REG_CTRL_1_DF_8:
 347                 len = sprintf(buf, "4480\n");
 348                 break;
 349         }
 350         return len;
 351 }
 352
 353 static ssize_t lis3l02dq_write_frequency(struct device *dev,
 354                                          struct device_attribute *attr,
 355                                          const char *buf,
 356                                          size_t len)
 357 {
 358         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 359         long val;
 360         int ret;
 361         u8 t;
 362
 363         ret = strict_strtol(buf, 10, &val);
 364         if (ret)
 365                 return ret;
 366
 367         mutex_lock(&indio_dev->mlock);
 368         ret = lis3l02dq_spi_read_reg_8(dev,
 369                                        LIS3L02DQ_REG_CTRL_1_ADDR,
 370                                        &t);
 371         if (ret)
 372                 goto error_ret_mutex;
 373         /* Wipe the bits clean */
 374         t &= ~LIS3L02DQ_DEC_MASK;
 375         switch (val) {
 376         case 280:
 377                 t |= LIS3L02DQ_REG_CTRL_1_DF_128;
 378                 break;
 379         case 560:
 380                 t |= LIS3L02DQ_REG_CTRL_1_DF_64;
 381                 break;
 382         case 1120:
 383                 t |= LIS3L02DQ_REG_CTRL_1_DF_32;
 384                 break;
 385         case 4480:
 386                 t |= LIS3L02DQ_REG_CTRL_1_DF_8;
 387                 break;
 388         default:
 389                 ret = -EINVAL;
 390                 goto error_ret_mutex;
 391         };
 392
 393         ret = lis3l02dq_spi_write_reg_8(dev,
 394                                         LIS3L02DQ_REG_CTRL_1_ADDR,
 395                                         &t);
 396
 397 error_ret_mutex:
 398         mutex_unlock(&indio_dev->mlock);
 399
 400         return ret ? ret : len;
 401 }
 402
 403 static int lis3l02dq_initial_setup(struct lis3l02dq_state *st)
 404 {
 405         int ret;
 406         u8 val, valtest;
 407
 408         st->us->mode = SPI_MODE_3;
 409
 410         spi_setup(st->us);
 411
 412         val = LIS3L02DQ_DEFAULT_CTRL1;
 413         /* Write suitable defaults to ctrl1 */
 414         ret = lis3l02dq_spi_write_reg_8(&st->indio_dev->dev,
 415                                         LIS3L02DQ_REG_CTRL_1_ADDR,
 416                                         &val);
 417         if (ret) {
 418                 dev_err(&st->us->dev, "problem with setup control register 1");
 419                 goto err_ret;
 420         }
 421         /* Repeat as sometimes doesn't work first time?*/
 422         ret = lis3l02dq_spi_write_reg_8(&st->indio_dev->dev,
 423                                         LIS3L02DQ_REG_CTRL_1_ADDR,
 424                                         &val);
 425         if (ret) {
 426                 dev_err(&st->us->dev, "problem with setup control register 1");
 427                 goto err_ret;
 428         }
 429
 430         /* Read back to check this has worked acts as loose test of correct
 431          * chip */
 432         ret = lis3l02dq_spi_read_reg_8(&st->indio_dev->dev,
 433                                        LIS3L02DQ_REG_CTRL_1_ADDR,
 434                                        &valtest);
 435         if (ret || (valtest != val)) {
 436                 dev_err(&st->indio_dev->dev, "device not playing ball");
 437                 ret = -EINVAL;
 438                 goto err_ret;
 439         }
 440
 441         val = LIS3L02DQ_DEFAULT_CTRL2;
 442         ret = lis3l02dq_spi_write_reg_8(&st->indio_dev->dev,
 443                                         LIS3L02DQ_REG_CTRL_2_ADDR,
 444                                         &val);
 445         if (ret) {
 446                 dev_err(&st->us->dev, "problem with setup control register 2");
 447                 goto err_ret;
 448         }
 449
 450         val = LIS3L02DQ_REG_WAKE_UP_CFG_LATCH_SRC;
 451         ret = lis3l02dq_spi_write_reg_8(&st->indio_dev->dev,
 452                                         LIS3L02DQ_REG_WAKE_UP_CFG_ADDR,
 453                                         &val);
 454         if (ret)
 455                 dev_err(&st->us->dev, "problem with interrupt cfg register");
 456 err_ret:
 457
 458         return ret;
 459 }
 460
 461 #define LIS3L02DQ_SIGNED_ATTR(name, reg)        \
 462         IIO_DEVICE_ATTR(name,                   \
 463                         S_IWUSR | S_IRUGO,      \
 464                         lis3l02dq_read_signed,  \
 465                         lis3l02dq_write_signed, \
 466                         reg);
 467
 468 #define LIS3L02DQ_UNSIGNED_ATTR(name, reg)              \
 469         IIO_DEVICE_ATTR(name,                           \
 470                         S_IWUSR | S_IRUGO,              \
 471                         lis3l02dq_read_unsigned,        \
 472                         lis3l02dq_write_unsigned,       \
 473                         reg);
 474
 475 static LIS3L02DQ_SIGNED_ATTR(accel_x_calibbias,
 476                              LIS3L02DQ_REG_OFFSET_X_ADDR);
 477 static LIS3L02DQ_SIGNED_ATTR(accel_y_calibbias,
 478                              LIS3L02DQ_REG_OFFSET_Y_ADDR);
 479 static LIS3L02DQ_SIGNED_ATTR(accel_z_calibbias,
 480                              LIS3L02DQ_REG_OFFSET_Z_ADDR);
 481
 482 static LIS3L02DQ_UNSIGNED_ATTR(accel_x_calibscale,
 483                                LIS3L02DQ_REG_GAIN_X_ADDR);
 484 static LIS3L02DQ_UNSIGNED_ATTR(accel_y_calibscale,
 485                                LIS3L02DQ_REG_GAIN_Y_ADDR);
 486 static LIS3L02DQ_UNSIGNED_ATTR(accel_z_calibscale,
 487                                LIS3L02DQ_REG_GAIN_Z_ADDR);
 488
 489 static IIO_DEVICE_ATTR(accel_mag_either_rising_value,
 490                        S_IWUSR | S_IRUGO,
 491                        lis3l02dq_read_16bit_signed,
 492                        lis3l02dq_write_16bit_signed,
 493                        LIS3L02DQ_REG_THS_L_ADDR);
 494 /* RFC The reading method for these will change depending on whether
 495  * ring buffer capture is in use. Is it worth making these take two
 496  * functions and let the core handle which to call, or leave as in this
 497  * driver where it is the drivers problem to manage this?
 498  */
 499
 500 static IIO_DEV_ATTR_ACCEL_X(lis3l02dq_read_accel,
 501                             LIS3L02DQ_REG_OUT_X_L_ADDR);
 502
 503 static IIO_DEV_ATTR_ACCEL_Y(lis3l02dq_read_accel,
 504                             LIS3L02DQ_REG_OUT_Y_L_ADDR);
 505
 506 static IIO_DEV_ATTR_ACCEL_Z(lis3l02dq_read_accel,
 507                             LIS3L02DQ_REG_OUT_Z_L_ADDR);
 508
 509 static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
 510                               lis3l02dq_read_frequency,
 511                               lis3l02dq_write_frequency);
 512
 513 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("280 560 1120 4480");
 514
 515 static ssize_t lis3l02dq_read_interrupt_config(struct device *dev,
 516                                                struct device_attribute *attr,
 517                                                char *buf)
 518 {
 519         int ret;
 520         s8 val;
 521         struct iio_event_attr *this_attr = to_iio_event_attr(attr);
 522
 523         ret = lis3l02dq_spi_read_reg_8(dev->parent,
 524                                        LIS3L02DQ_REG_WAKE_UP_CFG_ADDR,
 525                                        (u8 *)&val);
 526
 527         return ret ? ret : sprintf(buf, "%d\n", !!(val & this_attr->mask));
 528 }
 529
 530 static ssize_t lis3l02dq_write_interrupt_config(struct device *dev,
 531                                                 struct device_attribute *attr,
 532                                                 const char *buf,
 533                                                 size_t len)
 534 {
 535         struct iio_event_attr *this_attr = to_iio_event_attr(attr);
 536         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 537         int ret, currentlyset, changed = 0;
 538         u8 valold, controlold;
 539         bool val;
 540
 541         val = !(buf[0] == '0');
 542
 543         mutex_lock(&indio_dev->mlock);
 544         /* read current value */
 545         ret = lis3l02dq_spi_read_reg_8(dev->parent,
 546                                        LIS3L02DQ_REG_WAKE_UP_CFG_ADDR,
 547                                        &valold);
 548         if (ret)
 549                 goto error_mutex_unlock;
 550
 551         /* read current control */
 552         ret = lis3l02dq_spi_read_reg_8(dev,
 553                                        LIS3L02DQ_REG_CTRL_2_ADDR,
 554                                        &controlold);
 555         if (ret)
 556                 goto error_mutex_unlock;
 557         currentlyset = !!(valold & this_attr->mask);
 558         if (val == false && currentlyset) {
 559                 valold &= ~this_attr->mask;
 560                 changed = 1;
 561                 iio_remove_event_from_list(this_attr->listel,
 562                                                  &indio_dev->interrupts[0]
 563                                                  ->ev_list);
 564         } else if (val == true && !currentlyset) {
 565                 changed = 1;
 566                 valold |= this_attr->mask;
 567                 iio_add_event_to_list(this_attr->listel,
 568                                             &indio_dev->interrupts[0]->ev_list);
 569         }
 570
 571         if (changed) {
 572                 ret = lis3l02dq_spi_write_reg_8(dev,
 573                                                 LIS3L02DQ_REG_WAKE_UP_CFG_ADDR,
 574                                                 &valold);
 575                 if (ret)
 576                         goto error_mutex_unlock;
 577                 /* This always enables the interrupt, even if we've remove the
 578                  * last thing using it. For this device we can use the reference
 579                  * count on the handler to tell us if anyone wants the interrupt
 580                  */
 581                 controlold = this_attr->listel->refcount ?
 582                         (controlold | LIS3L02DQ_REG_CTRL_2_ENABLE_INTERRUPT) :
 583                         (controlold & ~LIS3L02DQ_REG_CTRL_2_ENABLE_INTERRUPT);
 584                 ret = lis3l02dq_spi_write_reg_8(dev,
 585                                                 LIS3L02DQ_REG_CTRL_2_ADDR,
 586                                                 &controlold);
 587                 if (ret)
 588                         goto error_mutex_unlock;
 589         }
 590 error_mutex_unlock:
 591         mutex_unlock(&indio_dev->mlock);
 592
 593         return ret ? ret : len;
 594 }
 595
 596
 597 static int lis3l02dq_thresh_handler_th(struct iio_dev *dev_info,
 598                                        int index,
 599                                        s64 timestamp,
 600                                        int no_test)
 601 {
 602         struct lis3l02dq_state *st = dev_info->dev_data;
 603
 604         /* Stash the timestamp somewhere convenient for the bh */
 605         st->last_timestamp = timestamp;
 606         schedule_work(&st->work_thresh);
 607
 608         return 0;
 609 }
 610
 611
 612 /* Unforunately it appears the interrupt won't clear unless you read from the
 613  * src register.
 614  */
 615 static void lis3l02dq_thresh_handler_bh_no_check(struct work_struct *work_s)
 616 {
 617        struct lis3l02dq_state *st
 618                = container_of(work_s,
 619                        struct lis3l02dq_state, work_thresh);
 620
 621         u8 t;
 622
 623         lis3l02dq_spi_read_reg_8(&st->indio_dev->dev,
 624                                  LIS3L02DQ_REG_WAKE_UP_SRC_ADDR,
 625                                  &t);
 626
 627         if (t & LIS3L02DQ_REG_WAKE_UP_SRC_INTERRUPT_Z_HIGH)
 628                 iio_push_event(st->indio_dev, 0,
 629                                IIO_EVENT_CODE_ACCEL_Z_HIGH,
 630                                st->last_timestamp);
 631
 632         if (t & LIS3L02DQ_REG_WAKE_UP_SRC_INTERRUPT_Z_LOW)
 633                 iio_push_event(st->indio_dev, 0,
 634                                IIO_EVENT_CODE_ACCEL_Z_LOW,
 635                                st->last_timestamp);
 636
 637         if (t & LIS3L02DQ_REG_WAKE_UP_SRC_INTERRUPT_Y_HIGH)
 638                 iio_push_event(st->indio_dev, 0,
 639                                IIO_EVENT_CODE_ACCEL_Y_HIGH,
 640                                st->last_timestamp);
 641
 642         if (t & LIS3L02DQ_REG_WAKE_UP_SRC_INTERRUPT_Y_LOW)
 643                 iio_push_event(st->indio_dev, 0,
 644                                IIO_EVENT_CODE_ACCEL_Y_LOW,
 645                                st->last_timestamp);
 646
 647         if (t & LIS3L02DQ_REG_WAKE_UP_SRC_INTERRUPT_X_HIGH)
 648                 iio_push_event(st->indio_dev, 0,
 649                                IIO_EVENT_CODE_ACCEL_X_HIGH,
 650                                st->last_timestamp);
 651
 652         if (t & LIS3L02DQ_REG_WAKE_UP_SRC_INTERRUPT_X_LOW)
 653                 iio_push_event(st->indio_dev, 0,
 654                                IIO_EVENT_CODE_ACCEL_X_LOW,
 655                                st->last_timestamp);
 656         /* reenable the irq */
 657         enable_irq(st->us->irq);
 658         /* Ack and allow for new interrupts */
 659         lis3l02dq_spi_read_reg_8(&st->indio_dev->dev,
 660                                  LIS3L02DQ_REG_WAKE_UP_ACK_ADDR,
 661                                  &t);
 662
 663         return;
 664 }
 665
 666 /* A shared handler for a number of threshold types */
 667 IIO_EVENT_SH(threshold, &lis3l02dq_thresh_handler_th);
 668
 669 IIO_EVENT_ATTR_SH(accel_x_mag_pos_rising_en,
 670                   iio_event_threshold,
 671                   lis3l02dq_read_interrupt_config,
 672                   lis3l02dq_write_interrupt_config,
 673                   LIS3L02DQ_REG_WAKE_UP_CFG_INTERRUPT_X_HIGH);
 674
 675 IIO_EVENT_ATTR_SH(accel_y_mag_pos_rising_en,
 676                   iio_event_threshold,
 677                   lis3l02dq_read_interrupt_config,
 678                   lis3l02dq_write_interrupt_config,
 679                   LIS3L02DQ_REG_WAKE_UP_CFG_INTERRUPT_Y_HIGH);
 680
 681 IIO_EVENT_ATTR_SH(accel_z_mag_pos_rising_en,
 682                   iio_event_threshold,
 683                   lis3l02dq_read_interrupt_config,
 684                   lis3l02dq_write_interrupt_config,
 685                   LIS3L02DQ_REG_WAKE_UP_CFG_INTERRUPT_Z_HIGH);
 686
 687 IIO_EVENT_ATTR_SH(accel_x_mag_neg_rising_en,
 688                   iio_event_threshold,
 689                   lis3l02dq_read_interrupt_config,
 690                   lis3l02dq_write_interrupt_config,
 691                   LIS3L02DQ_REG_WAKE_UP_CFG_INTERRUPT_X_LOW);
 692
 693 IIO_EVENT_ATTR_SH(accel_y_mag_neg_rising_en,
 694                   iio_event_threshold,
 695                   lis3l02dq_read_interrupt_config,
 696                   lis3l02dq_write_interrupt_config,
 697                   LIS3L02DQ_REG_WAKE_UP_CFG_INTERRUPT_Y_LOW);
 698
 699 IIO_EVENT_ATTR_SH(accel_z_mag_neg_rising_en,
 700                   iio_event_threshold,
 701                   lis3l02dq_read_interrupt_config,
 702                   lis3l02dq_write_interrupt_config,
 703                   LIS3L02DQ_REG_WAKE_UP_CFG_INTERRUPT_Z_LOW);
 704
 705
 706 static struct attribute *lis3l02dq_event_attributes[] = {
 707         &iio_event_attr_accel_x_mag_pos_rising_en.dev_attr.attr,
 708         &iio_event_attr_accel_y_mag_pos_rising_en.dev_attr.attr,
 709         &iio_event_attr_accel_z_mag_pos_rising_en.dev_attr.attr,
 710         &iio_event_attr_accel_x_mag_neg_rising_en.dev_attr.attr,
 711         &iio_event_attr_accel_y_mag_neg_rising_en.dev_attr.attr,
 712         &iio_event_attr_accel_z_mag_neg_rising_en.dev_attr.attr,
 713         &iio_dev_attr_accel_mag_either_rising_value.dev_attr.attr,
 714         NULL
 715 };
 716
 717 static struct attribute_group lis3l02dq_event_attribute_group = {
 718         .attrs = lis3l02dq_event_attributes,
 719 };
 720
 721 static IIO_CONST_ATTR(name, "lis3l02dq");
 722 static IIO_CONST_ATTR(accel_scale, "0.00958");
 723
 724 static struct attribute *lis3l02dq_attributes[] = {
 725         &iio_dev_attr_accel_x_calibbias.dev_attr.attr,
 726         &iio_dev_attr_accel_y_calibbias.dev_attr.attr,
 727         &iio_dev_attr_accel_z_calibbias.dev_attr.attr,
 728         &iio_dev_attr_accel_x_calibscale.dev_attr.attr,
 729         &iio_dev_attr_accel_y_calibscale.dev_attr.attr,
 730         &iio_dev_attr_accel_z_calibscale.dev_attr.attr,
 731         &iio_const_attr_accel_scale.dev_attr.attr,
 732         &iio_dev_attr_accel_x_raw.dev_attr.attr,
 733         &iio_dev_attr_accel_y_raw.dev_attr.attr,
 734         &iio_dev_attr_accel_z_raw.dev_attr.attr,
 735         &iio_dev_attr_sampling_frequency.dev_attr.attr,
 736         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 737         &iio_const_attr_name.dev_attr.attr,
 738         NULL
 739 };
 740
 741 static const struct attribute_group lis3l02dq_attribute_group = {
 742         .attrs = lis3l02dq_attributes,
 743 };
 744
 745 static int __devinit lis3l02dq_probe(struct spi_device *spi)
 746 {
 747         int ret, regdone = 0;
 748         struct lis3l02dq_state *st = kzalloc(sizeof *st, GFP_KERNEL);
 749         if (!st) {
 750                 ret =  -ENOMEM;
 751                 goto error_ret;
 752         }
 753         INIT_WORK(&st->work_thresh, lis3l02dq_thresh_handler_bh_no_check);
 754         /* this is only used tor removal purposes */
 755         spi_set_drvdata(spi, st);
 756
 757         /* Allocate the comms buffers */
 758         st->rx = kzalloc(sizeof(*st->rx)*LIS3L02DQ_MAX_RX, GFP_KERNEL);
 759         if (st->rx == NULL) {
 760                 ret = -ENOMEM;
 761                 goto error_free_st;
 762         }
 763         st->tx = kzalloc(sizeof(*st->tx)*LIS3L02DQ_MAX_TX, GFP_KERNEL);
 764         if (st->tx == NULL) {
 765                 ret = -ENOMEM;
 766                 goto error_free_rx;
 767         }
 768         st->us = spi;
 769         mutex_init(&st->buf_lock);
 770         /* setup the industrialio driver allocated elements */
 771         st->indio_dev = iio_allocate_device();
 772         if (st->indio_dev == NULL) {
 773                 ret = -ENOMEM;
 774                 goto error_free_tx;
 775         }
 776
 777         st->indio_dev->dev.parent = &spi->dev;
 778         st->indio_dev->num_interrupt_lines = 1;
 779         st->indio_dev->event_attrs = &lis3l02dq_event_attribute_group;
 780         st->indio_dev->attrs = &lis3l02dq_attribute_group;
 781         st->indio_dev->dev_data = (void *)(st);
 782         st->indio_dev->driver_module = THIS_MODULE;
 783         st->indio_dev->modes = INDIO_DIRECT_MODE;
 784
 785         ret = lis3l02dq_configure_ring(st->indio_dev);
 786         if (ret)
 787                 goto error_free_dev;
 788
 789         ret = iio_device_register(st->indio_dev);
 790         if (ret)
 791                 goto error_unreg_ring_funcs;
 792         regdone = 1;
 793
 794         ret = lis3l02dq_initialize_ring(st->indio_dev->ring);
 795         if (ret) {
 796                 printk(KERN_ERR "failed to initialize the ring\n");
 797                 goto error_unreg_ring_funcs;
 798         }
 799
 800         if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0) {
 801                 st->inter = 0;
 802                 ret = iio_register_interrupt_line(spi->irq,
 803                                                   st->indio_dev,
 804                                                   0,
 805                                                   IRQF_TRIGGER_RISING,
 806                                                   "lis3l02dq");
 807                 if (ret)
 808                         goto error_uninitialize_ring;
 809
 810                 ret = lis3l02dq_probe_trigger(st->indio_dev);
 811                 if (ret)
 812                         goto error_unregister_line;
 813         }
 814
 815         /* Get the device into a sane initial state */
 816         ret = lis3l02dq_initial_setup(st);
 817         if (ret)
 818                 goto error_remove_trigger;
 819         return 0;
 820
 821 error_remove_trigger:
 822         if (st->indio_dev->modes & INDIO_RING_TRIGGERED)
 823                 lis3l02dq_remove_trigger(st->indio_dev);
 824 error_unregister_line:
 825         if (st->indio_dev->modes & INDIO_RING_TRIGGERED)
 826                 iio_unregister_interrupt_line(st->indio_dev, 0);
 827 error_uninitialize_ring:
 828         lis3l02dq_uninitialize_ring(st->indio_dev->ring);
 829 error_unreg_ring_funcs:
 830         lis3l02dq_unconfigure_ring(st->indio_dev);
 831 error_free_dev:
 832         if (regdone)
 833                 iio_device_unregister(st->indio_dev);
 834         else
 835                 iio_free_device(st->indio_dev);
 836 error_free_tx:
 837         kfree(st->tx);
 838 error_free_rx:
 839         kfree(st->rx);
 840 error_free_st:
 841         kfree(st);
 842 error_ret:
 843         return ret;
 844 }
 845
 846 /* Power down the device */
 847 static int lis3l02dq_stop_device(struct iio_dev *indio_dev)
 848 {
 849         int ret;
 850         struct lis3l02dq_state *st = indio_dev->dev_data;
 851         u8 val = 0;
 852
 853         mutex_lock(&indio_dev->mlock);
 854         ret = lis3l02dq_spi_write_reg_8(&indio_dev->dev,
 855                                         LIS3L02DQ_REG_CTRL_1_ADDR,
 856                                         &val);
 857         if (ret) {
 858                 dev_err(&st->us->dev, "problem with turning device off: ctrl1");
 859                 goto err_ret;
 860         }
 861
 862         ret = lis3l02dq_spi_write_reg_8(&indio_dev->dev,
 863                                         LIS3L02DQ_REG_CTRL_2_ADDR,
 864                                         &val);
 865         if (ret)
 866                 dev_err(&st->us->dev, "problem with turning device off: ctrl2");
 867 err_ret:
 868         mutex_unlock(&indio_dev->mlock);
 869         return ret;
 870 }
 871
 872 /* fixme, confirm ordering in this function */
 873 static int lis3l02dq_remove(struct spi_device *spi)
 874 {
 875         int ret;
 876         struct lis3l02dq_state *st = spi_get_drvdata(spi);
 877         struct iio_dev *indio_dev = st->indio_dev;
 878
 879         ret = lis3l02dq_stop_device(indio_dev);
 880         if (ret)
 881                 goto err_ret;
 882
 883         flush_scheduled_work();
 884
 885         lis3l02dq_remove_trigger(indio_dev);
 886         if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0)
 887                 iio_unregister_interrupt_line(indio_dev, 0);
 888
 889         lis3l02dq_uninitialize_ring(indio_dev->ring);
 890         lis3l02dq_unconfigure_ring(indio_dev);
 891         iio_device_unregister(indio_dev);
 892         kfree(st->tx);
 893         kfree(st->rx);
 894         kfree(st);
 895
 896         return 0;
 897
 898 err_ret:
 899         return ret;
 900 }
 901
 902 static struct spi_driver lis3l02dq_driver = {
 903         .driver = {
 904                 .name = "lis3l02dq",
 905                 .owner = THIS_MODULE,
 906         },
 907         .probe = lis3l02dq_probe,
 908         .remove = __devexit_p(lis3l02dq_remove),
 909 };
 910
 911 static __init int lis3l02dq_init(void)
 912 {
 913         return spi_register_driver(&lis3l02dq_driver);
 914 }
 915 module_init(lis3l02dq_init);
 916
 917 static __exit void lis3l02dq_exit(void)
 918 {
 919         spi_unregister_driver(&lis3l02dq_driver);
 920 }
 921 module_exit(lis3l02dq_exit);
 922
 923 MODULE_AUTHOR("Jonathan Cameron <jic23@cam.ac.uk>");
 924 MODULE_DESCRIPTION("ST LIS3L02DQ Accelerometer SPI driver");
 925 MODULE_LICENSE("GPL v2");