lis3lv02d.c | searchcode

/drivers/misc/lis3lv02d/lis3lv02d.c

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