1/*
   2 * ACPI Sony Notebook Control Driver (SNC and SPIC)
   3 *
   4 * Copyright (C) 2004-2005 Stelian Pop <stelian@popies.net>
   5 * Copyright (C) 2007-2009 Mattia Dongili <malattia@linux.it>
   6 *
   7 * Parts of this driver inspired from asus_acpi.c and ibm_acpi.c
   8 * which are copyrighted by their respective authors.
   9 *
  10 * The SNY6001 driver part is based on the sonypi driver which includes
  11 * material from:
  12 *
  13 * Copyright (C) 2001-2005 Stelian Pop <stelian@popies.net>
  14 *
  15 * Copyright (C) 2005 Narayanan R S <nars@kadamba.org>
  16 *
  17 * Copyright (C) 2001-2002 Alcôve <www.alcove.com>
  18 *
  19 * Copyright (C) 2001 Michael Ashley <m.ashley@unsw.edu.au>
  20 *
  21 * Copyright (C) 2001 Junichi Morita <jun1m@mars.dti.ne.jp>
  22 *
  23 * Copyright (C) 2000 Takaya Kinjo <t-kinjo@tc4.so-net.ne.jp>
  24 *
  25 * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com>
  26 *
  27 * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras.
  28 *
  29 * This program is free software; you can redistribute it and/or modify
  30 * it under the terms of the GNU General Public License as published by
  31 * the Free Software Foundation; either version 2 of the License, or
  32 * (at your option) any later version.
  33 *
  34 * This program is distributed in the hope that it will be useful,
  35 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  36 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  37 * GNU General Public License for more details.
  38 *
  39 * You should have received a copy of the GNU General Public License
  40 * along with this program; if not, write to the Free Software
  41 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  42 *
  43 */
  44
  45#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  46
  47#include <linux/kernel.h>
  48#include <linux/module.h>
  49#include <linux/moduleparam.h>
  50#include <linux/init.h>
  51#include <linux/types.h>
  52#include <linux/backlight.h>
  53#include <linux/platform_device.h>
  54#include <linux/err.h>
  55#include <linux/dmi.h>
  56#include <linux/pci.h>
  57#include <linux/interrupt.h>
  58#include <linux/delay.h>
  59#include <linux/input.h>
  60#include <linux/kfifo.h>
  61#include <linux/workqueue.h>
  62#include <linux/acpi.h>
  63#include <linux/slab.h>
  64#include <linux/sonypi.h>
  65#include <linux/sony-laptop.h>
  66#include <linux/rfkill.h>
  67#ifdef CONFIG_SONYPI_COMPAT
  68#include <linux/poll.h>
  69#include <linux/miscdevice.h>
  70#endif
  71#include <asm/uaccess.h>
  72#include <acpi/video.h>
  73
  74#define dprintk(fmt, ...)			\
  75do {						\
  76	if (debug)				\
  77		pr_warn(fmt, ##__VA_ARGS__);	\
  78} while (0)
  79
  80#define SONY_NC_CLASS		"sony-nc"
  81#define SONY_NC_HID		"SNY5001"
  82#define SONY_NC_DRIVER_NAME	"Sony Notebook Control Driver"
  83
  84#define SONY_PIC_CLASS		"sony-pic"
  85#define SONY_PIC_HID		"SNY6001"
  86#define SONY_PIC_DRIVER_NAME	"Sony Programmable IO Control Driver"
  87
  88MODULE_AUTHOR("Stelian Pop, Mattia Dongili");
  89MODULE_DESCRIPTION("Sony laptop extras driver (SPIC and SNC ACPI device)");
  90MODULE_LICENSE("GPL");
  91
  92static int debug;
  93module_param(debug, int, 0);
  94MODULE_PARM_DESC(debug, "set this to 1 (and RTFM) if you want to help "
  95		 "the development of this driver");
  96
  97static int no_spic;		/* = 0 */
  98module_param(no_spic, int, 0444);
  99MODULE_PARM_DESC(no_spic,
 100		 "set this if you don't want to enable the SPIC device");
 101
 102static int compat;		/* = 0 */
 103module_param(compat, int, 0444);
 104MODULE_PARM_DESC(compat,
 105		 "set this if you want to enable backward compatibility mode");
 106
 107static unsigned long mask = 0xffffffff;
 108module_param(mask, ulong, 0644);
 109MODULE_PARM_DESC(mask,
 110		 "set this to the mask of event you want to enable (see doc)");
 111
 112static int camera;		/* = 0 */
 113module_param(camera, int, 0444);
 114MODULE_PARM_DESC(camera,
 115		 "set this to 1 to enable Motion Eye camera controls "
 116		 "(only use it if you have a C1VE or C1VN model)");
 117
 118#ifdef CONFIG_SONYPI_COMPAT
 119static int minor = -1;
 120module_param(minor, int, 0);
 121MODULE_PARM_DESC(minor,
 122		 "minor number of the misc device for the SPIC compatibility code, "
 123		 "default is -1 (automatic)");
 124#endif
 125
 126static int kbd_backlight = -1;
 127module_param(kbd_backlight, int, 0444);
 128MODULE_PARM_DESC(kbd_backlight,
 129		 "set this to 0 to disable keyboard backlight, "
 130		 "1 to enable it with automatic control and 2 to have it always "
 131		 "on (default: no change from current value)");
 132
 133static int kbd_backlight_timeout = -1;
 134module_param(kbd_backlight_timeout, int, 0444);
 135MODULE_PARM_DESC(kbd_backlight_timeout,
 136		 "meaningful values vary from 0 to 3 and their meaning depends "
 137		 "on the model (default: no change from current value)");
 138
 139#ifdef CONFIG_PM_SLEEP
 140static void sony_nc_thermal_resume(void);
 141#endif
 142static int sony_nc_kbd_backlight_setup(struct platform_device *pd,
 143		unsigned int handle);
 144static void sony_nc_kbd_backlight_cleanup(struct platform_device *pd,
 145		unsigned int handle);
 146
 147static int sony_nc_battery_care_setup(struct platform_device *pd,
 148		unsigned int handle);
 149static void sony_nc_battery_care_cleanup(struct platform_device *pd);
 150
 151static int sony_nc_thermal_setup(struct platform_device *pd);
 152static void sony_nc_thermal_cleanup(struct platform_device *pd);
 153
 154static int sony_nc_lid_resume_setup(struct platform_device *pd,
 155				    unsigned int handle);
 156static void sony_nc_lid_resume_cleanup(struct platform_device *pd);
 157
 158static int sony_nc_gfx_switch_setup(struct platform_device *pd,
 159		unsigned int handle);
 160static void sony_nc_gfx_switch_cleanup(struct platform_device *pd);
 161static int __sony_nc_gfx_switch_status_get(void);
 162
 163static int sony_nc_highspeed_charging_setup(struct platform_device *pd);
 164static void sony_nc_highspeed_charging_cleanup(struct platform_device *pd);
 165
 166static int sony_nc_lowbatt_setup(struct platform_device *pd);
 167static void sony_nc_lowbatt_cleanup(struct platform_device *pd);
 168
 169static int sony_nc_fanspeed_setup(struct platform_device *pd);
 170static void sony_nc_fanspeed_cleanup(struct platform_device *pd);
 171
 172static int sony_nc_usb_charge_setup(struct platform_device *pd);
 173static void sony_nc_usb_charge_cleanup(struct platform_device *pd);
 174
 175static int sony_nc_panelid_setup(struct platform_device *pd);
 176static void sony_nc_panelid_cleanup(struct platform_device *pd);
 177
 178static int sony_nc_smart_conn_setup(struct platform_device *pd);
 179static void sony_nc_smart_conn_cleanup(struct platform_device *pd);
 180
 181static int sony_nc_touchpad_setup(struct platform_device *pd,
 182				  unsigned int handle);
 183static void sony_nc_touchpad_cleanup(struct platform_device *pd);
 184
 185enum sony_nc_rfkill {
 186	SONY_WIFI,
 187	SONY_BLUETOOTH,
 188	SONY_WWAN,
 189	SONY_WIMAX,
 190	N_SONY_RFKILL,
 191};
 192
 193static int sony_rfkill_handle;
 194static struct rfkill *sony_rfkill_devices[N_SONY_RFKILL];
 195static int sony_rfkill_address[N_SONY_RFKILL] = {0x300, 0x500, 0x700, 0x900};
 196static int sony_nc_rfkill_setup(struct acpi_device *device,
 197		unsigned int handle);
 198static void sony_nc_rfkill_cleanup(void);
 199static void sony_nc_rfkill_update(void);
 200
 201/*********** Input Devices ***********/
 202
 203#define SONY_LAPTOP_BUF_SIZE	128
 204struct sony_laptop_input_s {
 205	atomic_t		users;
 206	struct input_dev	*jog_dev;
 207	struct input_dev	*key_dev;
 208	struct kfifo		fifo;
 209	spinlock_t		fifo_lock;
 210	struct timer_list	release_key_timer;
 211};
 212
 213static struct sony_laptop_input_s sony_laptop_input = {
 214	.users = ATOMIC_INIT(0),
 215};
 216
 217struct sony_laptop_keypress {
 218	struct input_dev *dev;
 219	int key;
 220};
 221
 222/* Correspondance table between sonypi events
 223 * and input layer indexes in the keymap
 224 */
 225static int sony_laptop_input_index[] = {
 226	-1,	/*  0 no event */
 227	-1,	/*  1 SONYPI_EVENT_JOGDIAL_DOWN */
 228	-1,	/*  2 SONYPI_EVENT_JOGDIAL_UP */
 229	-1,	/*  3 SONYPI_EVENT_JOGDIAL_DOWN_PRESSED */
 230	-1,	/*  4 SONYPI_EVENT_JOGDIAL_UP_PRESSED */
 231	-1,	/*  5 SONYPI_EVENT_JOGDIAL_PRESSED */
 232	-1,	/*  6 SONYPI_EVENT_JOGDIAL_RELEASED */
 233	 0,	/*  7 SONYPI_EVENT_CAPTURE_PRESSED */
 234	 1,	/*  8 SONYPI_EVENT_CAPTURE_RELEASED */
 235	 2,	/*  9 SONYPI_EVENT_CAPTURE_PARTIALPRESSED */
 236	 3,	/* 10 SONYPI_EVENT_CAPTURE_PARTIALRELEASED */
 237	 4,	/* 11 SONYPI_EVENT_FNKEY_ESC */
 238	 5,	/* 12 SONYPI_EVENT_FNKEY_F1 */
 239	 6,	/* 13 SONYPI_EVENT_FNKEY_F2 */
 240	 7,	/* 14 SONYPI_EVENT_FNKEY_F3 */
 241	 8,	/* 15 SONYPI_EVENT_FNKEY_F4 */
 242	 9,	/* 16 SONYPI_EVENT_FNKEY_F5 */
 243	10,	/* 17 SONYPI_EVENT_FNKEY_F6 */
 244	11,	/* 18 SONYPI_EVENT_FNKEY_F7 */
 245	12,	/* 19 SONYPI_EVENT_FNKEY_F8 */
 246	13,	/* 20 SONYPI_EVENT_FNKEY_F9 */
 247	14,	/* 21 SONYPI_EVENT_FNKEY_F10 */
 248	15,	/* 22 SONYPI_EVENT_FNKEY_F11 */
 249	16,	/* 23 SONYPI_EVENT_FNKEY_F12 */
 250	17,	/* 24 SONYPI_EVENT_FNKEY_1 */
 251	18,	/* 25 SONYPI_EVENT_FNKEY_2 */
 252	19,	/* 26 SONYPI_EVENT_FNKEY_D */
 253	20,	/* 27 SONYPI_EVENT_FNKEY_E */
 254	21,	/* 28 SONYPI_EVENT_FNKEY_F */
 255	22,	/* 29 SONYPI_EVENT_FNKEY_S */
 256	23,	/* 30 SONYPI_EVENT_FNKEY_B */
 257	24,	/* 31 SONYPI_EVENT_BLUETOOTH_PRESSED */
 258	25,	/* 32 SONYPI_EVENT_PKEY_P1 */
 259	26,	/* 33 SONYPI_EVENT_PKEY_P2 */
 260	27,	/* 34 SONYPI_EVENT_PKEY_P3 */
 261	28,	/* 35 SONYPI_EVENT_BACK_PRESSED */
 262	-1,	/* 36 SONYPI_EVENT_LID_CLOSED */
 263	-1,	/* 37 SONYPI_EVENT_LID_OPENED */
 264	29,	/* 38 SONYPI_EVENT_BLUETOOTH_ON */
 265	30,	/* 39 SONYPI_EVENT_BLUETOOTH_OFF */
 266	31,	/* 40 SONYPI_EVENT_HELP_PRESSED */
 267	32,	/* 41 SONYPI_EVENT_FNKEY_ONLY */
 268	33,	/* 42 SONYPI_EVENT_JOGDIAL_FAST_DOWN */
 269	34,	/* 43 SONYPI_EVENT_JOGDIAL_FAST_UP */
 270	35,	/* 44 SONYPI_EVENT_JOGDIAL_FAST_DOWN_PRESSED */
 271	36,	/* 45 SONYPI_EVENT_JOGDIAL_FAST_UP_PRESSED */
 272	37,	/* 46 SONYPI_EVENT_JOGDIAL_VFAST_DOWN */
 273	38,	/* 47 SONYPI_EVENT_JOGDIAL_VFAST_UP */
 274	39,	/* 48 SONYPI_EVENT_JOGDIAL_VFAST_DOWN_PRESSED */
 275	40,	/* 49 SONYPI_EVENT_JOGDIAL_VFAST_UP_PRESSED */
 276	41,	/* 50 SONYPI_EVENT_ZOOM_PRESSED */
 277	42,	/* 51 SONYPI_EVENT_THUMBPHRASE_PRESSED */
 278	43,	/* 52 SONYPI_EVENT_MEYE_FACE */
 279	44,	/* 53 SONYPI_EVENT_MEYE_OPPOSITE */
 280	45,	/* 54 SONYPI_EVENT_MEMORYSTICK_INSERT */
 281	46,	/* 55 SONYPI_EVENT_MEMORYSTICK_EJECT */
 282	-1,	/* 56 SONYPI_EVENT_ANYBUTTON_RELEASED */
 283	-1,	/* 57 SONYPI_EVENT_BATTERY_INSERT */
 284	-1,	/* 58 SONYPI_EVENT_BATTERY_REMOVE */
 285	-1,	/* 59 SONYPI_EVENT_FNKEY_RELEASED */
 286	47,	/* 60 SONYPI_EVENT_WIRELESS_ON */
 287	48,	/* 61 SONYPI_EVENT_WIRELESS_OFF */
 288	49,	/* 62 SONYPI_EVENT_ZOOM_IN_PRESSED */
 289	50,	/* 63 SONYPI_EVENT_ZOOM_OUT_PRESSED */
 290	51,	/* 64 SONYPI_EVENT_CD_EJECT_PRESSED */
 291	52,	/* 65 SONYPI_EVENT_MODEKEY_PRESSED */
 292	53,	/* 66 SONYPI_EVENT_PKEY_P4 */
 293	54,	/* 67 SONYPI_EVENT_PKEY_P5 */
 294	55,	/* 68 SONYPI_EVENT_SETTINGKEY_PRESSED */
 295	56,	/* 69 SONYPI_EVENT_VOLUME_INC_PRESSED */
 296	57,	/* 70 SONYPI_EVENT_VOLUME_DEC_PRESSED */
 297	-1,	/* 71 SONYPI_EVENT_BRIGHTNESS_PRESSED */
 298	58,	/* 72 SONYPI_EVENT_MEDIA_PRESSED */
 299	59,	/* 72 SONYPI_EVENT_VENDOR_PRESSED */
 300};
 301
 302static int sony_laptop_input_keycode_map[] = {
 303	KEY_CAMERA,	/*  0 SONYPI_EVENT_CAPTURE_PRESSED */
 304	KEY_RESERVED,	/*  1 SONYPI_EVENT_CAPTURE_RELEASED */
 305	KEY_RESERVED,	/*  2 SONYPI_EVENT_CAPTURE_PARTIALPRESSED */
 306	KEY_RESERVED,	/*  3 SONYPI_EVENT_CAPTURE_PARTIALRELEASED */
 307	KEY_FN_ESC,	/*  4 SONYPI_EVENT_FNKEY_ESC */
 308	KEY_FN_F1,	/*  5 SONYPI_EVENT_FNKEY_F1 */
 309	KEY_FN_F2,	/*  6 SONYPI_EVENT_FNKEY_F2 */
 310	KEY_FN_F3,	/*  7 SONYPI_EVENT_FNKEY_F3 */
 311	KEY_FN_F4,	/*  8 SONYPI_EVENT_FNKEY_F4 */
 312	KEY_FN_F5,	/*  9 SONYPI_EVENT_FNKEY_F5 */
 313	KEY_FN_F6,	/* 10 SONYPI_EVENT_FNKEY_F6 */
 314	KEY_FN_F7,	/* 11 SONYPI_EVENT_FNKEY_F7 */
 315	KEY_FN_F8,	/* 12 SONYPI_EVENT_FNKEY_F8 */
 316	KEY_FN_F9,	/* 13 SONYPI_EVENT_FNKEY_F9 */
 317	KEY_FN_F10,	/* 14 SONYPI_EVENT_FNKEY_F10 */
 318	KEY_FN_F11,	/* 15 SONYPI_EVENT_FNKEY_F11 */
 319	KEY_FN_F12,	/* 16 SONYPI_EVENT_FNKEY_F12 */
 320	KEY_FN_1,	/* 17 SONYPI_EVENT_FNKEY_1 */
 321	KEY_FN_2,	/* 18 SONYPI_EVENT_FNKEY_2 */
 322	KEY_FN_D,	/* 19 SONYPI_EVENT_FNKEY_D */
 323	KEY_FN_E,	/* 20 SONYPI_EVENT_FNKEY_E */
 324	KEY_FN_F,	/* 21 SONYPI_EVENT_FNKEY_F */
 325	KEY_FN_S,	/* 22 SONYPI_EVENT_FNKEY_S */
 326	KEY_FN_B,	/* 23 SONYPI_EVENT_FNKEY_B */
 327	KEY_BLUETOOTH,	/* 24 SONYPI_EVENT_BLUETOOTH_PRESSED */
 328	KEY_PROG1,	/* 25 SONYPI_EVENT_PKEY_P1 */
 329	KEY_PROG2,	/* 26 SONYPI_EVENT_PKEY_P2 */
 330	KEY_PROG3,	/* 27 SONYPI_EVENT_PKEY_P3 */
 331	KEY_BACK,	/* 28 SONYPI_EVENT_BACK_PRESSED */
 332	KEY_BLUETOOTH,	/* 29 SONYPI_EVENT_BLUETOOTH_ON */
 333	KEY_BLUETOOTH,	/* 30 SONYPI_EVENT_BLUETOOTH_OFF */
 334	KEY_HELP,	/* 31 SONYPI_EVENT_HELP_PRESSED */
 335	KEY_FN,		/* 32 SONYPI_EVENT_FNKEY_ONLY */
 336	KEY_RESERVED,	/* 33 SONYPI_EVENT_JOGDIAL_FAST_DOWN */
 337	KEY_RESERVED,	/* 34 SONYPI_EVENT_JOGDIAL_FAST_UP */
 338	KEY_RESERVED,	/* 35 SONYPI_EVENT_JOGDIAL_FAST_DOWN_PRESSED */
 339	KEY_RESERVED,	/* 36 SONYPI_EVENT_JOGDIAL_FAST_UP_PRESSED */
 340	KEY_RESERVED,	/* 37 SONYPI_EVENT_JOGDIAL_VFAST_DOWN */
 341	KEY_RESERVED,	/* 38 SONYPI_EVENT_JOGDIAL_VFAST_UP */
 342	KEY_RESERVED,	/* 39 SONYPI_EVENT_JOGDIAL_VFAST_DOWN_PRESSED */
 343	KEY_RESERVED,	/* 40 SONYPI_EVENT_JOGDIAL_VFAST_UP_PRESSED */
 344	KEY_ZOOM,	/* 41 SONYPI_EVENT_ZOOM_PRESSED */
 345	BTN_THUMB,	/* 42 SONYPI_EVENT_THUMBPHRASE_PRESSED */
 346	KEY_RESERVED,	/* 43 SONYPI_EVENT_MEYE_FACE */
 347	KEY_RESERVED,	/* 44 SONYPI_EVENT_MEYE_OPPOSITE */
 348	KEY_RESERVED,	/* 45 SONYPI_EVENT_MEMORYSTICK_INSERT */
 349	KEY_RESERVED,	/* 46 SONYPI_EVENT_MEMORYSTICK_EJECT */
 350	KEY_WLAN,	/* 47 SONYPI_EVENT_WIRELESS_ON */
 351	KEY_WLAN,	/* 48 SONYPI_EVENT_WIRELESS_OFF */
 352	KEY_ZOOMIN,	/* 49 SONYPI_EVENT_ZOOM_IN_PRESSED */
 353	KEY_ZOOMOUT,	/* 50 SONYPI_EVENT_ZOOM_OUT_PRESSED */
 354	KEY_EJECTCD,	/* 51 SONYPI_EVENT_CD_EJECT_PRESSED */
 355	KEY_F13,	/* 52 SONYPI_EVENT_MODEKEY_PRESSED */
 356	KEY_PROG4,	/* 53 SONYPI_EVENT_PKEY_P4 */
 357	KEY_F14,	/* 54 SONYPI_EVENT_PKEY_P5 */
 358	KEY_F15,	/* 55 SONYPI_EVENT_SETTINGKEY_PRESSED */
 359	KEY_VOLUMEUP,	/* 56 SONYPI_EVENT_VOLUME_INC_PRESSED */
 360	KEY_VOLUMEDOWN,	/* 57 SONYPI_EVENT_VOLUME_DEC_PRESSED */
 361	KEY_MEDIA,	/* 58 SONYPI_EVENT_MEDIA_PRESSED */
 362	KEY_VENDOR,	/* 59 SONYPI_EVENT_VENDOR_PRESSED */
 363};
 364
 365/* release buttons after a short delay if pressed */
 366static void do_sony_laptop_release_key(unsigned long unused)
 367{
 368	struct sony_laptop_keypress kp;
 369	unsigned long flags;
 370
 371	spin_lock_irqsave(&sony_laptop_input.fifo_lock, flags);
 372
 373	if (kfifo_out(&sony_laptop_input.fifo,
 374		      (unsigned char *)&kp, sizeof(kp)) == sizeof(kp)) {
 375		input_report_key(kp.dev, kp.key, 0);
 376		input_sync(kp.dev);
 377	}
 378
 379	/* If there is something in the fifo schedule next release. */
 380	if (kfifo_len(&sony_laptop_input.fifo) != 0)
 381		mod_timer(&sony_laptop_input.release_key_timer,
 382			  jiffies + msecs_to_jiffies(10));
 383
 384	spin_unlock_irqrestore(&sony_laptop_input.fifo_lock, flags);
 385}
 386
 387/* forward event to the input subsystem */
 388static void sony_laptop_report_input_event(u8 event)
 389{
 390	struct input_dev *jog_dev = sony_laptop_input.jog_dev;
 391	struct input_dev *key_dev = sony_laptop_input.key_dev;
 392	struct sony_laptop_keypress kp = { NULL };
 393	int scancode = -1;
 394
 395	if (event == SONYPI_EVENT_FNKEY_RELEASED ||
 396			event == SONYPI_EVENT_ANYBUTTON_RELEASED) {
 397		/* Nothing, not all VAIOs generate this event */
 398		return;
 399	}
 400
 401	/* report events */
 402	switch (event) {
 403	/* jog_dev events */
 404	case SONYPI_EVENT_JOGDIAL_UP:
 405	case SONYPI_EVENT_JOGDIAL_UP_PRESSED:
 406		input_report_rel(jog_dev, REL_WHEEL, 1);
 407		input_sync(jog_dev);
 408		return;
 409
 410	case SONYPI_EVENT_JOGDIAL_DOWN:
 411	case SONYPI_EVENT_JOGDIAL_DOWN_PRESSED:
 412		input_report_rel(jog_dev, REL_WHEEL, -1);
 413		input_sync(jog_dev);
 414		return;
 415
 416	/* key_dev events */
 417	case SONYPI_EVENT_JOGDIAL_PRESSED:
 418		kp.key = BTN_MIDDLE;
 419		kp.dev = jog_dev;
 420		break;
 421
 422	default:
 423		if (event >= ARRAY_SIZE(sony_laptop_input_index)) {
 424			dprintk("sony_laptop_report_input_event, event not known: %d\n", event);
 425			break;
 426		}
 427		if ((scancode = sony_laptop_input_index[event]) != -1) {
 428			kp.key = sony_laptop_input_keycode_map[scancode];
 429			if (kp.key != KEY_UNKNOWN)
 430				kp.dev = key_dev;
 431		}
 432		break;
 433	}
 434
 435	if (kp.dev) {
 436		/* if we have a scancode we emit it so we can always
 437		    remap the key */
 438		if (scancode != -1)
 439			input_event(kp.dev, EV_MSC, MSC_SCAN, scancode);
 440		input_report_key(kp.dev, kp.key, 1);
 441		input_sync(kp.dev);
 442
 443		/* schedule key release */
 444		kfifo_in_locked(&sony_laptop_input.fifo,
 445				(unsigned char *)&kp, sizeof(kp),
 446				&sony_laptop_input.fifo_lock);
 447		mod_timer(&sony_laptop_input.release_key_timer,
 448			  jiffies + msecs_to_jiffies(10));
 449	} else
 450		dprintk("unknown input event %.2x\n", event);
 451}
 452
 453static int sony_laptop_setup_input(struct acpi_device *acpi_device)
 454{
 455	struct input_dev *jog_dev;
 456	struct input_dev *key_dev;
 457	int i;
 458	int error;
 459
 460	/* don't run again if already initialized */
 461	if (atomic_add_return(1, &sony_laptop_input.users) > 1)
 462		return 0;
 463
 464	/* kfifo */
 465	spin_lock_init(&sony_laptop_input.fifo_lock);
 466	error = kfifo_alloc(&sony_laptop_input.fifo,
 467			    SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
 468	if (error) {
 469		pr_err("kfifo_alloc failed\n");
 470		goto err_dec_users;
 471	}
 472
 473	setup_timer(&sony_laptop_input.release_key_timer,
 474		    do_sony_laptop_release_key, 0);
 475
 476	/* input keys */
 477	key_dev = input_allocate_device();
 478	if (!key_dev) {
 479		error = -ENOMEM;
 480		goto err_free_kfifo;
 481	}
 482
 483	key_dev->name = "Sony Vaio Keys";
 484	key_dev->id.bustype = BUS_ISA;
 485	key_dev->id.vendor = PCI_VENDOR_ID_SONY;
 486	key_dev->dev.parent = &acpi_device->dev;
 487
 488	/* Initialize the Input Drivers: special keys */
 489	input_set_capability(key_dev, EV_MSC, MSC_SCAN);
 490
 491	__set_bit(EV_KEY, key_dev->evbit);
 492	key_dev->keycodesize = sizeof(sony_laptop_input_keycode_map[0]);
 493	key_dev->keycodemax = ARRAY_SIZE(sony_laptop_input_keycode_map);
 494	key_dev->keycode = &sony_laptop_input_keycode_map;
 495	for (i = 0; i < ARRAY_SIZE(sony_laptop_input_keycode_map); i++)
 496		__set_bit(sony_laptop_input_keycode_map[i], key_dev->keybit);
 497	__clear_bit(KEY_RESERVED, key_dev->keybit);
 498
 499	error = input_register_device(key_dev);
 500	if (error)
 501		goto err_free_keydev;
 502
 503	sony_laptop_input.key_dev = key_dev;
 504
 505	/* jogdial */
 506	jog_dev = input_allocate_device();
 507	if (!jog_dev) {
 508		error = -ENOMEM;
 509		goto err_unregister_keydev;
 510	}
 511
 512	jog_dev->name = "Sony Vaio Jogdial";
 513	jog_dev->id.bustype = BUS_ISA;
 514	jog_dev->id.vendor = PCI_VENDOR_ID_SONY;
 515	jog_dev->dev.parent = &acpi_device->dev;
 516
 517	input_set_capability(jog_dev, EV_KEY, BTN_MIDDLE);
 518	input_set_capability(jog_dev, EV_REL, REL_WHEEL);
 519
 520	error = input_register_device(jog_dev);
 521	if (error)
 522		goto err_free_jogdev;
 523
 524	sony_laptop_input.jog_dev = jog_dev;
 525
 526	return 0;
 527
 528err_free_jogdev:
 529	input_free_device(jog_dev);
 530
 531err_unregister_keydev:
 532	input_unregister_device(key_dev);
 533	/* to avoid kref underflow below at input_free_device */
 534	key_dev = NULL;
 535
 536err_free_keydev:
 537	input_free_device(key_dev);
 538
 539err_free_kfifo:
 540	kfifo_free(&sony_laptop_input.fifo);
 541
 542err_dec_users:
 543	atomic_dec(&sony_laptop_input.users);
 544	return error;
 545}
 546
 547static void sony_laptop_remove_input(void)
 548{
 549	struct sony_laptop_keypress kp = { NULL };
 550
 551	/* Cleanup only after the last user has gone */
 552	if (!atomic_dec_and_test(&sony_laptop_input.users))
 553		return;
 554
 555	del_timer_sync(&sony_laptop_input.release_key_timer);
 556
 557	/*
 558	 * Generate key-up events for remaining keys. Note that we don't
 559	 * need locking since nobody is adding new events to the kfifo.
 560	 */
 561	while (kfifo_out(&sony_laptop_input.fifo,
 562			 (unsigned char *)&kp, sizeof(kp)) == sizeof(kp)) {
 563		input_report_key(kp.dev, kp.key, 0);
 564		input_sync(kp.dev);
 565	}
 566
 567	/* destroy input devs */
 568	input_unregister_device(sony_laptop_input.key_dev);
 569	sony_laptop_input.key_dev = NULL;
 570
 571	if (sony_laptop_input.jog_dev) {
 572		input_unregister_device(sony_laptop_input.jog_dev);
 573		sony_laptop_input.jog_dev = NULL;
 574	}
 575
 576	kfifo_free(&sony_laptop_input.fifo);
 577}
 578
 579/*********** Platform Device ***********/
 580
 581static atomic_t sony_pf_users = ATOMIC_INIT(0);
 582static struct platform_driver sony_pf_driver = {
 583	.driver = {
 584		   .name = "sony-laptop",
 585		   }
 586};
 587static struct platform_device *sony_pf_device;
 588
 589static int sony_pf_add(void)
 590{
 591	int ret = 0;
 592
 593	/* don't run again if already initialized */
 594	if (atomic_add_return(1, &sony_pf_users) > 1)
 595		return 0;
 596
 597	ret = platform_driver_register(&sony_pf_driver);
 598	if (ret)
 599		goto out;
 600
 601	sony_pf_device = platform_device_alloc("sony-laptop", -1);
 602	if (!sony_pf_device) {
 603		ret = -ENOMEM;
 604		goto out_platform_registered;
 605	}
 606
 607	ret = platform_device_add(sony_pf_device);
 608	if (ret)
 609		goto out_platform_alloced;
 610
 611	return 0;
 612
 613      out_platform_alloced:
 614	platform_device_put(sony_pf_device);
 615	sony_pf_device = NULL;
 616      out_platform_registered:
 617	platform_driver_unregister(&sony_pf_driver);
 618      out:
 619	atomic_dec(&sony_pf_users);
 620	return ret;
 621}
 622
 623static void sony_pf_remove(void)
 624{
 625	/* deregister only after the last user has gone */
 626	if (!atomic_dec_and_test(&sony_pf_users))
 627		return;
 628
 629	platform_device_unregister(sony_pf_device);
 630	platform_driver_unregister(&sony_pf_driver);
 631}
 632
 633/*********** SNC (SNY5001) Device ***********/
 634
 635/* the device uses 1-based values, while the backlight subsystem uses
 636   0-based values */
 637#define SONY_MAX_BRIGHTNESS	8
 638
 639#define SNC_VALIDATE_IN		0
 640#define SNC_VALIDATE_OUT	1
 641
 642static ssize_t sony_nc_sysfs_show(struct device *, struct device_attribute *,
 643			      char *);
 644static ssize_t sony_nc_sysfs_store(struct device *, struct device_attribute *,
 645			       const char *, size_t);
 646static int boolean_validate(const int, const int);
 647static int brightness_default_validate(const int, const int);
 648
 649struct sony_nc_value {
 650	char *name;		/* name of the entry */
 651	char **acpiget;		/* names of the ACPI get function */
 652	char **acpiset;		/* names of the ACPI set function */
 653	int (*validate)(const int, const int);	/* input/output validation */
 654	int value;		/* current setting */
 655	int valid;		/* Has ever been set */
 656	int debug;		/* active only in debug mode ? */
 657	struct device_attribute devattr;	/* sysfs attribute */
 658};
 659
 660#define SNC_HANDLE_NAMES(_name, _values...) \
 661	static char *snc_##_name[] = { _values, NULL }
 662
 663#define SNC_HANDLE(_name, _getters, _setters, _validate, _debug) \
 664	{ \
 665		.name		= __stringify(_name), \
 666		.acpiget	= _getters, \
 667		.acpiset	= _setters, \
 668		.validate	= _validate, \
 669		.debug		= _debug, \
 670		.devattr	= __ATTR(_name, 0, sony_nc_sysfs_show, sony_nc_sysfs_store), \
 671	}
 672
 673#define SNC_HANDLE_NULL	{ .name = NULL }
 674
 675SNC_HANDLE_NAMES(fnkey_get, "GHKE");
 676
 677SNC_HANDLE_NAMES(brightness_def_get, "GPBR");
 678SNC_HANDLE_NAMES(brightness_def_set, "SPBR");
 679
 680SNC_HANDLE_NAMES(cdpower_get, "GCDP");
 681SNC_HANDLE_NAMES(cdpower_set, "SCDP", "CDPW");
 682
 683SNC_HANDLE_NAMES(audiopower_get, "GAZP");
 684SNC_HANDLE_NAMES(audiopower_set, "AZPW");
 685
 686SNC_HANDLE_NAMES(lanpower_get, "GLNP");
 687SNC_HANDLE_NAMES(lanpower_set, "LNPW");
 688
 689SNC_HANDLE_NAMES(lidstate_get, "GLID");
 690
 691SNC_HANDLE_NAMES(indicatorlamp_get, "GILS");
 692SNC_HANDLE_NAMES(indicatorlamp_set, "SILS");
 693
 694SNC_HANDLE_NAMES(gainbass_get, "GMGB");
 695SNC_HANDLE_NAMES(gainbass_set, "CMGB");
 696
 697SNC_HANDLE_NAMES(PID_get, "GPID");
 698
 699SNC_HANDLE_NAMES(CTR_get, "GCTR");
 700SNC_HANDLE_NAMES(CTR_set, "SCTR");
 701
 702SNC_HANDLE_NAMES(PCR_get, "GPCR");
 703SNC_HANDLE_NAMES(PCR_set, "SPCR");
 704
 705SNC_HANDLE_NAMES(CMI_get, "GCMI");
 706SNC_HANDLE_NAMES(CMI_set, "SCMI");
 707
 708static struct sony_nc_value sony_nc_values[] = {
 709	SNC_HANDLE(brightness_default, snc_brightness_def_get,
 710			snc_brightness_def_set, brightness_default_validate, 0),
 711	SNC_HANDLE(fnkey, snc_fnkey_get, NULL, NULL, 0),
 712	SNC_HANDLE(cdpower, snc_cdpower_get, snc_cdpower_set, boolean_validate, 0),
 713	SNC_HANDLE(audiopower, snc_audiopower_get, snc_audiopower_set,
 714			boolean_validate, 0),
 715	SNC_HANDLE(lanpower, snc_lanpower_get, snc_lanpower_set,
 716			boolean_validate, 1),
 717	SNC_HANDLE(lidstate, snc_lidstate_get, NULL,
 718			boolean_validate, 0),
 719	SNC_HANDLE(indicatorlamp, snc_indicatorlamp_get, snc_indicatorlamp_set,
 720			boolean_validate, 0),
 721	SNC_HANDLE(gainbass, snc_gainbass_get, snc_gainbass_set,
 722			boolean_validate, 0),
 723	/* unknown methods */
 724	SNC_HANDLE(PID, snc_PID_get, NULL, NULL, 1),
 725	SNC_HANDLE(CTR, snc_CTR_get, snc_CTR_set, NULL, 1),
 726	SNC_HANDLE(PCR, snc_PCR_get, snc_PCR_set, NULL, 1),
 727	SNC_HANDLE(CMI, snc_CMI_get, snc_CMI_set, NULL, 1),
 728	SNC_HANDLE_NULL
 729};
 730
 731static acpi_handle sony_nc_acpi_handle;
 732static struct acpi_device *sony_nc_acpi_device = NULL;
 733
 734/*
 735 * acpi_evaluate_object wrappers
 736 * all useful calls into SNC methods take one or zero parameters and return
 737 * integers or arrays.
 738 */
 739static union acpi_object *__call_snc_method(acpi_handle handle, char *method,
 740		u64 *value)
 741{
 742	union acpi_object *result = NULL;
 743	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
 744	acpi_status status;
 745
 746	if (value) {
 747		struct acpi_object_list params;
 748		union acpi_object in;
 749		in.type = ACPI_TYPE_INTEGER;
 750		in.integer.value = *value;
 751		params.count = 1;
 752		params.pointer = &in;
 753		status = acpi_evaluate_object(handle, method, &params, &output);
 754		dprintk("__call_snc_method: [%s:0x%.8x%.8x]\n", method,
 755				(unsigned int)(*value >> 32),
 756				(unsigned int)*value & 0xffffffff);
 757	} else {
 758		status = acpi_evaluate_object(handle, method, NULL, &output);
 759		dprintk("__call_snc_method: [%s]\n", method);
 760	}
 761
 762	if (ACPI_FAILURE(status)) {
 763		pr_err("Failed to evaluate [%s]\n", method);
 764		return NULL;
 765	}
 766
 767	result = (union acpi_object *) output.pointer;
 768	if (!result)
 769		dprintk("No return object [%s]\n", method);
 770
 771	return result;
 772}
 773
 774static int sony_nc_int_call(acpi_handle handle, char *name, int *value,
 775		int *result)
 776{
 777	union acpi_object *object = NULL;
 778	if (value) {
 779		u64 v = *value;
 780		object = __call_snc_method(handle, name, &v);
 781	} else
 782		object = __call_snc_method(handle, name, NULL);
 783
 784	if (!object)
 785		return -EINVAL;
 786
 787	if (object->type != ACPI_TYPE_INTEGER) {
 788		pr_warn("Invalid acpi_object: expected 0x%x got 0x%x\n",
 789				ACPI_TYPE_INTEGER, object->type);
 790		kfree(object);
 791		return -EINVAL;
 792	}
 793
 794	if (result)
 795		*result = object->integer.value;
 796
 797	kfree(object);
 798	return 0;
 799}
 800
 801#define MIN(a, b)	(a > b ? b : a)
 802static int sony_nc_buffer_call(acpi_handle handle, char *name, u64 *value,
 803		void *buffer, size_t buflen)
 804{
 805	int ret = 0;
 806	size_t len;
 807	union acpi_object *object = __call_snc_method(handle, name, value);
 808
 809	if (!object)
 810		return -EINVAL;
 811
 812	if (object->type == ACPI_TYPE_BUFFER) {
 
 
 813		len = MIN(buflen, object->buffer.length);
 
 814		memcpy(buffer, object->buffer.pointer, len);
 815
 816	} else if (object->type == ACPI_TYPE_INTEGER) {
 817		len = MIN(buflen, sizeof(object->integer.value));
 
 818		memcpy(buffer, &object->integer.value, len);
 819
 820	} else {
 821		pr_warn("Invalid acpi_object: expected 0x%x got 0x%x\n",
 822				ACPI_TYPE_BUFFER, object->type);
 823		ret = -EINVAL;
 824	}
 825
 826	kfree(object);
 827	return ret;
 828}
 829
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 830struct sony_nc_handles {
 831	u16 cap[0x10];
 832	struct device_attribute devattr;
 833};
 834
 835static struct sony_nc_handles *handles;
 836
 837static ssize_t sony_nc_handles_show(struct device *dev,
 838		struct device_attribute *attr, char *buffer)
 839{
 840	ssize_t len = 0;
 841	int i;
 842
 843	for (i = 0; i < ARRAY_SIZE(handles->cap); i++) {
 844		len += snprintf(buffer + len, PAGE_SIZE - len, "0x%.4x ",
 845				handles->cap[i]);
 846	}
 847	len += snprintf(buffer + len, PAGE_SIZE - len, "\n");
 848
 849	return len;
 850}
 851
 852static int sony_nc_handles_setup(struct platform_device *pd)
 853{
 854	int i, r, result, arg;
 855
 856	handles = kzalloc(sizeof(*handles), GFP_KERNEL);
 857	if (!handles)
 858		return -ENOMEM;
 859
 860	for (i = 0; i < ARRAY_SIZE(handles->cap); i++) {
 861		arg = i + 0x20;
 862		r = sony_nc_int_call(sony_nc_acpi_handle, "SN00", &arg,
 863					&result);
 864		if (!r) {
 865			dprintk("caching handle 0x%.4x (offset: 0x%.2x)\n",
 866					result, i);
 867			handles->cap[i] = result;
 868		}
 869	}
 870
 871	if (debug) {
 872		sysfs_attr_init(&handles->devattr.attr);
 873		handles->devattr.attr.name = "handles";
 874		handles->devattr.attr.mode = S_IRUGO;
 875		handles->devattr.show = sony_nc_handles_show;
 876
 877		/* allow reading capabilities via sysfs */
 878		if (device_create_file(&pd->dev, &handles->devattr)) {
 879			kfree(handles);
 880			handles = NULL;
 881			return -1;
 882		}
 883	}
 884
 885	return 0;
 886}
 887
 888static int sony_nc_handles_cleanup(struct platform_device *pd)
 889{
 890	if (handles) {
 891		if (debug)
 892			device_remove_file(&pd->dev, &handles->devattr);
 893		kfree(handles);
 894		handles = NULL;
 895	}
 896	return 0;
 897}
 898
 899static int sony_find_snc_handle(int handle)
 900{
 901	int i;
 902
 903	/* not initialized yet, return early */
 904	if (!handles || !handle)
 905		return -EINVAL;
 906
 907	for (i = 0; i < 0x10; i++) {
 908		if (handles->cap[i] == handle) {
 909			dprintk("found handle 0x%.4x (offset: 0x%.2x)\n",
 910					handle, i);
 911			return i;
 912		}
 913	}
 914	dprintk("handle 0x%.4x not found\n", handle);
 915	return -EINVAL;
 916}
 917
 918static int sony_call_snc_handle(int handle, int argument, int *result)
 919{
 920	int arg, ret = 0;
 921	int offset = sony_find_snc_handle(handle);
 922
 923	if (offset < 0)
 924		return offset;
 925
 926	arg = offset | argument;
 927	ret = sony_nc_int_call(sony_nc_acpi_handle, "SN07", &arg, result);
 928	dprintk("called SN07 with 0x%.4x (result: 0x%.4x)\n", arg, *result);
 929	return ret;
 930}
 931
 932/*
 933 * sony_nc_values input/output validate functions
 934 */
 935
 936/* brightness_default_validate:
 937 *
 938 * manipulate input output values to keep consistency with the
 939 * backlight framework for which brightness values are 0-based.
 940 */
 941static int brightness_default_validate(const int direction, const int value)
 942{
 943	switch (direction) {
 944		case SNC_VALIDATE_OUT:
 945			return value - 1;
 946		case SNC_VALIDATE_IN:
 947			if (value >= 0 && value < SONY_MAX_BRIGHTNESS)
 948				return value + 1;
 949	}
 950	return -EINVAL;
 951}
 952
 953/* boolean_validate:
 954 *
 955 * on input validate boolean values 0/1, on output just pass the
 956 * received value.
 957 */
 958static int boolean_validate(const int direction, const int value)
 959{
 960	if (direction == SNC_VALIDATE_IN) {
 961		if (value != 0 && value != 1)
 962			return -EINVAL;
 963	}
 964	return value;
 965}
 966
 967/*
 968 * Sysfs show/store common to all sony_nc_values
 969 */
 970static ssize_t sony_nc_sysfs_show(struct device *dev, struct device_attribute *attr,
 971			      char *buffer)
 972{
 973	int value, ret = 0;
 974	struct sony_nc_value *item =
 975	    container_of(attr, struct sony_nc_value, devattr);
 976
 977	if (!*item->acpiget)
 978		return -EIO;
 979
 980	ret = sony_nc_int_call(sony_nc_acpi_handle, *item->acpiget, NULL,
 981				&value);
 982	if (ret < 0)
 983		return -EIO;
 984
 985	if (item->validate)
 986		value = item->validate(SNC_VALIDATE_OUT, value);
 987
 988	return snprintf(buffer, PAGE_SIZE, "%d\n", value);
 989}
 990
 991static ssize_t sony_nc_sysfs_store(struct device *dev,
 992			       struct device_attribute *attr,
 993			       const char *buffer, size_t count)
 994{
 995	int value;
 996	int ret = 0;
 997	struct sony_nc_value *item =
 998	    container_of(attr, struct sony_nc_value, devattr);
 999
1000	if (!item->acpiset)
1001		return -EIO;
1002
1003	if (count > 31)
1004		return -EINVAL;
1005
1006	if (kstrtoint(buffer, 10, &value))
1007		return -EINVAL;
1008
1009	if (item->validate)
1010		value = item->validate(SNC_VALIDATE_IN, value);
1011
1012	if (value < 0)
1013		return value;
1014
1015	ret = sony_nc_int_call(sony_nc_acpi_handle, *item->acpiset,
1016			       &value, NULL);
1017	if (ret < 0)
1018		return -EIO;
1019
1020	item->value = value;
1021	item->valid = 1;
1022	return count;
1023}
1024
1025
1026/*
1027 * Backlight device
1028 */
1029struct sony_backlight_props {
1030	struct backlight_device *dev;
1031	int			handle;
1032	int			cmd_base;
1033	u8			offset;
1034	u8			maxlvl;
1035};
1036static struct sony_backlight_props sony_bl_props;
1037
1038static int sony_backlight_update_status(struct backlight_device *bd)
1039{
1040	int arg = bd->props.brightness + 1;
1041	return sony_nc_int_call(sony_nc_acpi_handle, "SBRT", &arg, NULL);
1042}
1043
1044static int sony_backlight_get_brightness(struct backlight_device *bd)
1045{
1046	int value;
1047
1048	if (sony_nc_int_call(sony_nc_acpi_handle, "GBRT", NULL, &value))
1049		return 0;
1050	/* brightness levels are 1-based, while backlight ones are 0-based */
1051	return value - 1;
1052}
1053
1054static int sony_nc_get_brightness_ng(struct backlight_device *bd)
1055{
1056	int result;
1057	struct sony_backlight_props *sdev =
1058		(struct sony_backlight_props *)bl_get_data(bd);
1059
1060	sony_call_snc_handle(sdev->handle, sdev->cmd_base + 0x100, &result);
1061
1062	return (result & 0xff) - sdev->offset;
1063}
1064
1065static int sony_nc_update_status_ng(struct backlight_device *bd)
1066{
1067	int value, result;
1068	struct sony_backlight_props *sdev =
1069		(struct sony_backlight_props *)bl_get_data(bd);
1070
1071	value = bd->props.brightness + sdev->offset;
1072	if (sony_call_snc_handle(sdev->handle, sdev->cmd_base | (value << 0x10),
1073				&result))
1074		return -EIO;
1075
1076	return value;
1077}
1078
1079static const struct backlight_ops sony_backlight_ops = {
1080	.options = BL_CORE_SUSPENDRESUME,
1081	.update_status = sony_backlight_update_status,
1082	.get_brightness = sony_backlight_get_brightness,
1083};
1084static const struct backlight_ops sony_backlight_ng_ops = {
1085	.options = BL_CORE_SUSPENDRESUME,
1086	.update_status = sony_nc_update_status_ng,
1087	.get_brightness = sony_nc_get_brightness_ng,
1088};
1089
1090/*
1091 * New SNC-only Vaios event mapping to driver known keys
1092 */
1093struct sony_nc_event {
1094	u8	data;
1095	u8	event;
1096};
1097
1098static struct sony_nc_event sony_100_events[] = {
1099	{ 0x90, SONYPI_EVENT_PKEY_P1 },
1100	{ 0x10, SONYPI_EVENT_ANYBUTTON_RELEASED },
1101	{ 0x91, SONYPI_EVENT_PKEY_P2 },
1102	{ 0x11, SONYPI_EVENT_ANYBUTTON_RELEASED },
1103	{ 0x81, SONYPI_EVENT_FNKEY_F1 },
1104	{ 0x01, SONYPI_EVENT_FNKEY_RELEASED },
1105	{ 0x82, SONYPI_EVENT_FNKEY_F2 },
1106	{ 0x02, SONYPI_EVENT_FNKEY_RELEASED },
1107	{ 0x83, SONYPI_EVENT_FNKEY_F3 },
1108	{ 0x03, SONYPI_EVENT_FNKEY_RELEASED },
1109	{ 0x84, SONYPI_EVENT_FNKEY_F4 },
1110	{ 0x04, SONYPI_EVENT_FNKEY_RELEASED },
1111	{ 0x85, SONYPI_EVENT_FNKEY_F5 },
1112	{ 0x05, SONYPI_EVENT_FNKEY_RELEASED },
1113	{ 0x86, SONYPI_EVENT_FNKEY_F6 },
1114	{ 0x06, SONYPI_EVENT_FNKEY_RELEASED },
1115	{ 0x87, SONYPI_EVENT_FNKEY_F7 },
1116	{ 0x07, SONYPI_EVENT_FNKEY_RELEASED },
1117	{ 0x88, SONYPI_EVENT_FNKEY_F8 },
1118	{ 0x08, SONYPI_EVENT_FNKEY_RELEASED },
1119	{ 0x89, SONYPI_EVENT_FNKEY_F9 },
1120	{ 0x09, SONYPI_EVENT_FNKEY_RELEASED },
1121	{ 0x8A, SONYPI_EVENT_FNKEY_F10 },
1122	{ 0x0A, SONYPI_EVENT_FNKEY_RELEASED },
1123	{ 0x8B, SONYPI_EVENT_FNKEY_F11 },
1124	{ 0x0B, SONYPI_EVENT_FNKEY_RELEASED },
1125	{ 0x8C, SONYPI_EVENT_FNKEY_F12 },
1126	{ 0x0C, SONYPI_EVENT_FNKEY_RELEASED },
1127	{ 0x9d, SONYPI_EVENT_ZOOM_PRESSED },
1128	{ 0x1d, SONYPI_EVENT_ANYBUTTON_RELEASED },
1129	{ 0x9f, SONYPI_EVENT_CD_EJECT_PRESSED },
1130	{ 0x1f, SONYPI_EVENT_ANYBUTTON_RELEASED },
1131	{ 0xa1, SONYPI_EVENT_MEDIA_PRESSED },
1132	{ 0x21, SONYPI_EVENT_ANYBUTTON_RELEASED },
1133	{ 0xa4, SONYPI_EVENT_CD_EJECT_PRESSED },
1134	{ 0x24, SONYPI_EVENT_ANYBUTTON_RELEASED },
1135	{ 0xa5, SONYPI_EVENT_VENDOR_PRESSED },
1136	{ 0x25, SONYPI_EVENT_ANYBUTTON_RELEASED },
1137	{ 0xa6, SONYPI_EVENT_HELP_PRESSED },
1138	{ 0x26, SONYPI_EVENT_ANYBUTTON_RELEASED },
1139	{ 0xa8, SONYPI_EVENT_FNKEY_1 },
1140	{ 0x28, SONYPI_EVENT_ANYBUTTON_RELEASED },
1141	{ 0, 0 },
1142};
1143
1144static struct sony_nc_event sony_127_events[] = {
1145	{ 0x81, SONYPI_EVENT_MODEKEY_PRESSED },
1146	{ 0x01, SONYPI_EVENT_ANYBUTTON_RELEASED },
1147	{ 0x82, SONYPI_EVENT_PKEY_P1 },
1148	{ 0x02, SONYPI_EVENT_ANYBUTTON_RELEASED },
1149	{ 0x83, SONYPI_EVENT_PKEY_P2 },
1150	{ 0x03, SONYPI_EVENT_ANYBUTTON_RELEASED },
1151	{ 0x84, SONYPI_EVENT_PKEY_P3 },
1152	{ 0x04, SONYPI_EVENT_ANYBUTTON_RELEASED },
1153	{ 0x85, SONYPI_EVENT_PKEY_P4 },
1154	{ 0x05, SONYPI_EVENT_ANYBUTTON_RELEASED },
1155	{ 0x86, SONYPI_EVENT_PKEY_P5 },
1156	{ 0x06, SONYPI_EVENT_ANYBUTTON_RELEASED },
1157	{ 0x87, SONYPI_EVENT_SETTINGKEY_PRESSED },
1158	{ 0x07, SONYPI_EVENT_ANYBUTTON_RELEASED },
1159	{ 0, 0 },
1160};
1161
1162static int sony_nc_hotkeys_decode(u32 event, unsigned int handle)
1163{
1164	int ret = -EINVAL;
1165	unsigned int result = 0;
1166	struct sony_nc_event *key_event;
1167
1168	if (sony_call_snc_handle(handle, 0x200, &result)) {
1169		dprintk("Unable to decode event 0x%.2x 0x%.2x\n", handle,
1170				event);
1171		return -EINVAL;
1172	}
1173
1174	result &= 0xFF;
1175
1176	if (handle == 0x0100)
1177		key_event = sony_100_events;
1178	else
1179		key_event = sony_127_events;
1180
1181	for (; key_event->data; key_event++) {
1182		if (key_event->data == result) {
1183			ret = key_event->event;
1184			break;
1185		}
1186	}
1187
1188	if (!key_event->data)
1189		pr_info("Unknown hotkey 0x%.2x/0x%.2x (handle 0x%.2x)\n",
1190				event, result, handle);
1191
1192	return ret;
1193}
1194
1195/*
1196 * ACPI callbacks
1197 */
1198enum event_types {
1199	HOTKEY = 1,
1200	KILLSWITCH,
1201	GFX_SWITCH
1202};
1203static void sony_nc_notify(struct acpi_device *device, u32 event)
1204{
1205	u32 real_ev = event;
1206	u8 ev_type = 0;
1207	int ret;
1208
1209	dprintk("sony_nc_notify, event: 0x%.2x\n", event);
1210
1211	if (event >= 0x90) {
1212		unsigned int result = 0;
1213		unsigned int arg = 0;
1214		unsigned int handle = 0;
1215		unsigned int offset = event - 0x90;
1216
1217		if (offset >= ARRAY_SIZE(handles->cap)) {
1218			pr_err("Event 0x%x outside of capabilities list\n",
1219					event);
1220			return;
1221		}
1222		handle = handles->cap[offset];
1223
1224		/* list of handles known for generating events */
1225		switch (handle) {
1226		/* hotkey event */
1227		case 0x0100:
1228		case 0x0127:
1229			ev_type = HOTKEY;
1230			ret = sony_nc_hotkeys_decode(event, handle);
1231
1232			if (ret > 0) {
1233				sony_laptop_report_input_event(ret);
1234				real_ev = ret;
1235			}
1236
1237			break;
1238
1239		/* wlan switch */
1240		case 0x0124:
1241		case 0x0135:
1242			/* events on this handle are reported when the
1243			 * switch changes position or for battery
1244			 * events. We'll notify both of them but only
1245			 * update the rfkill device status when the
1246			 * switch is moved.
1247			 */
1248			ev_type = KILLSWITCH;
1249			sony_call_snc_handle(handle, 0x0100, &result);
1250			real_ev = result & 0x03;
1251
1252			/* hw switch event */
1253			if (real_ev == 1)
1254				sony_nc_rfkill_update();
1255
1256			break;
1257
1258		case 0x0128:
1259		case 0x0146:
1260			/* Hybrid GFX switching */
1261			sony_call_snc_handle(handle, 0x0000, &result);
1262			dprintk("GFX switch event received (reason: %s)\n",
1263					(result == 0x1) ? "switch change" :
1264					(result == 0x2) ? "output switch" :
1265					(result == 0x3) ? "output switch" :
1266					"");
1267
1268			ev_type = GFX_SWITCH;
1269			real_ev = __sony_nc_gfx_switch_status_get();
1270			break;
1271
1272		case 0x015B:
1273			/* Hybrid GFX switching SVS151290S */
1274			ev_type = GFX_SWITCH;
1275			real_ev = __sony_nc_gfx_switch_status_get();
1276			break;
1277		default:
1278			dprintk("Unknown event 0x%x for handle 0x%x\n",
1279					event, handle);
1280			break;
1281		}
1282
1283		/* clear the event (and the event reason when present) */
1284		arg = 1 << offset;
1285		sony_nc_int_call(sony_nc_acpi_handle, "SN05", &arg, &result);
1286
1287	} else {
1288		/* old style event */
1289		ev_type = HOTKEY;
1290		sony_laptop_report_input_event(real_ev);
1291	}
1292	acpi_bus_generate_netlink_event(sony_nc_acpi_device->pnp.device_class,
1293			dev_name(&sony_nc_acpi_device->dev), ev_type, real_ev);
1294}
1295
1296static acpi_status sony_walk_callback(acpi_handle handle, u32 level,
1297				      void *context, void **return_value)
1298{
1299	struct acpi_device_info *info;
1300
1301	if (ACPI_SUCCESS(acpi_get_object_info(handle, &info))) {
1302		pr_warn("method: name: %4.4s, args %X\n",
1303			(char *)&info->name, info->param_count);
1304
1305		kfree(info);
1306	}
1307
1308	return AE_OK;
1309}
1310
1311/*
1312 * ACPI device
1313 */
1314static void sony_nc_function_setup(struct acpi_device *device,
1315		struct platform_device *pf_device)
1316{
1317	unsigned int i, result, bitmask, arg;
1318
1319	if (!handles)
1320		return;
1321
1322	/* setup found handles here */
1323	for (i = 0; i < ARRAY_SIZE(handles->cap); i++) {
1324		unsigned int handle = handles->cap[i];
1325
1326		if (!handle)
1327			continue;
1328
1329		dprintk("setting up handle 0x%.4x\n", handle);
1330
1331		switch (handle) {
1332		case 0x0100:
1333		case 0x0101:
1334		case 0x0127:
1335			/* setup hotkeys */
1336			sony_call_snc_handle(handle, 0, &result);
1337			break;
1338		case 0x0102:
1339			/* setup hotkeys */
1340			sony_call_snc_handle(handle, 0x100, &result);
1341			break;
1342		case 0x0105:
1343		case 0x0148:
1344			/* touchpad enable/disable */
1345			result = sony_nc_touchpad_setup(pf_device, handle);
1346			if (result)
1347				pr_err("couldn't set up touchpad control function (%d)\n",
1348						result);
1349			break;
1350		case 0x0115:
1351		case 0x0136:
1352		case 0x013f:
1353			result = sony_nc_battery_care_setup(pf_device, handle);
1354			if (result)
1355				pr_err("couldn't set up battery care function (%d)\n",
1356						result);
1357			break;
1358		case 0x0119:
1359		case 0x015D:
1360			result = sony_nc_lid_resume_setup(pf_device, handle);
1361			if (result)
1362				pr_err("couldn't set up lid resume function (%d)\n",
1363						result);
1364			break;
1365		case 0x0122:
1366			result = sony_nc_thermal_setup(pf_device);
1367			if (result)
1368				pr_err("couldn't set up thermal profile function (%d)\n",
1369						result);
1370			break;
1371		case 0x0128:
1372		case 0x0146:
1373		case 0x015B:
1374			result = sony_nc_gfx_switch_setup(pf_device, handle);
1375			if (result)
1376				pr_err("couldn't set up GFX Switch status (%d)\n",
1377						result);
1378			break;
1379		case 0x0131:
1380			result = sony_nc_highspeed_charging_setup(pf_device);
1381			if (result)
1382				pr_err("couldn't set up high speed charging function (%d)\n",
1383				       result);
1384			break;
1385		case 0x0124:
1386		case 0x0135:
1387			result = sony_nc_rfkill_setup(device, handle);
1388			if (result)
1389				pr_err("couldn't set up rfkill support (%d)\n",
1390						result);
1391			break;
1392		case 0x0137:
1393		case 0x0143:
1394		case 0x014b:
1395		case 0x014c:
1396		case 0x0153:
1397		case 0x0163:
1398			result = sony_nc_kbd_backlight_setup(pf_device, handle);
1399			if (result)
1400				pr_err("couldn't set up keyboard backlight function (%d)\n",
1401						result);
1402			break;
1403		case 0x0121:
1404			result = sony_nc_lowbatt_setup(pf_device);
1405			if (result)
1406				pr_err("couldn't set up low battery function (%d)\n",
1407				       result);
1408			break;
1409		case 0x0149:
1410			result = sony_nc_fanspeed_setup(pf_device);
1411			if (result)
1412				pr_err("couldn't set up fan speed function (%d)\n",
1413				       result);
1414			break;
1415		case 0x0155:
1416			result = sony_nc_usb_charge_setup(pf_device);
1417			if (result)
1418				pr_err("couldn't set up USB charge support (%d)\n",
1419						result);
1420			break;
1421		case 0x011D:
1422			result = sony_nc_panelid_setup(pf_device);
1423			if (result)
1424				pr_err("couldn't set up panel ID function (%d)\n",
1425				       result);
1426			break;
1427		case 0x0168:
1428			result = sony_nc_smart_conn_setup(pf_device);
1429			if (result)
1430				pr_err("couldn't set up smart connect support (%d)\n",
1431						result);
1432			break;
1433		default:
1434			continue;
1435		}
1436	}
1437
1438	/* Enable all events */
1439	arg = 0x10;
1440	if (!sony_nc_int_call(sony_nc_acpi_handle, "SN00", &arg, &bitmask))
1441		sony_nc_int_call(sony_nc_acpi_handle, "SN02", &bitmask,
1442				&result);
1443}
1444
1445static void sony_nc_function_cleanup(struct platform_device *pd)
1446{
1447	unsigned int i, result, bitmask, handle;
1448
 
 
 
1449	/* get enabled events and disable them */
1450	sony_nc_int_call(sony_nc_acpi_handle, "SN01", NULL, &bitmask);
1451	sony_nc_int_call(sony_nc_acpi_handle, "SN03", &bitmask, &result);
1452
1453	/* cleanup handles here */
1454	for (i = 0; i < ARRAY_SIZE(handles->cap); i++) {
1455
1456		handle = handles->cap[i];
1457
1458		if (!handle)
1459			continue;
1460
1461		switch (handle) {
1462		case 0x0105:
1463		case 0x0148:
1464			sony_nc_touchpad_cleanup(pd);
1465			break;
1466		case 0x0115:
1467		case 0x0136:
1468		case 0x013f:
1469			sony_nc_battery_care_cleanup(pd);
1470			break;
1471		case 0x0119:
1472		case 0x015D:
1473			sony_nc_lid_resume_cleanup(pd);
1474			break;
1475		case 0x0122:
1476			sony_nc_thermal_cleanup(pd);
1477			break;
1478		case 0x0128:
1479		case 0x0146:
1480		case 0x015B:
1481			sony_nc_gfx_switch_cleanup(pd);
1482			break;
1483		case 0x0131:
1484			sony_nc_highspeed_charging_cleanup(pd);
1485			break;
1486		case 0x0124:
1487		case 0x0135:
1488			sony_nc_rfkill_cleanup();
1489			break;
1490		case 0x0137:
1491		case 0x0143:
1492		case 0x014b:
1493		case 0x014c:
1494		case 0x0153:
1495		case 0x0163:
1496			sony_nc_kbd_backlight_cleanup(pd, handle);
1497			break;
1498		case 0x0121:
1499			sony_nc_lowbatt_cleanup(pd);
1500			break;
1501		case 0x0149:
1502			sony_nc_fanspeed_cleanup(pd);
1503			break;
1504		case 0x0155:
1505			sony_nc_usb_charge_cleanup(pd);
1506			break;
1507		case 0x011D:
1508			sony_nc_panelid_cleanup(pd);
1509			break;
1510		case 0x0168:
1511			sony_nc_smart_conn_cleanup(pd);
1512			break;
1513		default:
1514			continue;
1515		}
1516	}
1517
1518	/* finally cleanup the handles list */
1519	sony_nc_handles_cleanup(pd);
1520}
1521
1522#ifdef CONFIG_PM_SLEEP
1523static void sony_nc_function_resume(void)
1524{
1525	unsigned int i, result, bitmask, arg;
1526
1527	dprintk("Resuming SNC device\n");
1528
1529	for (i = 0; i < ARRAY_SIZE(handles->cap); i++) {
1530		unsigned int handle = handles->cap[i];
1531
1532		if (!handle)
1533			continue;
1534
1535		switch (handle) {
1536		case 0x0100:
1537		case 0x0101:
1538		case 0x0127:
1539			/* re-enable hotkeys */
1540			sony_call_snc_handle(handle, 0, &result);
1541			break;
1542		case 0x0102:
1543			/* re-enable hotkeys */
1544			sony_call_snc_handle(handle, 0x100, &result);
1545			break;
1546		case 0x0122:
1547			sony_nc_thermal_resume();
1548			break;
1549		case 0x0124:
1550		case 0x0135:
1551			sony_nc_rfkill_update();
1552			break;
1553		default:
1554			continue;
1555		}
1556	}
1557
1558	/* Enable all events */
1559	arg = 0x10;
1560	if (!sony_nc_int_call(sony_nc_acpi_handle, "SN00", &arg, &bitmask))
1561		sony_nc_int_call(sony_nc_acpi_handle, "SN02", &bitmask,
1562				&result);
1563}
1564
1565static int sony_nc_resume(struct device *dev)
1566{
1567	struct sony_nc_value *item;
1568
1569	for (item = sony_nc_values; item->name; item++) {
1570		int ret;
1571
1572		if (!item->valid)
1573			continue;
1574		ret = sony_nc_int_call(sony_nc_acpi_handle, *item->acpiset,
1575				       &item->value, NULL);
1576		if (ret < 0) {
1577			pr_err("%s: %d\n", __func__, ret);
1578			break;
1579		}
1580	}
1581
1582	if (acpi_has_method(sony_nc_acpi_handle, "ECON")) {
1583		int arg = 1;
1584		if (sony_nc_int_call(sony_nc_acpi_handle, "ECON", &arg, NULL))
1585			dprintk("ECON Method failed\n");
1586	}
1587
1588	if (acpi_has_method(sony_nc_acpi_handle, "SN00"))
1589		sony_nc_function_resume();
1590
1591	return 0;
1592}
1593#endif
1594
1595static SIMPLE_DEV_PM_OPS(sony_nc_pm, NULL, sony_nc_resume);
1596
1597static void sony_nc_rfkill_cleanup(void)
1598{
1599	int i;
1600
1601	for (i = 0; i < N_SONY_RFKILL; i++) {
1602		if (sony_rfkill_devices[i]) {
1603			rfkill_unregister(sony_rfkill_devices[i]);
1604			rfkill_destroy(sony_rfkill_devices[i]);
1605		}
1606	}
1607}
1608
1609static int sony_nc_rfkill_set(void *data, bool blocked)
1610{
1611	int result;
1612	int argument = sony_rfkill_address[(long) data] + 0x100;
1613
1614	if (!blocked)
1615		argument |= 0x070000;
1616
1617	return sony_call_snc_handle(sony_rfkill_handle, argument, &result);
1618}
1619
1620static const struct rfkill_ops sony_rfkill_ops = {
1621	.set_block = sony_nc_rfkill_set,
1622};
1623
1624static int sony_nc_setup_rfkill(struct acpi_device *device,
1625				enum sony_nc_rfkill nc_type)
1626{
1627	int err = 0;
1628	struct rfkill *rfk;
1629	enum rfkill_type type;
1630	const char *name;
1631	int result;
1632	bool hwblock, swblock;
1633
1634	switch (nc_type) {
1635	case SONY_WIFI:
1636		type = RFKILL_TYPE_WLAN;
1637		name = "sony-wifi";
1638		break;
1639	case SONY_BLUETOOTH:
1640		type = RFKILL_TYPE_BLUETOOTH;
1641		name = "sony-bluetooth";
1642		break;
1643	case SONY_WWAN:
1644		type = RFKILL_TYPE_WWAN;
1645		name = "sony-wwan";
1646		break;
1647	case SONY_WIMAX:
1648		type = RFKILL_TYPE_WIMAX;
1649		name = "sony-wimax";
1650		break;
1651	default:
1652		return -EINVAL;
1653	}
1654
1655	rfk = rfkill_alloc(name, &device->dev, type,
1656			   &sony_rfkill_ops, (void *)nc_type);
1657	if (!rfk)
1658		return -ENOMEM;
1659
1660	if (sony_call_snc_handle(sony_rfkill_handle, 0x200, &result) < 0) {
 
1661		rfkill_destroy(rfk);
1662		return -1;
1663	}
1664	hwblock = !(result & 0x1);
1665
1666	if (sony_call_snc_handle(sony_rfkill_handle,
1667				sony_rfkill_address[nc_type],
1668				&result) < 0) {
 
1669		rfkill_destroy(rfk);
1670		return -1;
1671	}
1672	swblock = !(result & 0x2);
1673
1674	rfkill_init_sw_state(rfk, swblock);
1675	rfkill_set_hw_state(rfk, hwblock);
1676
1677	err = rfkill_register(rfk);
1678	if (err) {
1679		rfkill_destroy(rfk);
1680		return err;
1681	}
1682	sony_rfkill_devices[nc_type] = rfk;
1683	return err;
1684}
1685
1686static void sony_nc_rfkill_update(void)
1687{
1688	enum sony_nc_rfkill i;
1689	int result;
1690	bool hwblock;
1691
1692	sony_call_snc_handle(sony_rfkill_handle, 0x200, &result);
1693	hwblock = !(result & 0x1);
1694
1695	for (i = 0; i < N_SONY_RFKILL; i++) {
1696		int argument = sony_rfkill_address[i];
1697
1698		if (!sony_rfkill_devices[i])
1699			continue;
1700
1701		if (hwblock) {
1702			if (rfkill_set_hw_state(sony_rfkill_devices[i], true)) {
1703				/* we already know we're blocked */
1704			}
1705			continue;
1706		}
1707
1708		sony_call_snc_handle(sony_rfkill_handle, argument, &result);
1709		rfkill_set_states(sony_rfkill_devices[i],
1710				  !(result & 0x2), false);
1711	}
1712}
1713
1714static int sony_nc_rfkill_setup(struct acpi_device *device,
1715		unsigned int handle)
1716{
1717	u64 offset;
1718	int i;
1719	unsigned char buffer[32] = { 0 };
1720
1721	offset = sony_find_snc_handle(handle);
1722	sony_rfkill_handle = handle;
1723
1724	i = sony_nc_buffer_call(sony_nc_acpi_handle, "SN06", &offset, buffer,
1725			32);
1726	if (i < 0)
1727		return i;
1728
1729	/* The buffer is filled with magic numbers describing the devices
1730	 * available, 0xff terminates the enumeration.
1731	 * Known codes:
1732	 *	0x00 WLAN
1733	 *	0x10 BLUETOOTH
1734	 *	0x20 WWAN GPRS-EDGE
1735	 *	0x21 WWAN HSDPA
1736	 *	0x22 WWAN EV-DO
1737	 *	0x23 WWAN GPS
1738	 *	0x25 Gobi WWAN no GPS
1739	 *	0x26 Gobi WWAN + GPS
1740	 *	0x28 Gobi WWAN no GPS
1741	 *	0x29 Gobi WWAN + GPS
1742	 *	0x30 WIMAX
1743	 *	0x50 Gobi WWAN no GPS
1744	 *	0x51 Gobi WWAN + GPS
1745	 *	0x70 no SIM card slot
1746	 *	0x71 SIM card slot
1747	 */
1748	for (i = 0; i < ARRAY_SIZE(buffer); i++) {
1749
1750		if (buffer[i] == 0xff)
1751			break;
1752
1753		dprintk("Radio devices, found 0x%.2x\n", buffer[i]);
1754
1755		if (buffer[i] == 0 && !sony_rfkill_devices[SONY_WIFI])
1756			sony_nc_setup_rfkill(device, SONY_WIFI);
1757
1758		if (buffer[i] == 0x10 && !sony_rfkill_devices[SONY_BLUETOOTH])
1759			sony_nc_setup_rfkill(device, SONY_BLUETOOTH);
1760
1761		if (((0xf0 & buffer[i]) == 0x20 ||
1762					(0xf0 & buffer[i]) == 0x50) &&
1763				!sony_rfkill_devices[SONY_WWAN])
1764			sony_nc_setup_rfkill(device, SONY_WWAN);
1765
1766		if (buffer[i] == 0x30 && !sony_rfkill_devices[SONY_WIMAX])
1767			sony_nc_setup_rfkill(device, SONY_WIMAX);
1768	}
1769	return 0;
1770}
1771
1772/* Keyboard backlight feature */
1773struct kbd_backlight {
1774	unsigned int handle;
1775	unsigned int base;
1776	unsigned int mode;
1777	unsigned int timeout;
1778	unsigned int has_timeout;
1779	struct device_attribute mode_attr;
1780	struct device_attribute timeout_attr;
1781};
1782
1783static struct kbd_backlight *kbdbl_ctl;
1784
1785static ssize_t __sony_nc_kbd_backlight_mode_set(u8 value)
1786{
1787	int result;
1788
1789	if (value > 2)
1790		return -EINVAL;
1791
1792	if (sony_call_snc_handle(kbdbl_ctl->handle,
1793				(value << 0x10) | (kbdbl_ctl->base), &result))
1794		return -EIO;
1795
1796	/* Try to turn the light on/off immediately */
1797	if (value != 1)
1798		sony_call_snc_handle(kbdbl_ctl->handle,
1799				(value << 0x0f) | (kbdbl_ctl->base + 0x100),
1800				&result);
1801
1802	kbdbl_ctl->mode = value;
1803
1804	return 0;
1805}
1806
1807static ssize_t sony_nc_kbd_backlight_mode_store(struct device *dev,
1808		struct device_attribute *attr,
1809		const char *buffer, size_t count)
1810{
1811	int ret = 0;
1812	unsigned long value;
1813
1814	if (count > 31)
1815		return -EINVAL;
1816
1817	if (kstrtoul(buffer, 10, &value))
1818		return -EINVAL;
1819
1820	ret = __sony_nc_kbd_backlight_mode_set(value);
1821	if (ret < 0)
1822		return ret;
1823
1824	return count;
1825}
1826
1827static ssize_t sony_nc_kbd_backlight_mode_show(struct device *dev,
1828		struct device_attribute *attr, char *buffer)
1829{
1830	ssize_t count = 0;
1831	count = snprintf(buffer, PAGE_SIZE, "%d\n", kbdbl_ctl->mode);
1832	return count;
1833}
1834
1835static int __sony_nc_kbd_backlight_timeout_set(u8 value)
1836{
1837	int result;
1838
1839	if (value > 3)
1840		return -EINVAL;
1841
1842	if (sony_call_snc_handle(kbdbl_ctl->handle, (value << 0x10) |
1843				(kbdbl_ctl->base + 0x200), &result))
1844		return -EIO;
1845
1846	kbdbl_ctl->timeout = value;
1847
1848	return 0;
1849}
1850
1851static ssize_t sony_nc_kbd_backlight_timeout_store(struct device *dev,
1852		struct device_attribute *attr,
1853		const char *buffer, size_t count)
1854{
1855	int ret = 0;
1856	unsigned long value;
1857
1858	if (count > 31)
1859		return -EINVAL;
1860
1861	if (kstrtoul(buffer, 10, &value))
1862		return -EINVAL;
1863
1864	ret = __sony_nc_kbd_backlight_timeout_set(value);
1865	if (ret < 0)
1866		return ret;
1867
1868	return count;
1869}
1870
1871static ssize_t sony_nc_kbd_backlight_timeout_show(struct device *dev,
1872		struct device_attribute *attr, char *buffer)
1873{
1874	ssize_t count = 0;
1875	count = snprintf(buffer, PAGE_SIZE, "%d\n", kbdbl_ctl->timeout);
1876	return count;
1877}
1878
1879static int sony_nc_kbd_backlight_setup(struct platform_device *pd,
1880		unsigned int handle)
1881{
1882	int result;
1883	int probe_base = 0;
1884	int ctl_base = 0;
1885	int ret = 0;
1886
1887	if (kbdbl_ctl) {
1888		pr_warn("handle 0x%.4x: keyboard backlight setup already done for 0x%.4x\n",
1889				handle, kbdbl_ctl->handle);
1890		return -EBUSY;
1891	}
1892
1893	/* verify the kbd backlight presence, some of these handles are not used
1894	 * for keyboard backlight only
1895	 */
1896	switch (handle) {
1897	case 0x0153:
1898		probe_base = 0x0;
1899		ctl_base = 0x0;
1900		break;
1901	case 0x0137:
1902		probe_base = 0x0B00;
1903		ctl_base = 0x0C00;
1904		break;
1905	default:
1906		probe_base = 0x0100;
1907		ctl_base = 0x4000;
1908		break;
1909	}
1910
1911	ret = sony_call_snc_handle(handle, probe_base, &result);
1912	if (ret)
1913		return ret;
 
 
 
 
 
 
1914
1915	if ((handle == 0x0137 && !(result & 0x02)) ||
1916			!(result & 0x01)) {
1917		dprintk("no backlight keyboard found\n");
1918		return 0;
 
1919	}
1920
1921	kbdbl_ctl = kzalloc(sizeof(*kbdbl_ctl), GFP_KERNEL);
1922	if (!kbdbl_ctl)
1923		return -ENOMEM;
1924
1925	kbdbl_ctl->mode = kbd_backlight;
1926	kbdbl_ctl->timeout = kbd_backlight_timeout;
1927	kbdbl_ctl->handle = handle;
1928	kbdbl_ctl->base = ctl_base;
1929	/* Some models do not allow timeout control */
1930	kbdbl_ctl->has_timeout = handle != 0x0153;
1931
1932	sysfs_attr_init(&kbdbl_ctl->mode_attr.attr);
1933	kbdbl_ctl->mode_attr.attr.name = "kbd_backlight";
1934	kbdbl_ctl->mode_attr.attr.mode = S_IRUGO | S_IWUSR;
1935	kbdbl_ctl->mode_attr.show = sony_nc_kbd_backlight_mode_show;
1936	kbdbl_ctl->mode_attr.store = sony_nc_kbd_backlight_mode_store;
1937
1938	ret = device_create_file(&pd->dev, &kbdbl_ctl->mode_attr);
1939	if (ret)
1940		goto outkzalloc;
1941
1942	__sony_nc_kbd_backlight_mode_set(kbdbl_ctl->mode);
1943
1944	if (kbdbl_ctl->has_timeout) {
1945		sysfs_attr_init(&kbdbl_ctl->timeout_attr.attr);
1946		kbdbl_ctl->timeout_attr.attr.name = "kbd_backlight_timeout";
1947		kbdbl_ctl->timeout_attr.attr.mode = S_IRUGO | S_IWUSR;
1948		kbdbl_ctl->timeout_attr.show =
1949			sony_nc_kbd_backlight_timeout_show;
1950		kbdbl_ctl->timeout_attr.store =
1951			sony_nc_kbd_backlight_timeout_store;
1952
1953		ret = device_create_file(&pd->dev, &kbdbl_ctl->timeout_attr);
1954		if (ret)
1955			goto outmode;
1956
1957		__sony_nc_kbd_backlight_timeout_set(kbdbl_ctl->timeout);
1958	}
1959
1960
1961	return 0;
1962
1963outmode:
1964	device_remove_file(&pd->dev, &kbdbl_ctl->mode_attr);
1965outkzalloc:
1966	kfree(kbdbl_ctl);
1967	kbdbl_ctl = NULL;
1968	return ret;
1969}
1970
1971static void sony_nc_kbd_backlight_cleanup(struct platform_device *pd,
1972		unsigned int handle)
1973{
1974	if (kbdbl_ctl && handle == kbdbl_ctl->handle) {
1975		device_remove_file(&pd->dev, &kbdbl_ctl->mode_attr);
1976		if (kbdbl_ctl->has_timeout)
1977			device_remove_file(&pd->dev, &kbdbl_ctl->timeout_attr);
1978		kfree(kbdbl_ctl);
1979		kbdbl_ctl = NULL;
1980	}
1981}
1982
1983struct battery_care_control {
1984	struct device_attribute attrs[2];
1985	unsigned int handle;
1986};
1987static struct battery_care_control *bcare_ctl;
1988
1989static ssize_t sony_nc_battery_care_limit_store(struct device *dev,
1990		struct device_attribute *attr,
1991		const char *buffer, size_t count)
1992{
1993	unsigned int result, cmd;
1994	unsigned long value;
1995
1996	if (count > 31)
1997		return -EINVAL;
1998
1999	if (kstrtoul(buffer, 10, &value))
2000		return -EINVAL;
2001
2002	/*  limit values (2 bits):
2003	 *  00 - none
2004	 *  01 - 80%
2005	 *  10 - 50%
2006	 *  11 - 100%
2007	 *
2008	 *  bit 0: 0 disable BCL, 1 enable BCL
2009	 *  bit 1: 1 tell to store the battery limit (see bits 6,7) too
2010	 *  bits 2,3: reserved
2011	 *  bits 4,5: store the limit into the EC
2012	 *  bits 6,7: store the limit into the battery
2013	 */
2014	cmd = 0;
2015
2016	if (value > 0) {
2017		if (value <= 50)
2018			cmd = 0x20;
2019
2020		else if (value <= 80)
2021			cmd = 0x10;
2022
2023		else if (value <= 100)
2024			cmd = 0x30;
2025
2026		else
2027			return -EINVAL;
2028
2029		/*
2030		 * handle 0x0115 should allow storing on battery too;
2031		 * handle 0x0136 same as 0x0115 + health status;
2032		 * handle 0x013f, same as 0x0136 but no storing on the battery
2033		 */
2034		if (bcare_ctl->handle != 0x013f)
2035			cmd = cmd | (cmd << 2);
2036
2037		cmd = (cmd | 0x1) << 0x10;
2038	}
2039
2040	if (sony_call_snc_handle(bcare_ctl->handle, cmd | 0x0100, &result))
2041		return -EIO;
2042
2043	return count;
2044}
2045
2046static ssize_t sony_nc_battery_care_limit_show(struct device *dev,
2047		struct device_attribute *attr, char *buffer)
2048{
2049	unsigned int result, status;
2050
2051	if (sony_call_snc_handle(bcare_ctl->handle, 0x0000, &result))
2052		return -EIO;
2053
2054	status = (result & 0x01) ? ((result & 0x30) >> 0x04) : 0;
2055	switch (status) {
2056	case 1:
2057		status = 80;
2058		break;
2059	case 2:
2060		status = 50;
2061		break;
2062	case 3:
2063		status = 100;
2064		break;
2065	default:
2066		status = 0;
2067		break;
2068	}
2069
2070	return snprintf(buffer, PAGE_SIZE, "%d\n", status);
2071}
2072
2073static ssize_t sony_nc_battery_care_health_show(struct device *dev,
2074		struct device_attribute *attr, char *buffer)
2075{
2076	ssize_t count = 0;
2077	unsigned int health;
2078
2079	if (sony_call_snc_handle(bcare_ctl->handle, 0x0200, &health))
2080		return -EIO;
2081
2082	count = snprintf(buffer, PAGE_SIZE, "%d\n", health & 0xff);
2083
2084	return count;
2085}
2086
2087static int sony_nc_battery_care_setup(struct platform_device *pd,
2088		unsigned int handle)
2089{
2090	int ret = 0;
2091
2092	bcare_ctl = kzalloc(sizeof(struct battery_care_control), GFP_KERNEL);
2093	if (!bcare_ctl)
2094		return -ENOMEM;
2095
2096	bcare_ctl->handle = handle;
2097
2098	sysfs_attr_init(&bcare_ctl->attrs[0].attr);
2099	bcare_ctl->attrs[0].attr.name = "battery_care_limiter";
2100	bcare_ctl->attrs[0].attr.mode = S_IRUGO | S_IWUSR;
2101	bcare_ctl->attrs[0].show = sony_nc_battery_care_limit_show;
2102	bcare_ctl->attrs[0].store = sony_nc_battery_care_limit_store;
2103
2104	ret = device_create_file(&pd->dev, &bcare_ctl->attrs[0]);
2105	if (ret)
2106		goto outkzalloc;
2107
2108	/* 0x0115 is for models with no health reporting capability */
2109	if (handle == 0x0115)
2110		return 0;
2111
2112	sysfs_attr_init(&bcare_ctl->attrs[1].attr);
2113	bcare_ctl->attrs[1].attr.name = "battery_care_health";
2114	bcare_ctl->attrs[1].attr.mode = S_IRUGO;
2115	bcare_ctl->attrs[1].show = sony_nc_battery_care_health_show;
2116
2117	ret = device_create_file(&pd->dev, &bcare_ctl->attrs[1]);
2118	if (ret)
2119		goto outlimiter;
2120
2121	return 0;
2122
2123outlimiter:
2124	device_remove_file(&pd->dev, &bcare_ctl->attrs[0]);
2125
2126outkzalloc:
2127	kfree(bcare_ctl);
2128	bcare_ctl = NULL;
2129
2130	return ret;
2131}
2132
2133static void sony_nc_battery_care_cleanup(struct platform_device *pd)
2134{
2135	if (bcare_ctl) {
2136		device_remove_file(&pd->dev, &bcare_ctl->attrs[0]);
2137		if (bcare_ctl->handle != 0x0115)
2138			device_remove_file(&pd->dev, &bcare_ctl->attrs[1]);
2139
2140		kfree(bcare_ctl);
2141		bcare_ctl = NULL;
2142	}
2143}
2144
2145struct snc_thermal_ctrl {
2146	unsigned int mode;
2147	unsigned int profiles;
2148	struct device_attribute mode_attr;
2149	struct device_attribute profiles_attr;
2150};
2151static struct snc_thermal_ctrl *th_handle;
2152
2153#define THM_PROFILE_MAX 3
2154static const char * const snc_thermal_profiles[] = {
2155	"balanced",
2156	"silent",
2157	"performance"
2158};
2159
2160static int sony_nc_thermal_mode_set(unsigned short mode)
2161{
2162	unsigned int result;
2163
2164	/* the thermal profile seems to be a two bit bitmask:
2165	 * lsb -> silent
2166	 * msb -> performance
2167	 * no bit set is the normal operation and is always valid
2168	 * Some vaio models only have "balanced" and "performance"
2169	 */
2170	if ((mode && !(th_handle->profiles & mode)) || mode >= THM_PROFILE_MAX)
2171		return -EINVAL;
2172
2173	if (sony_call_snc_handle(0x0122, mode << 0x10 | 0x0200, &result))
2174		return -EIO;
2175
2176	th_handle->mode = mode;
2177
2178	return 0;
2179}
2180
2181static int sony_nc_thermal_mode_get(void)
2182{
2183	unsigned int result;
2184
2185	if (sony_call_snc_handle(0x0122, 0x0100, &result))
2186		return -EIO;
2187
2188	return result & 0xff;
2189}
2190
2191static ssize_t sony_nc_thermal_profiles_show(struct device *dev,
2192		struct device_attribute *attr, char *buffer)
2193{
2194	short cnt;
2195	size_t idx = 0;
2196
2197	for (cnt = 0; cnt < THM_PROFILE_MAX; cnt++) {
2198		if (!cnt || (th_handle->profiles & cnt))
2199			idx += snprintf(buffer + idx, PAGE_SIZE - idx, "%s ",
2200					snc_thermal_profiles[cnt]);
2201	}
2202	idx += snprintf(buffer + idx, PAGE_SIZE - idx, "\n");
2203
2204	return idx;
2205}
2206
2207static ssize_t sony_nc_thermal_mode_store(struct device *dev,
2208		struct device_attribute *attr,
2209		const char *buffer, size_t count)
2210{
2211	unsigned short cmd;
2212	size_t len = count;
2213
2214	if (count == 0)
2215		return -EINVAL;
2216
2217	/* skip the newline if present */
2218	if (buffer[len - 1] == '\n')
2219		len--;
2220
2221	for (cmd = 0; cmd < THM_PROFILE_MAX; cmd++)
2222		if (strncmp(buffer, snc_thermal_profiles[cmd], len) == 0)
2223			break;
2224
2225	if (sony_nc_thermal_mode_set(cmd))
2226		return -EIO;
2227
2228	return count;
2229}
2230
2231static ssize_t sony_nc_thermal_mode_show(struct device *dev,
2232		struct device_attribute *attr, char *buffer)
2233{
2234	ssize_t count = 0;
2235	int mode = sony_nc_thermal_mode_get();
2236
2237	if (mode < 0)
2238		return mode;
2239
2240	count = snprintf(buffer, PAGE_SIZE, "%s\n", snc_thermal_profiles[mode]);
2241
2242	return count;
2243}
2244
2245static int sony_nc_thermal_setup(struct platform_device *pd)
2246{
2247	int ret = 0;
2248	th_handle = kzalloc(sizeof(struct snc_thermal_ctrl), GFP_KERNEL);
2249	if (!th_handle)
2250		return -ENOMEM;
2251
2252	ret = sony_call_snc_handle(0x0122, 0x0000, &th_handle->profiles);
2253	if (ret) {
2254		pr_warn("couldn't to read the thermal profiles\n");
2255		goto outkzalloc;
2256	}
2257
2258	ret = sony_nc_thermal_mode_get();
2259	if (ret < 0) {
2260		pr_warn("couldn't to read the current thermal profile");
2261		goto outkzalloc;
2262	}
2263	th_handle->mode = ret;
2264
2265	sysfs_attr_init(&th_handle->profiles_attr.attr);
2266	th_handle->profiles_attr.attr.name = "thermal_profiles";
2267	th_handle->profiles_attr.attr.mode = S_IRUGO;
2268	th_handle->profiles_attr.show = sony_nc_thermal_profiles_show;
2269
2270	sysfs_attr_init(&th_handle->mode_attr.attr);
2271	th_handle->mode_attr.attr.name = "thermal_control";
2272	th_handle->mode_attr.attr.mode = S_IRUGO | S_IWUSR;
2273	th_handle->mode_attr.show = sony_nc_thermal_mode_show;
2274	th_handle->mode_attr.store = sony_nc_thermal_mode_store;
2275
2276	ret = device_create_file(&pd->dev, &th_handle->profiles_attr);
2277	if (ret)
2278		goto outkzalloc;
2279
2280	ret = device_create_file(&pd->dev, &th_handle->mode_attr);
2281	if (ret)
2282		goto outprofiles;
2283
2284	return 0;
2285
2286outprofiles:
2287	device_remove_file(&pd->dev, &th_handle->profiles_attr);
2288outkzalloc:
2289	kfree(th_handle);
2290	th_handle = NULL;
2291	return ret;
2292}
2293
2294static void sony_nc_thermal_cleanup(struct platform_device *pd)
2295{
2296	if (th_handle) {
2297		device_remove_file(&pd->dev, &th_handle->profiles_attr);
2298		device_remove_file(&pd->dev, &th_handle->mode_attr);
2299		kfree(th_handle);
2300		th_handle = NULL;
2301	}
2302}
2303
2304#ifdef CONFIG_PM_SLEEP
2305static void sony_nc_thermal_resume(void)
2306{
2307	unsigned int status = sony_nc_thermal_mode_get();
 
 
 
 
 
2308
2309	if (status != th_handle->mode)
2310		sony_nc_thermal_mode_set(th_handle->mode);
2311}
2312#endif
2313
2314/* resume on LID open */
2315#define LID_RESUME_S5	0
2316#define LID_RESUME_S4	1
2317#define LID_RESUME_S3	2
2318#define LID_RESUME_MAX	3
2319struct snc_lid_resume_control {
2320	struct device_attribute attrs[LID_RESUME_MAX];
2321	unsigned int status;
2322	int handle;
2323};
2324static struct snc_lid_resume_control *lid_ctl;
2325
2326static ssize_t sony_nc_lid_resume_store(struct device *dev,
2327					struct device_attribute *attr,
2328					const char *buffer, size_t count)
2329{
2330	unsigned int result;
2331	unsigned long value;
2332	unsigned int pos = LID_RESUME_S5;
2333	if (count > 31)
2334		return -EINVAL;
2335
2336	if (kstrtoul(buffer, 10, &value) || value > 1)
2337		return -EINVAL;
2338
2339	/* the value we have to write to SNC is a bitmask:
2340	 * +--------------+
2341	 * | S3 | S4 | S5 |
2342	 * +--------------+
2343	 *   2    1    0
2344	 */
2345	while (pos < LID_RESUME_MAX) {
2346		if (&lid_ctl->attrs[pos].attr == &attr->attr)
2347			break;
2348		pos++;
2349	}
2350	if (pos == LID_RESUME_MAX)
2351		return -EINVAL;
2352
2353	if (value)
2354		value = lid_ctl->status | (1 << pos);
2355	else
2356		value = lid_ctl->status & ~(1 << pos);
2357
2358	if (sony_call_snc_handle(lid_ctl->handle, value << 0x10 | 0x0100,
2359				&result))
2360		return -EIO;
2361
2362	lid_ctl->status = value;
2363
2364	return count;
2365}
2366
2367static ssize_t sony_nc_lid_resume_show(struct device *dev,
2368					struct device_attribute *attr,
2369					char *buffer)
2370{
2371	unsigned int pos = LID_RESUME_S5;
2372
2373	while (pos < LID_RESUME_MAX) {
2374		if (&lid_ctl->attrs[pos].attr == &attr->attr)
2375			return snprintf(buffer, PAGE_SIZE, "%d\n",
2376					(lid_ctl->status >> pos) & 0x01);
2377		pos++;
2378	}
2379	return -EINVAL;
2380}
2381
2382static int sony_nc_lid_resume_setup(struct platform_device *pd,
2383					unsigned int handle)
2384{
2385	unsigned int result;
2386	int i;
2387
2388	if (sony_call_snc_handle(handle, 0x0000, &result))
2389		return -EIO;
2390
2391	lid_ctl = kzalloc(sizeof(struct snc_lid_resume_control), GFP_KERNEL);
2392	if (!lid_ctl)
2393		return -ENOMEM;
2394
2395	lid_ctl->status = result & 0x7;
2396	lid_ctl->handle = handle;
2397
2398	sysfs_attr_init(&lid_ctl->attrs[0].attr);
2399	lid_ctl->attrs[LID_RESUME_S5].attr.name = "lid_resume_S5";
2400	lid_ctl->attrs[LID_RESUME_S5].attr.mode = S_IRUGO | S_IWUSR;
2401	lid_ctl->attrs[LID_RESUME_S5].show = sony_nc_lid_resume_show;
2402	lid_ctl->attrs[LID_RESUME_S5].store = sony_nc_lid_resume_store;
2403
2404	if (handle == 0x0119) {
2405		sysfs_attr_init(&lid_ctl->attrs[1].attr);
2406		lid_ctl->attrs[LID_RESUME_S4].attr.name = "lid_resume_S4";
2407		lid_ctl->attrs[LID_RESUME_S4].attr.mode = S_IRUGO | S_IWUSR;
2408		lid_ctl->attrs[LID_RESUME_S4].show = sony_nc_lid_resume_show;
2409		lid_ctl->attrs[LID_RESUME_S4].store = sony_nc_lid_resume_store;
2410
2411		sysfs_attr_init(&lid_ctl->attrs[2].attr);
2412		lid_ctl->attrs[LID_RESUME_S3].attr.name = "lid_resume_S3";
2413		lid_ctl->attrs[LID_RESUME_S3].attr.mode = S_IRUGO | S_IWUSR;
2414		lid_ctl->attrs[LID_RESUME_S3].show = sony_nc_lid_resume_show;
2415		lid_ctl->attrs[LID_RESUME_S3].store = sony_nc_lid_resume_store;
2416	}
2417	for (i = 0; i < LID_RESUME_MAX &&
2418			lid_ctl->attrs[i].attr.name; i++) {
2419		result = device_create_file(&pd->dev, &lid_ctl->attrs[i]);
2420		if (result)
2421			goto liderror;
2422	}
2423
2424	return 0;
2425
2426liderror:
2427	for (i--; i >= 0; i--)
2428		device_remove_file(&pd->dev, &lid_ctl->attrs[i]);
2429
2430	kfree(lid_ctl);
2431	lid_ctl = NULL;
2432
2433	return result;
2434}
2435
2436static void sony_nc_lid_resume_cleanup(struct platform_device *pd)
2437{
2438	int i;
2439
2440	if (lid_ctl) {
2441		for (i = 0; i < LID_RESUME_MAX; i++) {
2442			if (!lid_ctl->attrs[i].attr.name)
2443				break;
2444
2445			device_remove_file(&pd->dev, &lid_ctl->attrs[i]);
2446		}
2447
2448		kfree(lid_ctl);
2449		lid_ctl = NULL;
2450	}
2451}
2452
2453/* GFX Switch position */
2454enum gfx_switch {
2455	SPEED,
2456	STAMINA,
2457	AUTO
2458};
2459struct snc_gfx_switch_control {
2460	struct device_attribute attr;
2461	unsigned int handle;
2462};
2463static struct snc_gfx_switch_control *gfxs_ctl;
2464
2465/* returns 0 for speed, 1 for stamina */
2466static int __sony_nc_gfx_switch_status_get(void)
2467{
2468	unsigned int result;
2469
2470	if (sony_call_snc_handle(gfxs_ctl->handle,
2471				gfxs_ctl->handle == 0x015B ? 0x0000 : 0x0100,
2472				&result))
2473		return -EIO;
2474
2475	switch (gfxs_ctl->handle) {
2476	case 0x0146:
2477		/* 1: discrete GFX (speed)
2478		 * 0: integrated GFX (stamina)
2479		 */
2480		return result & 0x1 ? SPEED : STAMINA;
2481		break;
2482	case 0x015B:
2483		/* 0: discrete GFX (speed)
2484		 * 1: integrated GFX (stamina)
2485		 */
2486		return result & 0x1 ? STAMINA : SPEED;
2487		break;
2488	case 0x0128:
2489		/* it's a more elaborated bitmask, for now:
2490		 * 2: integrated GFX (stamina)
2491		 * 0: discrete GFX (speed)
2492		 */
2493		dprintk("GFX Status: 0x%x\n", result);
2494		return result & 0x80 ? AUTO :
2495			result & 0x02 ? STAMINA : SPEED;
2496		break;
2497	}
2498	return -EINVAL;
2499}
2500
2501static ssize_t sony_nc_gfx_switch_status_show(struct device *dev,
2502				       struct device_attribute *attr,
2503				       char *buffer)
2504{
2505	int pos = __sony_nc_gfx_switch_status_get();
2506
2507	if (pos < 0)
2508		return pos;
2509
2510	return snprintf(buffer, PAGE_SIZE, "%s\n",
2511					pos == SPEED ? "speed" :
2512					pos == STAMINA ? "stamina" :
2513					pos == AUTO ? "auto" : "unknown");
2514}
2515
2516static int sony_nc_gfx_switch_setup(struct platform_device *pd,
2517		unsigned int handle)
2518{
2519	unsigned int result;
2520
2521	gfxs_ctl = kzalloc(sizeof(struct snc_gfx_switch_control), GFP_KERNEL);
2522	if (!gfxs_ctl)
2523		return -ENOMEM;
2524
2525	gfxs_ctl->handle = handle;
2526
2527	sysfs_attr_init(&gfxs_ctl->attr.attr);
2528	gfxs_ctl->attr.attr.name = "gfx_switch_status";
2529	gfxs_ctl->attr.attr.mode = S_IRUGO;
2530	gfxs_ctl->attr.show = sony_nc_gfx_switch_status_show;
2531
2532	result = device_create_file(&pd->dev, &gfxs_ctl->attr);
2533	if (result)
2534		goto gfxerror;
2535
2536	return 0;
2537
2538gfxerror:
2539	kfree(gfxs_ctl);
2540	gfxs_ctl = NULL;
2541
2542	return result;
2543}
2544
2545static void sony_nc_gfx_switch_cleanup(struct platform_device *pd)
2546{
2547	if (gfxs_ctl) {
2548		device_remove_file(&pd->dev, &gfxs_ctl->attr);
2549
2550		kfree(gfxs_ctl);
2551		gfxs_ctl = NULL;
2552	}
2553}
2554
2555/* High speed charging function */
2556static struct device_attribute *hsc_handle;
2557
2558static ssize_t sony_nc_highspeed_charging_store(struct device *dev,
2559		struct device_attribute *attr,
2560		const char *buffer, size_t count)
2561{
2562	unsigned int result;
2563	unsigned long value;
2564
2565	if (count > 31)
2566		return -EINVAL;
2567
2568	if (kstrtoul(buffer, 10, &value) || value > 1)
2569		return -EINVAL;
2570
2571	if (sony_call_snc_handle(0x0131, value << 0x10 | 0x0200, &result))
2572		return -EIO;
2573
2574	return count;
2575}
2576
2577static ssize_t sony_nc_highspeed_charging_show(struct device *dev,
2578		struct device_attribute *attr, char *buffer)
2579{
2580	unsigned int result;
2581
2582	if (sony_call_snc_handle(0x0131, 0x0100, &result))
2583		return -EIO;
2584
2585	return snprintf(buffer, PAGE_SIZE, "%d\n", result & 0x01);
2586}
2587
2588static int sony_nc_highspeed_charging_setup(struct platform_device *pd)
2589{
2590	unsigned int result;
2591
2592	if (sony_call_snc_handle(0x0131, 0x0000, &result) || !(result & 0x01)) {
2593		/* some models advertise the handle but have no implementation
2594		 * for it
2595		 */
2596		pr_info("No High Speed Charging capability found\n");
2597		return 0;
2598	}
2599
2600	hsc_handle = kzalloc(sizeof(struct device_attribute), GFP_KERNEL);
2601	if (!hsc_handle)
2602		return -ENOMEM;
2603
2604	sysfs_attr_init(&hsc_handle->attr);
2605	hsc_handle->attr.name = "battery_highspeed_charging";
2606	hsc_handle->attr.mode = S_IRUGO | S_IWUSR;
2607	hsc_handle->show = sony_nc_highspeed_charging_show;
2608	hsc_handle->store = sony_nc_highspeed_charging_store;
2609
2610	result = device_create_file(&pd->dev, hsc_handle);
2611	if (result) {
2612		kfree(hsc_handle);
2613		hsc_handle = NULL;
2614		return result;
2615	}
2616
2617	return 0;
2618}
2619
2620static void sony_nc_highspeed_charging_cleanup(struct platform_device *pd)
2621{
2622	if (hsc_handle) {
2623		device_remove_file(&pd->dev, hsc_handle);
2624		kfree(hsc_handle);
2625		hsc_handle = NULL;
2626	}
2627}
2628
2629/* low battery function */
2630static struct device_attribute *lowbatt_handle;
2631
2632static ssize_t sony_nc_lowbatt_store(struct device *dev,
2633		struct device_attribute *attr,
2634		const char *buffer, size_t count)
2635{
2636	unsigned int result;
2637	unsigned long value;
2638
2639	if (count > 31)
2640		return -EINVAL;
2641
2642	if (kstrtoul(buffer, 10, &value) || value > 1)
2643		return -EINVAL;
2644
2645	if (sony_call_snc_handle(0x0121, value << 8, &result))
2646		return -EIO;
2647
2648	return count;
2649}
2650
2651static ssize_t sony_nc_lowbatt_show(struct device *dev,
2652		struct device_attribute *attr, char *buffer)
2653{
2654	unsigned int result;
2655
2656	if (sony_call_snc_handle(0x0121, 0x0200, &result))
2657		return -EIO;
2658
2659	return snprintf(buffer, PAGE_SIZE, "%d\n", result & 1);
2660}
2661
2662static int sony_nc_lowbatt_setup(struct platform_device *pd)
2663{
2664	unsigned int result;
2665
2666	lowbatt_handle = kzalloc(sizeof(struct device_attribute), GFP_KERNEL);
2667	if (!lowbatt_handle)
2668		return -ENOMEM;
2669
2670	sysfs_attr_init(&lowbatt_handle->attr);
2671	lowbatt_handle->attr.name = "lowbatt_hibernate";
2672	lowbatt_handle->attr.mode = S_IRUGO | S_IWUSR;
2673	lowbatt_handle->show = sony_nc_lowbatt_show;
2674	lowbatt_handle->store = sony_nc_lowbatt_store;
2675
2676	result = device_create_file(&pd->dev, lowbatt_handle);
2677	if (result) {
2678		kfree(lowbatt_handle);
2679		lowbatt_handle = NULL;
2680		return result;
2681	}
2682
2683	return 0;
2684}
2685
2686static void sony_nc_lowbatt_cleanup(struct platform_device *pd)
2687{
2688	if (lowbatt_handle) {
2689		device_remove_file(&pd->dev, lowbatt_handle);
2690		kfree(lowbatt_handle);
2691		lowbatt_handle = NULL;
2692	}
2693}
2694
2695/* fan speed function */
2696static struct device_attribute *fan_handle, *hsf_handle;
2697
2698static ssize_t sony_nc_hsfan_store(struct device *dev,
2699		struct device_attribute *attr,
2700		const char *buffer, size_t count)
2701{
2702	unsigned int result;
2703	unsigned long value;
2704
2705	if (count > 31)
2706		return -EINVAL;
2707
2708	if (kstrtoul(buffer, 10, &value) || value > 1)
2709		return -EINVAL;
2710
2711	if (sony_call_snc_handle(0x0149, value << 0x10 | 0x0200, &result))
2712		return -EIO;
2713
2714	return count;
2715}
2716
2717static ssize_t sony_nc_hsfan_show(struct device *dev,
2718		struct device_attribute *attr, char *buffer)
2719{
2720	unsigned int result;
2721
2722	if (sony_call_snc_handle(0x0149, 0x0100, &result))
2723		return -EIO;
2724
2725	return snprintf(buffer, PAGE_SIZE, "%d\n", result & 0x01);
2726}
2727
2728static ssize_t sony_nc_fanspeed_show(struct device *dev,
2729		struct device_attribute *attr, char *buffer)
2730{
2731	unsigned int result;
2732
2733	if (sony_call_snc_handle(0x0149, 0x0300, &result))
2734		return -EIO;
2735
2736	return snprintf(buffer, PAGE_SIZE, "%d\n", result & 0xff);
2737}
2738
2739static int sony_nc_fanspeed_setup(struct platform_device *pd)
2740{
2741	unsigned int result;
2742
2743	fan_handle = kzalloc(sizeof(struct device_attribute), GFP_KERNEL);
2744	if (!fan_handle)
2745		return -ENOMEM;
2746
2747	hsf_handle = kzalloc(sizeof(struct device_attribute), GFP_KERNEL);
2748	if (!hsf_handle) {
2749		result = -ENOMEM;
2750		goto out_hsf_handle_alloc;
2751	}
2752
2753	sysfs_attr_init(&fan_handle->attr);
2754	fan_handle->attr.name = "fanspeed";
2755	fan_handle->attr.mode = S_IRUGO;
2756	fan_handle->show = sony_nc_fanspeed_show;
2757	fan_handle->store = NULL;
2758
2759	sysfs_attr_init(&hsf_handle->attr);
2760	hsf_handle->attr.name = "fan_forced";
2761	hsf_handle->attr.mode = S_IRUGO | S_IWUSR;
2762	hsf_handle->show = sony_nc_hsfan_show;
2763	hsf_handle->store = sony_nc_hsfan_store;
2764
2765	result = device_create_file(&pd->dev, fan_handle);
2766	if (result)
2767		goto out_fan_handle;
2768
2769	result = device_create_file(&pd->dev, hsf_handle);
2770	if (result)
2771		goto out_hsf_handle;
2772
2773	return 0;
2774
2775out_hsf_handle:
2776	device_remove_file(&pd->dev, fan_handle);
2777
2778out_fan_handle:
2779	kfree(hsf_handle);
2780	hsf_handle = NULL;
2781
2782out_hsf_handle_alloc:
2783	kfree(fan_handle);
2784	fan_handle = NULL;
2785	return result;
2786}
2787
2788static void sony_nc_fanspeed_cleanup(struct platform_device *pd)
2789{
2790	if (fan_handle) {
2791		device_remove_file(&pd->dev, fan_handle);
2792		kfree(fan_handle);
2793		fan_handle = NULL;
2794	}
2795	if (hsf_handle) {
2796		device_remove_file(&pd->dev, hsf_handle);
2797		kfree(hsf_handle);
2798		hsf_handle = NULL;
2799	}
2800}
2801
2802/* USB charge function */
2803static struct device_attribute *uc_handle;
2804
2805static ssize_t sony_nc_usb_charge_store(struct device *dev,
2806		struct device_attribute *attr,
2807		const char *buffer, size_t count)
2808{
2809	unsigned int result;
2810	unsigned long value;
2811
2812	if (count > 31)
2813		return -EINVAL;
2814
2815	if (kstrtoul(buffer, 10, &value) || value > 1)
2816		return -EINVAL;
2817
2818	if (sony_call_snc_handle(0x0155, value << 0x10 | 0x0100, &result))
2819		return -EIO;
2820
2821	return count;
2822}
2823
2824static ssize_t sony_nc_usb_charge_show(struct device *dev,
2825		struct device_attribute *attr, char *buffer)
2826{
2827	unsigned int result;
2828
2829	if (sony_call_snc_handle(0x0155, 0x0000, &result))
2830		return -EIO;
2831
2832	return snprintf(buffer, PAGE_SIZE, "%d\n", result & 0x01);
2833}
2834
2835static int sony_nc_usb_charge_setup(struct platform_device *pd)
2836{
2837	unsigned int result;
2838
2839	if (sony_call_snc_handle(0x0155, 0x0000, &result) || !(result & 0x01)) {
2840		/* some models advertise the handle but have no implementation
2841		 * for it
2842		 */
2843		pr_info("No USB Charge capability found\n");
2844		return 0;
2845	}
2846
2847	uc_handle = kzalloc(sizeof(struct device_attribute), GFP_KERNEL);
2848	if (!uc_handle)
2849		return -ENOMEM;
2850
2851	sysfs_attr_init(&uc_handle->attr);
2852	uc_handle->attr.name = "usb_charge";
2853	uc_handle->attr.mode = S_IRUGO | S_IWUSR;
2854	uc_handle->show = sony_nc_usb_charge_show;
2855	uc_handle->store = sony_nc_usb_charge_store;
2856
2857	result = device_create_file(&pd->dev, uc_handle);
2858	if (result) {
2859		kfree(uc_handle);
2860		uc_handle = NULL;
2861		return result;
2862	}
2863
2864	return 0;
2865}
2866
2867static void sony_nc_usb_charge_cleanup(struct platform_device *pd)
2868{
2869	if (uc_handle) {
2870		device_remove_file(&pd->dev, uc_handle);
2871		kfree(uc_handle);
2872		uc_handle = NULL;
2873	}
2874}
2875
2876/* Panel ID function */
2877static struct device_attribute *panel_handle;
2878
2879static ssize_t sony_nc_panelid_show(struct device *dev,
2880		struct device_attribute *attr, char *buffer)
2881{
2882	unsigned int result;
2883
2884	if (sony_call_snc_handle(0x011D, 0x0000, &result))
2885		return -EIO;
2886
2887	return snprintf(buffer, PAGE_SIZE, "%d\n", result);
2888}
2889
2890static int sony_nc_panelid_setup(struct platform_device *pd)
2891{
2892	unsigned int result;
2893
2894	panel_handle = kzalloc(sizeof(struct device_attribute), GFP_KERNEL);
2895	if (!panel_handle)
2896		return -ENOMEM;
2897
2898	sysfs_attr_init(&panel_handle->attr);
2899	panel_handle->attr.name = "panel_id";
2900	panel_handle->attr.mode = S_IRUGO;
2901	panel_handle->show = sony_nc_panelid_show;
2902	panel_handle->store = NULL;
2903
2904	result = device_create_file(&pd->dev, panel_handle);
2905	if (result) {
2906		kfree(panel_handle);
2907		panel_handle = NULL;
2908		return result;
2909	}
2910
2911	return 0;
2912}
2913
2914static void sony_nc_panelid_cleanup(struct platform_device *pd)
2915{
2916	if (panel_handle) {
2917		device_remove_file(&pd->dev, panel_handle);
2918		kfree(panel_handle);
2919		panel_handle = NULL;
2920	}
2921}
2922
2923/* smart connect function */
2924static struct device_attribute *sc_handle;
2925
2926static ssize_t sony_nc_smart_conn_store(struct device *dev,
2927		struct device_attribute *attr,
2928		const char *buffer, size_t count)
2929{
2930	unsigned int result;
2931	unsigned long value;
2932
2933	if (count > 31)
2934		return -EINVAL;
2935
2936	if (kstrtoul(buffer, 10, &value) || value > 1)
2937		return -EINVAL;
2938
2939	if (sony_call_snc_handle(0x0168, value << 0x10, &result))
2940		return -EIO;
2941
2942	return count;
2943}
2944
2945static int sony_nc_smart_conn_setup(struct platform_device *pd)
2946{
2947	unsigned int result;
2948
2949	sc_handle = kzalloc(sizeof(struct device_attribute), GFP_KERNEL);
2950	if (!sc_handle)
2951		return -ENOMEM;
2952
2953	sysfs_attr_init(&sc_handle->attr);
2954	sc_handle->attr.name = "smart_connect";
2955	sc_handle->attr.mode = S_IWUSR;
2956	sc_handle->show = NULL;
2957	sc_handle->store = sony_nc_smart_conn_store;
2958
2959	result = device_create_file(&pd->dev, sc_handle);
2960	if (result) {
2961		kfree(sc_handle);
2962		sc_handle = NULL;
2963		return result;
2964	}
2965
2966	return 0;
2967}
2968
2969static void sony_nc_smart_conn_cleanup(struct platform_device *pd)
2970{
2971	if (sc_handle) {
2972		device_remove_file(&pd->dev, sc_handle);
2973		kfree(sc_handle);
2974		sc_handle = NULL;
2975	}
2976}
2977
2978/* Touchpad enable/disable */
2979struct touchpad_control {
2980	struct device_attribute attr;
2981	int handle;
2982};
2983static struct touchpad_control *tp_ctl;
2984
2985static ssize_t sony_nc_touchpad_store(struct device *dev,
2986		struct device_attribute *attr, const char *buffer, size_t count)
2987{
2988	unsigned int result;
2989	unsigned long value;
2990
2991	if (count > 31)
2992		return -EINVAL;
2993
2994	if (kstrtoul(buffer, 10, &value) || value > 1)
2995		return -EINVAL;
2996
2997	/* sysfs: 0 disabled, 1 enabled
2998	 * EC: 0 enabled, 1 disabled
2999	 */
3000	if (sony_call_snc_handle(tp_ctl->handle,
3001				(!value << 0x10) | 0x100, &result))
3002		return -EIO;
3003
3004	return count;
3005}
3006
3007static ssize_t sony_nc_touchpad_show(struct device *dev,
3008		struct device_attribute *attr, char *buffer)
3009{
3010	unsigned int result;
3011
3012	if (sony_call_snc_handle(tp_ctl->handle, 0x000, &result))
3013		return -EINVAL;
3014
3015	return snprintf(buffer, PAGE_SIZE, "%d\n", !(result & 0x01));
3016}
3017
3018static int sony_nc_touchpad_setup(struct platform_device *pd,
3019		unsigned int handle)
3020{
3021	int ret = 0;
3022
3023	tp_ctl = kzalloc(sizeof(struct touchpad_control), GFP_KERNEL);
3024	if (!tp_ctl)
3025		return -ENOMEM;
3026
3027	tp_ctl->handle = handle;
3028
3029	sysfs_attr_init(&tp_ctl->attr.attr);
3030	tp_ctl->attr.attr.name = "touchpad";
3031	tp_ctl->attr.attr.mode = S_IRUGO | S_IWUSR;
3032	tp_ctl->attr.show = sony_nc_touchpad_show;
3033	tp_ctl->attr.store = sony_nc_touchpad_store;
3034
3035	ret = device_create_file(&pd->dev, &tp_ctl->attr);
3036	if (ret) {
3037		kfree(tp_ctl);
3038		tp_ctl = NULL;
3039	}
3040
3041	return ret;
3042}
3043
3044static void sony_nc_touchpad_cleanup(struct platform_device *pd)
3045{
3046	if (tp_ctl) {
3047		device_remove_file(&pd->dev, &tp_ctl->attr);
3048		kfree(tp_ctl);
3049		tp_ctl = NULL;
3050	}
3051}
3052
3053static void sony_nc_backlight_ng_read_limits(int handle,
3054		struct sony_backlight_props *props)
3055{
3056	u64 offset;
3057	int i;
3058	int lvl_table_len = 0;
3059	u8 min = 0xff, max = 0x00;
3060	unsigned char buffer[32] = { 0 };
3061
3062	props->handle = handle;
3063	props->offset = 0;
3064	props->maxlvl = 0xff;
3065
3066	offset = sony_find_snc_handle(handle);
3067
3068	/* try to read the boundaries from ACPI tables, if we fail the above
3069	 * defaults should be reasonable
3070	 */
3071	i = sony_nc_buffer_call(sony_nc_acpi_handle, "SN06", &offset, buffer,
3072			32);
3073	if (i < 0)
3074		return;
3075
3076	switch (handle) {
3077	case 0x012f:
3078	case 0x0137:
3079		lvl_table_len = 9;
3080		break;
3081	case 0x143:
3082	case 0x14b:
3083	case 0x14c:
3084		lvl_table_len = 16;
3085		break;
3086	}
3087
3088	/* the buffer lists brightness levels available, brightness levels are
3089	 * from position 0 to 8 in the array, other values are used by ALS
3090	 * control.
3091	 */
3092	for (i = 0; i < lvl_table_len && i < ARRAY_SIZE(buffer); i++) {
3093
3094		dprintk("Brightness level: %d\n", buffer[i]);
3095
3096		if (!buffer[i])
3097			break;
3098
3099		if (buffer[i] > max)
3100			max = buffer[i];
3101		if (buffer[i] < min)
3102			min = buffer[i];
3103	}
3104	props->offset = min;
3105	props->maxlvl = max;
3106	dprintk("Brightness levels: min=%d max=%d\n", props->offset,
3107			props->maxlvl);
3108}
3109
3110static void sony_nc_backlight_setup(void)
3111{
3112	int max_brightness = 0;
3113	const struct backlight_ops *ops = NULL;
3114	struct backlight_properties props;
3115
3116	if (sony_find_snc_handle(0x12f) >= 0) {
3117		ops = &sony_backlight_ng_ops;
3118		sony_bl_props.cmd_base = 0x0100;
3119		sony_nc_backlight_ng_read_limits(0x12f, &sony_bl_props);
3120		max_brightness = sony_bl_props.maxlvl - sony_bl_props.offset;
3121
3122	} else if (sony_find_snc_handle(0x137) >= 0) {
3123		ops = &sony_backlight_ng_ops;
3124		sony_bl_props.cmd_base = 0x0100;
3125		sony_nc_backlight_ng_read_limits(0x137, &sony_bl_props);
3126		max_brightness = sony_bl_props.maxlvl - sony_bl_props.offset;
3127
3128	} else if (sony_find_snc_handle(0x143) >= 0) {
3129		ops = &sony_backlight_ng_ops;
3130		sony_bl_props.cmd_base = 0x3000;
3131		sony_nc_backlight_ng_read_limits(0x143, &sony_bl_props);
3132		max_brightness = sony_bl_props.maxlvl - sony_bl_props.offset;
3133
3134	} else if (sony_find_snc_handle(0x14b) >= 0) {
3135		ops = &sony_backlight_ng_ops;
3136		sony_bl_props.cmd_base = 0x3000;
3137		sony_nc_backlight_ng_read_limits(0x14b, &sony_bl_props);
3138		max_brightness = sony_bl_props.maxlvl - sony_bl_props.offset;
3139
3140	} else if (sony_find_snc_handle(0x14c) >= 0) {
3141		ops = &sony_backlight_ng_ops;
3142		sony_bl_props.cmd_base = 0x3000;
3143		sony_nc_backlight_ng_read_limits(0x14c, &sony_bl_props);
3144		max_brightness = sony_bl_props.maxlvl - sony_bl_props.offset;
3145
3146	} else if (acpi_has_method(sony_nc_acpi_handle, "GBRT")) {
3147		ops = &sony_backlight_ops;
3148		max_brightness = SONY_MAX_BRIGHTNESS - 1;
3149
3150	} else
3151		return;
3152
3153	memset(&props, 0, sizeof(struct backlight_properties));
3154	props.type = BACKLIGHT_PLATFORM;
3155	props.max_brightness = max_brightness;
3156	sony_bl_props.dev = backlight_device_register("sony", NULL,
3157						      &sony_bl_props,
3158						      ops, &props);
3159
3160	if (IS_ERR(sony_bl_props.dev)) {
3161		pr_warn("unable to register backlight device\n");
3162		sony_bl_props.dev = NULL;
3163	} else
3164		sony_bl_props.dev->props.brightness =
3165			ops->get_brightness(sony_bl_props.dev);
3166}
3167
3168static void sony_nc_backlight_cleanup(void)
3169{
3170	backlight_device_unregister(sony_bl_props.dev);
3171}
3172
3173static int sony_nc_add(struct acpi_device *device)
3174{
3175	acpi_status status;
3176	int result = 0;
3177	struct sony_nc_value *item;
3178
3179	sony_nc_acpi_device = device;
3180	strcpy(acpi_device_class(device), "sony/hotkey");
3181
3182	sony_nc_acpi_handle = device->handle;
3183
3184	/* read device status */
3185	result = acpi_bus_get_status(device);
3186	/* bail IFF the above call was successful and the device is not present */
3187	if (!result && !device->status.present) {
3188		dprintk("Device not present\n");
3189		result = -ENODEV;
3190		goto outwalk;
3191	}
3192
3193	result = sony_pf_add();
3194	if (result)
3195		goto outpresent;
3196
3197	if (debug) {
3198		status = acpi_walk_namespace(ACPI_TYPE_METHOD,
3199				sony_nc_acpi_handle, 1, sony_walk_callback,
3200				NULL, NULL, NULL);
3201		if (ACPI_FAILURE(status)) {
3202			pr_warn("unable to walk acpi resources\n");
3203			result = -ENODEV;
3204			goto outpresent;
3205		}
3206	}
3207
3208	result = sony_laptop_setup_input(device);
3209	if (result) {
3210		pr_err("Unable to create input devices\n");
3211		goto outplatform;
3212	}
3213
3214	if (acpi_has_method(sony_nc_acpi_handle, "ECON")) {
3215		int arg = 1;
3216		if (sony_nc_int_call(sony_nc_acpi_handle, "ECON", &arg, NULL))
3217			dprintk("ECON Method failed\n");
3218	}
3219
3220	if (acpi_has_method(sony_nc_acpi_handle, "SN00")) {
3221		dprintk("Doing SNC setup\n");
3222		/* retrieve the available handles */
3223		result = sony_nc_handles_setup(sony_pf_device);
3224		if (!result)
3225			sony_nc_function_setup(device, sony_pf_device);
3226	}
3227
3228	if (acpi_video_get_backlight_type() == acpi_backlight_vendor)
3229		sony_nc_backlight_setup();
3230
3231	/* create sony_pf sysfs attributes related to the SNC device */
3232	for (item = sony_nc_values; item->name; ++item) {
3233
3234		if (!debug && item->debug)
3235			continue;
3236
3237		/* find the available acpiget as described in the DSDT */
3238		for (; item->acpiget && *item->acpiget; ++item->acpiget) {
3239			if (acpi_has_method(sony_nc_acpi_handle,
3240							*item->acpiget)) {
3241				dprintk("Found %s getter: %s\n",
3242						item->name, *item->acpiget);
3243				item->devattr.attr.mode |= S_IRUGO;
3244				break;
3245			}
3246		}
3247
3248		/* find the available acpiset as described in the DSDT */
3249		for (; item->acpiset && *item->acpiset; ++item->acpiset) {
3250			if (acpi_has_method(sony_nc_acpi_handle,
3251							*item->acpiset)) {
3252				dprintk("Found %s setter: %s\n",
3253						item->name, *item->acpiset);
3254				item->devattr.attr.mode |= S_IWUSR;
3255				break;
3256			}
3257		}
3258
3259		if (item->devattr.attr.mode != 0) {
3260			result =
3261			    device_create_file(&sony_pf_device->dev,
3262					       &item->devattr);
3263			if (result)
3264				goto out_sysfs;
3265		}
3266	}
3267
3268	pr_info("SNC setup done.\n");
3269	return 0;
3270
3271out_sysfs:
3272	for (item = sony_nc_values; item->name; ++item) {
3273		device_remove_file(&sony_pf_device->dev, &item->devattr);
3274	}
3275	sony_nc_backlight_cleanup();
3276	sony_nc_function_cleanup(sony_pf_device);
3277	sony_nc_handles_cleanup(sony_pf_device);
3278
3279outplatform:
3280	sony_laptop_remove_input();
3281
3282outpresent:
3283	sony_pf_remove();
3284
3285outwalk:
3286	sony_nc_rfkill_cleanup();
3287	return result;
3288}
3289
3290static int sony_nc_remove(struct acpi_device *device)
3291{
3292	struct sony_nc_value *item;
3293
3294	sony_nc_backlight_cleanup();
3295
3296	sony_nc_acpi_device = NULL;
3297
3298	for (item = sony_nc_values; item->name; ++item) {
3299		device_remove_file(&sony_pf_device->dev, &item->devattr);
3300	}
3301
3302	sony_nc_function_cleanup(sony_pf_device);
3303	sony_nc_handles_cleanup(sony_pf_device);
3304	sony_pf_remove();
3305	sony_laptop_remove_input();
3306	dprintk(SONY_NC_DRIVER_NAME " removed.\n");
3307
3308	return 0;
3309}
3310
3311static const struct acpi_device_id sony_device_ids[] = {
3312	{SONY_NC_HID, 0},
3313	{SONY_PIC_HID, 0},
3314	{"", 0},
3315};
3316MODULE_DEVICE_TABLE(acpi, sony_device_ids);
3317
3318static const struct acpi_device_id sony_nc_device_ids[] = {
3319	{SONY_NC_HID, 0},
3320	{"", 0},
3321};
3322
3323static struct acpi_driver sony_nc_driver = {
3324	.name = SONY_NC_DRIVER_NAME,
3325	.class = SONY_NC_CLASS,
3326	.ids = sony_nc_device_ids,
3327	.owner = THIS_MODULE,
3328	.ops = {
3329		.add = sony_nc_add,
3330		.remove = sony_nc_remove,
3331		.notify = sony_nc_notify,
3332		},
3333	.drv.pm = &sony_nc_pm,
3334};
3335
3336/*********** SPIC (SNY6001) Device ***********/
3337
3338#define SONYPI_DEVICE_TYPE1	0x00000001
3339#define SONYPI_DEVICE_TYPE2	0x00000002
3340#define SONYPI_DEVICE_TYPE3	0x00000004
3341
3342#define SONYPI_TYPE1_OFFSET	0x04
3343#define SONYPI_TYPE2_OFFSET	0x12
3344#define SONYPI_TYPE3_OFFSET	0x12
3345
3346struct sony_pic_ioport {
3347	struct acpi_resource_io	io1;
3348	struct acpi_resource_io	io2;
3349	struct list_head	list;
3350};
3351
3352struct sony_pic_irq {
3353	struct acpi_resource_irq	irq;
3354	struct list_head		list;
3355};
3356
3357struct sonypi_eventtypes {
3358	u8			data;
3359	unsigned long		mask;
3360	struct sonypi_event	*events;
3361};
3362
3363struct sony_pic_dev {
3364	struct acpi_device		*acpi_dev;
3365	struct sony_pic_irq		*cur_irq;
3366	struct sony_pic_ioport		*cur_ioport;
3367	struct list_head		interrupts;
3368	struct list_head		ioports;
3369	struct mutex			lock;
3370	struct sonypi_eventtypes	*event_types;
3371	int                             (*handle_irq)(const u8, const u8);
3372	int				model;
3373	u16				evport_offset;
3374	u8				camera_power;
3375	u8				bluetooth_power;
3376	u8				wwan_power;
3377};
3378
3379static struct sony_pic_dev spic_dev = {
3380	.interrupts	= LIST_HEAD_INIT(spic_dev.interrupts),
3381	.ioports	= LIST_HEAD_INIT(spic_dev.ioports),
3382};
3383
3384static int spic_drv_registered;
3385
3386/* Event masks */
3387#define SONYPI_JOGGER_MASK			0x00000001
3388#define SONYPI_CAPTURE_MASK			0x00000002
3389#define SONYPI_FNKEY_MASK			0x00000004
3390#define SONYPI_BLUETOOTH_MASK			0x00000008
3391#define SONYPI_PKEY_MASK			0x00000010
3392#define SONYPI_BACK_MASK			0x00000020
3393#define SONYPI_HELP_MASK			0x00000040
3394#define SONYPI_LID_MASK				0x00000080
3395#define SONYPI_ZOOM_MASK			0x00000100
3396#define SONYPI_THUMBPHRASE_MASK			0x00000200
3397#define SONYPI_MEYE_MASK			0x00000400
3398#define SONYPI_MEMORYSTICK_MASK			0x00000800
3399#define SONYPI_BATTERY_MASK			0x00001000
3400#define SONYPI_WIRELESS_MASK			0x00002000
3401
3402struct sonypi_event {
3403	u8	data;
3404	u8	event;
3405};
3406
3407/* The set of possible button release events */
3408static struct sonypi_event sonypi_releaseev[] = {
3409	{ 0x00, SONYPI_EVENT_ANYBUTTON_RELEASED },
3410	{ 0, 0 }
3411};
3412
3413/* The set of possible jogger events  */
3414static struct sonypi_event sonypi_joggerev[] = {
3415	{ 0x1f, SONYPI_EVENT_JOGDIAL_UP },
3416	{ 0x01, SONYPI_EVENT_JOGDIAL_DOWN },
3417	{ 0x5f, SONYPI_EVENT_JOGDIAL_UP_PRESSED },
3418	{ 0x41, SONYPI_EVENT_JOGDIAL_DOWN_PRESSED },
3419	{ 0x1e, SONYPI_EVENT_JOGDIAL_FAST_UP },
3420	{ 0x02, SONYPI_EVENT_JOGDIAL_FAST_DOWN },
3421	{ 0x5e, SONYPI_EVENT_JOGDIAL_FAST_UP_PRESSED },
3422	{ 0x42, SONYPI_EVENT_JOGDIAL_FAST_DOWN_PRESSED },
3423	{ 0x1d, SONYPI_EVENT_JOGDIAL_VFAST_UP },
3424	{ 0x03, SONYPI_EVENT_JOGDIAL_VFAST_DOWN },
3425	{ 0x5d, SONYPI_EVENT_JOGDIAL_VFAST_UP_PRESSED },
3426	{ 0x43, SONYPI_EVENT_JOGDIAL_VFAST_DOWN_PRESSED },
3427	{ 0x40, SONYPI_EVENT_JOGDIAL_PRESSED },
3428	{ 0, 0 }
3429};
3430
3431/* The set of possible capture button events */
3432static struct sonypi_event sonypi_captureev[] = {
3433	{ 0x05, SONYPI_EVENT_CAPTURE_PARTIALPRESSED },
3434	{ 0x07, SONYPI_EVENT_CAPTURE_PRESSED },
3435	{ 0x40, SONYPI_EVENT_CAPTURE_PRESSED },
3436	{ 0x01, SONYPI_EVENT_CAPTURE_PARTIALRELEASED },
3437	{ 0, 0 }
3438};
3439
3440/* The set of possible fnkeys events */
3441static struct sonypi_event sonypi_fnkeyev[] = {
3442	{ 0x10, SONYPI_EVENT_FNKEY_ESC },
3443	{ 0x11, SONYPI_EVENT_FNKEY_F1 },
3444	{ 0x12, SONYPI_EVENT_FNKEY_F2 },
3445	{ 0x13, SONYPI_EVENT_FNKEY_F3 },
3446	{ 0x14, SONYPI_EVENT_FNKEY_F4 },
3447	{ 0x15, SONYPI_EVENT_FNKEY_F5 },
3448	{ 0x16, SONYPI_EVENT_FNKEY_F6 },
3449	{ 0x17, SONYPI_EVENT_FNKEY_F7 },
3450	{ 0x18, SONYPI_EVENT_FNKEY_F8 },
3451	{ 0x19, SONYPI_EVENT_FNKEY_F9 },
3452	{ 0x1a, SONYPI_EVENT_FNKEY_F10 },
3453	{ 0x1b, SONYPI_EVENT_FNKEY_F11 },
3454	{ 0x1c, SONYPI_EVENT_FNKEY_F12 },
3455	{ 0x1f, SONYPI_EVENT_FNKEY_RELEASED },
3456	{ 0x21, SONYPI_EVENT_FNKEY_1 },
3457	{ 0x22, SONYPI_EVENT_FNKEY_2 },
3458	{ 0x31, SONYPI_EVENT_FNKEY_D },
3459	{ 0x32, SONYPI_EVENT_FNKEY_E },
3460	{ 0x33, SONYPI_EVENT_FNKEY_F },
3461	{ 0x34, SONYPI_EVENT_FNKEY_S },
3462	{ 0x35, SONYPI_EVENT_FNKEY_B },
3463	{ 0x36, SONYPI_EVENT_FNKEY_ONLY },
3464	{ 0, 0 }
3465};
3466
3467/* The set of possible program key events */
3468static struct sonypi_event sonypi_pkeyev[] = {
3469	{ 0x01, SONYPI_EVENT_PKEY_P1 },
3470	{ 0x02, SONYPI_EVENT_PKEY_P2 },
3471	{ 0x04, SONYPI_EVENT_PKEY_P3 },
3472	{ 0x20, SONYPI_EVENT_PKEY_P1 },
3473	{ 0, 0 }
3474};
3475
3476/* The set of possible bluetooth events */
3477static struct sonypi_event sonypi_blueev[] = {
3478	{ 0x55, SONYPI_EVENT_BLUETOOTH_PRESSED },
3479	{ 0x59, SONYPI_EVENT_BLUETOOTH_ON },
3480	{ 0x5a, SONYPI_EVENT_BLUETOOTH_OFF },
3481	{ 0, 0 }
3482};
3483
3484/* The set of possible wireless events */
3485static struct sonypi_event sonypi_wlessev[] = {
3486	{ 0x59, SONYPI_EVENT_IGNORE },
3487	{ 0x5a, SONYPI_EVENT_IGNORE },
3488	{ 0, 0 }
3489};
3490
3491/* The set of possible back button events */
3492static struct sonypi_event sonypi_backev[] = {
3493	{ 0x20, SONYPI_EVENT_BACK_PRESSED },
3494	{ 0, 0 }
3495};
3496
3497/* The set of possible help button events */
3498static struct sonypi_event sonypi_helpev[] = {
3499	{ 0x3b, SONYPI_EVENT_HELP_PRESSED },
3500	{ 0, 0 }
3501};
3502
3503
3504/* The set of possible lid events */
3505static struct sonypi_event sonypi_lidev[] = {
3506	{ 0x51, SONYPI_EVENT_LID_CLOSED },
3507	{ 0x50, SONYPI_EVENT_LID_OPENED },
3508	{ 0, 0 }
3509};
3510
3511/* The set of possible zoom events */
3512static struct sonypi_event sonypi_zoomev[] = {
3513	{ 0x39, SONYPI_EVENT_ZOOM_PRESSED },
3514	{ 0x10, SONYPI_EVENT_ZOOM_IN_PRESSED },
3515	{ 0x20, SONYPI_EVENT_ZOOM_OUT_PRESSED },
3516	{ 0x04, SONYPI_EVENT_ZOOM_PRESSED },
3517	{ 0, 0 }
3518};
3519
3520/* The set of possible thumbphrase events */
3521static struct sonypi_event sonypi_thumbphraseev[] = {
3522	{ 0x3a, SONYPI_EVENT_THUMBPHRASE_PRESSED },
3523	{ 0, 0 }
3524};
3525
3526/* The set of possible motioneye camera events */
3527static struct sonypi_event sonypi_meyeev[] = {
3528	{ 0x00, SONYPI_EVENT_MEYE_FACE },
3529	{ 0x01, SONYPI_EVENT_MEYE_OPPOSITE },
3530	{ 0, 0 }
3531};
3532
3533/* The set of possible memorystick events */
3534static struct sonypi_event sonypi_memorystickev[] = {
3535	{ 0x53, SONYPI_EVENT_MEMORYSTICK_INSERT },
3536	{ 0x54, SONYPI_EVENT_MEMORYSTICK_EJECT },
3537	{ 0, 0 }
3538};
3539
3540/* The set of possible battery events */
3541static struct sonypi_event sonypi_batteryev[] = {
3542	{ 0x20, SONYPI_EVENT_BATTERY_INSERT },
3543	{ 0x30, SONYPI_EVENT_BATTERY_REMOVE },
3544	{ 0, 0 }
3545};
3546
3547/* The set of possible volume events */
3548static struct sonypi_event sonypi_volumeev[] = {
3549	{ 0x01, SONYPI_EVENT_VOLUME_INC_PRESSED },
3550	{ 0x02, SONYPI_EVENT_VOLUME_DEC_PRESSED },
3551	{ 0, 0 }
3552};
3553
3554/* The set of possible brightness events */
3555static struct sonypi_event sonypi_brightnessev[] = {
3556	{ 0x80, SONYPI_EVENT_BRIGHTNESS_PRESSED },
3557	{ 0, 0 }
3558};
3559
3560static struct sonypi_eventtypes type1_events[] = {
3561	{ 0, 0xffffffff, sonypi_releaseev },
3562	{ 0x70, SONYPI_MEYE_MASK, sonypi_meyeev },
3563	{ 0x30, SONYPI_LID_MASK, sonypi_lidev },
3564	{ 0x60, SONYPI_CAPTURE_MASK, sonypi_captureev },
3565	{ 0x10, SONYPI_JOGGER_MASK, sonypi_joggerev },
3566	{ 0x20, SONYPI_FNKEY_MASK, sonypi_fnkeyev },
3567	{ 0x30, SONYPI_BLUETOOTH_MASK, sonypi_blueev },
3568	{ 0x40, SONYPI_PKEY_MASK, sonypi_pkeyev },
3569	{ 0x30, SONYPI_MEMORYSTICK_MASK, sonypi_memorystickev },
3570	{ 0x40, SONYPI_BATTERY_MASK, sonypi_batteryev },
3571	{ 0 },
3572};
3573static struct sonypi_eventtypes type2_events[] = {
3574	{ 0, 0xffffffff, sonypi_releaseev },
3575	{ 0x38, SONYPI_LID_MASK, sonypi_lidev },
3576	{ 0x11, SONYPI_JOGGER_MASK, sonypi_joggerev },
3577	{ 0x61, SONYPI_CAPTURE_MASK, sonypi_captureev },
3578	{ 0x21, SONYPI_FNKEY_MASK, sonypi_fnkeyev },
3579	{ 0x31, SONYPI_BLUETOOTH_MASK, sonypi_blueev },
3580	{ 0x08, SONYPI_PKEY_MASK, sonypi_pkeyev },
3581	{ 0x11, SONYPI_BACK_MASK, sonypi_backev },
3582	{ 0x21, SONYPI_HELP_MASK, sonypi_helpev },
3583	{ 0x21, SONYPI_ZOOM_MASK, sonypi_zoomev },
3584	{ 0x20, SONYPI_THUMBPHRASE_MASK, sonypi_thumbphraseev },
3585	{ 0x31, SONYPI_MEMORYSTICK_MASK, sonypi_memorystickev },
3586	{ 0x41, SONYPI_BATTERY_MASK, sonypi_batteryev },
3587	{ 0x31, SONYPI_PKEY_MASK, sonypi_pkeyev },
3588	{ 0 },
3589};
3590static struct sonypi_eventtypes type3_events[] = {
3591	{ 0, 0xffffffff, sonypi_releaseev },
3592	{ 0x21, SONYPI_FNKEY_MASK, sonypi_fnkeyev },
3593	{ 0x31, SONYPI_WIRELESS_MASK, sonypi_wlessev },
3594	{ 0x31, SONYPI_MEMORYSTICK_MASK, sonypi_memorystickev },
3595	{ 0x41, SONYPI_BATTERY_MASK, sonypi_batteryev },
3596	{ 0x31, SONYPI_PKEY_MASK, sonypi_pkeyev },
3597	{ 0x05, SONYPI_PKEY_MASK, sonypi_pkeyev },
3598	{ 0x05, SONYPI_ZOOM_MASK, sonypi_zoomev },
3599	{ 0x05, SONYPI_CAPTURE_MASK, sonypi_captureev },
3600	{ 0x05, SONYPI_PKEY_MASK, sonypi_volumeev },
3601	{ 0x05, SONYPI_PKEY_MASK, sonypi_brightnessev },
3602	{ 0 },
3603};
3604
3605/* low level spic calls */
3606#define ITERATIONS_LONG		10000
3607#define ITERATIONS_SHORT	10
3608#define wait_on_command(command, iterations) {				\
3609	unsigned int n = iterations;					\
3610	while (--n && (command))					\
3611		udelay(1);						\
3612	if (!n)								\
3613		dprintk("command failed at %s : %s (line %d)\n",	\
3614				__FILE__, __func__, __LINE__);	\
3615}
3616
3617static u8 sony_pic_call1(u8 dev)
3618{
3619	u8 v1, v2;
3620
3621	wait_on_command(inb_p(spic_dev.cur_ioport->io1.minimum + 4) & 2,
3622			ITERATIONS_LONG);
3623	outb(dev, spic_dev.cur_ioport->io1.minimum + 4);
3624	v1 = inb_p(spic_dev.cur_ioport->io1.minimum + 4);
3625	v2 = inb_p(spic_dev.cur_ioport->io1.minimum);
3626	dprintk("sony_pic_call1(0x%.2x): 0x%.4x\n", dev, (v2 << 8) | v1);
3627	return v2;
3628}
3629
3630static u8 sony_pic_call2(u8 dev, u8 fn)
3631{
3632	u8 v1;
3633
3634	wait_on_command(inb_p(spic_dev.cur_ioport->io1.minimum + 4) & 2,
3635			ITERATIONS_LONG);
3636	outb(dev, spic_dev.cur_ioport->io1.minimum + 4);
3637	wait_on_command(inb_p(spic_dev.cur_ioport->io1.minimum + 4) & 2,
3638			ITERATIONS_LONG);
3639	outb(fn, spic_dev.cur_ioport->io1.minimum);
3640	v1 = inb_p(spic_dev.cur_ioport->io1.minimum);
3641	dprintk("sony_pic_call2(0x%.2x - 0x%.2x): 0x%.4x\n", dev, fn, v1);
3642	return v1;
3643}
3644
3645static u8 sony_pic_call3(u8 dev, u8 fn, u8 v)
3646{
3647	u8 v1;
3648
3649	wait_on_command(inb_p(spic_dev.cur_ioport->io1.minimum + 4) & 2, ITERATIONS_LONG);
3650	outb(dev, spic_dev.cur_ioport->io1.minimum + 4);
3651	wait_on_command(inb_p(spic_dev.cur_ioport->io1.minimum + 4) & 2, ITERATIONS_LONG);
3652	outb(fn, spic_dev.cur_ioport->io1.minimum);
3653	wait_on_command(inb_p(spic_dev.cur_ioport->io1.minimum + 4) & 2, ITERATIONS_LONG);
3654	outb(v, spic_dev.cur_ioport->io1.minimum);
3655	v1 = inb_p(spic_dev.cur_ioport->io1.minimum);
3656	dprintk("sony_pic_call3(0x%.2x - 0x%.2x - 0x%.2x): 0x%.4x\n",
3657			dev, fn, v, v1);
3658	return v1;
3659}
3660
3661/*
3662 * minidrivers for SPIC models
3663 */
3664static int type3_handle_irq(const u8 data_mask, const u8 ev)
3665{
3666	/*
3667	 * 0x31 could mean we have to take some extra action and wait for
3668	 * the next irq for some Type3 models, it will generate a new
3669	 * irq and we can read new data from the device:
3670	 *  - 0x5c and 0x5f requires 0xA0
3671	 *  - 0x61 requires 0xB3
3672	 */
3673	if (data_mask == 0x31) {
3674		if (ev == 0x5c || ev == 0x5f)
3675			sony_pic_call1(0xA0);
3676		else if (ev == 0x61)
3677			sony_pic_call1(0xB3);
3678		return 0;
3679	}
3680	return 1;
3681}
3682
3683static void sony_pic_detect_device_type(struct sony_pic_dev *dev)
3684{
3685	struct pci_dev *pcidev;
3686
3687	pcidev = pci_get_device(PCI_VENDOR_ID_INTEL,
3688			PCI_DEVICE_ID_INTEL_82371AB_3, NULL);
3689	if (pcidev) {
3690		dev->model = SONYPI_DEVICE_TYPE1;
3691		dev->evport_offset = SONYPI_TYPE1_OFFSET;
3692		dev->event_types = type1_events;
3693		goto out;
3694	}
3695
3696	pcidev = pci_get_device(PCI_VENDOR_ID_INTEL,
3697			PCI_DEVICE_ID_INTEL_ICH6_1, NULL);
3698	if (pcidev) {
3699		dev->model = SONYPI_DEVICE_TYPE2;
3700		dev->evport_offset = SONYPI_TYPE2_OFFSET;
3701		dev->event_types = type2_events;
3702		goto out;
3703	}
3704
3705	pcidev = pci_get_device(PCI_VENDOR_ID_INTEL,
3706			PCI_DEVICE_ID_INTEL_ICH7_1, NULL);
3707	if (pcidev) {
3708		dev->model = SONYPI_DEVICE_TYPE3;
3709		dev->handle_irq = type3_handle_irq;
3710		dev->evport_offset = SONYPI_TYPE3_OFFSET;
3711		dev->event_types = type3_events;
3712		goto out;
3713	}
3714
3715	pcidev = pci_get_device(PCI_VENDOR_ID_INTEL,
3716			PCI_DEVICE_ID_INTEL_ICH8_4, NULL);
3717	if (pcidev) {
3718		dev->model = SONYPI_DEVICE_TYPE3;
3719		dev->handle_irq = type3_handle_irq;
3720		dev->evport_offset = SONYPI_TYPE3_OFFSET;
3721		dev->event_types = type3_events;
3722		goto out;
3723	}
3724
3725	pcidev = pci_get_device(PCI_VENDOR_ID_INTEL,
3726			PCI_DEVICE_ID_INTEL_ICH9_1, NULL);
3727	if (pcidev) {
3728		dev->model = SONYPI_DEVICE_TYPE3;
3729		dev->handle_irq = type3_handle_irq;
3730		dev->evport_offset = SONYPI_TYPE3_OFFSET;
3731		dev->event_types = type3_events;
3732		goto out;
3733	}
3734
3735	/* default */
3736	dev->model = SONYPI_DEVICE_TYPE2;
3737	dev->evport_offset = SONYPI_TYPE2_OFFSET;
3738	dev->event_types = type2_events;
3739
3740out:
3741	pci_dev_put(pcidev);
3742
3743	pr_info("detected Type%d model\n",
3744		dev->model == SONYPI_DEVICE_TYPE1 ? 1 :
3745		dev->model == SONYPI_DEVICE_TYPE2 ? 2 : 3);
3746}
3747
3748/* camera tests and poweron/poweroff */
3749#define SONYPI_CAMERA_PICTURE		5
3750#define SONYPI_CAMERA_CONTROL		0x10
3751
3752#define SONYPI_CAMERA_BRIGHTNESS		0
3753#define SONYPI_CAMERA_CONTRAST			1
3754#define SONYPI_CAMERA_HUE			2
3755#define SONYPI_CAMERA_COLOR			3
3756#define SONYPI_CAMERA_SHARPNESS			4
3757
3758#define SONYPI_CAMERA_EXPOSURE_MASK		0xC
3759#define SONYPI_CAMERA_WHITE_BALANCE_MASK	0x3
3760#define SONYPI_CAMERA_PICTURE_MODE_MASK		0x30
3761#define SONYPI_CAMERA_MUTE_MASK			0x40
3762
3763/* the rest don't need a loop until not 0xff */
3764#define SONYPI_CAMERA_AGC			6
3765#define SONYPI_CAMERA_AGC_MASK			0x30
3766#define SONYPI_CAMERA_SHUTTER_MASK 		0x7
3767
3768#define SONYPI_CAMERA_SHUTDOWN_REQUEST		7
3769#define SONYPI_CAMERA_CONTROL			0x10
3770
3771#define SONYPI_CAMERA_STATUS 			7
3772#define SONYPI_CAMERA_STATUS_READY 		0x2
3773#define SONYPI_CAMERA_STATUS_POSITION		0x4
3774
3775#define SONYPI_DIRECTION_BACKWARDS 		0x4
3776
3777#define SONYPI_CAMERA_REVISION 			8
3778#define SONYPI_CAMERA_ROMVERSION 		9
3779
3780static int __sony_pic_camera_ready(void)
3781{
3782	u8 v;
3783
3784	v = sony_pic_call2(0x8f, SONYPI_CAMERA_STATUS);
3785	return (v != 0xff && (v & SONYPI_CAMERA_STATUS_READY));
3786}
3787
3788static int __sony_pic_camera_off(void)
3789{
3790	if (!camera) {
3791		pr_warn("camera control not enabled\n");
3792		return -ENODEV;
3793	}
3794
3795	wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_PICTURE,
3796				SONYPI_CAMERA_MUTE_MASK),
3797			ITERATIONS_SHORT);
3798
3799	if (spic_dev.camera_power) {
3800		sony_pic_call2(0x91, 0);
3801		spic_dev.camera_power = 0;
3802	}
3803	return 0;
3804}
3805
3806static int __sony_pic_camera_on(void)
3807{
3808	int i, j, x;
3809
3810	if (!camera) {
3811		pr_warn("camera control not enabled\n");
3812		return -ENODEV;
3813	}
3814
3815	if (spic_dev.camera_power)
3816		return 0;
3817
3818	for (j = 5; j > 0; j--) {
3819
3820		for (x = 0; x < 100 && sony_pic_call2(0x91, 0x1); x++)
3821			msleep(10);
3822		sony_pic_call1(0x93);
3823
3824		for (i = 400; i > 0; i--) {
3825			if (__sony_pic_camera_ready())
3826				break;
3827			msleep(10);
3828		}
3829		if (i)
3830			break;
3831	}
3832
3833	if (j == 0) {
3834		pr_warn("failed to power on camera\n");
3835		return -ENODEV;
3836	}
3837
3838	wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_CONTROL,
3839				0x5a),
3840			ITERATIONS_SHORT);
3841
3842	spic_dev.camera_power = 1;
3843	return 0;
3844}
3845
3846/* External camera command (exported to the motion eye v4l driver) */
3847int sony_pic_camera_command(int command, u8 value)
3848{
3849	if (!camera)
3850		return -EIO;
3851
3852	mutex_lock(&spic_dev.lock);
3853
3854	switch (command) {
3855	case SONY_PIC_COMMAND_SETCAMERA:
3856		if (value)
3857			__sony_pic_camera_on();
3858		else
3859			__sony_pic_camera_off();
3860		break;
3861	case SONY_PIC_COMMAND_SETCAMERABRIGHTNESS:
3862		wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_BRIGHTNESS, value),
3863				ITERATIONS_SHORT);
3864		break;
3865	case SONY_PIC_COMMAND_SETCAMERACONTRAST:
3866		wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_CONTRAST, value),
3867				ITERATIONS_SHORT);
3868		break;
3869	case SONY_PIC_COMMAND_SETCAMERAHUE:
3870		wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_HUE, value),
3871				ITERATIONS_SHORT);
3872		break;
3873	case SONY_PIC_COMMAND_SETCAMERACOLOR:
3874		wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_COLOR, value),
3875				ITERATIONS_SHORT);
3876		break;
3877	case SONY_PIC_COMMAND_SETCAMERASHARPNESS:
3878		wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_SHARPNESS, value),
3879				ITERATIONS_SHORT);
3880		break;
3881	case SONY_PIC_COMMAND_SETCAMERAPICTURE:
3882		wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_PICTURE, value),
3883				ITERATIONS_SHORT);
3884		break;
3885	case SONY_PIC_COMMAND_SETCAMERAAGC:
3886		wait_on_command(sony_pic_call3(0x90, SONYPI_CAMERA_AGC, value),
3887				ITERATIONS_SHORT);
3888		break;
3889	default:
3890		pr_err("sony_pic_camera_command invalid: %d\n", command);
3891		break;
3892	}
3893	mutex_unlock(&spic_dev.lock);
3894	return 0;
3895}
3896EXPORT_SYMBOL(sony_pic_camera_command);
3897
3898/* gprs/edge modem (SZ460N and SZ210P), thanks to Joshua Wise */
3899static void __sony_pic_set_wwanpower(u8 state)
3900{
3901	state = !!state;
3902	if (spic_dev.wwan_power == state)
3903		return;
3904	sony_pic_call2(0xB0, state);
3905	sony_pic_call1(0x82);
3906	spic_dev.wwan_power = state;
3907}
3908
3909static ssize_t sony_pic_wwanpower_store(struct device *dev,
3910		struct device_attribute *attr,
3911		const char *buffer, size_t count)
3912{
3913	unsigned long value;
3914	if (count > 31)
3915		return -EINVAL;
3916
3917	if (kstrtoul(buffer, 10, &value))
3918		return -EINVAL;
3919
3920	mutex_lock(&spic_dev.lock);
3921	__sony_pic_set_wwanpower(value);
3922	mutex_unlock(&spic_dev.lock);
3923
3924	return count;
3925}
3926
3927static ssize_t sony_pic_wwanpower_show(struct device *dev,
3928		struct device_attribute *attr, char *buffer)
3929{
3930	ssize_t count;
3931	mutex_lock(&spic_dev.lock);
3932	count = snprintf(buffer, PAGE_SIZE, "%d\n", spic_dev.wwan_power);
3933	mutex_unlock(&spic_dev.lock);
3934	return count;
3935}
3936
3937/* bluetooth subsystem power state */
3938static void __sony_pic_set_bluetoothpower(u8 state)
3939{
3940	state = !!state;
3941	if (spic_dev.bluetooth_power == state)
3942		return;
3943	sony_pic_call2(0x96, state);
3944	sony_pic_call1(0x82);
3945	spic_dev.bluetooth_power = state;
3946}
3947
3948static ssize_t sony_pic_bluetoothpower_store(struct device *dev,
3949		struct device_attribute *attr,
3950		const char *buffer, size_t count)
3951{
3952	unsigned long value;
3953	if (count > 31)
3954		return -EINVAL;
3955
3956	if (kstrtoul(buffer, 10, &value))
3957		return -EINVAL;
3958
3959	mutex_lock(&spic_dev.lock);
3960	__sony_pic_set_bluetoothpower(value);
3961	mutex_unlock(&spic_dev.lock);
3962
3963	return count;
3964}
3965
3966static ssize_t sony_pic_bluetoothpower_show(struct device *dev,
3967		struct device_attribute *attr, char *buffer)
3968{
3969	ssize_t count = 0;
3970	mutex_lock(&spic_dev.lock);
3971	count = snprintf(buffer, PAGE_SIZE, "%d\n", spic_dev.bluetooth_power);
3972	mutex_unlock(&spic_dev.lock);
3973	return count;
3974}
3975
3976/* fan speed */
3977/* FAN0 information (reverse engineered from ACPI tables) */
3978#define SONY_PIC_FAN0_STATUS	0x93
3979static int sony_pic_set_fanspeed(unsigned long value)
3980{
3981	return ec_write(SONY_PIC_FAN0_STATUS, value);
3982}
3983
3984static int sony_pic_get_fanspeed(u8 *value)
3985{
3986	return ec_read(SONY_PIC_FAN0_STATUS, value);
3987}
3988
3989static ssize_t sony_pic_fanspeed_store(struct device *dev,
3990		struct device_attribute *attr,
3991		const char *buffer, size_t count)
3992{
3993	unsigned long value;
3994	if (count > 31)
3995		return -EINVAL;
3996
3997	if (kstrtoul(buffer, 10, &value))
3998		return -EINVAL;
3999
4000	if (sony_pic_set_fanspeed(value))
4001		return -EIO;
4002
4003	return count;
4004}
4005
4006static ssize_t sony_pic_fanspeed_show(struct device *dev,
4007		struct device_attribute *attr, char *buffer)
4008{
4009	u8 value = 0;
4010	if (sony_pic_get_fanspeed(&value))
4011		return -EIO;
4012
4013	return snprintf(buffer, PAGE_SIZE, "%d\n", value);
4014}
4015
4016#define SPIC_ATTR(_name, _mode)					\
4017struct device_attribute spic_attr_##_name = __ATTR(_name,	\
4018		_mode, sony_pic_## _name ##_show,		\
4019		sony_pic_## _name ##_store)
4020
4021static SPIC_ATTR(bluetoothpower, 0644);
4022static SPIC_ATTR(wwanpower, 0644);
4023static SPIC_ATTR(fanspeed, 0644);
4024
4025static struct attribute *spic_attributes[] = {
4026	&spic_attr_bluetoothpower.attr,
4027	&spic_attr_wwanpower.attr,
4028	&spic_attr_fanspeed.attr,
4029	NULL
4030};
4031
4032static struct attribute_group spic_attribute_group = {
4033	.attrs = spic_attributes
4034};
4035
4036/******** SONYPI compatibility **********/
4037#ifdef CONFIG_SONYPI_COMPAT
4038
4039/* battery / brightness / temperature  addresses */
4040#define SONYPI_BAT_FLAGS	0x81
4041#define SONYPI_LCD_LIGHT	0x96
4042#define SONYPI_BAT1_PCTRM	0xa0
4043#define SONYPI_BAT1_LEFT	0xa2
4044#define SONYPI_BAT1_MAXRT	0xa4
4045#define SONYPI_BAT2_PCTRM	0xa8
4046#define SONYPI_BAT2_LEFT	0xaa
4047#define SONYPI_BAT2_MAXRT	0xac
4048#define SONYPI_BAT1_MAXTK	0xb0
4049#define SONYPI_BAT1_FULL	0xb2
4050#define SONYPI_BAT2_MAXTK	0xb8
4051#define SONYPI_BAT2_FULL	0xba
4052#define SONYPI_TEMP_STATUS	0xC1
4053
4054struct sonypi_compat_s {
4055	struct fasync_struct	*fifo_async;
4056	struct kfifo		fifo;
4057	spinlock_t		fifo_lock;
4058	wait_queue_head_t	fifo_proc_list;
4059	atomic_t		open_count;
4060};
4061static struct sonypi_compat_s sonypi_compat = {
4062	.open_count = ATOMIC_INIT(0),
4063};
4064
4065static int sonypi_misc_fasync(int fd, struct file *filp, int on)
4066{
4067	return fasync_helper(fd, filp, on, &sonypi_compat.fifo_async);
4068}
4069
4070static int sonypi_misc_release(struct inode *inode, struct file *file)
4071{
4072	atomic_dec(&sonypi_compat.open_count);
4073	return 0;
4074}
4075
4076static int sonypi_misc_open(struct inode *inode, struct file *file)
4077{
4078	/* Flush input queue on first open */
4079	unsigned long flags;
4080
4081	spin_lock_irqsave(&sonypi_compat.fifo_lock, flags);
4082
4083	if (atomic_inc_return(&sonypi_compat.open_count) == 1)
4084		kfifo_reset(&sonypi_compat.fifo);
4085
4086	spin_unlock_irqrestore(&sonypi_compat.fifo_lock, flags);
4087
4088	return 0;
4089}
4090
4091static ssize_t sonypi_misc_read(struct file *file, char __user *buf,
4092				size_t count, loff_t *pos)
4093{
4094	ssize_t ret;
4095	unsigned char c;
4096
4097	if ((kfifo_len(&sonypi_compat.fifo) == 0) &&
4098	    (file->f_flags & O_NONBLOCK))
4099		return -EAGAIN;
4100
4101	ret = wait_event_interruptible(sonypi_compat.fifo_proc_list,
4102				       kfifo_len(&sonypi_compat.fifo) != 0);
4103	if (ret)
4104		return ret;
4105
4106	while (ret < count &&
4107	       (kfifo_out_locked(&sonypi_compat.fifo, &c, sizeof(c),
4108			  &sonypi_compat.fifo_lock) == sizeof(c))) {
4109		if (put_user(c, buf++))
4110			return -EFAULT;
4111		ret++;
4112	}
4113
4114	if (ret > 0) {
4115		struct inode *inode = file_inode(file);
4116		inode->i_atime = current_fs_time(inode->i_sb);
4117	}
4118
4119	return ret;
4120}
4121
4122static unsigned int sonypi_misc_poll(struct file *file, poll_table *wait)
4123{
4124	poll_wait(file, &sonypi_compat.fifo_proc_list, wait);
4125	if (kfifo_len(&sonypi_compat.fifo))
4126		return POLLIN | POLLRDNORM;
4127	return 0;
4128}
4129
4130static int ec_read16(u8 addr, u16 *value)
4131{
4132	u8 val_lb, val_hb;
4133	if (ec_read(addr, &val_lb))
4134		return -1;
4135	if (ec_read(addr + 1, &val_hb))
4136		return -1;
4137	*value = val_lb | (val_hb << 8);
4138	return 0;
4139}
4140
4141static long sonypi_misc_ioctl(struct file *fp, unsigned int cmd,
4142							unsigned long arg)
4143{
4144	int ret = 0;
4145	void __user *argp = (void __user *)arg;
4146	u8 val8;
4147	u16 val16;
4148	int value;
4149
4150	mutex_lock(&spic_dev.lock);
4151	switch (cmd) {
4152	case SONYPI_IOCGBRT:
4153		if (sony_bl_props.dev == NULL) {
4154			ret = -EIO;
4155			break;
4156		}
4157		if (sony_nc_int_call(sony_nc_acpi_handle, "GBRT", NULL,
4158					&value)) {
4159			ret = -EIO;
4160			break;
4161		}
4162		val8 = ((value & 0xff) - 1) << 5;
4163		if (copy_to_user(argp, &val8, sizeof(val8)))
4164				ret = -EFAULT;
4165		break;
4166	case SONYPI_IOCSBRT:
4167		if (sony_bl_props.dev == NULL) {
4168			ret = -EIO;
4169			break;
4170		}
4171		if (copy_from_user(&val8, argp, sizeof(val8))) {
4172			ret = -EFAULT;
4173			break;
4174		}
4175		value = (val8 >> 5) + 1;
4176		if (sony_nc_int_call(sony_nc_acpi_handle, "SBRT", &value,
4177					NULL)) {
4178			ret = -EIO;
4179			break;
4180		}
4181		/* sync the backlight device status */
4182		sony_bl_props.dev->props.brightness =
4183		    sony_backlight_get_brightness(sony_bl_props.dev);
4184		break;
4185	case SONYPI_IOCGBAT1CAP:
4186		if (ec_read16(SONYPI_BAT1_FULL, &val16)) {
4187			ret = -EIO;
4188			break;
4189		}
4190		if (copy_to_user(argp, &val16, sizeof(val16)))
4191			ret = -EFAULT;
4192		break;
4193	case SONYPI_IOCGBAT1REM:
4194		if (ec_read16(SONYPI_BAT1_LEFT, &val16)) {
4195			ret = -EIO;
4196			break;
4197		}
4198		if (copy_to_user(argp, &val16, sizeof(val16)))
4199			ret = -EFAULT;
4200		break;
4201	case SONYPI_IOCGBAT2CAP:
4202		if (ec_read16(SONYPI_BAT2_FULL, &val16)) {
4203			ret = -EIO;
4204			break;
4205		}
4206		if (copy_to_user(argp, &val16, sizeof(val16)))
4207			ret = -EFAULT;
4208		break;
4209	case SONYPI_IOCGBAT2REM:
4210		if (ec_read16(SONYPI_BAT2_LEFT, &val16)) {
4211			ret = -EIO;
4212			break;
4213		}
4214		if (copy_to_user(argp, &val16, sizeof(val16)))
4215			ret = -EFAULT;
4216		break;
4217	case SONYPI_IOCGBATFLAGS:
4218		if (ec_read(SONYPI_BAT_FLAGS, &val8)) {
4219			ret = -EIO;
4220			break;
4221		}
4222		val8 &= 0x07;
4223		if (copy_to_user(argp, &val8, sizeof(val8)))
4224			ret = -EFAULT;
4225		break;
4226	case SONYPI_IOCGBLUE:
4227		val8 = spic_dev.bluetooth_power;
4228		if (copy_to_user(argp, &val8, sizeof(val8)))
4229			ret = -EFAULT;
4230		break;
4231	case SONYPI_IOCSBLUE:
4232		if (copy_from_user(&val8, argp, sizeof(val8))) {
4233			ret = -EFAULT;
4234			break;
4235		}
4236		__sony_pic_set_bluetoothpower(val8);
4237		break;
4238	/* FAN Controls */
4239	case SONYPI_IOCGFAN:
4240		if (sony_pic_get_fanspeed(&val8)) {
4241			ret = -EIO;
4242			break;
4243		}
4244		if (copy_to_user(argp, &val8, sizeof(val8)))
4245			ret = -EFAULT;
4246		break;
4247	case SONYPI_IOCSFAN:
4248		if (copy_from_user(&val8, argp, sizeof(val8))) {
4249			ret = -EFAULT;
4250			break;
4251		}
4252		if (sony_pic_set_fanspeed(val8))
4253			ret = -EIO;
4254		break;
4255	/* GET Temperature (useful under APM) */
4256	case SONYPI_IOCGTEMP:
4257		if (ec_read(SONYPI_TEMP_STATUS, &val8)) {
4258			ret = -EIO;
4259			break;
4260		}
4261		if (copy_to_user(argp, &val8, sizeof(val8)))
4262			ret = -EFAULT;
4263		break;
4264	default:
4265		ret = -EINVAL;
4266	}
4267	mutex_unlock(&spic_dev.lock);
4268	return ret;
4269}
4270
4271static const struct file_operations sonypi_misc_fops = {
4272	.owner		= THIS_MODULE,
4273	.read		= sonypi_misc_read,
4274	.poll		= sonypi_misc_poll,
4275	.open		= sonypi_misc_open,
4276	.release	= sonypi_misc_release,
4277	.fasync		= sonypi_misc_fasync,
4278	.unlocked_ioctl	= sonypi_misc_ioctl,
4279	.llseek		= noop_llseek,
4280};
4281
4282static struct miscdevice sonypi_misc_device = {
4283	.minor		= MISC_DYNAMIC_MINOR,
4284	.name		= "sonypi",
4285	.fops		= &sonypi_misc_fops,
4286};
4287
4288static void sonypi_compat_report_event(u8 event)
4289{
4290	kfifo_in_locked(&sonypi_compat.fifo, (unsigned char *)&event,
4291			sizeof(event), &sonypi_compat.fifo_lock);
4292	kill_fasync(&sonypi_compat.fifo_async, SIGIO, POLL_IN);
4293	wake_up_interruptible(&sonypi_compat.fifo_proc_list);
4294}
4295
4296static int sonypi_compat_init(void)
4297{
4298	int error;
4299
4300	spin_lock_init(&sonypi_compat.fifo_lock);
4301	error =
4302	 kfifo_alloc(&sonypi_compat.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
4303	if (error) {
4304		pr_err("kfifo_alloc failed\n");
4305		return error;
4306	}
4307
4308	init_waitqueue_head(&sonypi_compat.fifo_proc_list);
4309
4310	if (minor != -1)
4311		sonypi_misc_device.minor = minor;
4312	error = misc_register(&sonypi_misc_device);
4313	if (error) {
4314		pr_err("misc_register failed\n");
4315		goto err_free_kfifo;
4316	}
4317	if (minor == -1)
4318		pr_info("device allocated minor is %d\n",
4319			sonypi_misc_device.minor);
4320
4321	return 0;
4322
4323err_free_kfifo:
4324	kfifo_free(&sonypi_compat.fifo);
4325	return error;
4326}
4327
4328static void sonypi_compat_exit(void)
4329{
4330	misc_deregister(&sonypi_misc_device);
4331	kfifo_free(&sonypi_compat.fifo);
4332}
4333#else
4334static int sonypi_compat_init(void) { return 0; }
4335static void sonypi_compat_exit(void) { }
4336static void sonypi_compat_report_event(u8 event) { }
4337#endif /* CONFIG_SONYPI_COMPAT */
4338
4339/*
4340 * ACPI callbacks
4341 */
4342static acpi_status
4343sony_pic_read_possible_resource(struct acpi_resource *resource, void *context)
4344{
4345	u32 i;
4346	struct sony_pic_dev *dev = (struct sony_pic_dev *)context;
4347
4348	switch (resource->type) {
4349	case ACPI_RESOURCE_TYPE_START_DEPENDENT:
4350		{
4351			/* start IO enumeration */
4352			struct sony_pic_ioport *ioport = kzalloc(sizeof(*ioport), GFP_KERNEL);
4353			if (!ioport)
4354				return AE_ERROR;
4355
4356			list_add(&ioport->list, &dev->ioports);
4357			return AE_OK;
4358		}
4359
4360	case ACPI_RESOURCE_TYPE_END_DEPENDENT:
4361		/* end IO enumeration */
4362		return AE_OK;
4363
4364	case ACPI_RESOURCE_TYPE_IRQ:
4365		{
4366			struct acpi_resource_irq *p = &resource->data.irq;
4367			struct sony_pic_irq *interrupt = NULL;
4368			if (!p || !p->interrupt_count) {
4369				/*
4370				 * IRQ descriptors may have no IRQ# bits set,
4371				 * particularly those those w/ _STA disabled
4372				 */
4373				dprintk("Blank IRQ resource\n");
4374				return AE_OK;
4375			}
4376			for (i = 0; i < p->interrupt_count; i++) {
4377				if (!p->interrupts[i]) {
4378					pr_warn("Invalid IRQ %d\n",
4379						p->interrupts[i]);
4380					continue;
4381				}
4382				interrupt = kzalloc(sizeof(*interrupt),
4383						GFP_KERNEL);
4384				if (!interrupt)
4385					return AE_ERROR;
4386
4387				list_add(&interrupt->list, &dev->interrupts);
4388				interrupt->irq.triggering = p->triggering;
4389				interrupt->irq.polarity = p->polarity;
4390				interrupt->irq.sharable = p->sharable;
4391				interrupt->irq.interrupt_count = 1;
4392				interrupt->irq.interrupts[0] = p->interrupts[i];
4393			}
4394			return AE_OK;
4395		}
4396	case ACPI_RESOURCE_TYPE_IO:
4397		{
4398			struct acpi_resource_io *io = &resource->data.io;
4399			struct sony_pic_ioport *ioport =
4400				list_first_entry(&dev->ioports, struct sony_pic_ioport, list);
4401			if (!io) {
4402				dprintk("Blank IO resource\n");
4403				return AE_OK;
4404			}
4405
4406			if (!ioport->io1.minimum) {
4407				memcpy(&ioport->io1, io, sizeof(*io));
4408				dprintk("IO1 at 0x%.4x (0x%.2x)\n", ioport->io1.minimum,
4409						ioport->io1.address_length);
4410			}
4411			else if (!ioport->io2.minimum) {
4412				memcpy(&ioport->io2, io, sizeof(*io));
4413				dprintk("IO2 at 0x%.4x (0x%.2x)\n", ioport->io2.minimum,
4414						ioport->io2.address_length);
4415			}
4416			else {
4417				pr_err("Unknown SPIC Type, more than 2 IO Ports\n");
4418				return AE_ERROR;
4419			}
4420			return AE_OK;
4421		}
 
 
 
 
4422	default:
4423		dprintk("Resource %d isn't an IRQ nor an IO port\n",
4424			resource->type);
 
4425
4426	case ACPI_RESOURCE_TYPE_END_TAG:
4427		return AE_OK;
4428	}
4429	return AE_CTRL_TERMINATE;
4430}
4431
4432static int sony_pic_possible_resources(struct acpi_device *device)
4433{
4434	int result = 0;
4435	acpi_status status = AE_OK;
4436
4437	if (!device)
4438		return -EINVAL;
4439
4440	/* get device status */
4441	/* see acpi_pci_link_get_current acpi_pci_link_get_possible */
4442	dprintk("Evaluating _STA\n");
4443	result = acpi_bus_get_status(device);
4444	if (result) {
4445		pr_warn("Unable to read status\n");
4446		goto end;
4447	}
4448
4449	if (!device->status.enabled)
4450		dprintk("Device disabled\n");
4451	else
4452		dprintk("Device enabled\n");
4453
4454	/*
4455	 * Query and parse 'method'
4456	 */
4457	dprintk("Evaluating %s\n", METHOD_NAME__PRS);
4458	status = acpi_walk_resources(device->handle, METHOD_NAME__PRS,
4459			sony_pic_read_possible_resource, &spic_dev);
4460	if (ACPI_FAILURE(status)) {
4461		pr_warn("Failure evaluating %s\n", METHOD_NAME__PRS);
4462		result = -ENODEV;
4463	}
4464end:
4465	return result;
4466}
4467
4468/*
4469 *  Disable the spic device by calling its _DIS method
4470 */
4471static int sony_pic_disable(struct acpi_device *device)
4472{
4473	acpi_status ret = acpi_evaluate_object(device->handle, "_DIS", NULL,
4474					       NULL);
4475
4476	if (ACPI_FAILURE(ret) && ret != AE_NOT_FOUND)
4477		return -ENXIO;
4478
4479	dprintk("Device disabled\n");
4480	return 0;
4481}
4482
4483
4484/*
4485 *  Based on drivers/acpi/pci_link.c:acpi_pci_link_set
4486 *
4487 *  Call _SRS to set current resources
4488 */
4489static int sony_pic_enable(struct acpi_device *device,
4490		struct sony_pic_ioport *ioport, struct sony_pic_irq *irq)
4491{
4492	acpi_status status;
4493	int result = 0;
4494	/* Type 1 resource layout is:
4495	 *    IO
4496	 *    IO
4497	 *    IRQNoFlags
4498	 *    End
4499	 *
4500	 * Type 2 and 3 resource layout is:
4501	 *    IO
4502	 *    IRQNoFlags
4503	 *    End
4504	 */
4505	struct {
4506		struct acpi_resource res1;
4507		struct acpi_resource res2;
4508		struct acpi_resource res3;
4509		struct acpi_resource res4;
4510	} *resource;
4511	struct acpi_buffer buffer = { 0, NULL };
4512
4513	if (!ioport || !irq)
4514		return -EINVAL;
4515
4516	/* init acpi_buffer */
4517	resource = kzalloc(sizeof(*resource) + 1, GFP_KERNEL);
4518	if (!resource)
4519		return -ENOMEM;
4520
4521	buffer.length = sizeof(*resource) + 1;
4522	buffer.pointer = resource;
4523
4524	/* setup Type 1 resources */
4525	if (spic_dev.model == SONYPI_DEVICE_TYPE1) {
4526
4527		/* setup io resources */
4528		resource->res1.type = ACPI_RESOURCE_TYPE_IO;
4529		resource->res1.length = sizeof(struct acpi_resource);
4530		memcpy(&resource->res1.data.io, &ioport->io1,
4531				sizeof(struct acpi_resource_io));
4532
4533		resource->res2.type = ACPI_RESOURCE_TYPE_IO;
4534		resource->res2.length = sizeof(struct acpi_resource);
4535		memcpy(&resource->res2.data.io, &ioport->io2,
4536				sizeof(struct acpi_resource_io));
4537
4538		/* setup irq resource */
4539		resource->res3.type = ACPI_RESOURCE_TYPE_IRQ;
4540		resource->res3.length = sizeof(struct acpi_resource);
4541		memcpy(&resource->res3.data.irq, &irq->irq,
4542				sizeof(struct acpi_resource_irq));
4543		/* we requested a shared irq */
4544		resource->res3.data.irq.sharable = ACPI_SHARED;
4545
4546		resource->res4.type = ACPI_RESOURCE_TYPE_END_TAG;
4547		resource->res4.length = sizeof(struct acpi_resource);
4548	}
4549	/* setup Type 2/3 resources */
4550	else {
4551		/* setup io resource */
4552		resource->res1.type = ACPI_RESOURCE_TYPE_IO;
4553		resource->res1.length = sizeof(struct acpi_resource);
4554		memcpy(&resource->res1.data.io, &ioport->io1,
4555				sizeof(struct acpi_resource_io));
4556
4557		/* setup irq resource */
4558		resource->res2.type = ACPI_RESOURCE_TYPE_IRQ;
4559		resource->res2.length = sizeof(struct acpi_resource);
4560		memcpy(&resource->res2.data.irq, &irq->irq,
4561				sizeof(struct acpi_resource_irq));
4562		/* we requested a shared irq */
4563		resource->res2.data.irq.sharable = ACPI_SHARED;
4564
4565		resource->res3.type = ACPI_RESOURCE_TYPE_END_TAG;
4566		resource->res3.length = sizeof(struct acpi_resource);
4567	}
4568
4569	/* Attempt to set the resource */
4570	dprintk("Evaluating _SRS\n");
4571	status = acpi_set_current_resources(device->handle, &buffer);
4572
4573	/* check for total failure */
4574	if (ACPI_FAILURE(status)) {
4575		pr_err("Error evaluating _SRS\n");
4576		result = -ENODEV;
4577		goto end;
4578	}
4579
4580	/* Necessary device initializations calls (from sonypi) */
4581	sony_pic_call1(0x82);
4582	sony_pic_call2(0x81, 0xff);
4583	sony_pic_call1(compat ? 0x92 : 0x82);
4584
4585end:
4586	kfree(resource);
4587	return result;
4588}
4589
4590/*****************
4591 *
4592 * ISR: some event is available
4593 *
4594 *****************/
4595static irqreturn_t sony_pic_irq(int irq, void *dev_id)
4596{
4597	int i, j;
4598	u8 ev = 0;
4599	u8 data_mask = 0;
4600	u8 device_event = 0;
4601
4602	struct sony_pic_dev *dev = (struct sony_pic_dev *) dev_id;
4603
4604	ev = inb_p(dev->cur_ioport->io1.minimum);
4605	if (dev->cur_ioport->io2.minimum)
4606		data_mask = inb_p(dev->cur_ioport->io2.minimum);
4607	else
4608		data_mask = inb_p(dev->cur_ioport->io1.minimum +
4609				dev->evport_offset);
4610
4611	dprintk("event ([%.2x] [%.2x]) at port 0x%.4x(+0x%.2x)\n",
4612			ev, data_mask, dev->cur_ioport->io1.minimum,
4613			dev->evport_offset);
4614
4615	if (ev == 0x00 || ev == 0xff)
4616		return IRQ_HANDLED;
4617
4618	for (i = 0; dev->event_types[i].mask; i++) {
4619
4620		if ((data_mask & dev->event_types[i].data) !=
4621		    dev->event_types[i].data)
4622			continue;
4623
4624		if (!(mask & dev->event_types[i].mask))
4625			continue;
4626
4627		for (j = 0; dev->event_types[i].events[j].event; j++) {
4628			if (ev == dev->event_types[i].events[j].data) {
4629				device_event =
4630					dev->event_types[i].events[j].event;
4631				/* some events may require ignoring */
4632				if (!device_event)
4633					return IRQ_HANDLED;
4634				goto found;
4635			}
4636		}
4637	}
4638	/* Still not able to decode the event try to pass
4639	 * it over to the minidriver
4640	 */
4641	if (dev->handle_irq && dev->handle_irq(data_mask, ev) == 0)
4642		return IRQ_HANDLED;
4643
4644	dprintk("unknown event ([%.2x] [%.2x]) at port 0x%.4x(+0x%.2x)\n",
4645			ev, data_mask, dev->cur_ioport->io1.minimum,
4646			dev->evport_offset);
4647	return IRQ_HANDLED;
4648
4649found:
4650	sony_laptop_report_input_event(device_event);
4651	sonypi_compat_report_event(device_event);
4652	return IRQ_HANDLED;
4653}
4654
4655/*****************
4656 *
4657 *  ACPI driver
4658 *
4659 *****************/
4660static int sony_pic_remove(struct acpi_device *device)
4661{
4662	struct sony_pic_ioport *io, *tmp_io;
4663	struct sony_pic_irq *irq, *tmp_irq;
4664
4665	if (sony_pic_disable(device)) {
4666		pr_err("Couldn't disable device\n");
4667		return -ENXIO;
4668	}
4669
4670	free_irq(spic_dev.cur_irq->irq.interrupts[0], &spic_dev);
4671	release_region(spic_dev.cur_ioport->io1.minimum,
4672			spic_dev.cur_ioport->io1.address_length);
4673	if (spic_dev.cur_ioport->io2.minimum)
4674		release_region(spic_dev.cur_ioport->io2.minimum,
4675				spic_dev.cur_ioport->io2.address_length);
4676
4677	sonypi_compat_exit();
4678
4679	sony_laptop_remove_input();
4680
4681	/* pf attrs */
4682	sysfs_remove_group(&sony_pf_device->dev.kobj, &spic_attribute_group);
4683	sony_pf_remove();
4684
4685	list_for_each_entry_safe(io, tmp_io, &spic_dev.ioports, list) {
4686		list_del(&io->list);
4687		kfree(io);
4688	}
4689	list_for_each_entry_safe(irq, tmp_irq, &spic_dev.interrupts, list) {
4690		list_del(&irq->list);
4691		kfree(irq);
4692	}
4693	spic_dev.cur_ioport = NULL;
4694	spic_dev.cur_irq = NULL;
4695
4696	dprintk(SONY_PIC_DRIVER_NAME " removed.\n");
4697	return 0;
4698}
4699
4700static int sony_pic_add(struct acpi_device *device)
4701{
4702	int result;
4703	struct sony_pic_ioport *io, *tmp_io;
4704	struct sony_pic_irq *irq, *tmp_irq;
4705
4706	spic_dev.acpi_dev = device;
4707	strcpy(acpi_device_class(device), "sony/hotkey");
4708	sony_pic_detect_device_type(&spic_dev);
4709	mutex_init(&spic_dev.lock);
4710
4711	/* read _PRS resources */
4712	result = sony_pic_possible_resources(device);
4713	if (result) {
4714		pr_err("Unable to read possible resources\n");
4715		goto err_free_resources;
4716	}
4717
4718	/* setup input devices and helper fifo */
4719	result = sony_laptop_setup_input(device);
4720	if (result) {
4721		pr_err("Unable to create input devices\n");
4722		goto err_free_resources;
4723	}
4724
4725	result = sonypi_compat_init();
4726	if (result)
4727		goto err_remove_input;
4728
4729	/* request io port */
4730	list_for_each_entry_reverse(io, &spic_dev.ioports, list) {
4731		if (request_region(io->io1.minimum, io->io1.address_length,
4732					"Sony Programmable I/O Device")) {
4733			dprintk("I/O port1: 0x%.4x (0x%.4x) + 0x%.2x\n",
4734					io->io1.minimum, io->io1.maximum,
4735					io->io1.address_length);
4736			/* Type 1 have 2 ioports */
4737			if (io->io2.minimum) {
4738				if (request_region(io->io2.minimum,
4739						io->io2.address_length,
4740						"Sony Programmable I/O Device")) {
4741					dprintk("I/O port2: 0x%.4x (0x%.4x) + 0x%.2x\n",
4742							io->io2.minimum, io->io2.maximum,
4743							io->io2.address_length);
4744					spic_dev.cur_ioport = io;
4745					break;
4746				}
4747				else {
4748					dprintk("Unable to get I/O port2: "
4749							"0x%.4x (0x%.4x) + 0x%.2x\n",
4750							io->io2.minimum, io->io2.maximum,
4751							io->io2.address_length);
4752					release_region(io->io1.minimum,
4753							io->io1.address_length);
4754				}
4755			}
4756			else {
4757				spic_dev.cur_ioport = io;
4758				break;
4759			}
4760		}
4761	}
4762	if (!spic_dev.cur_ioport) {
4763		pr_err("Failed to request_region\n");
4764		result = -ENODEV;
4765		goto err_remove_compat;
4766	}
4767
4768	/* request IRQ */
4769	list_for_each_entry_reverse(irq, &spic_dev.interrupts, list) {
4770		if (!request_irq(irq->irq.interrupts[0], sony_pic_irq,
4771					0, "sony-laptop", &spic_dev)) {
4772			dprintk("IRQ: %d - triggering: %d - "
4773					"polarity: %d - shr: %d\n",
4774					irq->irq.interrupts[0],
4775					irq->irq.triggering,
4776					irq->irq.polarity,
4777					irq->irq.sharable);
4778			spic_dev.cur_irq = irq;
4779			break;
4780		}
4781	}
4782	if (!spic_dev.cur_irq) {
4783		pr_err("Failed to request_irq\n");
4784		result = -ENODEV;
4785		goto err_release_region;
4786	}
4787
4788	/* set resource status _SRS */
4789	result = sony_pic_enable(device, spic_dev.cur_ioport, spic_dev.cur_irq);
4790	if (result) {
4791		pr_err("Couldn't enable device\n");
4792		goto err_free_irq;
4793	}
4794
4795	spic_dev.bluetooth_power = -1;
4796	/* create device attributes */
4797	result = sony_pf_add();
4798	if (result)
4799		goto err_disable_device;
4800
4801	result = sysfs_create_group(&sony_pf_device->dev.kobj, &spic_attribute_group);
4802	if (result)
4803		goto err_remove_pf;
4804
4805	pr_info("SPIC setup done.\n");
4806	return 0;
4807
4808err_remove_pf:
4809	sony_pf_remove();
4810
4811err_disable_device:
4812	sony_pic_disable(device);
4813
4814err_free_irq:
4815	free_irq(spic_dev.cur_irq->irq.interrupts[0], &spic_dev);
4816
4817err_release_region:
4818	release_region(spic_dev.cur_ioport->io1.minimum,
4819			spic_dev.cur_ioport->io1.address_length);
4820	if (spic_dev.cur_ioport->io2.minimum)
4821		release_region(spic_dev.cur_ioport->io2.minimum,
4822				spic_dev.cur_ioport->io2.address_length);
4823
4824err_remove_compat:
4825	sonypi_compat_exit();
4826
4827err_remove_input:
4828	sony_laptop_remove_input();
4829
4830err_free_resources:
4831	list_for_each_entry_safe(io, tmp_io, &spic_dev.ioports, list) {
4832		list_del(&io->list);
4833		kfree(io);
4834	}
4835	list_for_each_entry_safe(irq, tmp_irq, &spic_dev.interrupts, list) {
4836		list_del(&irq->list);
4837		kfree(irq);
4838	}
4839	spic_dev.cur_ioport = NULL;
4840	spic_dev.cur_irq = NULL;
4841
4842	return result;
4843}
4844
4845#ifdef CONFIG_PM_SLEEP
4846static int sony_pic_suspend(struct device *dev)
4847{
4848	if (sony_pic_disable(to_acpi_device(dev)))
4849		return -ENXIO;
4850	return 0;
4851}
4852
4853static int sony_pic_resume(struct device *dev)
4854{
4855	sony_pic_enable(to_acpi_device(dev),
4856			spic_dev.cur_ioport, spic_dev.cur_irq);
4857	return 0;
4858}
4859#endif
4860
4861static SIMPLE_DEV_PM_OPS(sony_pic_pm, sony_pic_suspend, sony_pic_resume);
4862
4863static const struct acpi_device_id sony_pic_device_ids[] = {
4864	{SONY_PIC_HID, 0},
4865	{"", 0},
4866};
4867
4868static struct acpi_driver sony_pic_driver = {
4869	.name = SONY_PIC_DRIVER_NAME,
4870	.class = SONY_PIC_CLASS,
4871	.ids = sony_pic_device_ids,
4872	.owner = THIS_MODULE,
4873	.ops = {
4874		.add = sony_pic_add,
4875		.remove = sony_pic_remove,
4876		},
4877	.drv.pm = &sony_pic_pm,
4878};
4879
4880static struct dmi_system_id __initdata sonypi_dmi_table[] = {
4881	{
4882		.ident = "Sony Vaio",
4883		.matches = {
4884			DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
4885			DMI_MATCH(DMI_PRODUCT_NAME, "PCG-"),
4886		},
4887	},
4888	{
4889		.ident = "Sony Vaio",
4890		.matches = {
4891			DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
4892			DMI_MATCH(DMI_PRODUCT_NAME, "VGN-"),
4893		},
4894	},
4895	{ }
4896};
4897
4898static int __init sony_laptop_init(void)
4899{
4900	int result;
4901
4902	if (!no_spic && dmi_check_system(sonypi_dmi_table)) {
4903		result = acpi_bus_register_driver(&sony_pic_driver);
4904		if (result) {
4905			pr_err("Unable to register SPIC driver\n");
4906			goto out;
4907		}
4908		spic_drv_registered = 1;
4909	}
4910
4911	result = acpi_bus_register_driver(&sony_nc_driver);
4912	if (result) {
4913		pr_err("Unable to register SNC driver\n");
4914		goto out_unregister_pic;
4915	}
4916
4917	return 0;
4918
4919out_unregister_pic:
4920	if (spic_drv_registered)
4921		acpi_bus_unregister_driver(&sony_pic_driver);
4922out:
4923	return result;
4924}
4925
4926static void __exit sony_laptop_exit(void)
4927{
4928	acpi_bus_unregister_driver(&sony_nc_driver);
4929	if (spic_drv_registered)
4930		acpi_bus_unregister_driver(&sony_pic_driver);
4931}
4932
4933module_init(sony_laptop_init);
4934module_exit(sony_laptop_exit);