hp_accel.c 11.7 KB
Newer Older
1 2 3 4 5
/*
 *  hp_accel.c - Interface between LIS3LV02DL driver and HP ACPI BIOS
 *
 *  Copyright (C) 2007-2008 Yan Burman
 *  Copyright (C) 2008 Eric Piel
6
 *  Copyright (C) 2008-2009 Pavel Machek
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

23 24
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

25 26 27 28 29 30 31 32 33 34 35 36
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/dmi.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <linux/freezer.h>
#include <linux/uaccess.h>
E
Eric Piel 已提交
37
#include <linux/leds.h>
38
#include <linux/atomic.h>
39
#include <acpi/acpi_drivers.h>
40
#include "../../misc/lis3lv02d/lis3lv02d.h"
41

J
Jean Delvare 已提交
42
#define DRIVER_NAME     "hp_accel"
43 44
#define ACPI_MDPS_CLASS "accelerometer"

45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
/* Delayed LEDs infrastructure ------------------------------------ */

/* Special LED class that can defer work */
struct delayed_led_classdev {
	struct led_classdev led_classdev;
	struct work_struct work;
	enum led_brightness new_brightness;

	unsigned int led;		/* For driver */
	void (*set_brightness)(struct delayed_led_classdev *data, enum led_brightness value);
};

static inline void delayed_set_status_worker(struct work_struct *work)
{
	struct delayed_led_classdev *data =
			container_of(work, struct delayed_led_classdev, work);

	data->set_brightness(data, data->new_brightness);
}

static inline void delayed_sysfs_set(struct led_classdev *led_cdev,
			      enum led_brightness brightness)
{
	struct delayed_led_classdev *data = container_of(led_cdev,
			     struct delayed_led_classdev, led_classdev);
	data->new_brightness = brightness;
	schedule_work(&data->work);
}

/* HP-specific accelerometer driver ------------------------------------ */
75 76 77 78

/* For automatic insertion of the module */
static struct acpi_device_id lis3lv02d_device_ids[] = {
	{"HPQ0004", 0}, /* HP Mobile Data Protection System PNP */
T
Takashi Iwai 已提交
79
	{"HPQ6000", 0}, /* HP Mobile Data Protection System PNP */
80 81 82 83 84 85 86
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, lis3lv02d_device_ids);


/**
 * lis3lv02d_acpi_init - ACPI _INI method: initialize the device.
87
 * @lis3: pointer to the device struct
88
 *
89
 * Returns 0 on success.
90
 */
91
int lis3lv02d_acpi_init(struct lis3lv02d *lis3)
92
{
93 94 95 96 97 98
	struct acpi_device *dev = lis3->bus_priv;
	if (acpi_evaluate_object(dev->handle, METHOD_NAME__INI,
				 NULL, NULL) != AE_OK)
		return -EINVAL;

	return 0;
99 100 101 102
}

/**
 * lis3lv02d_acpi_read - ACPI ALRD method: read a register
103
 * @lis3: pointer to the device struct
104 105 106
 * @reg:    the register to read
 * @ret:    result of the operation
 *
107
 * Returns 0 on success.
108
 */
109
int lis3lv02d_acpi_read(struct lis3lv02d *lis3, int reg, u8 *ret)
110
{
111
	struct acpi_device *dev = lis3->bus_priv;
112 113 114 115 116 117 118
	union acpi_object arg0 = { ACPI_TYPE_INTEGER };
	struct acpi_object_list args = { 1, &arg0 };
	unsigned long long lret;
	acpi_status status;

	arg0.integer.value = reg;

119
	status = acpi_evaluate_integer(dev->handle, "ALRD", &args, &lret);
120
	*ret = lret;
121
	return (status != AE_OK) ? -EINVAL : 0;
122 123 124 125
}

/**
 * lis3lv02d_acpi_write - ACPI ALWR method: write to a register
126
 * @lis3: pointer to the device struct
127 128 129
 * @reg:    the register to write to
 * @val:    the value to write
 *
130
 * Returns 0 on success.
131
 */
132
int lis3lv02d_acpi_write(struct lis3lv02d *lis3, int reg, u8 val)
133
{
134
	struct acpi_device *dev = lis3->bus_priv;
135 136 137 138 139 140 141 142 143
	unsigned long long ret; /* Not used when writting */
	union acpi_object in_obj[2];
	struct acpi_object_list args = { 2, in_obj };

	in_obj[0].type          = ACPI_TYPE_INTEGER;
	in_obj[0].integer.value = reg;
	in_obj[1].type          = ACPI_TYPE_INTEGER;
	in_obj[1].integer.value = val;

144 145 146 147
	if (acpi_evaluate_integer(dev->handle, "ALWR", &args, &ret) != AE_OK)
		return -EINVAL;

	return 0;
148 149 150 151
}

static int lis3lv02d_dmi_matched(const struct dmi_system_id *dmi)
{
152
	lis3_dev.ac = *((union axis_conversion *)dmi->driver_data);
153
	pr_info("hardware type %s found\n", dmi->ident);
154 155 156 157 158 159

	return 1;
}

/* Represents, for each axis seen by userspace, the corresponding hw axis (+1).
 * If the value is negative, the opposite of the hw value is used. */
160 161 162 163 164 165 166 167 168 169 170 171 172
#define DEFINE_CONV(name, x, y, z)			      \
	static union axis_conversion lis3lv02d_axis_##name = \
		{ .as_array = { x, y, z } }
DEFINE_CONV(normal, 1, 2, 3);
DEFINE_CONV(y_inverted, 1, -2, 3);
DEFINE_CONV(x_inverted, -1, 2, 3);
DEFINE_CONV(z_inverted, 1, 2, -3);
DEFINE_CONV(xy_swap, 2, 1, 3);
DEFINE_CONV(xy_rotated_left, -2, 1, 3);
DEFINE_CONV(xy_rotated_left_usd, -2, 1, -3);
DEFINE_CONV(xy_swap_inverted, -2, -1, 3);
DEFINE_CONV(xy_rotated_right, 2, -1, 3);
DEFINE_CONV(xy_swap_yz_inverted, 2, -1, -3);
173 174 175 176 177 178 179 180 181

#define AXIS_DMI_MATCH(_ident, _name, _axis) {		\
	.ident = _ident,				\
	.callback = lis3lv02d_dmi_matched,		\
	.matches = {					\
		DMI_MATCH(DMI_PRODUCT_NAME, _name)	\
	},						\
	.driver_data = &lis3lv02d_axis_##_axis		\
}
182 183 184 185 186 187 188 189 190 191 192 193

#define AXIS_DMI_MATCH2(_ident, _class1, _name1,	\
				_class2, _name2,	\
				_axis) {		\
	.ident = _ident,				\
	.callback = lis3lv02d_dmi_matched,		\
	.matches = {					\
		DMI_MATCH(DMI_##_class1, _name1),	\
		DMI_MATCH(DMI_##_class2, _name2),	\
	},						\
	.driver_data = &lis3lv02d_axis_##_axis		\
}
194 195 196 197 198 199 200
static struct dmi_system_id lis3lv02d_dmi_ids[] = {
	/* product names are truncated to match all kinds of a same model */
	AXIS_DMI_MATCH("NC64x0", "HP Compaq nc64", x_inverted),
	AXIS_DMI_MATCH("NC84x0", "HP Compaq nc84", z_inverted),
	AXIS_DMI_MATCH("NX9420", "HP Compaq nx9420", x_inverted),
	AXIS_DMI_MATCH("NW9440", "HP Compaq nw9440", x_inverted),
	AXIS_DMI_MATCH("NC2510", "HP Compaq 2510", y_inverted),
E
Eric Piel 已提交
201
	AXIS_DMI_MATCH("NC2710", "HP Compaq 2710", xy_swap),
202 203
	AXIS_DMI_MATCH("NC8510", "HP Compaq 8510", xy_swap_inverted),
	AXIS_DMI_MATCH("HP2133", "HP 2133", xy_rotated_left),
204
	AXIS_DMI_MATCH("HP2140", "HP 2140", xy_swap_inverted),
205
	AXIS_DMI_MATCH("NC653x", "HP Compaq 653", xy_rotated_left_usd),
P
Pavel Herrmann 已提交
206 207
	AXIS_DMI_MATCH("NC6730b", "HP Compaq 6730b", xy_rotated_left_usd),
	AXIS_DMI_MATCH("NC6730s", "HP Compaq 6730s", xy_swap),
208
	AXIS_DMI_MATCH("NC651xx", "HP Compaq 651", xy_rotated_right),
E
Eric Piel 已提交
209 210 211
	AXIS_DMI_MATCH("NC6710x", "HP Compaq 6710", xy_swap_yz_inverted),
	AXIS_DMI_MATCH("NC6715x", "HP Compaq 6715", y_inverted),
	AXIS_DMI_MATCH("NC693xx", "HP EliteBook 693", xy_rotated_right),
212
	AXIS_DMI_MATCH("NC693xx", "HP EliteBook 853", xy_swap),
213
	AXIS_DMI_MATCH("NC854xx", "HP EliteBook 854", y_inverted),
214
	AXIS_DMI_MATCH("NC273xx", "HP EliteBook 273", y_inverted),
215 216 217 218 219 220 221 222 223 224
	/* Intel-based HP Pavilion dv5 */
	AXIS_DMI_MATCH2("HPDV5_I",
			PRODUCT_NAME, "HP Pavilion dv5",
			BOARD_NAME, "3603",
			x_inverted),
	/* AMD-based HP Pavilion dv5 */
	AXIS_DMI_MATCH2("HPDV5_A",
			PRODUCT_NAME, "HP Pavilion dv5",
			BOARD_NAME, "3600",
			y_inverted),
225
	AXIS_DMI_MATCH("DV7", "HP Pavilion dv7", x_inverted),
226
	AXIS_DMI_MATCH("HP8710", "HP Compaq 8710", y_inverted),
227
	AXIS_DMI_MATCH("HDX18", "HP HDX 18", x_inverted),
228 229 230 231
	AXIS_DMI_MATCH("HPB432x", "HP ProBook 432", xy_rotated_left),
	AXIS_DMI_MATCH("HPB442x", "HP ProBook 442", xy_rotated_left),
	AXIS_DMI_MATCH("HPB452x", "HP ProBook 452", y_inverted),
	AXIS_DMI_MATCH("HPB522x", "HP ProBook 522", xy_swap),
232
	AXIS_DMI_MATCH("HPB532x", "HP ProBook 532", y_inverted),
É
Éric Piel 已提交
233
	AXIS_DMI_MATCH("HPB655x", "HP ProBook 655", xy_swap_inverted),
234
	AXIS_DMI_MATCH("Mini510x", "HP Mini 510", xy_rotated_left_usd),
235 236 237 238
	AXIS_DMI_MATCH("HPB63xx", "HP ProBook 63", xy_swap),
	AXIS_DMI_MATCH("HPB64xx", "HP ProBook 64", xy_swap),
	AXIS_DMI_MATCH("HPB64xx", "HP EliteBook 84", xy_swap),
	AXIS_DMI_MATCH("HPB65xx", "HP ProBook 65", x_inverted),
239 240 241 242 243 244 245 246 247 248
	{ NULL, }
/* Laptop models without axis info (yet):
 * "NC6910" "HP Compaq 6910"
 * "NC2400" "HP Compaq nc2400"
 * "NX74x0" "HP Compaq nx74"
 * "NX6325" "HP Compaq nx6325"
 * "NC4400" "HP Compaq nc4400"
 */
};

249
static void hpled_set(struct delayed_led_classdev *led_cdev, enum led_brightness value)
E
Eric Piel 已提交
250
{
251
	struct acpi_device *dev = lis3_dev.bus_priv;
E
Eric Piel 已提交
252 253 254 255 256
	unsigned long long ret; /* Not used when writing */
	union acpi_object in_obj[1];
	struct acpi_object_list args = { 1, in_obj };

	in_obj[0].type          = ACPI_TYPE_INTEGER;
257
	in_obj[0].integer.value = !!value;
E
Eric Piel 已提交
258

259
	acpi_evaluate_integer(dev->handle, "ALED", &args, &ret);
E
Eric Piel 已提交
260 261
}

262 263 264 265 266 267 268 269
static struct delayed_led_classdev hpled_led = {
	.led_classdev = {
		.name			= "hp::hddprotect",
		.default_trigger	= "none",
		.brightness_set		= delayed_sysfs_set,
		.flags                  = LED_CORE_SUSPENDRESUME,
	},
	.set_brightness = hpled_set,
E
Eric Piel 已提交
270
};
271

272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
static acpi_status
lis3lv02d_get_resource(struct acpi_resource *resource, void *context)
{
	if (resource->type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ) {
		struct acpi_resource_extended_irq *irq;
		u32 *device_irq = context;

		irq = &resource->data.extended_irq;
		*device_irq = irq->interrupts[0];
	}

	return AE_OK;
}

static void lis3lv02d_enum_resources(struct acpi_device *device)
{
	acpi_status status;

	status = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
291
					lis3lv02d_get_resource, &lis3_dev.irq);
292 293 294 295
	if (ACPI_FAILURE(status))
		printk(KERN_DEBUG DRIVER_NAME ": Error getting resources\n");
}

296 297
static int lis3lv02d_add(struct acpi_device *device)
{
E
Eric Piel 已提交
298
	int ret;
299 300 301 302

	if (!device)
		return -EINVAL;

303
	lis3_dev.bus_priv = device;
304 305 306
	lis3_dev.init = lis3lv02d_acpi_init;
	lis3_dev.read = lis3lv02d_acpi_read;
	lis3_dev.write = lis3lv02d_acpi_write;
307 308
	strcpy(acpi_device_name(device), DRIVER_NAME);
	strcpy(acpi_device_class(device), ACPI_MDPS_CLASS);
309
	device->driver_data = &lis3_dev;
310

311 312
	/* obtain IRQ number of our device from ACPI */
	lis3lv02d_enum_resources(device);
313 314

	/* If possible use a "standard" axes order */
315
	if (lis3_dev.ac.x && lis3_dev.ac.y && lis3_dev.ac.z) {
316 317
		pr_info("Using custom axes %d,%d,%d\n",
			lis3_dev.ac.x, lis3_dev.ac.y, lis3_dev.ac.z);
318
	} else if (dmi_check_system(lis3lv02d_dmi_ids) == 0) {
319
		pr_info("laptop model unknown, using default axes configuration\n");
320
		lis3_dev.ac = lis3lv02d_axis_normal;
321 322
	}

323 324
	/* call the core layer do its init */
	ret = lis3lv02d_init_device(&lis3_dev);
E
Eric Piel 已提交
325 326 327
	if (ret)
		return ret;

328 329
	INIT_WORK(&hpled_led.work, delayed_set_status_worker);
	ret = led_classdev_register(NULL, &hpled_led.led_classdev);
E
Eric Piel 已提交
330
	if (ret) {
331
		lis3lv02d_joystick_disable(&lis3_dev);
332
		lis3lv02d_poweroff(&lis3_dev);
333
		flush_work(&hpled_led.work);
E
Eric Piel 已提交
334 335 336 337
		return ret;
	}

	return ret;
338 339 340 341 342 343 344
}

static int lis3lv02d_remove(struct acpi_device *device, int type)
{
	if (!device)
		return -EINVAL;

345
	lis3lv02d_joystick_disable(&lis3_dev);
346
	lis3lv02d_poweroff(&lis3_dev);
347

348
	led_classdev_unregister(&hpled_led.led_classdev);
349
	flush_work(&hpled_led.work);
E
Eric Piel 已提交
350

351
	return lis3lv02d_remove_fs(&lis3_dev);
352 353 354
}


355
#ifdef CONFIG_PM_SLEEP
356
static int lis3lv02d_suspend(struct device *dev)
357 358
{
	/* make sure the device is off when we suspend */
359
	lis3lv02d_poweroff(&lis3_dev);
360 361 362
	return 0;
}

363
static int lis3lv02d_resume(struct device *dev)
364
{
365
	return lis3lv02d_poweron(&lis3_dev);
366
}
367 368 369

static SIMPLE_DEV_PM_OPS(hp_accel_pm, lis3lv02d_suspend, lis3lv02d_resume);
#define HP_ACCEL_PM (&hp_accel_pm)
370
#else
371
#define HP_ACCEL_PM NULL
372 373 374 375 376 377 378 379 380 381
#endif

/* For the HP MDPS aka 3D Driveguard */
static struct acpi_driver lis3lv02d_driver = {
	.name  = DRIVER_NAME,
	.class = ACPI_MDPS_CLASS,
	.ids   = lis3lv02d_device_ids,
	.ops = {
		.add     = lis3lv02d_add,
		.remove  = lis3lv02d_remove,
382 383
	},
	.drv.pm = HP_ACCEL_PM,
384
};
385
module_acpi_driver(lis3lv02d_driver);
386

E
Eric Piel 已提交
387
MODULE_DESCRIPTION("Glue between LIS3LV02Dx and HP ACPI BIOS and support for disk protection LED.");
388 389
MODULE_AUTHOR("Yan Burman, Eric Piel, Pavel Machek");
MODULE_LICENSE("GPL");