drivers/input/misc/cma3000_d0x.c

   1 /*
   2  * VTI CMA3000_D0x Accelerometer driver
   3  *
   4  * Copyright (C) 2010 Texas Instruments
   5  * Author: Hemanth V <hemanthv@ti.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License version 2 as published by
   9  * the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with
  17  * this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <linux/types.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/delay.h>
  23 #include <linux/slab.h>
  24 #include <linux/input.h>
  25 #include <linux/input/cma3000.h>
  26
  27 #include "cma3000_d0x.h"
  28
  29 #define CMA3000_WHOAMI      0x00
  30 #define CMA3000_REVID       0x01
  31 #define CMA3000_CTRL        0x02
  32 #define CMA3000_STATUS      0x03
  33 #define CMA3000_RSTR        0x04
  34 #define CMA3000_INTSTATUS   0x05
  35 #define CMA3000_DOUTX       0x06
  36 #define CMA3000_DOUTY       0x07
  37 #define CMA3000_DOUTZ       0x08
  38 #define CMA3000_MDTHR       0x09
  39 #define CMA3000_MDFFTMR     0x0A
  40 #define CMA3000_FFTHR       0x0B
  41
  42 #define CMA3000_RANGE2G    (1 << 7)
  43 #define CMA3000_RANGE8G    (0 << 7)
  44 #define CMA3000_BUSI2C     (0 << 4)
  45 #define CMA3000_MODEMASK   (7 << 1)
  46 #define CMA3000_GRANGEMASK (1 << 7)
  47
  48 #define CMA3000_STATUS_PERR    1
  49 #define CMA3000_INTSTATUS_FFDET (1 << 2)
  50
  51 /* Settling time delay in ms */
  52 #define CMA3000_SETDELAY    30
  53
  54 /* Delay for clearing interrupt in us */
  55 #define CMA3000_INTDELAY    44
  56
  57
  58 /*
  59  * Bit weights in mg for bit 0, other bits need
  60  * multipy factor 2^n. Eight bit is the sign bit.
  61  */
  62 #define BIT_TO_2G  18
  63 #define BIT_TO_8G  71
  64
  65 struct cma3000_accl_data {
  66         const struct cma3000_bus_ops *bus_ops;
  67         const struct cma3000_platform_data *pdata;
  68
  69         struct device *dev;
  70         struct input_dev *input_dev;
  71
  72         int bit_to_mg;
  73         int irq;
  74
  75         int g_range;
  76         u8 mode;
  77
  78         struct mutex mutex;
  79         bool opened;
  80         bool suspended;
  81 };
  82
  83 #define CMA3000_READ(data, reg, msg) \
  84         (data->bus_ops->read(data->dev, reg, msg))
  85 #define CMA3000_SET(data, reg, val, msg) \
  86         ((data)->bus_ops->write(data->dev, reg, val, msg))
  87
  88 /*
  89  * Conversion for each of the eight modes to g, depending
  90  * on G range i.e 2G or 8G. Some modes always operate in
  91  * 8G.
  92  */
  93
  94 static int mode_to_mg[8][2] = {
  95         { 0, 0 },
  96         { BIT_TO_8G, BIT_TO_2G },
  97         { BIT_TO_8G, BIT_TO_2G },
  98         { BIT_TO_8G, BIT_TO_8G },
  99         { BIT_TO_8G, BIT_TO_8G },
 100         { BIT_TO_8G, BIT_TO_2G },
 101         { BIT_TO_8G, BIT_TO_2G },
 102         { 0, 0},
 103 };
 104
 105 static void decode_mg(struct cma3000_accl_data *data, int *datax,
 106                                 int *datay, int *dataz)
 107 {
 108         /* Data in 2's complement, convert to mg */
 109         *datax = ((s8)*datax) * data->bit_to_mg;
 110         *datay = ((s8)*datay) * data->bit_to_mg;
 111         *dataz = ((s8)*dataz) * data->bit_to_mg;
 112 }
 113
 114 static irqreturn_t cma3000_thread_irq(int irq, void *dev_id)
 115 {
 116         struct cma3000_accl_data *data = dev_id;
 117         int datax, datay, dataz;
 118         u8 ctrl, mode, range, intr_status;
 119
 120         intr_status = CMA3000_READ(data, CMA3000_INTSTATUS, "interrupt status");
 121         if (intr_status < 0)
 122                 return IRQ_NONE;
 123
 124         /* Check if free fall is detected, report immediately */
 125         if (intr_status & CMA3000_INTSTATUS_FFDET) {
 126                 input_report_abs(data->input_dev, ABS_MISC, 1);
 127                 input_sync(data->input_dev);
 128         } else {
 129                 input_report_abs(data->input_dev, ABS_MISC, 0);
 130         }
 131
 132         datax = CMA3000_READ(data, CMA3000_DOUTX, "X");
 133         datay = CMA3000_READ(data, CMA3000_DOUTY, "Y");
 134         dataz = CMA3000_READ(data, CMA3000_DOUTZ, "Z");
 135
 136         ctrl = CMA3000_READ(data, CMA3000_CTRL, "ctrl");
 137         mode = (ctrl & CMA3000_MODEMASK) >> 1;
 138         range = (ctrl & CMA3000_GRANGEMASK) >> 7;
 139
 140         data->bit_to_mg = mode_to_mg[mode][range];
 141
 142         /* Interrupt not for this device */
 143         if (data->bit_to_mg == 0)
 144                 return IRQ_NONE;
 145
 146         /* Decode register values to milli g */
 147         decode_mg(data, &datax, &datay, &dataz);
 148
 149         input_report_abs(data->input_dev, ABS_X, datax);
 150         input_report_abs(data->input_dev, ABS_Y, datay);
 151         input_report_abs(data->input_dev, ABS_Z, dataz);
 152         input_sync(data->input_dev);
 153
 154         return IRQ_HANDLED;
 155 }
 156
 157 static int cma3000_reset(struct cma3000_accl_data *data)
 158 {
 159         int val;
 160
 161         /* Reset sequence */
 162         CMA3000_SET(data, CMA3000_RSTR, 0x02, "Reset");
 163         CMA3000_SET(data, CMA3000_RSTR, 0x0A, "Reset");
 164         CMA3000_SET(data, CMA3000_RSTR, 0x04, "Reset");
 165
 166         /* Settling time delay */
 167         mdelay(10);
 168
 169         val = CMA3000_READ(data, CMA3000_STATUS, "Status");
 170         if (val < 0) {
 171                 dev_err(data->dev, "Reset failed\n");
 172                 return val;
 173         }
 174
 175         if (val & CMA3000_STATUS_PERR) {
 176                 dev_err(data->dev, "Parity Error\n");
 177                 return -EIO;
 178         }
 179
 180         return 0;
 181 }
 182
 183 static int cma3000_poweron(struct cma3000_accl_data *data)
 184 {
 185         const struct cma3000_platform_data *pdata = data->pdata;
 186         u8 ctrl = 0;
 187         int ret;
 188
 189         if (data->g_range == CMARANGE_2G) {
 190                 ctrl = (data->mode << 1) | CMA3000_RANGE2G;
 191         } else if (data->g_range == CMARANGE_8G) {
 192                 ctrl = (data->mode << 1) | CMA3000_RANGE8G;
 193         } else {
 194                 dev_info(data->dev,
 195                          "Invalid G range specified, assuming 8G\n");
 196                 ctrl = (data->mode << 1) | CMA3000_RANGE8G;
 197         }
 198
 199         ctrl |= data->bus_ops->ctrl_mod;
 200
 201         CMA3000_SET(data, CMA3000_MDTHR, pdata->mdthr,
 202                     "Motion Detect Threshold");
 203         CMA3000_SET(data, CMA3000_MDFFTMR, pdata->mdfftmr,
 204                     "Time register");
 205         CMA3000_SET(data, CMA3000_FFTHR, pdata->ffthr,
 206                     "Free fall threshold");
 207         ret = CMA3000_SET(data, CMA3000_CTRL, ctrl, "Mode setting");
 208         if (ret < 0)
 209                 return -EIO;
 210
 211         msleep(CMA3000_SETDELAY);
 212
 213         return 0;
 214 }
 215
 216 static int cma3000_poweroff(struct cma3000_accl_data *data)
 217 {
 218         int ret;
 219
 220         ret = CMA3000_SET(data, CMA3000_CTRL, CMAMODE_POFF, "Mode setting");
 221         msleep(CMA3000_SETDELAY);
 222
 223         return ret;
 224 }
 225
 226 static int cma3000_open(struct input_dev *input_dev)
 227 {
 228         struct cma3000_accl_data *data = input_get_drvdata(input_dev);
 229
 230         mutex_lock(&data->mutex);
 231
 232         if (!data->suspended)
 233                 cma3000_poweron(data);
 234
 235         data->opened = true;
 236
 237         mutex_unlock(&data->mutex);
 238
 239         return 0;
 240 }
 241
 242 static void cma3000_close(struct input_dev *input_dev)
 243 {
 244         struct cma3000_accl_data *data = input_get_drvdata(input_dev);
 245
 246         mutex_lock(&data->mutex);
 247
 248         if (!data->suspended)
 249                 cma3000_poweroff(data);
 250
 251         data->opened = false;
 252
 253         mutex_unlock(&data->mutex);
 254 }
 255
 256 void cma3000_suspend(struct cma3000_accl_data *data)
 257 {
 258         mutex_lock(&data->mutex);
 259
 260         if (!data->suspended && data->opened)
 261                 cma3000_poweroff(data);
 262
 263         data->suspended = true;
 264
 265         mutex_unlock(&data->mutex);
 266 }
 267 EXPORT_SYMBOL(cma3000_suspend);
 268
 269
 270 void cma3000_resume(struct cma3000_accl_data *data)
 271 {
 272         mutex_lock(&data->mutex);
 273
 274         if (data->suspended && data->opened)
 275                 cma3000_poweron(data);
 276
 277         data->suspended = false;
 278
 279         mutex_unlock(&data->mutex);
 280 }
 281 EXPORT_SYMBOL(cma3000_resume);
 282
 283 struct cma3000_accl_data *cma3000_init(struct device *dev, int irq,
 284                                        const struct cma3000_bus_ops *bops)
 285 {
 286         const struct cma3000_platform_data *pdata = dev->platform_data;
 287         struct cma3000_accl_data *data;
 288         struct input_dev *input_dev;
 289         int rev;
 290         int error;
 291
 292         if (!pdata) {
 293                 dev_err(dev, "platform data not found\n");
 294                 error = -EINVAL;
 295                 goto err_out;
 296         }
 297
 298
 299         /* if no IRQ return error */
 300         if (irq == 0) {
 301                 error = -EINVAL;
 302                 goto err_out;
 303         }
 304
 305         data = kzalloc(sizeof(struct cma3000_accl_data), GFP_KERNEL);
 306         input_dev = input_allocate_device();
 307         if (!data || !input_dev) {
 308                 error = -ENOMEM;
 309                 goto err_free_mem;
 310         }
 311
 312         data->dev = dev;
 313         data->input_dev = input_dev;
 314         data->bus_ops = bops;
 315         data->pdata = pdata;
 316         data->irq = irq;
 317         mutex_init(&data->mutex);
 318
 319         data->mode = pdata->mode;
 320         if (data->mode < CMAMODE_DEFAULT || data->mode > CMAMODE_POFF) {
 321                 data->mode = CMAMODE_MOTDET;
 322                 dev_warn(dev,
 323                          "Invalid mode specified, assuming Motion Detect\n");
 324         }
 325
 326         data->g_range = pdata->g_range;
 327         if (data->g_range != CMARANGE_2G && data->g_range != CMARANGE_8G) {
 328                 dev_info(dev,
 329                          "Invalid G range specified, assuming 8G\n");
 330                 data->g_range = CMARANGE_8G;
 331         }
 332
 333         input_dev->name = "cma3000-accelerometer";
 334         input_dev->id.bustype = bops->bustype;
 335         input_dev->open = cma3000_open;
 336         input_dev->close = cma3000_close;
 337
 338          __set_bit(EV_ABS, input_dev->evbit);
 339
 340         input_set_abs_params(input_dev, ABS_X,
 341                         -data->g_range, data->g_range, pdata->fuzz_x, 0);
 342         input_set_abs_params(input_dev, ABS_Y,
 343                         -data->g_range, data->g_range, pdata->fuzz_y, 0);
 344         input_set_abs_params(input_dev, ABS_Z,
 345                         -data->g_range, data->g_range, pdata->fuzz_z, 0);
 346         input_set_abs_params(input_dev, ABS_MISC, 0, 1, 0, 0);
 347
 348         input_set_drvdata(input_dev, data);
 349
 350         error = cma3000_reset(data);
 351         if (error)
 352                 goto err_free_mem;
 353
 354         rev = CMA3000_READ(data, CMA3000_REVID, "Revid");
 355         if (rev < 0) {
 356                 error = rev;
 357                 goto err_free_mem;
 358         }
 359
 360         pr_info("CMA3000 Accelerometer: Revision %x\n", rev);
 361
 362         error = request_threaded_irq(irq, NULL, cma3000_thread_irq,
 363                                      pdata->irqflags | IRQF_ONESHOT,
 364                                      "cma3000_d0x", data);
 365         if (error) {
 366                 dev_err(dev, "request_threaded_irq failed\n");
 367                 goto err_free_mem;
 368         }
 369
 370         error = input_register_device(data->input_dev);
 371         if (error) {
 372                 dev_err(dev, "Unable to register input device\n");
 373                 goto err_free_irq;
 374         }
 375
 376         return data;
 377
 378 err_free_irq:
 379         free_irq(irq, data);
 380 err_free_mem:
 381         input_free_device(input_dev);
 382         kfree(data);
 383 err_out:
 384         return ERR_PTR(error);
 385 }
 386 EXPORT_SYMBOL(cma3000_init);
 387
 388 void cma3000_exit(struct cma3000_accl_data *data)
 389 {
 390         free_irq(data->irq, data);
 391         input_unregister_device(data->input_dev);
 392         kfree(data);
 393 }
 394 EXPORT_SYMBOL(cma3000_exit);
 395
 396 MODULE_DESCRIPTION("CMA3000-D0x Accelerometer Driver");
 397 MODULE_LICENSE("GPL");
 398 MODULE_AUTHOR("Hemanth V <hemanthv@ti.com>");