lis3lv02d.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  lis3lv02d.c - ST LIS3LV02DL accelerometer driver
   4 *
   5 *  Copyright (C) 2007-2008 Yan Burman
   6 *  Copyright (C) 2008 Eric Piel
   7 *  Copyright (C) 2008-2009 Pavel Machek
   8 */
   9
  10#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  11
  12#include <linux/kernel.h>
  13#include <linux/sched/signal.h>
  14#include <linux/dmi.h>
  15#include <linux/minmax.h>
  16#include <linux/module.h>
  17#include <linux/types.h>
  18#include <linux/interrupt.h>
  19#include <linux/input.h>
  20#include <linux/delay.h>
  21#include <linux/wait.h>
  22#include <linux/poll.h>
  23#include <linux/slab.h>
  24#include <linux/freezer.h>
  25#include <linux/uaccess.h>
  26#include <linux/miscdevice.h>
  27#include <linux/pm_runtime.h>
  28#include <linux/atomic.h>
  29#include <linux/of.h>
  30#include "lis3lv02d.h"
  31
  32#define DRIVER_NAME     "lis3lv02d"
  33
  34/* joystick device poll interval in milliseconds */
  35#define MDPS_POLL_INTERVAL 50
  36#define MDPS_POLL_MIN	   0
  37#define MDPS_POLL_MAX	   2000
  38
  39#define LIS3_SYSFS_POWERDOWN_DELAY 5000 /* In milliseconds */
  40
  41#define SELFTEST_OK	       0
  42#define SELFTEST_FAIL	       -1
  43#define SELFTEST_IRQ	       -2
  44
  45#define IRQ_LINE0	       0
  46#define IRQ_LINE1	       1
  47
  48/*
  49 * The sensor can also generate interrupts (DRDY) but it's pretty pointless
  50 * because they are generated even if the data do not change. So it's better
  51 * to keep the interrupt for the free-fall event. The values are updated at
  52 * 40Hz (at the lowest frequency), but as it can be pretty time consuming on
  53 * some low processor, we poll the sensor only at 20Hz... enough for the
  54 * joystick.
  55 */
  56
  57#define LIS3_PWRON_DELAY_WAI_12B	(5000)
  58#define LIS3_PWRON_DELAY_WAI_8B		(3000)
  59
  60/*
  61 * LIS3LV02D spec says 1024 LSBs corresponds 1 G -> 1LSB is 1000/1024 mG
  62 * LIS302D spec says: 18 mG / digit
  63 * LIS3_ACCURACY is used to increase accuracy of the intermediate
  64 * calculation results.
  65 */
  66#define LIS3_ACCURACY			1024
  67/* Sensitivity values for -2G +2G scale */
  68#define LIS3_SENSITIVITY_12B		((LIS3_ACCURACY * 1000) / 1024)
  69#define LIS3_SENSITIVITY_8B		(18 * LIS3_ACCURACY)
  70
  71/*
  72 * LIS331DLH spec says 1LSBs corresponds 4G/4096 -> 1LSB is 1000/1024 mG.
  73 * Below macros defines sensitivity values for +/-2G. Dataout bits for
  74 * +/-2G range is 12 bits so 4 bits adjustment must be done to get 12bit
  75 * data from 16bit value. Currently this driver supports only 2G range.
  76 */
  77#define LIS3DLH_SENSITIVITY_2G		((LIS3_ACCURACY * 1000) / 1024)
  78#define SHIFT_ADJ_2G			4
  79
  80#define LIS3_DEFAULT_FUZZ_12B		3
  81#define LIS3_DEFAULT_FLAT_12B		3
  82#define LIS3_DEFAULT_FUZZ_8B		1
  83#define LIS3_DEFAULT_FLAT_8B		1
  84
  85struct lis3lv02d lis3_dev = {
  86	.misc_wait   = __WAIT_QUEUE_HEAD_INITIALIZER(lis3_dev.misc_wait),
  87};
  88EXPORT_SYMBOL_GPL(lis3_dev);
  89
  90/* just like param_set_int() but does sanity-check so that it won't point
  91 * over the axis array size
  92 */
  93static int param_set_axis(const char *val, const struct kernel_param *kp)
  94{
  95	int ret = param_set_int(val, kp);
  96	if (!ret) {
  97		int val = *(int *)kp->arg;
  98		if (val < 0)
  99			val = -val;
 100		if (!val || val > 3)
 101			return -EINVAL;
 102	}
 103	return ret;
 104}
 105
 106static const struct kernel_param_ops param_ops_axis = {
 107	.set = param_set_axis,
 108	.get = param_get_int,
 109};
 110
 111#define param_check_axis(name, p) param_check_int(name, p)
 112
 113module_param_array_named(axes, lis3_dev.ac.as_array, axis, NULL, 0644);
 114MODULE_PARM_DESC(axes, "Axis-mapping for x,y,z directions");
 115
 116static s16 lis3lv02d_read_8(struct lis3lv02d *lis3, int reg)
 117{
 118	s8 lo;
 119	if (lis3->read(lis3, reg, &lo) < 0)
 120		return 0;
 121
 122	return lo;
 123}
 124
 125static s16 lis3lv02d_read_12(struct lis3lv02d *lis3, int reg)
 126{
 127	u8 lo, hi;
 128
 129	lis3->read(lis3, reg - 1, &lo);
 130	lis3->read(lis3, reg, &hi);
 131	/* In "12 bit right justified" mode, bit 6, bit 7, bit 8 = bit 5 */
 132	return (s16)((hi << 8) | lo);
 133}
 134
 135/* 12bits for 2G range, 13 bits for 4G range and 14 bits for 8G range */
 136static s16 lis331dlh_read_data(struct lis3lv02d *lis3, int reg)
 137{
 138	u8 lo, hi;
 139	int v;
 140
 141	lis3->read(lis3, reg - 1, &lo);
 142	lis3->read(lis3, reg, &hi);
 143	v = (int) ((hi << 8) | lo);
 144
 145	return (s16) v >> lis3->shift_adj;
 146}
 147
 148/**
 149 * lis3lv02d_get_axis - For the given axis, give the value converted
 150 * @axis:      1,2,3 - can also be negative
 151 * @hw_values: raw values returned by the hardware
 152 *
 153 * Returns the converted value.
 154 */
 155static inline int lis3lv02d_get_axis(s8 axis, int hw_values[3])
 156{
 157	if (axis > 0)
 158		return hw_values[axis - 1];
 159	else
 160		return -hw_values[-axis - 1];
 161}
 162
 163/**
 164 * lis3lv02d_get_xyz - Get X, Y and Z axis values from the accelerometer
 165 * @lis3: pointer to the device struct
 166 * @x:    where to store the X axis value
 167 * @y:    where to store the Y axis value
 168 * @z:    where to store the Z axis value
 169 *
 170 * Note that 40Hz input device can eat up about 10% CPU at 800MHZ
 171 */
 172static void lis3lv02d_get_xyz(struct lis3lv02d *lis3, int *x, int *y, int *z)
 173{
 174	int position[3];
 175	int i;
 176
 177	if (lis3->blkread) {
 178		if (lis3->whoami == WAI_12B) {
 179			u16 data[3];
 180			lis3->blkread(lis3, OUTX_L, 6, (u8 *)data);
 181			for (i = 0; i < 3; i++)
 182				position[i] = (s16)le16_to_cpu(data[i]);
 183		} else {
 184			u8 data[5];
 185			/* Data: x, dummy, y, dummy, z */
 186			lis3->blkread(lis3, OUTX, 5, data);
 187			for (i = 0; i < 3; i++)
 188				position[i] = (s8)data[i * 2];
 189		}
 190	} else {
 191		position[0] = lis3->read_data(lis3, OUTX);
 192		position[1] = lis3->read_data(lis3, OUTY);
 193		position[2] = lis3->read_data(lis3, OUTZ);
 194	}
 195
 196	for (i = 0; i < 3; i++)
 197		position[i] = (position[i] * lis3->scale) / LIS3_ACCURACY;
 198
 199	*x = lis3lv02d_get_axis(lis3->ac.x, position);
 200	*y = lis3lv02d_get_axis(lis3->ac.y, position);
 201	*z = lis3lv02d_get_axis(lis3->ac.z, position);
 202}
 203
 204/* conversion btw sampling rate and the register values */
 205static int lis3_12_rates[4] = {40, 160, 640, 2560};
 206static int lis3_8_rates[2] = {100, 400};
 207static int lis3_3dc_rates[16] = {0, 1, 10, 25, 50, 100, 200, 400, 1600, 5000};
 208static int lis3_3dlh_rates[4] = {50, 100, 400, 1000};
 209
 210/* ODR is Output Data Rate */
 211static int lis3lv02d_get_odr_index(struct lis3lv02d *lis3)
 212{
 213	u8 ctrl;
 214	int shift;
 215
 216	lis3->read(lis3, CTRL_REG1, &ctrl);
 217	ctrl &= lis3->odr_mask;
 218	shift = ffs(lis3->odr_mask) - 1;
 219	return (ctrl >> shift);
 220}
 221
 222static int lis3lv02d_get_pwron_wait(struct lis3lv02d *lis3)
 223{
 224	int odr_idx = lis3lv02d_get_odr_index(lis3);
 225	int div = lis3->odrs[odr_idx];
 226
 227	if (div == 0) {
 228		if (odr_idx == 0) {
 229			/* Power-down mode, not sampling no need to sleep */
 230			return 0;
 231		}
 232
 233		dev_err(&lis3->fdev->dev, "Error unknown odrs-index: %d\n", odr_idx);
 234		return -ENXIO;
 235	}
 236
 237	/* LIS3 power on delay is quite long */
 238	msleep(lis3->pwron_delay / div);
 239	return 0;
 240}
 241
 242static int lis3lv02d_set_odr(struct lis3lv02d *lis3, int rate)
 243{
 244	u8 ctrl;
 245	int i, len, shift;
 246
 247	if (!rate)
 248		return -EINVAL;
 249
 250	lis3->read(lis3, CTRL_REG1, &ctrl);
 251	ctrl &= ~lis3->odr_mask;
 252	len = 1 << hweight_long(lis3->odr_mask); /* # of possible values */
 253	shift = ffs(lis3->odr_mask) - 1;
 254
 255	for (i = 0; i < len; i++)
 256		if (lis3->odrs[i] == rate) {
 257			lis3->write(lis3, CTRL_REG1,
 258					ctrl | (i << shift));
 259			return 0;
 260		}
 261	return -EINVAL;
 262}
 263
 264static int lis3lv02d_selftest(struct lis3lv02d *lis3, s16 results[3])
 265{
 266	u8 ctlreg, reg;
 267	s16 x, y, z;
 268	u8 selftest;
 269	int ret;
 270	u8 ctrl_reg_data;
 271	unsigned char irq_cfg;
 272
 273	mutex_lock(&lis3->mutex);
 274
 275	irq_cfg = lis3->irq_cfg;
 276	if (lis3->whoami == WAI_8B) {
 277		lis3->data_ready_count[IRQ_LINE0] = 0;
 278		lis3->data_ready_count[IRQ_LINE1] = 0;
 279
 280		/* Change interrupt cfg to data ready for selftest */
 281		atomic_inc(&lis3->wake_thread);
 282		lis3->irq_cfg = LIS3_IRQ1_DATA_READY | LIS3_IRQ2_DATA_READY;
 283		lis3->read(lis3, CTRL_REG3, &ctrl_reg_data);
 284		lis3->write(lis3, CTRL_REG3, (ctrl_reg_data &
 285				~(LIS3_IRQ1_MASK | LIS3_IRQ2_MASK)) |
 286				(LIS3_IRQ1_DATA_READY | LIS3_IRQ2_DATA_READY));
 287	}
 288
 289	if ((lis3->whoami == WAI_3DC) || (lis3->whoami == WAI_3DLH)) {
 290		ctlreg = CTRL_REG4;
 291		selftest = CTRL4_ST0;
 292	} else {
 293		ctlreg = CTRL_REG1;
 294		if (lis3->whoami == WAI_12B)
 295			selftest = CTRL1_ST;
 296		else
 297			selftest = CTRL1_STP;
 298	}
 299
 300	lis3->read(lis3, ctlreg, &reg);
 301	lis3->write(lis3, ctlreg, (reg | selftest));
 302	ret = lis3lv02d_get_pwron_wait(lis3);
 303	if (ret)
 304		goto fail;
 305
 306	/* Read directly to avoid axis remap */
 307	x = lis3->read_data(lis3, OUTX);
 308	y = lis3->read_data(lis3, OUTY);
 309	z = lis3->read_data(lis3, OUTZ);
 310
 311	/* back to normal settings */
 312	lis3->write(lis3, ctlreg, reg);
 313	ret = lis3lv02d_get_pwron_wait(lis3);
 314	if (ret)
 315		goto fail;
 316
 317	results[0] = x - lis3->read_data(lis3, OUTX);
 318	results[1] = y - lis3->read_data(lis3, OUTY);
 319	results[2] = z - lis3->read_data(lis3, OUTZ);
 320
 321	ret = 0;
 322
 323	if (lis3->whoami == WAI_8B) {
 324		/* Restore original interrupt configuration */
 325		atomic_dec(&lis3->wake_thread);
 326		lis3->write(lis3, CTRL_REG3, ctrl_reg_data);
 327		lis3->irq_cfg = irq_cfg;
 328
 329		if ((irq_cfg & LIS3_IRQ1_MASK) &&
 330			lis3->data_ready_count[IRQ_LINE0] < 2) {
 331			ret = SELFTEST_IRQ;
 332			goto fail;
 333		}
 334
 335		if ((irq_cfg & LIS3_IRQ2_MASK) &&
 336			lis3->data_ready_count[IRQ_LINE1] < 2) {
 337			ret = SELFTEST_IRQ;
 338			goto fail;
 339		}
 340	}
 341
 342	if (lis3->pdata) {
 343		int i;
 344		for (i = 0; i < 3; i++) {
 345			/* Check against selftest acceptance limits */
 346			if ((results[i] < lis3->pdata->st_min_limits[i]) ||
 347			    (results[i] > lis3->pdata->st_max_limits[i])) {
 348				ret = SELFTEST_FAIL;
 349				goto fail;
 350			}
 351		}
 352	}
 353
 354	/* test passed */
 355fail:
 356	mutex_unlock(&lis3->mutex);
 357	return ret;
 358}
 359
 360/*
 361 * Order of registers in the list affects to order of the restore process.
 362 * Perhaps it is a good idea to set interrupt enable register as a last one
 363 * after all other configurations
 364 */
 365static u8 lis3_wai8_regs[] = { FF_WU_CFG_1, FF_WU_THS_1, FF_WU_DURATION_1,
 366			       FF_WU_CFG_2, FF_WU_THS_2, FF_WU_DURATION_2,
 367			       CLICK_CFG, CLICK_SRC, CLICK_THSY_X, CLICK_THSZ,
 368			       CLICK_TIMELIMIT, CLICK_LATENCY, CLICK_WINDOW,
 369			       CTRL_REG1, CTRL_REG2, CTRL_REG3};
 370
 371static u8 lis3_wai12_regs[] = {FF_WU_CFG, FF_WU_THS_L, FF_WU_THS_H,
 372			       FF_WU_DURATION, DD_CFG, DD_THSI_L, DD_THSI_H,
 373			       DD_THSE_L, DD_THSE_H,
 374			       CTRL_REG1, CTRL_REG3, CTRL_REG2};
 375
 376static inline void lis3_context_save(struct lis3lv02d *lis3)
 377{
 378	int i;
 379	for (i = 0; i < lis3->regs_size; i++)
 380		lis3->read(lis3, lis3->regs[i], &lis3->reg_cache[i]);
 381	lis3->regs_stored = true;
 382}
 383
 384static inline void lis3_context_restore(struct lis3lv02d *lis3)
 385{
 386	int i;
 387	if (lis3->regs_stored)
 388		for (i = 0; i < lis3->regs_size; i++)
 389			lis3->write(lis3, lis3->regs[i], lis3->reg_cache[i]);
 390}
 391
 392void lis3lv02d_poweroff(struct lis3lv02d *lis3)
 393{
 394	if (lis3->reg_ctrl)
 395		lis3_context_save(lis3);
 396	/* disable X,Y,Z axis and power down */
 397	lis3->write(lis3, CTRL_REG1, 0x00);
 398	if (lis3->reg_ctrl)
 399		lis3->reg_ctrl(lis3, LIS3_REG_OFF);
 400}
 401EXPORT_SYMBOL_GPL(lis3lv02d_poweroff);
 402
 403int lis3lv02d_poweron(struct lis3lv02d *lis3)
 404{
 405	int err;
 406	u8 reg;
 407
 408	lis3->init(lis3);
 409
 410	/*
 411	 * Common configuration
 412	 * BDU: (12 bits sensors only) LSB and MSB values are not updated until
 413	 *      both have been read. So the value read will always be correct.
 414	 * Set BOOT bit to refresh factory tuning values.
 415	 */
 416	if (lis3->pdata) {
 417		lis3->read(lis3, CTRL_REG2, &reg);
 418		if (lis3->whoami ==  WAI_12B)
 419			reg |= CTRL2_BDU | CTRL2_BOOT;
 420		else if (lis3->whoami ==  WAI_3DLH)
 421			reg |= CTRL2_BOOT_3DLH;
 422		else
 423			reg |= CTRL2_BOOT_8B;
 424		lis3->write(lis3, CTRL_REG2, reg);
 425
 426		if (lis3->whoami ==  WAI_3DLH) {
 427			lis3->read(lis3, CTRL_REG4, &reg);
 428			reg |= CTRL4_BDU;
 429			lis3->write(lis3, CTRL_REG4, reg);
 430		}
 431	}
 432
 433	err = lis3lv02d_get_pwron_wait(lis3);
 434	if (err)
 435		return err;
 436
 437	if (lis3->reg_ctrl)
 438		lis3_context_restore(lis3);
 439
 440	return 0;
 441}
 442EXPORT_SYMBOL_GPL(lis3lv02d_poweron);
 443
 444
 445static void lis3lv02d_joystick_poll(struct input_dev *input)
 446{
 447	struct lis3lv02d *lis3 = input_get_drvdata(input);
 448	int x, y, z;
 449
 450	mutex_lock(&lis3->mutex);
 451	lis3lv02d_get_xyz(lis3, &x, &y, &z);
 452	input_report_abs(input, ABS_X, x);
 453	input_report_abs(input, ABS_Y, y);
 454	input_report_abs(input, ABS_Z, z);
 455	input_sync(input);
 456	mutex_unlock(&lis3->mutex);
 457}
 458
 459static int lis3lv02d_joystick_open(struct input_dev *input)
 460{
 461	struct lis3lv02d *lis3 = input_get_drvdata(input);
 462
 463	if (lis3->pm_dev)
 464		pm_runtime_get_sync(lis3->pm_dev);
 465
 466	if (lis3->pdata && lis3->whoami == WAI_8B && lis3->idev)
 467		atomic_set(&lis3->wake_thread, 1);
 468	/*
 469	 * Update coordinates for the case where poll interval is 0 and
 470	 * the chip in running purely under interrupt control
 471	 */
 472	lis3lv02d_joystick_poll(input);
 473
 474	return 0;
 475}
 476
 477static void lis3lv02d_joystick_close(struct input_dev *input)
 478{
 479	struct lis3lv02d *lis3 = input_get_drvdata(input);
 480
 481	atomic_set(&lis3->wake_thread, 0);
 482	if (lis3->pm_dev)
 483		pm_runtime_put(lis3->pm_dev);
 484}
 485
 486static irqreturn_t lis302dl_interrupt(int irq, void *data)
 487{
 488	struct lis3lv02d *lis3 = data;
 489
 490	if (!test_bit(0, &lis3->misc_opened))
 491		goto out;
 492
 493	/*
 494	 * Be careful: on some HP laptops the bios force DD when on battery and
 495	 * the lid is closed. This leads to interrupts as soon as a little move
 496	 * is done.
 497	 */
 498	atomic_inc(&lis3->count);
 499
 500	wake_up_interruptible(&lis3->misc_wait);
 501	kill_fasync(&lis3->async_queue, SIGIO, POLL_IN);
 502out:
 503	if (atomic_read(&lis3->wake_thread))
 504		return IRQ_WAKE_THREAD;
 505	return IRQ_HANDLED;
 506}
 507
 508static void lis302dl_interrupt_handle_click(struct lis3lv02d *lis3)
 509{
 510	struct input_dev *dev = lis3->idev;
 511	u8 click_src;
 512
 513	mutex_lock(&lis3->mutex);
 514	lis3->read(lis3, CLICK_SRC, &click_src);
 515
 516	if (click_src & CLICK_SINGLE_X) {
 517		input_report_key(dev, lis3->mapped_btns[0], 1);
 518		input_report_key(dev, lis3->mapped_btns[0], 0);
 519	}
 520
 521	if (click_src & CLICK_SINGLE_Y) {
 522		input_report_key(dev, lis3->mapped_btns[1], 1);
 523		input_report_key(dev, lis3->mapped_btns[1], 0);
 524	}
 525
 526	if (click_src & CLICK_SINGLE_Z) {
 527		input_report_key(dev, lis3->mapped_btns[2], 1);
 528		input_report_key(dev, lis3->mapped_btns[2], 0);
 529	}
 530	input_sync(dev);
 531	mutex_unlock(&lis3->mutex);
 532}
 533
 534static inline void lis302dl_data_ready(struct lis3lv02d *lis3, int index)
 535{
 536	int dummy;
 537
 538	/* Dummy read to ack interrupt */
 539	lis3lv02d_get_xyz(lis3, &dummy, &dummy, &dummy);
 540	lis3->data_ready_count[index]++;
 541}
 542
 543static irqreturn_t lis302dl_interrupt_thread1_8b(int irq, void *data)
 544{
 545	struct lis3lv02d *lis3 = data;
 546	u8 irq_cfg = lis3->irq_cfg & LIS3_IRQ1_MASK;
 547
 548	if (irq_cfg == LIS3_IRQ1_CLICK)
 549		lis302dl_interrupt_handle_click(lis3);
 550	else if (unlikely(irq_cfg == LIS3_IRQ1_DATA_READY))
 551		lis302dl_data_ready(lis3, IRQ_LINE0);
 552	else
 553		lis3lv02d_joystick_poll(lis3->idev);
 554
 555	return IRQ_HANDLED;
 556}
 557
 558static irqreturn_t lis302dl_interrupt_thread2_8b(int irq, void *data)
 559{
 560	struct lis3lv02d *lis3 = data;
 561	u8 irq_cfg = lis3->irq_cfg & LIS3_IRQ2_MASK;
 562
 563	if (irq_cfg == LIS3_IRQ2_CLICK)
 564		lis302dl_interrupt_handle_click(lis3);
 565	else if (unlikely(irq_cfg == LIS3_IRQ2_DATA_READY))
 566		lis302dl_data_ready(lis3, IRQ_LINE1);
 567	else
 568		lis3lv02d_joystick_poll(lis3->idev);
 569
 570	return IRQ_HANDLED;
 571}
 572
 573static int lis3lv02d_misc_open(struct inode *inode, struct file *file)
 574{
 575	struct lis3lv02d *lis3 = container_of(file->private_data,
 576					      struct lis3lv02d, miscdev);
 577
 578	if (test_and_set_bit(0, &lis3->misc_opened))
 579		return -EBUSY; /* already open */
 580
 581	if (lis3->pm_dev)
 582		pm_runtime_get_sync(lis3->pm_dev);
 583
 584	atomic_set(&lis3->count, 0);
 585	return 0;
 586}
 587
 588static int lis3lv02d_misc_release(struct inode *inode, struct file *file)
 589{
 590	struct lis3lv02d *lis3 = container_of(file->private_data,
 591					      struct lis3lv02d, miscdev);
 592
 593	clear_bit(0, &lis3->misc_opened); /* release the device */
 594	if (lis3->pm_dev)
 595		pm_runtime_put(lis3->pm_dev);
 596	return 0;
 597}
 598
 599static ssize_t lis3lv02d_misc_read(struct file *file, char __user *buf,
 600				size_t count, loff_t *pos)
 601{
 602	struct lis3lv02d *lis3 = container_of(file->private_data,
 603					      struct lis3lv02d, miscdev);
 604
 605	DECLARE_WAITQUEUE(wait, current);
 606	u32 data;
 607	unsigned char byte_data;
 608	ssize_t retval = 1;
 609
 610	if (count < 1)
 611		return -EINVAL;
 612
 613	add_wait_queue(&lis3->misc_wait, &wait);
 614	while (true) {
 615		set_current_state(TASK_INTERRUPTIBLE);
 616		data = atomic_xchg(&lis3->count, 0);
 617		if (data)
 618			break;
 619
 620		if (file->f_flags & O_NONBLOCK) {
 621			retval = -EAGAIN;
 622			goto out;
 623		}
 624
 625		if (signal_pending(current)) {
 626			retval = -ERESTARTSYS;
 627			goto out;
 628		}
 629
 630		schedule();
 631	}
 632
 633	byte_data = min(data, 255);
 634
 635	/* make sure we are not going into copy_to_user() with
 636	 * TASK_INTERRUPTIBLE state */
 637	set_current_state(TASK_RUNNING);
 638	if (copy_to_user(buf, &byte_data, sizeof(byte_data)))
 639		retval = -EFAULT;
 640
 641out:
 642	__set_current_state(TASK_RUNNING);
 643	remove_wait_queue(&lis3->misc_wait, &wait);
 644
 645	return retval;
 646}
 647
 648static __poll_t lis3lv02d_misc_poll(struct file *file, poll_table *wait)
 649{
 650	struct lis3lv02d *lis3 = container_of(file->private_data,
 651					      struct lis3lv02d, miscdev);
 652
 653	poll_wait(file, &lis3->misc_wait, wait);
 654	if (atomic_read(&lis3->count))
 655		return EPOLLIN | EPOLLRDNORM;
 656	return 0;
 657}
 658
 659static int lis3lv02d_misc_fasync(int fd, struct file *file, int on)
 660{
 661	struct lis3lv02d *lis3 = container_of(file->private_data,
 662					      struct lis3lv02d, miscdev);
 663
 664	return fasync_helper(fd, file, on, &lis3->async_queue);
 665}
 666
 667static const struct file_operations lis3lv02d_misc_fops = {
 668	.owner   = THIS_MODULE,
 669	.read    = lis3lv02d_misc_read,
 670	.open    = lis3lv02d_misc_open,
 671	.release = lis3lv02d_misc_release,
 672	.poll    = lis3lv02d_misc_poll,
 673	.fasync  = lis3lv02d_misc_fasync,
 674};
 675
 676int lis3lv02d_joystick_enable(struct lis3lv02d *lis3)
 677{
 678	struct input_dev *input_dev;
 679	int err;
 680	int max_val, fuzz, flat;
 681	int btns[] = {BTN_X, BTN_Y, BTN_Z};
 682
 683	if (lis3->idev)
 684		return -EINVAL;
 685
 686	input_dev = input_allocate_device();
 687	if (!input_dev)
 688		return -ENOMEM;
 689
 690	input_dev->name       = "ST LIS3LV02DL Accelerometer";
 691	input_dev->phys       = DRIVER_NAME "/input0";
 692	input_dev->id.bustype = BUS_HOST;
 693	input_dev->id.vendor  = 0;
 694	input_dev->dev.parent = &lis3->fdev->dev;
 695
 696	input_dev->open = lis3lv02d_joystick_open;
 697	input_dev->close = lis3lv02d_joystick_close;
 698
 699	max_val = (lis3->mdps_max_val * lis3->scale) / LIS3_ACCURACY;
 700	if (lis3->whoami == WAI_12B) {
 701		fuzz = LIS3_DEFAULT_FUZZ_12B;
 702		flat = LIS3_DEFAULT_FLAT_12B;
 703	} else {
 704		fuzz = LIS3_DEFAULT_FUZZ_8B;
 705		flat = LIS3_DEFAULT_FLAT_8B;
 706	}
 707	fuzz = (fuzz * lis3->scale) / LIS3_ACCURACY;
 708	flat = (flat * lis3->scale) / LIS3_ACCURACY;
 709
 710	input_set_abs_params(input_dev, ABS_X, -max_val, max_val, fuzz, flat);
 711	input_set_abs_params(input_dev, ABS_Y, -max_val, max_val, fuzz, flat);
 712	input_set_abs_params(input_dev, ABS_Z, -max_val, max_val, fuzz, flat);
 713
 714	input_set_drvdata(input_dev, lis3);
 715	lis3->idev = input_dev;
 716
 717	err = input_setup_polling(input_dev, lis3lv02d_joystick_poll);
 718	if (err)
 719		goto err_free_input;
 720
 721	input_set_poll_interval(input_dev, MDPS_POLL_INTERVAL);
 722	input_set_min_poll_interval(input_dev, MDPS_POLL_MIN);
 723	input_set_max_poll_interval(input_dev, MDPS_POLL_MAX);
 724
 725	lis3->mapped_btns[0] = lis3lv02d_get_axis(abs(lis3->ac.x), btns);
 726	lis3->mapped_btns[1] = lis3lv02d_get_axis(abs(lis3->ac.y), btns);
 727	lis3->mapped_btns[2] = lis3lv02d_get_axis(abs(lis3->ac.z), btns);
 728
 729	err = input_register_device(lis3->idev);
 730	if (err)
 731		goto err_free_input;
 732
 733	return 0;
 734
 735err_free_input:
 736	input_free_device(input_dev);
 737	lis3->idev = NULL;
 738	return err;
 739
 740}
 741EXPORT_SYMBOL_GPL(lis3lv02d_joystick_enable);
 742
 743void lis3lv02d_joystick_disable(struct lis3lv02d *lis3)
 744{
 745	if (lis3->irq)
 746		free_irq(lis3->irq, lis3);
 747	if (lis3->pdata && lis3->pdata->irq2)
 748		free_irq(lis3->pdata->irq2, lis3);
 749
 750	if (!lis3->idev)
 751		return;
 752
 753	if (lis3->irq)
 754		misc_deregister(&lis3->miscdev);
 755	input_unregister_device(lis3->idev);
 756	lis3->idev = NULL;
 757}
 758EXPORT_SYMBOL_GPL(lis3lv02d_joystick_disable);
 759
 760/* Sysfs stuff */
 761static void lis3lv02d_sysfs_poweron(struct lis3lv02d *lis3)
 762{
 763	/*
 764	 * SYSFS functions are fast visitors so put-call
 765	 * immediately after the get-call. However, keep
 766	 * chip running for a while and schedule delayed
 767	 * suspend. This way periodic sysfs calls doesn't
 768	 * suffer from relatively long power up time.
 769	 */
 770
 771	if (lis3->pm_dev) {
 772		pm_runtime_get_sync(lis3->pm_dev);
 773		pm_runtime_put_noidle(lis3->pm_dev);
 774		pm_schedule_suspend(lis3->pm_dev, LIS3_SYSFS_POWERDOWN_DELAY);
 775	}
 776}
 777
 778static ssize_t lis3lv02d_selftest_show(struct device *dev,
 779				struct device_attribute *attr, char *buf)
 780{
 781	struct lis3lv02d *lis3 = dev_get_drvdata(dev);
 782	s16 values[3];
 783
 784	static const char ok[] = "OK";
 785	static const char fail[] = "FAIL";
 786	static const char irq[] = "FAIL_IRQ";
 787	const char *res;
 788
 789	lis3lv02d_sysfs_poweron(lis3);
 790	switch (lis3lv02d_selftest(lis3, values)) {
 791	case SELFTEST_FAIL:
 792		res = fail;
 793		break;
 794	case SELFTEST_IRQ:
 795		res = irq;
 796		break;
 797	case SELFTEST_OK:
 798	default:
 799		res = ok;
 800		break;
 801	}
 802	return sprintf(buf, "%s %d %d %d\n", res,
 803		values[0], values[1], values[2]);
 804}
 805
 806static ssize_t lis3lv02d_position_show(struct device *dev,
 807				struct device_attribute *attr, char *buf)
 808{
 809	struct lis3lv02d *lis3 = dev_get_drvdata(dev);
 810	int x, y, z;
 811
 812	lis3lv02d_sysfs_poweron(lis3);
 813	mutex_lock(&lis3->mutex);
 814	lis3lv02d_get_xyz(lis3, &x, &y, &z);
 815	mutex_unlock(&lis3->mutex);
 816	return sprintf(buf, "(%d,%d,%d)\n", x, y, z);
 817}
 818
 819static ssize_t lis3lv02d_rate_show(struct device *dev,
 820			struct device_attribute *attr, char *buf)
 821{
 822	struct lis3lv02d *lis3 = dev_get_drvdata(dev);
 823	int odr_idx;
 824
 825	lis3lv02d_sysfs_poweron(lis3);
 826
 827	odr_idx = lis3lv02d_get_odr_index(lis3);
 828	return sprintf(buf, "%d\n", lis3->odrs[odr_idx]);
 829}
 830
 831static ssize_t lis3lv02d_rate_set(struct device *dev,
 832				struct device_attribute *attr, const char *buf,
 833				size_t count)
 834{
 835	struct lis3lv02d *lis3 = dev_get_drvdata(dev);
 836	unsigned long rate;
 837	int ret;
 838
 839	ret = kstrtoul(buf, 0, &rate);
 840	if (ret)
 841		return ret;
 842
 843	lis3lv02d_sysfs_poweron(lis3);
 844	if (lis3lv02d_set_odr(lis3, rate))
 845		return -EINVAL;
 846
 847	return count;
 848}
 849
 850static DEVICE_ATTR(selftest, S_IRUSR, lis3lv02d_selftest_show, NULL);
 851static DEVICE_ATTR(position, S_IRUGO, lis3lv02d_position_show, NULL);
 852static DEVICE_ATTR(rate, S_IRUGO | S_IWUSR, lis3lv02d_rate_show,
 853					    lis3lv02d_rate_set);
 854
 855static struct attribute *lis3lv02d_attrs[] = {
 856	&dev_attr_selftest.attr,
 857	&dev_attr_position.attr,
 858	&dev_attr_rate.attr,
 859	NULL
 860};
 861ATTRIBUTE_GROUPS(lis3lv02d);
 862
 863static int lis3lv02d_add_fs(struct lis3lv02d *lis3)
 864{
 865	lis3->fdev = faux_device_create_with_groups(DRIVER_NAME, NULL, NULL, lis3lv02d_groups);
 866	if (!lis3->fdev)
 867		return -ENODEV;
 868
 869	faux_device_set_drvdata(lis3->fdev, lis3);
 870	return 0;
 871}
 872
 873void lis3lv02d_remove_fs(struct lis3lv02d *lis3)
 874{
 875	faux_device_destroy(lis3->fdev);
 876	if (lis3->pm_dev) {
 877		/* Barrier after the sysfs remove */
 878		pm_runtime_barrier(lis3->pm_dev);
 879
 880		/* SYSFS may have left chip running. Turn off if necessary */
 881		if (!pm_runtime_suspended(lis3->pm_dev))
 882			lis3lv02d_poweroff(lis3);
 883
 884		pm_runtime_disable(lis3->pm_dev);
 885		pm_runtime_set_suspended(lis3->pm_dev);
 886	}
 887	kfree(lis3->reg_cache);
 888}
 889EXPORT_SYMBOL_GPL(lis3lv02d_remove_fs);
 890
 891static void lis3lv02d_8b_configure(struct lis3lv02d *lis3,
 892				struct lis3lv02d_platform_data *p)
 893{
 894	int err;
 895	int ctrl2 = p->hipass_ctrl;
 896
 897	if (p->click_flags) {
 898		lis3->write(lis3, CLICK_CFG, p->click_flags);
 899		lis3->write(lis3, CLICK_TIMELIMIT, p->click_time_limit);
 900		lis3->write(lis3, CLICK_LATENCY, p->click_latency);
 901		lis3->write(lis3, CLICK_WINDOW, p->click_window);
 902		lis3->write(lis3, CLICK_THSZ, p->click_thresh_z & 0xf);
 903		lis3->write(lis3, CLICK_THSY_X,
 904			(p->click_thresh_x & 0xf) |
 905			(p->click_thresh_y << 4));
 906
 907		if (lis3->idev) {
 908			input_set_capability(lis3->idev, EV_KEY, BTN_X);
 909			input_set_capability(lis3->idev, EV_KEY, BTN_Y);
 910			input_set_capability(lis3->idev, EV_KEY, BTN_Z);
 911		}
 912	}
 913
 914	if (p->wakeup_flags) {
 915		lis3->write(lis3, FF_WU_CFG_1, p->wakeup_flags);
 916		lis3->write(lis3, FF_WU_THS_1, p->wakeup_thresh & 0x7f);
 917		/* pdata value + 1 to keep this backward compatible*/
 918		lis3->write(lis3, FF_WU_DURATION_1, p->duration1 + 1);
 919		ctrl2 ^= HP_FF_WU1; /* Xor to keep compatible with old pdata*/
 920	}
 921
 922	if (p->wakeup_flags2) {
 923		lis3->write(lis3, FF_WU_CFG_2, p->wakeup_flags2);
 924		lis3->write(lis3, FF_WU_THS_2, p->wakeup_thresh2 & 0x7f);
 925		/* pdata value + 1 to keep this backward compatible*/
 926		lis3->write(lis3, FF_WU_DURATION_2, p->duration2 + 1);
 927		ctrl2 ^= HP_FF_WU2; /* Xor to keep compatible with old pdata*/
 928	}
 929	/* Configure hipass filters */
 930	lis3->write(lis3, CTRL_REG2, ctrl2);
 931
 932	if (p->irq2) {
 933		err = request_threaded_irq(p->irq2,
 934					NULL,
 935					lis302dl_interrupt_thread2_8b,
 936					IRQF_TRIGGER_RISING | IRQF_ONESHOT |
 937					(p->irq_flags2 & IRQF_TRIGGER_MASK),
 938					DRIVER_NAME, lis3);
 939		if (err < 0)
 940			pr_err("No second IRQ. Limited functionality\n");
 941	}
 942}
 943
 944#ifdef CONFIG_OF
 945int lis3lv02d_init_dt(struct lis3lv02d *lis3)
 946{
 947	struct lis3lv02d_platform_data *pdata;
 948	struct device_node *np = lis3->of_node;
 949	u32 val;
 950	s32 sval;
 951
 952	if (!lis3->of_node)
 953		return 0;
 954
 955	pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
 956	if (!pdata)
 957		return -ENOMEM;
 958
 959	if (of_property_read_bool(np, "st,click-single-x"))
 960		pdata->click_flags |= LIS3_CLICK_SINGLE_X;
 961	if (of_property_read_bool(np, "st,click-double-x"))
 962		pdata->click_flags |= LIS3_CLICK_DOUBLE_X;
 963
 964	if (of_property_read_bool(np, "st,click-single-y"))
 965		pdata->click_flags |= LIS3_CLICK_SINGLE_Y;
 966	if (of_property_read_bool(np, "st,click-double-y"))
 967		pdata->click_flags |= LIS3_CLICK_DOUBLE_Y;
 968
 969	if (of_property_read_bool(np, "st,click-single-z"))
 970		pdata->click_flags |= LIS3_CLICK_SINGLE_Z;
 971	if (of_property_read_bool(np, "st,click-double-z"))
 972		pdata->click_flags |= LIS3_CLICK_DOUBLE_Z;
 973
 974	if (!of_property_read_u32(np, "st,click-threshold-x", &val))
 975		pdata->click_thresh_x = val;
 976	if (!of_property_read_u32(np, "st,click-threshold-y", &val))
 977		pdata->click_thresh_y = val;
 978	if (!of_property_read_u32(np, "st,click-threshold-z", &val))
 979		pdata->click_thresh_z = val;
 980
 981	if (!of_property_read_u32(np, "st,click-time-limit", &val))
 982		pdata->click_time_limit = val;
 983	if (!of_property_read_u32(np, "st,click-latency", &val))
 984		pdata->click_latency = val;
 985	if (!of_property_read_u32(np, "st,click-window", &val))
 986		pdata->click_window = val;
 987
 988	if (of_property_read_bool(np, "st,irq1-disable"))
 989		pdata->irq_cfg |= LIS3_IRQ1_DISABLE;
 990	if (of_property_read_bool(np, "st,irq1-ff-wu-1"))
 991		pdata->irq_cfg |= LIS3_IRQ1_FF_WU_1;
 992	if (of_property_read_bool(np, "st,irq1-ff-wu-2"))
 993		pdata->irq_cfg |= LIS3_IRQ1_FF_WU_2;
 994	if (of_property_read_bool(np, "st,irq1-data-ready"))
 995		pdata->irq_cfg |= LIS3_IRQ1_DATA_READY;
 996	if (of_property_read_bool(np, "st,irq1-click"))
 997		pdata->irq_cfg |= LIS3_IRQ1_CLICK;
 998
 999	if (of_property_read_bool(np, "st,irq2-disable"))
1000		pdata->irq_cfg |= LIS3_IRQ2_DISABLE;
1001	if (of_property_read_bool(np, "st,irq2-ff-wu-1"))
1002		pdata->irq_cfg |= LIS3_IRQ2_FF_WU_1;
1003	if (of_property_read_bool(np, "st,irq2-ff-wu-2"))
1004		pdata->irq_cfg |= LIS3_IRQ2_FF_WU_2;
1005	if (of_property_read_bool(np, "st,irq2-data-ready"))
1006		pdata->irq_cfg |= LIS3_IRQ2_DATA_READY;
1007	if (of_property_read_bool(np, "st,irq2-click"))
1008		pdata->irq_cfg |= LIS3_IRQ2_CLICK;
1009
1010	if (of_property_read_bool(np, "st,irq-open-drain"))
1011		pdata->irq_cfg |= LIS3_IRQ_OPEN_DRAIN;
1012	if (of_property_read_bool(np, "st,irq-active-low"))
1013		pdata->irq_cfg |= LIS3_IRQ_ACTIVE_LOW;
1014
1015	if (!of_property_read_u32(np, "st,wu-duration-1", &val))
1016		pdata->duration1 = val;
1017	if (!of_property_read_u32(np, "st,wu-duration-2", &val))
1018		pdata->duration2 = val;
1019
1020	if (of_property_read_bool(np, "st,wakeup-x-lo"))
1021		pdata->wakeup_flags |= LIS3_WAKEUP_X_LO;
1022	if (of_property_read_bool(np, "st,wakeup-x-hi"))
1023		pdata->wakeup_flags |= LIS3_WAKEUP_X_HI;
1024	if (of_property_read_bool(np, "st,wakeup-y-lo"))
1025		pdata->wakeup_flags |= LIS3_WAKEUP_Y_LO;
1026	if (of_property_read_bool(np, "st,wakeup-y-hi"))
1027		pdata->wakeup_flags |= LIS3_WAKEUP_Y_HI;
1028	if (of_property_read_bool(np, "st,wakeup-z-lo"))
1029		pdata->wakeup_flags |= LIS3_WAKEUP_Z_LO;
1030	if (of_property_read_bool(np, "st,wakeup-z-hi"))
1031		pdata->wakeup_flags |= LIS3_WAKEUP_Z_HI;
1032	if (!of_property_read_u32(np, "st,wakeup-threshold", &val))
1033		pdata->wakeup_thresh = val;
1034
1035	if (of_property_read_bool(np, "st,wakeup2-x-lo"))
1036		pdata->wakeup_flags2 |= LIS3_WAKEUP_X_LO;
1037	if (of_property_read_bool(np, "st,wakeup2-x-hi"))
1038		pdata->wakeup_flags2 |= LIS3_WAKEUP_X_HI;
1039	if (of_property_read_bool(np, "st,wakeup2-y-lo"))
1040		pdata->wakeup_flags2 |= LIS3_WAKEUP_Y_LO;
1041	if (of_property_read_bool(np, "st,wakeup2-y-hi"))
1042		pdata->wakeup_flags2 |= LIS3_WAKEUP_Y_HI;
1043	if (of_property_read_bool(np, "st,wakeup2-z-lo"))
1044		pdata->wakeup_flags2 |= LIS3_WAKEUP_Z_LO;
1045	if (of_property_read_bool(np, "st,wakeup2-z-hi"))
1046		pdata->wakeup_flags2 |= LIS3_WAKEUP_Z_HI;
1047	if (!of_property_read_u32(np, "st,wakeup2-threshold", &val))
1048		pdata->wakeup_thresh2 = val;
1049
1050	if (!of_property_read_u32(np, "st,highpass-cutoff-hz", &val)) {
1051		switch (val) {
1052		case 1:
1053			pdata->hipass_ctrl = LIS3_HIPASS_CUTFF_1HZ;
1054			break;
1055		case 2:
1056			pdata->hipass_ctrl = LIS3_HIPASS_CUTFF_2HZ;
1057			break;
1058		case 4:
1059			pdata->hipass_ctrl = LIS3_HIPASS_CUTFF_4HZ;
1060			break;
1061		case 8:
1062			pdata->hipass_ctrl = LIS3_HIPASS_CUTFF_8HZ;
1063			break;
1064		}
1065	}
1066
1067	if (of_property_read_bool(np, "st,hipass1-disable"))
1068		pdata->hipass_ctrl |= LIS3_HIPASS1_DISABLE;
1069	if (of_property_read_bool(np, "st,hipass2-disable"))
1070		pdata->hipass_ctrl |= LIS3_HIPASS2_DISABLE;
1071
1072	if (of_property_read_s32(np, "st,axis-x", &sval) == 0)
1073		pdata->axis_x = sval;
1074	if (of_property_read_s32(np, "st,axis-y", &sval) == 0)
1075		pdata->axis_y = sval;
1076	if (of_property_read_s32(np, "st,axis-z", &sval) == 0)
1077		pdata->axis_z = sval;
1078
1079	if (of_property_read_u32(np, "st,default-rate", &val) == 0)
1080		pdata->default_rate = val;
1081
1082	if (of_property_read_s32(np, "st,min-limit-x", &sval) == 0)
1083		pdata->st_min_limits[0] = sval;
1084	if (of_property_read_s32(np, "st,min-limit-y", &sval) == 0)
1085		pdata->st_min_limits[1] = sval;
1086	if (of_property_read_s32(np, "st,min-limit-z", &sval) == 0)
1087		pdata->st_min_limits[2] = sval;
1088
1089	if (of_property_read_s32(np, "st,max-limit-x", &sval) == 0)
1090		pdata->st_max_limits[0] = sval;
1091	if (of_property_read_s32(np, "st,max-limit-y", &sval) == 0)
1092		pdata->st_max_limits[1] = sval;
1093	if (of_property_read_s32(np, "st,max-limit-z", &sval) == 0)
1094		pdata->st_max_limits[2] = sval;
1095
1096
1097	lis3->pdata = pdata;
1098
1099	return 0;
1100}
1101
1102#else
1103int lis3lv02d_init_dt(struct lis3lv02d *lis3)
1104{
1105	return 0;
1106}
1107#endif
1108EXPORT_SYMBOL_GPL(lis3lv02d_init_dt);
1109
1110/*
1111 * Initialise the accelerometer and the various subsystems.
1112 * Should be rather independent of the bus system.
1113 */
1114int lis3lv02d_init_device(struct lis3lv02d *lis3)
1115{
1116	int err;
1117	irq_handler_t thread_fn;
1118	int irq_flags = 0;
1119
1120	lis3->whoami = lis3lv02d_read_8(lis3, WHO_AM_I);
1121
1122	switch (lis3->whoami) {
1123	case WAI_12B:
1124		pr_info("12 bits sensor found\n");
1125		lis3->read_data = lis3lv02d_read_12;
1126		lis3->mdps_max_val = 2048;
1127		lis3->pwron_delay = LIS3_PWRON_DELAY_WAI_12B;
1128		lis3->odrs = lis3_12_rates;
1129		lis3->odr_mask = CTRL1_DF0 | CTRL1_DF1;
1130		lis3->scale = LIS3_SENSITIVITY_12B;
1131		lis3->regs = lis3_wai12_regs;
1132		lis3->regs_size = ARRAY_SIZE(lis3_wai12_regs);
1133		break;
1134	case WAI_8B:
1135		pr_info("8 bits sensor found\n");
1136		lis3->read_data = lis3lv02d_read_8;
1137		lis3->mdps_max_val = 128;
1138		lis3->pwron_delay = LIS3_PWRON_DELAY_WAI_8B;
1139		lis3->odrs = lis3_8_rates;
1140		lis3->odr_mask = CTRL1_DR;
1141		lis3->scale = LIS3_SENSITIVITY_8B;
1142		lis3->regs = lis3_wai8_regs;
1143		lis3->regs_size = ARRAY_SIZE(lis3_wai8_regs);
1144		break;
1145	case WAI_3DC:
1146		pr_info("8 bits 3DC sensor found\n");
1147		lis3->read_data = lis3lv02d_read_8;
1148		lis3->mdps_max_val = 128;
1149		lis3->pwron_delay = LIS3_PWRON_DELAY_WAI_8B;
1150		lis3->odrs = lis3_3dc_rates;
1151		lis3->odr_mask = CTRL1_ODR0|CTRL1_ODR1|CTRL1_ODR2|CTRL1_ODR3;
1152		lis3->scale = LIS3_SENSITIVITY_8B;
1153		break;
1154	case WAI_3DLH:
1155		pr_info("16 bits lis331dlh sensor found\n");
1156		lis3->read_data = lis331dlh_read_data;
1157		lis3->mdps_max_val = 2048; /* 12 bits for 2G */
1158		lis3->shift_adj = SHIFT_ADJ_2G;
1159		lis3->pwron_delay = LIS3_PWRON_DELAY_WAI_8B;
1160		lis3->odrs = lis3_3dlh_rates;
1161		lis3->odr_mask = CTRL1_DR0 | CTRL1_DR1;
1162		lis3->scale = LIS3DLH_SENSITIVITY_2G;
1163		break;
1164	default:
1165		pr_err("unknown sensor type 0x%X\n", lis3->whoami);
1166		return -ENODEV;
1167	}
1168
1169	lis3->reg_cache = kzalloc(max(sizeof(lis3_wai8_regs),
1170				     sizeof(lis3_wai12_regs)), GFP_KERNEL);
1171
1172	if (lis3->reg_cache == NULL)
1173		return -ENOMEM;
1174
1175	mutex_init(&lis3->mutex);
1176	atomic_set(&lis3->wake_thread, 0);
1177
1178	lis3lv02d_add_fs(lis3);
1179	err = lis3lv02d_poweron(lis3);
1180	if (err) {
1181		lis3lv02d_remove_fs(lis3);
1182		return err;
1183	}
1184
1185	if (lis3->pm_dev) {
1186		pm_runtime_set_active(lis3->pm_dev);
1187		pm_runtime_enable(lis3->pm_dev);
1188	}
1189
1190	if (lis3lv02d_joystick_enable(lis3))
1191		pr_err("joystick initialization failed\n");
1192
1193	/* passing in platform specific data is purely optional and only
1194	 * used by the SPI transport layer at the moment */
1195	if (lis3->pdata) {
1196		struct lis3lv02d_platform_data *p = lis3->pdata;
1197
1198		if (lis3->whoami == WAI_8B)
1199			lis3lv02d_8b_configure(lis3, p);
1200
1201		irq_flags = p->irq_flags1 & IRQF_TRIGGER_MASK;
1202
1203		lis3->irq_cfg = p->irq_cfg;
1204		if (p->irq_cfg)
1205			lis3->write(lis3, CTRL_REG3, p->irq_cfg);
1206
1207		if (p->default_rate)
1208			lis3lv02d_set_odr(lis3, p->default_rate);
1209	}
1210
1211	/* bail if we did not get an IRQ from the bus layer */
1212	if (!lis3->irq) {
1213		pr_debug("No IRQ. Disabling /dev/freefall\n");
1214		goto out;
1215	}
1216
1217	/*
1218	 * The sensor can generate interrupts for free-fall and direction
1219	 * detection (distinguishable with FF_WU_SRC and DD_SRC) but to keep
1220	 * the things simple and _fast_ we activate it only for free-fall, so
1221	 * no need to read register (very slow with ACPI). For the same reason,
1222	 * we forbid shared interrupts.
1223	 *
1224	 * IRQF_TRIGGER_RISING seems pointless on HP laptops because the
1225	 * io-apic is not configurable (and generates a warning) but I keep it
1226	 * in case of support for other hardware.
1227	 */
1228	if (lis3->pdata && lis3->whoami == WAI_8B)
1229		thread_fn = lis302dl_interrupt_thread1_8b;
1230	else
1231		thread_fn = NULL;
1232
1233	err = request_threaded_irq(lis3->irq, lis302dl_interrupt,
1234				thread_fn,
1235				IRQF_TRIGGER_RISING | IRQF_ONESHOT |
1236				irq_flags,
1237				DRIVER_NAME, lis3);
1238
1239	if (err < 0) {
1240		pr_err("Cannot get IRQ\n");
1241		goto out;
1242	}
1243
1244	lis3->miscdev.minor	= MISC_DYNAMIC_MINOR;
1245	lis3->miscdev.name	= "freefall";
1246	lis3->miscdev.fops	= &lis3lv02d_misc_fops;
1247
1248	if (misc_register(&lis3->miscdev))
1249		pr_err("misc_register failed\n");
1250out:
1251	return 0;
1252}
1253EXPORT_SYMBOL_GPL(lis3lv02d_init_device);
1254
1255MODULE_DESCRIPTION("ST LIS3LV02Dx three-axis digital accelerometer driver");
1256MODULE_AUTHOR("Yan Burman, Eric Piel, Pavel Machek");
1257MODULE_LICENSE("GPL");