Release 4.11 drivers/platform/x86/toshiba_acpi.c

Directory: drivers/platform/x86
/*
 *  toshiba_acpi.c - Toshiba Laptop ACPI Extras
 *
 *  Copyright (C) 2002-2004 John Belmonte
 *  Copyright (C) 2008 Philip Langdale
 *  Copyright (C) 2010 Pierre Ducroquet
 *  Copyright (C) 2014-2016 Azael Avalos
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  The full GNU General Public License is included in this distribution in
 *  the file called "COPYING".
 *
 *  The devolpment page for this driver is located at
 *  http://memebeam.org/toys/ToshibaAcpiDriver.
 *
 *  Credits:
 *      Jonathan A. Buzzard - Toshiba HCI info, and critical tips on reverse
 *              engineering the Windows drivers
 *      Yasushi Nagato - changes for linux kernel 2.4 -> 2.5
 *      Rob Miller - TV out and hotkeys help
 */


#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt


#define TOSHIBA_ACPI_VERSION	"0.24"

#define PROC_INTERFACE_VERSION	1

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/backlight.h>
#include <linux/input.h>
#include <linux/input/sparse-keymap.h>
#include <linux/leds.h>
#include <linux/slab.h>
#include <linux/workqueue.h>
#include <linux/i8042.h>
#include <linux/acpi.h>
#include <linux/dmi.h>
#include <linux/uaccess.h>
#include <linux/miscdevice.h>
#include <linux/rfkill.h>
#include <linux/iio/iio.h>
#include <linux/toshiba.h>
#include <acpi/video.h>

MODULE_AUTHOR("John Belmonte");
MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
MODULE_LICENSE("GPL");


#define TOSHIBA_WMI_EVENT_GUID "59142400-C6A3-40FA-BADB-8A2652834100"

/* Scan code for Fn key on TOS1900 models */

#define TOS1900_FN_SCAN		0x6e

/* Toshiba ACPI method paths */

#define METHOD_VIDEO_OUT	"\\_SB_.VALX.DSSX"

/*
 * The Toshiba configuration interface is composed of the HCI and the SCI,
 * which are defined as follows:
 *
 * HCI is Toshiba's "Hardware Control Interface" which is supposed to
 * be uniform across all their models.  Ideally we would just call
 * dedicated ACPI methods instead of using this primitive interface.
 * However the ACPI methods seem to be incomplete in some areas (for
 * example they allow setting, but not reading, the LCD brightness value),
 * so this is still useful.
 *
 * SCI stands for "System Configuration Interface" which aim is to
 * conceal differences in hardware between different models.
 */


#define TCI_WORDS			6

/* Operations */

#define HCI_SET				0xff00

#define HCI_GET				0xfe00

#define SCI_OPEN			0xf100

#define SCI_CLOSE			0xf200

#define SCI_GET				0xf300

#define SCI_SET				0xf400

/* Return codes */

#define TOS_SUCCESS			0x0000

#define TOS_SUCCESS2			0x0001

#define TOS_OPEN_CLOSE_OK		0x0044

#define TOS_FAILURE			0x1000

#define TOS_NOT_SUPPORTED		0x8000

#define TOS_ALREADY_OPEN		0x8100

#define TOS_NOT_OPENED			0x8200

#define TOS_INPUT_DATA_ERROR		0x8300

#define TOS_WRITE_PROTECTED		0x8400

#define TOS_NOT_PRESENT			0x8600

#define TOS_FIFO_EMPTY			0x8c00

#define TOS_DATA_NOT_AVAILABLE		0x8d20

#define TOS_NOT_INITIALIZED		0x8d50

#define TOS_NOT_INSTALLED		0x8e00

/* Registers */

#define HCI_FAN				0x0004

#define HCI_TR_BACKLIGHT		0x0005

#define HCI_SYSTEM_EVENT		0x0016

#define HCI_VIDEO_OUT			0x001c

#define HCI_HOTKEY_EVENT		0x001e

#define HCI_LCD_BRIGHTNESS		0x002a

#define HCI_WIRELESS			0x0056

#define HCI_ACCELEROMETER		0x006d

#define HCI_COOLING_METHOD		0x007f

#define HCI_KBD_ILLUMINATION		0x0095

#define HCI_ECO_MODE			0x0097

#define HCI_ACCELEROMETER2		0x00a6

#define HCI_SYSTEM_INFO			0xc000

#define SCI_PANEL_POWER_ON		0x010d

#define SCI_ILLUMINATION		0x014e

#define SCI_USB_SLEEP_CHARGE		0x0150

#define SCI_KBD_ILLUM_STATUS		0x015c

#define SCI_USB_SLEEP_MUSIC		0x015e

#define SCI_USB_THREE			0x0169

#define SCI_TOUCHPAD			0x050e

#define SCI_KBD_FUNCTION_KEYS		0x0522

/* Field definitions */

#define HCI_ACCEL_MASK			0x7fff

#define HCI_ACCEL_DIRECTION_MASK	0x8000

#define HCI_HOTKEY_DISABLE		0x0b

#define HCI_HOTKEY_ENABLE		0x09

#define HCI_HOTKEY_SPECIAL_FUNCTIONS	0x10

#define HCI_LCD_BRIGHTNESS_BITS		3

#define HCI_LCD_BRIGHTNESS_SHIFT	(16-HCI_LCD_BRIGHTNESS_BITS)

#define HCI_LCD_BRIGHTNESS_LEVELS	(1 << HCI_LCD_BRIGHTNESS_BITS)

#define HCI_MISC_SHIFT			0x10

#define HCI_SYSTEM_TYPE1		0x10

#define HCI_SYSTEM_TYPE2		0x11

#define HCI_VIDEO_OUT_LCD		0x1

#define HCI_VIDEO_OUT_CRT		0x2

#define HCI_VIDEO_OUT_TV		0x4

#define SCI_KBD_MODE_MASK		0x1f

#define SCI_KBD_MODE_FNZ		0x1

#define SCI_KBD_MODE_AUTO		0x2

#define SCI_KBD_MODE_ON			0x8

#define SCI_KBD_MODE_OFF		0x10

#define SCI_KBD_TIME_MAX		0x3c001a

#define HCI_WIRELESS_STATUS		0x1

#define HCI_WIRELESS_WWAN		0x3

#define HCI_WIRELESS_WWAN_STATUS	0x2000

#define HCI_WIRELESS_WWAN_POWER		0x4000

#define SCI_USB_CHARGE_MODE_MASK	0xff

#define SCI_USB_CHARGE_DISABLED		0x00

#define SCI_USB_CHARGE_ALTERNATE	0x09

#define SCI_USB_CHARGE_TYPICAL		0x11

#define SCI_USB_CHARGE_AUTO		0x21

#define SCI_USB_CHARGE_BAT_MASK		0x7

#define SCI_USB_CHARGE_BAT_LVL_OFF	0x1

#define SCI_USB_CHARGE_BAT_LVL_ON	0x4

#define SCI_USB_CHARGE_BAT_LVL		0x0200

#define SCI_USB_CHARGE_RAPID_DSP	0x0300


struct toshiba_acpi_dev {
	
struct acpi_device *acpi_dev;
	
const char *method_hci;
	
struct input_dev *hotkey_dev;
	
struct work_struct hotkey_work;
	
struct backlight_device *backlight_dev;
	
struct led_classdev led_dev;
	
struct led_classdev kbd_led;
	
struct led_classdev eco_led;
	
struct miscdevice miscdev;
	
struct rfkill *wwan_rfk;
	
struct iio_dev *indio_dev;

	
int force_fan;
	
int last_key_event;
	
int key_event_valid;
	
int kbd_type;
	
int kbd_mode;
	
int kbd_time;
	
int usbsc_bat_level;
	
int usbsc_mode_base;
	
int hotkey_event_type;
	
int max_cooling_method;

	
unsigned int illumination_supported:1;
	
unsigned int video_supported:1;
	
unsigned int fan_supported:1;
	
unsigned int system_event_supported:1;
	
unsigned int ntfy_supported:1;
	
unsigned int info_supported:1;
	
unsigned int tr_backlight_supported:1;
	
unsigned int kbd_illum_supported:1;
	
unsigned int touchpad_supported:1;
	
unsigned int eco_supported:1;
	
unsigned int accelerometer_supported:1;
	
unsigned int usb_sleep_charge_supported:1;
	
unsigned int usb_rapid_charge_supported:1;
	
unsigned int usb_sleep_music_supported:1;
	
unsigned int kbd_function_keys_supported:1;
	
unsigned int panel_power_on_supported:1;
	
unsigned int usb_three_supported:1;
	
unsigned int wwan_supported:1;
	
unsigned int cooling_method_supported:1;
	
unsigned int sysfs_created:1;
	
unsigned int special_functions;

	
bool kbd_event_generated;
	
bool kbd_led_registered;
	
bool illumination_led_registered;
	
bool eco_led_registered;
	
bool killswitch;
};


static struct toshiba_acpi_dev *toshiba_acpi;


static bool disable_hotkeys;
module_param(disable_hotkeys, bool, 0444);
MODULE_PARM_DESC(disable_hotkeys, "Disables the hotkeys activation");


static const struct acpi_device_id toshiba_device_ids[] = {
	{"TOS6200", 0},
	{"TOS6207", 0},
	{"TOS6208", 0},
	{"TOS1900", 0},
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, toshiba_device_ids);


static const struct key_entry toshiba_acpi_keymap[] = {
	{ KE_KEY, 0x9e, { KEY_RFKILL } },
	{ KE_KEY, 0x101, { KEY_MUTE } },
	{ KE_KEY, 0x102, { KEY_ZOOMOUT } },
	{ KE_KEY, 0x103, { KEY_ZOOMIN } },
	{ KE_KEY, 0x10f, { KEY_TAB } },
	{ KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } },
	{ KE_KEY, 0x139, { KEY_ZOOMRESET } },
	{ KE_KEY, 0x13b, { KEY_COFFEE } },
	{ KE_KEY, 0x13c, { KEY_BATTERY } },
	{ KE_KEY, 0x13d, { KEY_SLEEP } },
	{ KE_KEY, 0x13e, { KEY_SUSPEND } },
	{ KE_KEY, 0x13f, { KEY_SWITCHVIDEOMODE } },
	{ KE_KEY, 0x140, { KEY_BRIGHTNESSDOWN } },
	{ KE_KEY, 0x141, { KEY_BRIGHTNESSUP } },
	{ KE_KEY, 0x142, { KEY_WLAN } },
	{ KE_KEY, 0x143, { KEY_TOUCHPAD_TOGGLE } },
	{ KE_KEY, 0x17f, { KEY_FN } },
	{ KE_KEY, 0xb05, { KEY_PROG2 } },
	{ KE_KEY, 0xb06, { KEY_WWW } },
	{ KE_KEY, 0xb07, { KEY_MAIL } },
	{ KE_KEY, 0xb30, { KEY_STOP } },
	{ KE_KEY, 0xb31, { KEY_PREVIOUSSONG } },
	{ KE_KEY, 0xb32, { KEY_NEXTSONG } },
	{ KE_KEY, 0xb33, { KEY_PLAYPAUSE } },
	{ KE_KEY, 0xb5a, { KEY_MEDIA } },
	{ KE_IGNORE, 0x1430, { KEY_RESERVED } }, /* Wake from sleep */
	{ KE_IGNORE, 0x1501, { KEY_RESERVED } }, /* Output changed */
	{ KE_IGNORE, 0x1502, { KEY_RESERVED } }, /* HDMI plugged/unplugged */
	{ KE_IGNORE, 0x1ABE, { KEY_RESERVED } }, /* Protection level set */
	{ KE_IGNORE, 0x1ABF, { KEY_RESERVED } }, /* Protection level off */
	{ KE_END, 0 },
};


static const struct key_entry toshiba_acpi_alt_keymap[] = {
	{ KE_KEY, 0x102, { KEY_ZOOMOUT } },
	{ KE_KEY, 0x103, { KEY_ZOOMIN } },
	{ KE_KEY, 0x12c, { KEY_KBDILLUMTOGGLE } },
	{ KE_KEY, 0x139, { KEY_ZOOMRESET } },
	{ KE_KEY, 0x13c, { KEY_BRIGHTNESSDOWN } },
	{ KE_KEY, 0x13d, { KEY_BRIGHTNESSUP } },
	{ KE_KEY, 0x13e, { KEY_SWITCHVIDEOMODE } },
	{ KE_KEY, 0x13f, { KEY_TOUCHPAD_TOGGLE } },
	{ KE_KEY, 0x157, { KEY_MUTE } },
	{ KE_KEY, 0x158, { KEY_WLAN } },
	{ KE_END, 0 },
};

/*
 * List of models which have a broken acpi-video backlight interface and thus
 * need to use the toshiba (vendor) interface instead.
 */

static const struct dmi_system_id toshiba_vendor_backlight_dmi[] = {
	{}
};

/*
 * Utility
 */



static inline void _set_bit(u32 *word, u32 mask, int value)
{
	*word = (*word & ~mask) | (mask * value);
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Grover 33 97.06% 1 50.00%
Azael Avalos 1 2.94% 1 50.00%
Total 34 100.00% 2 100.00%

/*
 * ACPI interface wrappers
 */



static int write_acpi_int(const char *methodName, int val)
{
	acpi_status status;

	status = acpi_execute_simple_method(NULL, (char *)methodName, val);
	return (status == AE_OK) ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Grover 34 77.27% 1 20.00%
Seth Forshee 5 11.36% 1 20.00%
John Belmonte 2 4.55% 1 20.00%
Rui Zhang 2 4.55% 1 20.00%
Al Viro 1 2.27% 1 20.00%
Total 44 100.00% 5 100.00%

/*
 * Perform a raw configuration call.  Here we don't care about input or output
 * buffer format.
 */


static acpi_status tci_raw(struct toshiba_acpi_dev *dev,
			   const u32 in[TCI_WORDS], u32 out[TCI_WORDS])
{
	union acpi_object in_objs[TCI_WORDS], out_objs[TCI_WORDS + 1];
	struct acpi_object_list params;
	struct acpi_buffer results;
	acpi_status status;
	int i;

	params.count = TCI_WORDS;
	params.pointer = in_objs;
	for (i = 0; i < TCI_WORDS; ++i) {
		in_objs[i].type = ACPI_TYPE_INTEGER;
		in_objs[i].integer.value = in[i];
	}

	results.length = sizeof(out_objs);
	results.pointer = out_objs;

	status = acpi_evaluate_object(dev->acpi_dev->handle,
				      (char *)dev->method_hci, &params,
				      &results);
	if ((status == AE_OK) && (out_objs->package.count <= TCI_WORDS)) {
		for (i = 0; i < out_objs->package.count; ++i)
			out[i] = out_objs->package.elements[i].integer.value;
	}

	return status;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Grover 166 83.00% 2 28.57%
Azael Avalos 17 8.50% 2 28.57%
Seth Forshee 12 6.00% 2 28.57%
John Belmonte 5 2.50% 1 14.29%
Total 200 100.00% 7 100.00%

/*
 * Common hci tasks
 *
 * In addition to the ACPI status, the HCI system returns a result which
 * may be useful (such as "not supported").
 */



static u32 hci_write(struct toshiba_acpi_dev *dev, u32 reg, u32 in1)
{
	u32 in[TCI_WORDS] = { HCI_SET, reg, in1, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status = tci_raw(dev, in, out);

	return ACPI_SUCCESS(status) ? out[0] : TOS_FAILURE;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Grover 51 75.00% 1 16.67%
Azael Avalos 10 14.71% 4 66.67%
Seth Forshee 7 10.29% 1 16.67%
Total 68 100.00% 6 100.00%



static u32 hci_read(struct toshiba_acpi_dev *dev, u32 reg, u32 *out1)
{
	u32 in[TCI_WORDS] = { HCI_GET, reg, 0, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status = tci_raw(dev, in, out);

	if (ACPI_FAILURE(status))
		return TOS_FAILURE;

	*out1 = out[2];

	return out[0];
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Grover 57 71.25% 1 20.00%
Azael Avalos 16 20.00% 3 60.00%
Seth Forshee 7 8.75% 1 20.00%
Total 80 100.00% 5 100.00%

/*
 * Common sci tasks
 */



static int sci_open(struct toshiba_acpi_dev *dev)
{
	u32 in[TCI_WORDS] = { SCI_OPEN, 0, 0, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status = tci_raw(dev, in, out);

	if  (ACPI_FAILURE(status)) {
		pr_err("ACPI call to open SCI failed\n");
		return 0;
	}

	if (out[0] == TOS_OPEN_CLOSE_OK) {
		return 1;
	} else if (out[0] == TOS_ALREADY_OPEN) {
		pr_info("Toshiba SCI already opened\n");
		return 1;
	} else if (out[0] == TOS_NOT_SUPPORTED) {
		/*
                 * Some BIOSes do not have the SCI open/close functions
                 * implemented and return 0x8000 (Not Supported), failing to
                 * register some supported features.
                 *
                 * Simply return 1 if we hit those affected laptops to make the
                 * supported features work.
                 *
                 * In the case that some laptops really do not support the SCI,
                 * all the SCI dependent functions check for TOS_NOT_SUPPORTED,
                 * and thus, not registering support for the queried feature.
                 */
		return 1;
	} else if (out[0] == TOS_NOT_PRESENT) {
		pr_info("Toshiba SCI is not present\n");
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 135 99.26% 5 83.33%
Darren Hart 1 0.74% 1 16.67%
Total 136 100.00% 6 100.00%



static void sci_close(struct toshiba_acpi_dev *dev)
{
	u32 in[TCI_WORDS] = { SCI_CLOSE, 0, 0, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status = tci_raw(dev, in, out);

	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to close SCI failed\n");
		return;
	}

	if (out[0] == TOS_OPEN_CLOSE_OK)
		return;
	else if (out[0] == TOS_NOT_OPENED)
		pr_info("Toshiba SCI not opened\n");
	else if (out[0] == TOS_NOT_PRESENT)
		pr_info("Toshiba SCI is not present\n");
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 104 100.00% 4 100.00%
Total 104 100.00% 4 100.00%



static u32 sci_read(struct toshiba_acpi_dev *dev, u32 reg, u32 *out1)
{
	u32 in[TCI_WORDS] = { SCI_GET, reg, 0, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status = tci_raw(dev, in, out);

	if (ACPI_FAILURE(status))
		return TOS_FAILURE;

	*out1 = out[2];

	return out[0];
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 80 100.00% 3 100.00%
Total 80 100.00% 3 100.00%



static u32 sci_write(struct toshiba_acpi_dev *dev, u32 reg, u32 in1)
{
	u32 in[TCI_WORDS] = { SCI_SET, reg, in1, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status = tci_raw(dev, in, out);

	return ACPI_SUCCESS(status) ? out[0] : TOS_FAILURE;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 68 100.00% 4 100.00%
Total 68 100.00% 4 100.00%

/* Illumination support */


static void toshiba_illumination_available(struct toshiba_acpi_dev *dev)
{
	u32 in[TCI_WORDS] = { SCI_GET, SCI_ILLUMINATION, 0, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status;

	dev->illumination_supported = 0;
	dev->illumination_led_registered = false;

	if (!sci_open(dev))
		return;

	status = tci_raw(dev, in, out);
	sci_close(dev);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to query Illumination support failed\n");
		return;
	}

	if (out[0] != TOS_SUCCESS)
		return;

	dev->illumination_supported = 1;
}

Contributors
Person Tokens Prop Commits CommitProp
Pierre Ducroquet 53 49.07% 1 16.67%
Azael Avalos 49 45.37% 4 66.67%
Seth Forshee 6 5.56% 1 16.67%
Total 108 100.00% 6 100.00%



static void toshiba_illumination_set(struct led_classdev *cdev,
				     enum led_brightness brightness)
{
	struct toshiba_acpi_dev *dev = container_of(cdev,
			struct toshiba_acpi_dev, led_dev);
	u32 result;
	u32 state;

	/* First request : initialize communication. */
	if (!sci_open(dev))
		return;

	/* Switch the illumination on/off */
	state = brightness ? 1 : 0;
	result = sci_write(dev, SCI_ILLUMINATION, state);
	sci_close(dev);
	if (result == TOS_FAILURE)
		pr_err("ACPI call for illumination failed\n");
}

Contributors
Person Tokens Prop Commits CommitProp
Pierre Ducroquet 38 46.34% 1 16.67%
Azael Avalos 26 31.71% 3 50.00%
Seth Forshee 17 20.73% 1 16.67%
Joe Perches 1 1.22% 1 16.67%
Total 82 100.00% 6 100.00%



static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev)
{
	struct toshiba_acpi_dev *dev = container_of(cdev,
			struct toshiba_acpi_dev, led_dev);
	u32 result;
	u32 state;

	/* First request : initialize communication. */
	if (!sci_open(dev))
		return LED_OFF;

	/* Check the illumination */
	result = sci_read(dev, SCI_ILLUMINATION, &state);
	sci_close(dev);
	if (result == TOS_FAILURE) {
		pr_err("ACPI call for illumination failed\n");
		return LED_OFF;
	} else if (result != TOS_SUCCESS) {
		return LED_OFF;
	}

	return state ? LED_FULL : LED_OFF;
}

Contributors
Person Tokens Prop Commits CommitProp
Pierre Ducroquet 43 43.88% 1 14.29%
Azael Avalos 38 38.78% 5 71.43%
Seth Forshee 17 17.35% 1 14.29%
Total 98 100.00% 7 100.00%

/* KBD Illumination */


static void toshiba_kbd_illum_available(struct toshiba_acpi_dev *dev)
{
	u32 in[TCI_WORDS] = { SCI_GET, SCI_KBD_ILLUM_STATUS, 0, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status;

	dev->kbd_illum_supported = 0;
	dev->kbd_led_registered = false;
	dev->kbd_event_generated = false;

	if (!sci_open(dev))
		return;

	status = tci_raw(dev, in, out);
	sci_close(dev);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to query kbd illumination support failed\n");
		return;
	}

	if (out[0] != TOS_SUCCESS)
		return;

	/*
         * Check for keyboard backlight timeout max value,
         * previous kbd backlight implementation set this to
         * 0x3c0003, and now the new implementation set this
         * to 0x3c001a, use this to distinguish between them.
         */
	if (out[3] == SCI_KBD_TIME_MAX)
		dev->kbd_type = 2;
	else
		dev->kbd_type = 1;
	/* Get the current keyboard backlight mode */
	dev->kbd_mode = out[2] & SCI_KBD_MODE_MASK;
	/* Get the current time (1-60 seconds) */
	dev->kbd_time = out[2] >> HCI_MISC_SHIFT;
	/* Flag as supported */
	dev->kbd_illum_supported = 1;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 162 100.00% 5 100.00%
Total 162 100.00% 5 100.00%



static int toshiba_kbd_illum_status_set(struct toshiba_acpi_dev *dev, u32 time)
{
	u32 result;

	if (!sci_open(dev))
		return -EIO;

	result = sci_write(dev, SCI_KBD_ILLUM_STATUS, time);
	sci_close(dev);
	if (result == TOS_FAILURE)
		pr_err("ACPI call to set KBD backlight status failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return result == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 53 68.83% 4 66.67%
Philip Langdale 17 22.08% 1 16.67%
Seth Forshee 7 9.09% 1 16.67%
Total 77 100.00% 6 100.00%



static int toshiba_kbd_illum_status_get(struct toshiba_acpi_dev *dev, u32 *time)
{
	u32 result;

	if (!sci_open(dev))
		return -EIO;

	result = sci_read(dev, SCI_KBD_ILLUM_STATUS, time);
	sci_close(dev);
	if (result == TOS_FAILURE)
		pr_err("ACPI call to get KBD backlight status failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return result == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 56 71.79% 4 66.67%
Philip Langdale 15 19.23% 1 16.67%
Seth Forshee 7 8.97% 1 16.67%
Total 78 100.00% 6 100.00%



static enum led_brightness toshiba_kbd_backlight_get(struct led_classdev *cdev)
{
	struct toshiba_acpi_dev *dev = container_of(cdev,
			struct toshiba_acpi_dev, kbd_led);
	u32 result;
	u32 state;

	/* Check the keyboard backlight state */
	result = hci_read(dev, HCI_KBD_ILLUMINATION, &state);
	if (result == TOS_FAILURE) {
		pr_err("ACPI call to get the keyboard backlight failed\n");
		return LED_OFF;
	} else if (result != TOS_SUCCESS) {
		return LED_OFF;
	}

	return state ? LED_FULL : LED_OFF;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 50 61.73% 4 57.14%
Philip Langdale 21 25.93% 1 14.29%
Johannes Berg 8 9.88% 1 14.29%
Seth Forshee 2 2.47% 1 14.29%
Total 81 100.00% 7 100.00%



static void toshiba_kbd_backlight_set(struct led_classdev *cdev,
				     enum led_brightness brightness)
{
	struct toshiba_acpi_dev *dev = container_of(cdev,
			struct toshiba_acpi_dev, kbd_led);
	u32 result;
	u32 state;

	/* Set the keyboard backlight state */
	state = brightness ? 1 : 0;
	result = hci_write(dev, HCI_KBD_ILLUMINATION, state);
	if (result == TOS_FAILURE)
		pr_err("ACPI call to set KBD Illumination mode failed\n");
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 38 56.72% 4 57.14%
Philip Langdale 22 32.84% 1 14.29%
Johannes Berg 5 7.46% 1 14.29%
Seth Forshee 2 2.99% 1 14.29%
Total 67 100.00% 7 100.00%

/* TouchPad support */


static int toshiba_touchpad_set(struct toshiba_acpi_dev *dev, u32 state)
{
	u32 result;

	if (!sci_open(dev))
		return -EIO;

	result = sci_write(dev, SCI_TOUCHPAD, state);
	sci_close(dev);
	if (result == TOS_FAILURE)
		pr_err("ACPI call to set the touchpad failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return result == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 77 100.00% 4 100.00%
Total 77 100.00% 4 100.00%



static int toshiba_touchpad_get(struct toshiba_acpi_dev *dev, u32 *state)
{
	u32 result;

	if (!sci_open(dev))
		return -EIO;

	result = sci_read(dev, SCI_TOUCHPAD, state);
	sci_close(dev);
	if (result == TOS_FAILURE)
		pr_err("ACPI call to query the touchpad failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return result == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 78 100.00% 4 100.00%
Total 78 100.00% 4 100.00%

/* Eco Mode support */


static void toshiba_eco_mode_available(struct toshiba_acpi_dev *dev)
{
	u32 in[TCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status;

	dev->eco_supported = 0;
	dev->eco_led_registered = false;

	status = tci_raw(dev, in, out);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to get ECO led failed\n");
		return;
	}

	if (out[0] == TOS_INPUT_DATA_ERROR) {
		/*
                 * If we receive 0x8300 (Input Data Error), it means that the
                 * LED device is present, but that we just screwed the input
                 * parameters.
                 *
                 * Let's query the status of the LED to see if we really have a
                 * success response, indicating the actual presense of the LED,
                 * bail out otherwise.
                 */
		in[3] = 1;
		status = tci_raw(dev, in, out);
		if (ACPI_FAILURE(status)) {
			pr_err("ACPI call to get ECO led failed\n");
			return;
		}

		if (out[0] != TOS_SUCCESS)
			return;

		dev->eco_supported = 1;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 138 99.28% 6 85.71%
Darren Hart 1 0.72% 1 14.29%
Total 139 100.00% 7 100.00%


static enum led_brightness

toshiba_eco_mode_get_status(struct led_classdev *cdev)
{
	struct toshiba_acpi_dev *dev = container_of(cdev,
			struct toshiba_acpi_dev, eco_led);
	u32 in[TCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 1, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status;

	status = tci_raw(dev, in, out);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to get ECO led failed\n");
		return LED_OFF;
	}

	if (out[0] != TOS_SUCCESS)
		return LED_OFF;

	return out[2] ? LED_FULL : LED_OFF;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 106 100.00% 3 100.00%
Total 106 100.00% 3 100.00%



static void toshiba_eco_mode_set_status(struct led_classdev *cdev,
				     enum led_brightness brightness)
{
	struct toshiba_acpi_dev *dev = container_of(cdev,
			struct toshiba_acpi_dev, eco_led);
	u32 in[TCI_WORDS] = { HCI_SET, HCI_ECO_MODE, 0, 1, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status;

	/* Switch the Eco Mode led on/off */
	in[2] = (brightness) ? 1 : 0;
	status = tci_raw(dev, in, out);
	if (ACPI_FAILURE(status))
		pr_err("ACPI call to set ECO led failed\n");
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 96 100.00% 2 100.00%
Total 96 100.00% 2 100.00%

/* Accelerometer support */


static void toshiba_accelerometer_available(struct toshiba_acpi_dev *dev)
{
	u32 in[TCI_WORDS] = { HCI_GET, HCI_ACCELEROMETER2, 0, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status;

	dev->accelerometer_supported = 0;

	/*
         * Check if the accelerometer call exists,
         * this call also serves as initialization
         */
	status = tci_raw(dev, in, out);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to query the accelerometer failed\n");
		return;
	}

	if (out[0] != TOS_SUCCESS)
		return;

	dev->accelerometer_supported = 1;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 88 98.88% 4 80.00%
Darren Hart 1 1.12% 1 20.00%
Total 89 100.00% 5 100.00%



static int toshiba_accelerometer_get(struct toshiba_acpi_dev *dev,
				     u32 *xy, u32 *z)
{
	u32 in[TCI_WORDS] = { HCI_GET, HCI_ACCELEROMETER, 0, 1, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status;

	/* Check the Accelerometer status */
	status = tci_raw(dev, in, out);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to query the accelerometer failed\n");
		return -EIO;
	}

	if (out[0] == TOS_NOT_SUPPORTED)
		return -ENODEV;

	if (out[0] != TOS_SUCCESS)
		return -EIO;

	*xy = out[2];
	*z = out[4];

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 123 100.00% 4 100.00%
Total 123 100.00% 4 100.00%

/* Sleep (Charge and Music) utilities support */


static void toshiba_usb_sleep_charge_available(struct toshiba_acpi_dev *dev)
{
	u32 in[TCI_WORDS] = { SCI_GET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status;

	dev->usb_sleep_charge_supported = 0;

	if (!sci_open(dev))
		return;

	status = tci_raw(dev, in, out);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to get USB Sleep and Charge mode failed\n");
		sci_close(dev);
		return;
	}

	if (out[0] != TOS_SUCCESS) {
		sci_close(dev);
		return;
	}

	dev->usbsc_mode_base = out[4];

	in[5] = SCI_USB_CHARGE_BAT_LVL;
	status = tci_raw(dev, in, out);
	sci_close(dev);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to get USB Sleep and Charge mode failed\n");
		return;
	}

	if (out[0] != TOS_SUCCESS)
		return;

	dev->usbsc_bat_level = out[2];
	/* Flag as supported */
	dev->usb_sleep_charge_supported = 1;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 176 100.00% 3 100.00%
Total 176 100.00% 3 100.00%



static int toshiba_usb_sleep_charge_get(struct toshiba_acpi_dev *dev,
					u32 *mode)
{
	u32 result;

	if (!sci_open(dev))
		return -EIO;

	result = sci_read(dev, SCI_USB_SLEEP_CHARGE, mode);
	sci_close(dev);
	if (result == TOS_FAILURE)
		pr_err("ACPI call to set USB S&C mode failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return result == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 78 100.00% 2 100.00%
Total 78 100.00% 2 100.00%



static int toshiba_usb_sleep_charge_set(struct toshiba_acpi_dev *dev,
					u32 mode)
{
	u32 result;

	if (!sci_open(dev))
		return -EIO;

	result = sci_write(dev, SCI_USB_SLEEP_CHARGE, mode);
	sci_close(dev);
	if (result == TOS_FAILURE)
		pr_err("ACPI call to set USB S&C mode failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return result == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 77 100.00% 2 100.00%
Total 77 100.00% 2 100.00%



static int toshiba_sleep_functions_status_get(struct toshiba_acpi_dev *dev,
					      u32 *mode)
{
	u32 in[TCI_WORDS] = { SCI_GET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status;

	if (!sci_open(dev))
		return -EIO;

	in[5] = SCI_USB_CHARGE_BAT_LVL;
	status = tci_raw(dev, in, out);
	sci_close(dev);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to get USB S&C battery level failed\n");
		return -EIO;
	}

	if (out[0] == TOS_NOT_SUPPORTED)
		return -ENODEV;

	if (out[0] != TOS_SUCCESS)
		return -EIO;

	*mode = out[2];

	return 0;

}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 113 84.33% 5 83.33%
Akio Idehara 21 15.67% 1 16.67%
Total 134 100.00% 6 100.00%



static int toshiba_sleep_functions_status_set(struct toshiba_acpi_dev *dev,
					      u32 mode)
{
	u32 in[TCI_WORDS] = { SCI_SET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status;

	if (!sci_open(dev))
		return -EIO;

	in[2] = mode;
	in[5] = SCI_USB_CHARGE_BAT_LVL;
	status = tci_raw(dev, in, out);
	sci_close(dev);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to set USB S&C battery level failed\n");
		return -EIO;
	}

	if (out[0] == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return out[0] == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 116 89.92% 5 83.33%
Akio Idehara 13 10.08% 1 16.67%
Total 129 100.00% 6 100.00%



static int toshiba_usb_rapid_charge_get(struct toshiba_acpi_dev *dev,
					u32 *state)
{
	u32 in[TCI_WORDS] = { SCI_GET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status;

	if (!sci_open(dev))
		return -EIO;

	in[5] = SCI_USB_CHARGE_RAPID_DSP;
	status = tci_raw(dev, in, out);
	sci_close(dev);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to get USB Rapid Charge failed\n");
		return -EIO;
	}

	if (out[0] == TOS_NOT_SUPPORTED)
		return -ENODEV;

	if (out[0] != TOS_SUCCESS && out[0] != TOS_SUCCESS2)
		return -EIO;

	*state = out[2];

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 141 100.00% 4 100.00%
Total 141 100.00% 4 100.00%



static int toshiba_usb_rapid_charge_set(struct toshiba_acpi_dev *dev,
					u32 state)
{
	u32 in[TCI_WORDS] = { SCI_SET, SCI_USB_SLEEP_CHARGE, 0, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status;

	if (!sci_open(dev))
		return -EIO;

	in[2] = state;
	in[5] = SCI_USB_CHARGE_RAPID_DSP;
	status = tci_raw(dev, in, out);
	sci_close(dev);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to set USB Rapid Charge failed\n");
		return -EIO;
	}

	if (out[0] == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return (out[0] == TOS_SUCCESS || out[0] == TOS_SUCCESS2) ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 132 95.65% 7 87.50%
Akio Idehara 6 4.35% 1 12.50%
Total 138 100.00% 8 100.00%



static int toshiba_usb_sleep_music_get(struct toshiba_acpi_dev *dev, u32 *state)
{
	u32 result;

	if (!sci_open(dev))
		return -EIO;

	result = sci_read(dev, SCI_USB_SLEEP_MUSIC, state);
	sci_close(dev);
	if (result == TOS_FAILURE)
		pr_err("ACPI call to get Sleep and Music failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return result == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 78 100.00% 4 100.00%
Total 78 100.00% 4 100.00%



static int toshiba_usb_sleep_music_set(struct toshiba_acpi_dev *dev, u32 state)
{
	u32 result;

	if (!sci_open(dev))
		return -EIO;

	result = sci_write(dev, SCI_USB_SLEEP_MUSIC, state);
	sci_close(dev);
	if (result == TOS_FAILURE)
		pr_err("ACPI call to set Sleep and Music failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return result == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 77 100.00% 3 100.00%
Total 77 100.00% 3 100.00%

/* Keyboard function keys */


static int toshiba_function_keys_get(struct toshiba_acpi_dev *dev, u32 *mode)
{
	u32 result;

	if (!sci_open(dev))
		return -EIO;

	result = sci_read(dev, SCI_KBD_FUNCTION_KEYS, mode);
	sci_close(dev);
	if (result == TOS_FAILURE)
		pr_err("ACPI call to get KBD function keys failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 84 100.00% 2 100.00%
Total 84 100.00% 2 100.00%



static int toshiba_function_keys_set(struct toshiba_acpi_dev *dev, u32 mode)
{
	u32 result;

	if (!sci_open(dev))
		return -EIO;

	result = sci_write(dev, SCI_KBD_FUNCTION_KEYS, mode);
	sci_close(dev);
	if (result == TOS_FAILURE)
		pr_err("ACPI call to set KBD function keys failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 83 100.00% 2 100.00%
Total 83 100.00% 2 100.00%

/* Panel Power ON */


static int toshiba_panel_power_on_get(struct toshiba_acpi_dev *dev, u32 *state)
{
	u32 result;

	if (!sci_open(dev))
		return -EIO;

	result = sci_read(dev, SCI_PANEL_POWER_ON, state);
	sci_close(dev);
	if (result == TOS_FAILURE)
		pr_err("ACPI call to get Panel Power ON failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return result == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 78 100.00% 2 100.00%
Total 78 100.00% 2 100.00%



static int toshiba_panel_power_on_set(struct toshiba_acpi_dev *dev, u32 state)
{
	u32 result;

	if (!sci_open(dev))
		return -EIO;

	result = sci_write(dev, SCI_PANEL_POWER_ON, state);
	sci_close(dev);
	if (result == TOS_FAILURE)
		pr_err("ACPI call to set Panel Power ON failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return result == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 77 100.00% 2 100.00%
Total 77 100.00% 2 100.00%

/* USB Three */


static int toshiba_usb_three_get(struct toshiba_acpi_dev *dev, u32 *state)
{
	u32 result;

	if (!sci_open(dev))
		return -EIO;

	result = sci_read(dev, SCI_USB_THREE, state);
	sci_close(dev);
	if (result == TOS_FAILURE)
		pr_err("ACPI call to get USB 3 failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 84 100.00% 2 100.00%
Total 84 100.00% 2 100.00%



static int toshiba_usb_three_set(struct toshiba_acpi_dev *dev, u32 state)
{
	u32 result;

	if (!sci_open(dev))
		return -EIO;

	result = sci_write(dev, SCI_USB_THREE, state);
	sci_close(dev);
	if (result == TOS_FAILURE)
		pr_err("ACPI call to set USB 3 failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 81 97.59% 3 75.00%
Seth Forshee 2 2.41% 1 25.00%
Total 83 100.00% 4 100.00%

/* Hotkey Event type */


static int toshiba_hotkey_event_type_get(struct toshiba_acpi_dev *dev,
					 u32 *type)
{
	u32 in[TCI_WORDS] = { HCI_GET, HCI_SYSTEM_INFO, 0x03, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status;

	status = tci_raw(dev, in, out);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to get System type failed\n");
		return -EIO;
	}

	if (out[0] == TOS_NOT_SUPPORTED)
		return -ENODEV;

	if (out[0] != TOS_SUCCESS)
		return -EIO;

	*type = out[3];

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 91 82.73% 5 50.00%
Holger Macht 11 10.00% 1 10.00%
Seth Forshee 3 2.73% 1 10.00%
Alexey Dobriyan 3 2.73% 1 10.00%
Andy Grover 1 0.91% 1 10.00%
Akio Idehara 1 0.91% 1 10.00%
Total 110 100.00% 10 100.00%

/* Wireless status (RFKill, WLAN, BT, WWAN) */


static int toshiba_wireless_status(struct toshiba_acpi_dev *dev)
{
	u32 in[TCI_WORDS] = { HCI_GET, HCI_WIRELESS, 0, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status;

	in[3] = HCI_WIRELESS_STATUS;
	status = tci_raw(dev, in, out);

	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to get Wireless status failed\n");
		return -EIO;
	}

	if (out[0] == TOS_NOT_SUPPORTED)
		return -ENODEV;

	if (out[0] != TOS_SUCCESS)
		return -EIO;

	dev->killswitch = !!(out[2] & HCI_WIRELESS_STATUS);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 120 100.00% 1 100.00%
Total 120 100.00% 1 100.00%

/* WWAN */


static void toshiba_wwan_available(struct toshiba_acpi_dev *dev)
{
	u32 in[TCI_WORDS] = { HCI_GET, HCI_WIRELESS, 0, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status;

	dev->wwan_supported = 0;

	/*
         * WWAN support can be queried by setting the in[3] value to
         * HCI_WIRELESS_WWAN (0x03).
         *
         * If supported, out[0] contains TOS_SUCCESS and out[2] contains
         * HCI_WIRELESS_WWAN_STATUS (0x2000).
         *
         * If not supported, out[0] contains TOS_INPUT_DATA_ERROR (0x8300)
         * or TOS_NOT_SUPPORTED (0x8000).
         */
	in[3] = HCI_WIRELESS_WWAN;
	status = tci_raw(dev, in, out);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to get WWAN status failed\n");
		return;
	}

	if (out[0] != TOS_SUCCESS)
		return;

	dev->wwan_supported = (out[2] == HCI_WIRELESS_WWAN_STATUS);
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 103 100.00% 1 100.00%
Total 103 100.00% 1 100.00%



static int toshiba_wwan_set(struct toshiba_acpi_dev *dev, u32 state)
{
	u32 in[TCI_WORDS] = { HCI_SET, HCI_WIRELESS, state, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status;

	in[3] = HCI_WIRELESS_WWAN_STATUS;
	status = tci_raw(dev, in, out);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to set WWAN status failed\n");
		return -EIO;
	}

	if (out[0] == TOS_NOT_SUPPORTED)
		return -ENODEV;

	if (out[0] != TOS_SUCCESS)
		return -EIO;

	/*
         * Some devices only need to call HCI_WIRELESS_WWAN_STATUS to
         * (de)activate the device, but some others need the
         * HCI_WIRELESS_WWAN_POWER call as well.
         */
	in[3] = HCI_WIRELESS_WWAN_POWER;
	status = tci_raw(dev, in, out);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to set WWAN power failed\n");
		return -EIO;
	}

	if (out[0] == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return out[0] == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 168 100.00% 1 100.00%
Total 168 100.00% 1 100.00%

/* Cooling Method */


static void toshiba_cooling_method_available(struct toshiba_acpi_dev *dev)
{
	u32 in[TCI_WORDS] = { HCI_GET, HCI_COOLING_METHOD, 0, 0, 0, 0 };
	u32 out[TCI_WORDS];
	acpi_status status;

	dev->cooling_method_supported = 0;
	dev->max_cooling_method = 0;

	status = tci_raw(dev, in, out);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to get Cooling Method failed\n");
		return;
	}

	if (out[0] != TOS_SUCCESS && out[0] != TOS_SUCCESS2)
		return;

	dev->cooling_method_supported = 1;
	dev->max_cooling_method = out[3];
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 110 100.00% 2 100.00%
Total 110 100.00% 2 100.00%



static int toshiba_cooling_method_get(struct toshiba_acpi_dev *dev, u32 *state)
{
	u32 result = hci_read(dev, HCI_COOLING_METHOD, state);

	if (result == TOS_FAILURE)
		pr_err("ACPI call to get Cooling Method failed\n");

	if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 64 100.00% 1 100.00%
Total 64 100.00% 1 100.00%



static int toshiba_cooling_method_set(struct toshiba_acpi_dev *dev, u32 state)
{
	u32 result = hci_write(dev, HCI_COOLING_METHOD, state);

	if (result == TOS_FAILURE)
		pr_err("ACPI call to set Cooling Method failed\n");

	if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return (result == TOS_SUCCESS || result == TOS_SUCCESS2) ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 63 100.00% 2 100.00%
Total 63 100.00% 2 100.00%

/* Transflective Backlight */


static int get_tr_backlight_status(struct toshiba_acpi_dev *dev, u32 *status)
{
	u32 result = hci_read(dev, HCI_TR_BACKLIGHT, status);

	if (result == TOS_FAILURE)
		pr_err("ACPI call to get Transflective Backlight failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return result == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 44 74.58% 5 71.43%
Alexey Dobriyan 13 22.03% 1 14.29%
Andy Grover 2 3.39% 1 14.29%
Total 59 100.00% 7 100.00%



static int set_tr_backlight_status(struct toshiba_acpi_dev *dev, u32 status)
{
	u32 result = hci_write(dev, HCI_TR_BACKLIGHT, !status);

	if (result == TOS_FAILURE)
		pr_err("ACPI call to set Transflective Backlight failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return result == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 48 81.36% 5 71.43%
Holger Macht 6 10.17% 1 14.29%
Seth Forshee 5 8.47% 1 14.29%
Total 59 100.00% 7 100.00%


static struct proc_dir_entry *toshiba_proc_dir;

/* LCD Brightness */


static int __get_lcd_brightness(struct toshiba_acpi_dev *dev)
{
	int brightness = 0;
	u32 result;
	u32 value;

	if (dev->tr_backlight_supported) {
		int ret = get_tr_backlight_status(dev, &value);

		if (ret)
			return ret;
		if (value)
			return 0;
		brightness++;
	}

	result = hci_read(dev, HCI_LCD_BRIGHTNESS, &value);
	if (result == TOS_FAILURE)
		pr_err("ACPI call to get LCD Brightness failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return result == TOS_SUCCESS ?
			brightness + (value >> HCI_LCD_BRIGHTNESS_SHIFT) :
			-EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 71 65.74% 8 66.67%
Akio Idehara 24 22.22% 1 8.33%
Holger Macht 8 7.41% 1 8.33%
Seth Forshee 5 4.63% 2 16.67%
Total 108 100.00% 12 100.00%



static int get_lcd_brightness(struct backlight_device *bd)
{
	struct toshiba_acpi_dev *dev = bl_get_data(bd);

	return __get_lcd_brightness(dev);
}

Contributors
Person Tokens Prop Commits CommitProp
Holger Macht 14 51.85% 1 33.33%
Seth Forshee 11 40.74% 1 33.33%
Azael Avalos 2 7.41% 1 33.33%
Total 27 100.00% 3 100.00%



static int lcd_proc_show(struct seq_file *m, void *v)
{
	struct toshiba_acpi_dev *dev = m->private;
	int levels;
	int value;

	if (!dev->backlight_dev)
		return -ENODEV;

	levels = dev->backlight_dev->props.max_brightness + 1;
	value = get_lcd_brightness(dev->backlight_dev);
	if (value < 0) {
		pr_err("Error reading LCD brightness\n");
		return value;
	}

	seq_printf(m, "brightness:              %d\n", value);
	seq_printf(m, "brightness_levels:       %d\n", levels);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 55 55.56% 3 37.50%
Alexey Dobriyan 16 16.16% 1 12.50%
Andy Grover 12 12.12% 1 12.50%
Akio Idehara 10 10.10% 1 12.50%
Seth Forshee 5 5.05% 1 12.50%
Holger Macht 1 1.01% 1 12.50%
Total 99 100.00% 8 100.00%



static int lcd_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, lcd_proc_show, PDE_DATA(inode));
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 26 89.66% 1 50.00%
Alexey Dobriyan 3 10.34% 1 50.00%
Total 29 100.00% 2 100.00%



static int set_lcd_brightness(struct toshiba_acpi_dev *dev, int value)
{
	u32 result;

	if (dev->tr_backlight_supported) {
		int ret = set_tr_backlight_status(dev, !value);

		if (ret)
			return ret;
		if (value)
			value--;
	}

	value = value << HCI_LCD_BRIGHTNESS_SHIFT;
	result = hci_write(dev, HCI_LCD_BRIGHTNESS, value);
	if (result == TOS_FAILURE)
		pr_err("ACPI call to set LCD Brightness failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return result == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 71 71.72% 7 87.50%
Seth Forshee 28 28.28% 1 12.50%
Total 99 100.00% 8 100.00%



static int set_lcd_status(struct backlight_device *bd)
{
	struct toshiba_acpi_dev *dev = bl_get_data(bd);

	return set_lcd_brightness(dev, bd->props.brightness);
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 28 84.85% 1 25.00%
Alexey Dobriyan 3 9.09% 1 25.00%
Andy Grover 2 6.06% 2 50.00%
Total 33 100.00% 4 100.00%



static ssize_t lcd_proc_write(struct file *file, const char __user *buf,
			      size_t count, loff_t *pos)
{
	struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file));
	char cmd[42];
	size_t len;
	int levels;
	int value;

	len = min(count, sizeof(cmd) - 1);
	if (copy_from_user(cmd, buf, len))
		return -EFAULT;
	cmd[len] = '\0';

	levels = dev->backlight_dev->props.max_brightness + 1;
	if (sscanf(cmd, " brightness : %i", &value) != 1 &&
	    value < 0 && value > levels)
		return -EINVAL;

	if (set_lcd_brightness(dev, value))
		return -EIO;

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 125 88.03% 3 42.86%
Andy Grover 8 5.63% 1 14.29%
Seth Forshee 8 5.63% 2 28.57%
Alexey Dobriyan 1 0.70% 1 14.29%
Total 142 100.00% 7 100.00%


static const struct file_operations lcd_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= lcd_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= lcd_proc_write,
};

/* Video-Out */


static int get_video_status(struct toshiba_acpi_dev *dev, u32 *status)
{
	u32 result = hci_read(dev, HCI_VIDEO_OUT, status);

	if (result == TOS_FAILURE)
		pr_err("ACPI call to get Video-Out failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return result == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 59 100.00% 4 100.00%
Total 59 100.00% 4 100.00%



static int video_proc_show(struct seq_file *m, void *v)
{
	struct toshiba_acpi_dev *dev = m->private;
	int is_lcd, is_crt, is_tv;
	u32 value;

	if (get_video_status(dev, &value))
		return -EIO;

	is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0;
	is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0;
	is_tv = (value & HCI_VIDEO_OUT_TV) ? 1 : 0;

	seq_printf(m, "lcd_out:                 %d\n", is_lcd);
	seq_printf(m, "crt_out:                 %d\n", is_crt);
	seq_printf(m, "tv_out:                  %d\n", is_tv);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 56 49.12% 3 42.86%
Andy Grover 52 45.61% 3 42.86%
Alexey Dobriyan 6 5.26% 1 14.29%
Total 114 100.00% 7 100.00%



static int video_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, video_proc_show, PDE_DATA(inode));
}

Contributors
Person Tokens Prop Commits CommitProp
Alexey Dobriyan 24 82.76% 1 25.00%
Seth Forshee 3 10.34% 1 25.00%
Al Viro 1 3.45% 1 25.00%
Andy Grover 1 3.45% 1 25.00%
Total 29 100.00% 4 100.00%



static ssize_t video_proc_write(struct file *file, const char __user *buf,
				size_t count, loff_t *pos)
{
	struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file));
	char *buffer;
	char *cmd;
	int lcd_out, crt_out, tv_out;
	int remain = count;
	int value;
	int ret;
	u32 video_out;

	cmd = kmalloc(count + 1, GFP_KERNEL);
	if (!cmd)
		return -ENOMEM;
	if (copy_from_user(cmd, buf, count)) {
		kfree(cmd);
		return -EFAULT;
	}
	cmd[count] = '\0';

	buffer = cmd;

	/*
         * Scan expression.  Multiple expressions may be delimited with ;
         * NOTE: To keep scanning simple, invalid fields are ignored.
         */
	while (remain) {
		if (sscanf(buffer, " lcd_out : %i", &value) == 1)
			lcd_out = value & 1;
		else if (sscanf(buffer, " crt_out : %i", &value) == 1)
			crt_out = value & 1;
		else if (sscanf(buffer, " tv_out : %i", &value) == 1)
			tv_out = value & 1;
		/* Advance to one character past the next ; */
		do {
			++buffer;
			--remain;
		} while (remain && *(buffer - 1) != ';');
	}

	kfree(cmd);

	lcd_out = crt_out = tv_out = -1;
	ret = get_video_status(dev, &video_out);
	if (!ret) {
		unsigned int new_video_out = video_out;

		if (lcd_out != -1)
			_set_bit(&new_video_out, HCI_VIDEO_OUT_LCD, lcd_out);
		if (crt_out != -1)
			_set_bit(&new_video_out, HCI_VIDEO_OUT_CRT, crt_out);
		if (tv_out != -1)
			_set_bit(&new_video_out, HCI_VIDEO_OUT_TV, tv_out);
		/*
                 * To avoid unnecessary video disruption, only write the new
                 * video setting if something changed.
                 */
		if (new_video_out != video_out)
			ret = write_acpi_int(METHOD_VIDEO_OUT, new_video_out);
	}

	return ret ? -EIO : count;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Grover 179 55.25% 2 13.33%
Alexey Dobriyan 77 23.77% 1 6.67%
Azael Avalos 26 8.02% 3 20.00%
Seth Forshee 21 6.48% 3 20.00%
John Belmonte 11 3.40% 1 6.67%
Al Viro 4 1.23% 2 13.33%
Len Brown 3 0.93% 1 6.67%
Darren Hart 2 0.62% 1 6.67%
Harvey Harrison 1 0.31% 1 6.67%
Total 324 100.00% 15 100.00%


static const struct file_operations video_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= video_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= video_proc_write,
};

/* Fan status */


static int get_fan_status(struct toshiba_acpi_dev *dev, u32 *status)
{
	u32 result = hci_read(dev, HCI_FAN, status);

	if (result == TOS_FAILURE)
		pr_err("ACPI call to get Fan status failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return result == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 33 55.93% 4 80.00%
Seth Forshee 26 44.07% 1 20.00%
Total 59 100.00% 5 100.00%



static int set_fan_status(struct toshiba_acpi_dev *dev, u32 status)
{
	u32 result = hci_write(dev, HCI_FAN, status);

	if (result == TOS_FAILURE)
		pr_err("ACPI call to set Fan status failed\n");
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return result == TOS_SUCCESS ? 0 : -EIO;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 54 93.10% 2 66.67%
Seth Forshee 4 6.90% 1 33.33%
Total 58 100.00% 3 100.00%



static int fan_proc_show(struct seq_file *m, void *v)
{
	struct toshiba_acpi_dev *dev = m->private;
	u32 value;

	if (get_fan_status(dev, &value))
		return -EIO;

	seq_printf(m, "running:                 %d\n", (value > 0));
	seq_printf(m, "force_on:                %d\n", dev->force_fan);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Grover 31 45.59% 2 28.57%
Seth Forshee 17 25.00% 3 42.86%
Alexey Dobriyan 13 19.12% 1 14.29%
Azael Avalos 7 10.29% 1 14.29%
Total 68 100.00% 7 100.00%



static int fan_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, fan_proc_show, PDE_DATA(inode));
}

Contributors
Person Tokens Prop Commits CommitProp
Alexey Dobriyan 24 82.76% 1 25.00%
Seth Forshee 3 10.34% 1 25.00%
Andy Grover 1 3.45% 1 25.00%
Al Viro 1 3.45% 1 25.00%
Total 29 100.00% 4 100.00%



static ssize_t fan_proc_write(struct file *file, const char __user *buf,
			      size_t count, loff_t *pos)
{
	struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file));
	char cmd[42];
	size_t len;
	int value;

	len = min(count, sizeof(cmd) - 1);
	if (copy_from_user(cmd, buf, len))
		return -EFAULT;
	cmd[len] = '\0';

	if (sscanf(cmd, " force_on : %i", &value) != 1 &&
	    value != 0 && value != 1)
		return -EINVAL;

	if (set_fan_status(dev, value))
		return -EIO;

	dev->force_fan = value;

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
Alexey Dobriyan 67 50.38% 1 16.67%
Andy Grover 35 26.32% 1 16.67%
Azael Avalos 14 10.53% 1 16.67%
Seth Forshee 13 9.77% 1 16.67%
Al Viro 4 3.01% 2 33.33%
Total 133 100.00% 6 100.00%


static const struct file_operations fan_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= fan_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= fan_proc_write,
};



static int keys_proc_show(struct seq_file *m, void *v)
{
	struct toshiba_acpi_dev *dev = m->private;

	seq_printf(m, "hotkey_ready:            %d\n", dev->key_event_valid);
	seq_printf(m, "hotkey:                  0x%04x\n", dev->last_key_event);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Grover 20 40.82% 3 50.00%
Alexey Dobriyan 14 28.57% 1 16.67%
Seth Forshee 13 26.53% 1 16.67%
Aristeu Sergio Rozanski Filho 2 4.08% 1 16.67%
Total 49 100.00% 6 100.00%



static int keys_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, keys_proc_show, PDE_DATA(inode));
}

Contributors
Person Tokens Prop Commits CommitProp
Alexey Dobriyan 24 82.76% 1 25.00%
Seth Forshee 3 10.34% 1 25.00%
Aristeu Sergio Rozanski Filho 1 3.45% 1 25.00%
Al Viro 1 3.45% 1 25.00%
Total 29 100.00% 4 100.00%



static ssize_t keys_proc_write(struct file *file, const char __user *buf,
			       size_t count, loff_t *pos)
{
	struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file));
	char cmd[42];
	size_t len;
	int value;

	len = min(count, sizeof(cmd) - 1);
	if (copy_from_user(cmd, buf, len))
		return -EFAULT;
	cmd[len] = '\0';

	if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0)
		dev->key_event_valid = 0;
	else
		return -EINVAL;

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
Alexey Dobriyan 61 52.14% 1 12.50%
Andy Grover 37 31.62% 2 25.00%
Seth Forshee 11 9.40% 1 12.50%
Al Viro 4 3.42% 2 25.00%
Aristeu Sergio Rozanski Filho 3 2.56% 1 12.50%
Len Brown 1 0.85% 1 12.50%
Total 117 100.00% 8 100.00%


static const struct file_operations keys_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= keys_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= keys_proc_write,
};



static int version_proc_show(struct seq_file *m, void *v)
{
	seq_printf(m, "driver:                  %s\n", TOSHIBA_ACPI_VERSION);
	seq_printf(m, "proc_interface:          %d\n", PROC_INTERFACE_VERSION);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Andy Grover 22 61.11% 2 66.67%
Alexey Dobriyan 14 38.89% 1 33.33%
Total 36 100.00% 3 100.00%



static int version_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, version_proc_show, PDE_DATA(inode));
}

Contributors
Person Tokens Prop Commits CommitProp
Alexey Dobriyan 25 86.21% 1 25.00%
Andy Grover 2 6.90% 1 25.00%
Al Viro 1 3.45% 1 25.00%
Len Brown 1 3.45% 1 25.00%
Total 29 100.00% 4 100.00%


static const struct file_operations version_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= version_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

/*
 * Proc and module init
 */


#define PROC_TOSHIBA		"toshiba"



static void create_toshiba_proc_entries(struct toshiba_acpi_dev *dev)
{
	if (dev->backlight_dev)
		proc_create_data("lcd", S_IRUGO | S_IWUSR, toshiba_proc_dir,
				 &lcd_proc_fops, dev);
	if (dev->video_supported)
		proc_create_data("video", S_IRUGO | S_IWUSR, toshiba_proc_dir,
				 &video_proc_fops, dev);
	if (dev->fan_supported)
		proc_create_data("fan", S_IRUGO | S_IWUSR, toshiba_proc_dir,
				 &fan_proc_fops, dev);
	if (dev->hotkey_dev)
		proc_create_data("keys", S_IRUGO | S_IWUSR, toshiba_proc_dir,
				 &keys_proc_fops, dev);
	proc_create_data("version", S_IRUGO, toshiba_proc_dir,
			 &version_proc_fops, dev);
}

Contributors
Person Tokens Prop Commits CommitProp
Alexey Dobriyan 50 44.25% 1 12.50%
Seth Forshee 43 38.05% 2 25.00%
Andy Grover 17 15.04% 2 25.00%
Axel Lin 2 1.77% 2 25.00%
Aristeu Sergio Rozanski Filho 1 0.88% 1 12.50%
Total 113 100.00% 8 100.00%



static void remove_toshiba_proc_entries(struct toshiba_acpi_dev *dev)
{
	if (dev->backlight_dev)
		remove_proc_entry("lcd", toshiba_proc_dir);
	if (dev->video_supported)
		remove_proc_entry("video", toshiba_proc_dir);
	if (dev->fan_supported)
		remove_proc_entry("fan", toshiba_proc_dir);
	if (dev->hotkey_dev)
		remove_proc_entry("keys", toshiba_proc_dir);
	remove_proc_entry("version", toshiba_proc_dir);
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 44 62.86% 1 16.67%
Seth Forshee 13 18.57% 1 16.67%
Andy Grover 6 8.57% 1 16.67%
Alexey Dobriyan 5 7.14% 1 16.67%
Axel Lin 2 2.86% 2 33.33%
Total 70 100.00% 6 100.00%


static const struct backlight_ops toshiba_backlight_data = {
	.options = BL_CORE_SUSPENDRESUME,
	.get_brightness = get_lcd_brightness,
	.update_status  = set_lcd_status,
};

/* Keyboard backlight work */
static void toshiba_acpi_kbd_bl_work(struct work_struct *work);

static DECLARE_WORK(kbd_bl_work, toshiba_acpi_kbd_bl_work);

/*
 * Sysfs files
 */


static ssize_t version_show(struct device *dev,
			    struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "%s\n", TOSHIBA_ACPI_VERSION);
}
Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 30 100.00% 2 100.00%
Total 30 100.00% 2 100.00%

static DEVICE_ATTR_RO(version);



static ssize_t fan_store(struct device *dev,
			 struct device_attribute *attr,
			 const char *buf, size_t count)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	int state;
	int ret;

	ret = kstrtoint(buf, 0, &state);
	if (ret)
		return ret;

	if (state != 0 && state != 1)
		return -EINVAL;

	ret = set_fan_status(toshiba, state);
	if (ret)
		return ret;

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 92 100.00% 3 100.00%
Total 92 100.00% 3 100.00%



static ssize_t fan_show(struct device *dev,
			struct device_attribute *attr, char *buf)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	u32 value;
	int ret;

	ret = get_fan_status(toshiba, &value);
	if (ret)
		return ret;

	return sprintf(buf, "%d\n", value);
}
Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 63 100.00% 2 100.00%
Total 63 100.00% 2 100.00%

static DEVICE_ATTR_RW(fan);



static ssize_t kbd_backlight_mode_store(struct device *dev,
					struct device_attribute *attr,
					const char *buf, size_t count)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	int mode;
	int ret;


	ret = kstrtoint(buf, 0, &mode);
	if (ret)
		return ret;

	/* Check for supported modes depending on keyboard backlight type */
	if (toshiba->kbd_type == 1) {
		/* Type 1 supports SCI_KBD_MODE_FNZ and SCI_KBD_MODE_AUTO */
		if (mode != SCI_KBD_MODE_FNZ && mode != SCI_KBD_MODE_AUTO)
			return -EINVAL;
	} else if (toshiba->kbd_type == 2) {
		/* Type 2 doesn't support SCI_KBD_MODE_FNZ */
		if (mode != SCI_KBD_MODE_AUTO && mode != SCI_KBD_MODE_ON &&
		    mode != SCI_KBD_MODE_OFF)
			return -EINVAL;
	}

	/*
         * Set the Keyboard Backlight Mode where:
         *      Auto - KBD backlight turns off automatically in given time
         *      FN-Z - KBD backlight "toggles" when hotkey pressed
         *      ON   - KBD backlight is always on
         *      OFF  - KBD backlight is always off
         */

	/* Only make a change if the actual mode has changed */
	if (toshiba->kbd_mode != mode) {
		/* Shift the time to "base time" (0x3c0000 == 60 seconds) */
		int time = toshiba->kbd_time << HCI_MISC_SHIFT;

		/* OR the "base time" to the actual method format */
		if (toshiba->kbd_type == 1) {
			/* Type 1 requires the current mode */
			time |= toshiba->kbd_mode;
		} else if (toshiba->kbd_type == 2) {
			/* Type 2 requires the desired mode */
			time |= mode;
		}

		ret = toshiba_kbd_illum_status_set(toshiba, time);
		if (ret)
			return ret;

		toshiba->kbd_mode = mode;

		/*
                 * Some laptop models with the second generation backlit
                 * keyboard (type 2) do not generate the keyboard backlight
                 * changed event (0x92), and thus, the driver will never update
                 * the sysfs entries.
                 *
                 * The event is generated right when changing the keyboard
                 * backlight mode and the *notify function will set the
                 * kbd_event_generated to true.
                 *
                 * In case the event is not generated, schedule the keyboard
                 * backlight work to update the sysfs entries and emulate the
                 * event via genetlink.
                 */
		if (toshiba->kbd_type == 2 &&
		    !toshiba_acpi->kbd_event_generated)
			schedule_work(&kbd_bl_work);
	}

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 208 96.30% 5 71.43%
Dan Carpenter 7 3.24% 1 14.29%
Darren Hart 1 0.46% 1 14.29%
Total 216 100.00% 7 100.00%



static ssize_t kbd_backlight_mode_show(struct device *dev,
				       struct device_attribute *attr,
				       char *buf)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	u32 time;

	if (toshiba_kbd_illum_status_get(toshiba, &time) < 0)
		return -EIO;

	return sprintf(buf, "%i\n", time & SCI_KBD_MODE_MASK);
}
Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 61 100.00% 3 100.00%
Total 61 100.00% 3 100.00%

static DEVICE_ATTR_RW(kbd_backlight_mode);



static ssize_t kbd_type_show(struct device *dev,
			     struct device_attribute *attr, char *buf)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);

	return sprintf(buf, "%d\n", toshiba->kbd_type);
}
Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 42 100.00% 2 100.00%
Total 42 100.00% 2 100.00%

static DEVICE_ATTR_RO(kbd_type);



static ssize_t available_kbd_modes_show(struct device *dev,
					struct device_attribute *attr,
					char *buf)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);

	if (toshiba->kbd_type == 1)
		return sprintf(buf, "0x%x 0x%x\n",
			       SCI_KBD_MODE_FNZ, SCI_KBD_MODE_AUTO);

	return sprintf(buf, "0x%x 0x%x 0x%x\n",
		       SCI_KBD_MODE_AUTO, SCI_KBD_MODE_ON, SCI_KBD_MODE_OFF);
}
Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 64 100.00% 4 100.00%
Total 64 100.00% 4 100.00%

static DEVICE_ATTR_RO(available_kbd_modes);



static ssize_t kbd_backlight_timeout_store(struct device *dev,
					   struct device_attribute *attr,
					   const char *buf, size_t count)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	int time;
	int ret;

	ret = kstrtoint(buf, 0, &time);
	if (ret)
		return ret;

	/* Check for supported values depending on kbd_type */
	if (toshiba->kbd_type == 1) {
		if (time < 0 || time > 60)
			return -EINVAL;
	} else if (toshiba->kbd_type == 2) {
		if (time < 1 || time > 60)
			return -EINVAL;
	}

	/* Set the Keyboard Backlight Timeout */

	/* Only make a change if the actual timeout has changed */
	if (toshiba->kbd_time != time) {
		/* Shift the time to "base time" (0x3c0000 == 60 seconds) */
		time = time << HCI_MISC_SHIFT;
		/* OR the "base time" to the actual method format */
		if (toshiba->kbd_type == 1)
			time |= SCI_KBD_MODE_FNZ;
		else if (toshiba->kbd_type == 2)
			time |= SCI_KBD_MODE_AUTO;

		ret = toshiba_kbd_illum_status_set(toshiba, time);
		if (ret)
			return ret;

		toshiba->kbd_time = time >> HCI_MISC_SHIFT;
	}

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 181 100.00% 3 100.00%
Total 181 100.00% 3 100.00%



static ssize_t kbd_backlight_timeout_show(struct device *dev,
					  struct device_attribute *attr,
					  char *buf)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	u32 time;

	if (toshiba_kbd_illum_status_get(toshiba, &time) < 0)
		return -EIO;

	return sprintf(buf, "%i\n", time >> HCI_MISC_SHIFT);
}
Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 61 100.00% 2 100.00%
Total 61 100.00% 2 100.00%

static DEVICE_ATTR_RW(kbd_backlight_timeout);



static ssize_t touchpad_store(struct device *dev,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	int state;
	int ret;

	/* Set the TouchPad on/off, 0 - Disable | 1 - Enable */
	ret = kstrtoint(buf, 0, &state);
	if (ret)
		return ret;
	if (state != 0 && state != 1)
		return -EINVAL;

	ret = toshiba_touchpad_set(toshiba, state);
	if (ret)
		return ret;

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 93 100.00% 3 100.00%
Total 93 100.00% 3 100.00%



static ssize_t touchpad_show(struct device *dev,
			     struct device_attribute *attr, char *buf)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	u32 state;
	int ret;

	ret = toshiba_touchpad_get(toshiba, &state);
	if (ret < 0)
		return ret;

	return sprintf(buf, "%i\n", state);
}
Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 65 100.00% 2 100.00%
Total 65 100.00% 2 100.00%

static DEVICE_ATTR_RW(touchpad);



static ssize_t usb_sleep_charge_show(struct device *dev,
				     struct device_attribute *attr, char *buf)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	u32 mode;
	int ret;

	ret = toshiba_usb_sleep_charge_get(toshiba, &mode);
	if (ret < 0)
		return ret;

	return sprintf(buf, "%x\n", mode & SCI_USB_CHARGE_MODE_MASK);
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 67 100.00% 2 100.00%
Total 67 100.00% 2 100.00%



static ssize_t usb_sleep_charge_store(struct device *dev,
				      struct device_attribute *attr,
				      const char *buf, size_t count)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	int state;
	u32 mode;
	int ret;

	ret = kstrtoint(buf, 0, &state);
	if (ret)
		return ret;
	/*
         * Check for supported values, where:
         * 0 - Disabled
         * 1 - Alternate (Non USB conformant devices that require more power)
         * 2 - Auto (USB conformant devices)
         * 3 - Typical
         */
	if (state != 0 && state != 1 && state != 2 && state != 3)
		return -EINVAL;

	/* Set the USB charging mode to internal value */
	mode = toshiba->usbsc_mode_base;
	if (state == 0)
		mode |= SCI_USB_CHARGE_DISABLED;
	else if (state == 1)
		mode |= SCI_USB_CHARGE_ALTERNATE;
	else if (state == 2)
		mode |= SCI_USB_CHARGE_AUTO;
	else if (state == 3)
		mode |= SCI_USB_CHARGE_TYPICAL;

	ret = toshiba_usb_sleep_charge_set(toshiba, mode);
	if (ret)
		return ret;

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 154 100.00% 4 100.00%
Total 154 100.00% 4 100.00%

static DEVICE_ATTR_RW(usb_sleep_charge);



static ssize_t sleep_functions_on_battery_show(struct device *dev,
					       struct device_attribute *attr,
					       char *buf)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	int bat_lvl, status;
	u32 state;
	int ret;
	int tmp;

	ret = toshiba_sleep_functions_status_get(toshiba, &state);
	if (ret < 0)
		return ret;

	/* Determine the status: 0x4 - Enabled | 0x1 - Disabled */
	tmp = state & SCI_USB_CHARGE_BAT_MASK;
	status = (tmp == 0x4) ? 1 : 0;
	/* Determine the battery level set */
	bat_lvl = state >> HCI_MISC_SHIFT;

	return sprintf(buf, "%d %d\n", status, bat_lvl);
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 101 100.00% 2 100.00%
Total 101 100.00% 2 100.00%



static ssize_t sleep_functions_on_battery_store(struct device *dev,
						struct device_attribute *attr,
						const char *buf, size_t count)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	u32 status;
	int value;
	int ret;
	int tmp;

	ret = kstrtoint(buf, 0, &value);
	if (ret)
		return ret;

	/*
         * Set the status of the function:
         * 0 - Disabled
         * 1-100 - Enabled
         */
	if (value < 0 || value > 100)
		return -EINVAL;

	if (value == 0) {
		tmp = toshiba->usbsc_bat_level << HCI_MISC_SHIFT;
		status = tmp | SCI_USB_CHARGE_BAT_LVL_OFF;
	} else {
		tmp = value << HCI_MISC_SHIFT;
		status = tmp | SCI_USB_CHARGE_BAT_LVL_ON;
	}
	ret = toshiba_sleep_functions_status_set(toshiba, status);
	if (ret < 0)
		return ret;

	toshiba->usbsc_bat_level = status >> HCI_MISC_SHIFT;

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 145 99.32% 1 50.00%
Darren Hart 1 0.68% 1 50.00%
Total 146 100.00% 2 100.00%

static DEVICE_ATTR_RW(sleep_functions_on_battery);



static ssize_t usb_rapid_charge_show(struct device *dev,
				     struct device_attribute *attr, char *buf)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	u32 state;
	int ret;

	ret = toshiba_usb_rapid_charge_get(toshiba, &state);
	if (ret < 0)
		return ret;

	return sprintf(buf, "%d\n", state);
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 65 100.00% 2 100.00%
Total 65 100.00% 2 100.00%



static ssize_t usb_rapid_charge_store(struct device *dev,
				      struct device_attribute *attr,
				      const char *buf, size_t count)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	int state;
	int ret;

	ret = kstrtoint(buf, 0, &state);
	if (ret)
		return ret;
	if (state != 0 && state != 1)
		return -EINVAL;

	ret = toshiba_usb_rapid_charge_set(toshiba, state);
	if (ret)
		return ret;

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 92 100.00% 2 100.00%
Total 92 100.00% 2 100.00%

static DEVICE_ATTR_RW(usb_rapid_charge);



static ssize_t usb_sleep_music_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	u32 state;
	int ret;

	ret = toshiba_usb_sleep_music_get(toshiba, &state);
	if (ret < 0)
		return ret;

	return sprintf(buf, "%d\n", state);
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 65 100.00% 2 100.00%
Total 65 100.00% 2 100.00%



static ssize_t usb_sleep_music_store(struct device *dev,
				     struct device_attribute *attr,
				     const char *buf, size_t count)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	int state;
	int ret;

	ret = kstrtoint(buf, 0, &state);
	if (ret)
		return ret;
	if (state != 0 && state != 1)
		return -EINVAL;

	ret = toshiba_usb_sleep_music_set(toshiba, state);
	if (ret)
		return ret;

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 92 100.00% 2 100.00%
Total 92 100.00% 2 100.00%

static DEVICE_ATTR_RW(usb_sleep_music);



static ssize_t kbd_function_keys_show(struct device *dev,
				      struct device_attribute *attr, char *buf)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	int mode;
	int ret;

	ret = toshiba_function_keys_get(toshiba, &mode);
	if (ret < 0)
		return ret;

	return sprintf(buf, "%d\n", mode);
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 65 100.00% 2 100.00%
Total 65 100.00% 2 100.00%



static ssize_t kbd_function_keys_store(struct device *dev,
				       struct device_attribute *attr,
				       const char *buf, size_t count)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	int mode;
	int ret;

	ret = kstrtoint(buf, 0, &mode);
	if (ret)
		return ret;
	/*
         * Check for the function keys mode where:
         * 0 - Normal operation (F{1-12} as usual and hotkeys via FN-F{1-12})
         * 1 - Special functions (Opposite of the above setting)
         */
	if (mode != 0 && mode != 1)
		return -EINVAL;

	ret = toshiba_function_keys_set(toshiba, mode);
	if (ret)
		return ret;

	pr_info("Reboot for changes to KBD Function Keys to take effect");

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 97 98.98% 2 66.67%
Darren Hart 1 1.02% 1 33.33%
Total 98 100.00% 3 100.00%

static DEVICE_ATTR_RW(kbd_function_keys);



static ssize_t panel_power_on_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	u32 state;
	int ret;

	ret = toshiba_panel_power_on_get(toshiba, &state);
	if (ret < 0)
		return ret;

	return sprintf(buf, "%d\n", state);
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 65 100.00% 3 100.00%
Total 65 100.00% 3 100.00%



static ssize_t panel_power_on_store(struct device *dev,
				    struct device_attribute *attr,
				    const char *buf, size_t count)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	int state;
	int ret;

	ret = kstrtoint(buf, 0, &state);
	if (ret)
		return ret;
	if (state != 0 && state != 1)
		return -EINVAL;

	ret = toshiba_panel_power_on_set(toshiba, state);
	if (ret)
		return ret;

	pr_info("Reboot for changes to Panel Power ON to take effect");

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 97 100.00% 3 100.00%
Total 97 100.00% 3 100.00%

static DEVICE_ATTR_RW(panel_power_on);



static ssize_t usb_three_show(struct device *dev,
			      struct device_attribute *attr, char *buf)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	u32 state;
	int ret;

	ret = toshiba_usb_three_get(toshiba, &state);
	if (ret < 0)
		return ret;

	return sprintf(buf, "%d\n", state);
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 65 100.00% 3 100.00%
Total 65 100.00% 3 100.00%



static ssize_t usb_three_store(struct device *dev,
			       struct device_attribute *attr,
			       const char *buf, size_t count)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	int state;
	int ret;

	ret = kstrtoint(buf, 0, &state);
	if (ret)
		return ret;
	/*
         * Check for USB 3 mode where:
         * 0 - Disabled (Acts like a USB 2 port, saving power)
         * 1 - Enabled
         */
	if (state != 0 && state != 1)
		return -EINVAL;

	ret = toshiba_usb_three_set(toshiba, state);
	if (ret)
		return ret;

	pr_info("Reboot for changes to USB 3 to take effect");

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 97 98.98% 3 75.00%
Darren Hart 1 1.02% 1 25.00%
Total 98 100.00% 4 100.00%

static DEVICE_ATTR_RW(usb_three);



static ssize_t cooling_method_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	int state;
	int ret;

	ret = toshiba_cooling_method_get(toshiba, &state);
	if (ret < 0)
		return ret;

	return sprintf(buf, "%d %d\n", state, toshiba->max_cooling_method);
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 69 100.00% 1 100.00%
Total 69 100.00% 1 100.00%



static ssize_t cooling_method_store(struct device *dev,
				    struct device_attribute *attr,
				    const char *buf, size_t count)
{
	struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
	int state;
	int ret;

	ret = kstrtoint(buf, 0, &state);
	if (ret)
		return ret;

	/*
         * Check for supported values
         * Depending on the laptop model, some only support these two:
         * 0 - Maximum Performance
         * 1 - Battery Optimized
         *
         * While some others support all three methods:
         * 0 - Maximum Performance
         * 1 - Performance
         * 2 - Battery Optimized
         */
	if (state < 0 || state > toshiba->max_cooling_method)
		return -EINVAL;

	ret = toshiba_cooling_method_set(toshiba, state);
	if (ret)
		return ret;

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 95 100.00% 1 100.00%
Total 95 100.00% 1 100.00%

static DEVICE_ATTR_RW(cooling_method);


static struct attribute *toshiba_attributes[] = {
	&dev_attr_version.attr,
	&dev_attr_fan.attr,
	&dev_attr_kbd_backlight_mode.attr,
	&dev_attr_kbd_type.attr,
	&dev_attr_available_kbd_modes.attr,
	&dev_attr_kbd_backlight_timeout.attr,
	&dev_attr_touchpad.attr,
	&dev_attr_usb_sleep_charge.attr,
	&dev_attr_sleep_functions_on_battery.attr,
	&dev_attr_usb_rapid_charge.attr,
	&dev_attr_usb_sleep_music.attr,
	&dev_attr_kbd_function_keys.attr,
	&dev_attr_panel_power_on.attr,
	&dev_attr_usb_three.attr,
	&dev_attr_cooling_method.attr,
	NULL,
};



static umode_t toshiba_sysfs_is_visible(struct kobject *kobj,
					struct attribute *attr, int idx)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct toshiba_acpi_dev *drv = dev_get_drvdata(dev);
	bool exists = true;

	if (attr == &dev_attr_fan.attr)
		exists = (drv->fan_supported) ? true : false;
	else if (attr == &dev_attr_kbd_backlight_mode.attr)
		exists = (drv->kbd_illum_supported) ? true : false;
	else if (attr == &dev_attr_kbd_backlight_timeout.attr)
		exists = (drv->kbd_mode == SCI_KBD_MODE_AUTO) ? true : false;
	else if (attr == &dev_attr_touchpad.attr)
		exists = (drv->touchpad_supported) ? true : false;
	else if (attr == &dev_attr_usb_sleep_charge.attr)
		exists = (drv->usb_sleep_charge_supported) ? true : false;
	else if (attr == &dev_attr_sleep_functions_on_battery.attr)
		exists = (drv->usb_sleep_charge_supported) ? true : false;
	else if (attr == &dev_attr_usb_rapid_charge.attr)
		exists = (drv->usb_rapid_charge_supported) ? true : false;
	else if (attr == &dev_attr_usb_sleep_music.attr)
		exists = (drv->usb_sleep_music_supported) ? true : false;
	else if (attr == &dev_attr_kbd_function_keys.attr)
		exists = (drv->kbd_function_keys_supported) ? true : false;
	else if (attr == &dev_attr_panel_power_on.attr)
		exists = (drv->panel_power_on_supported) ? true : false;
	else if (attr == &dev_attr_usb_three.attr)
		exists = (drv->usb_three_supported) ? true : false;
	else if (attr == &dev_attr_cooling_method.attr)
		exists = (drv->cooling_method_supported) ? true : false;

	return exists ? attr->mode : 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 311 96.28% 12 75.00%
Seth Forshee 6 1.86% 1 6.25%
Alexey Dobriyan 4 1.24% 1 6.25%
Andy Grover 2 0.62% 2 12.50%
Total 323 100.00% 16 100.00%


static struct attribute_group toshiba_attr_group = {
	.is_visible = toshiba_sysfs_is_visible,
	.attrs = toshiba_attributes,
};



static void toshiba_acpi_kbd_bl_work(struct work_struct *work)
{
	struct acpi_device *acpi_dev = toshiba_acpi->acpi_dev;

	/* Update the sysfs entries */
	if (sysfs_update_group(&acpi_dev->dev.kobj,
			       &toshiba_attr_group))
		pr_err("Unable to update sysfs entries\n");

	/* Emulate the keyboard backlight event */
	acpi_bus_generate_netlink_event(acpi_dev->pnp.device_class,
					dev_name(&acpi_dev->dev),
					0x92, 0);
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 63 100.00% 1 100.00%
Total 63 100.00% 1 100.00%

/*
 * IIO device
 */


enum toshiba_iio_accel_chan {
	
AXIS_X,
	
AXIS_Y,
	
AXIS_Z
};



static int toshiba_iio_accel_get_axis(enum toshiba_iio_accel_chan chan)
{
	u32 xyval, zval;
	int ret;

	ret = toshiba_accelerometer_get(toshiba_acpi, &xyval, &zval);
	if (ret < 0)
		return ret;

	switch (chan) {
	case AXIS_X:
		return xyval & HCI_ACCEL_DIRECTION_MASK ?
			-(xyval & HCI_ACCEL_MASK) : xyval & HCI_ACCEL_MASK;
	case AXIS_Y:
		return (xyval >> HCI_MISC_SHIFT) & HCI_ACCEL_DIRECTION_MASK ?
			-((xyval >> HCI_MISC_SHIFT) & HCI_ACCEL_MASK) :
			(xyval >> HCI_MISC_SHIFT) & HCI_ACCEL_MASK;
	case AXIS_Z:
		return zval & HCI_ACCEL_DIRECTION_MASK ?
			-(zval & HCI_ACCEL_MASK) : zval & HCI_ACCEL_MASK;
	}

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 118 100.00% 1 100.00%
Total 118 100.00% 1 100.00%



static int toshiba_iio_accel_read_raw(struct iio_dev *indio_dev,
				      struct iio_chan_spec const *chan,
				      int *val, int *val2, long mask)
{
	int ret;

	switch (mask) {
	case IIO_CHAN_INFO_RAW:
		ret = toshiba_iio_accel_get_axis(chan->channel);
		if (ret == -EIO || ret == -ENODEV)
			return ret;

		*val = ret;

		return IIO_VAL_INT;
	}

	return -EINVAL;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 76 100.00% 1 100.00%
Total 76 100.00% 1 100.00%


#define TOSHIBA_IIO_ACCEL_CHANNEL(axis, chan) { \
        .type = IIO_ACCEL, \
        .modified = 1, \
        .channel = chan, \
        .channel2 = IIO_MOD_##axis, \
        .output = 1, \
        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
}


static const struct iio_chan_spec toshiba_iio_accel_channels[] = {
	TOSHIBA_IIO_ACCEL_CHANNEL(X, AXIS_X),
	TOSHIBA_IIO_ACCEL_CHANNEL(Y, AXIS_Y),
	TOSHIBA_IIO_ACCEL_CHANNEL(Z, AXIS_Z),
};


static const struct iio_info toshiba_iio_accel_info = {
	.driver_module = THIS_MODULE,
	.read_raw = &toshiba_iio_accel_read_raw,
};

/*
 * Misc device
 */


static int toshiba_acpi_smm_bridge(SMMRegisters *regs)
{
	u32 in[TCI_WORDS] = { regs->eax, regs->ebx, regs->ecx,
			      regs->edx, regs->esi, regs->edi };
	u32 out[TCI_WORDS];
	acpi_status status;

	status = tci_raw(toshiba_acpi, in, out);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI call to query SMM registers failed\n");
		return -EIO;
	}

	/* Fillout the SMM struct with the TCI call results */
	regs->eax = out[0];
	regs->ebx = out[1];
	regs->ecx = out[2];
	regs->edx = out[3];
	regs->esi = out[4];
	regs->edi = out[5];

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 138 100.00% 1 100.00%
Total 138 100.00% 1 100.00%



static long toshiba_acpi_ioctl(struct file *fp, unsigned int cmd,
			       unsigned long arg)
{
	SMMRegisters __user *argp = (SMMRegisters __user *)arg;
	SMMRegisters regs;
	int ret;

	if (!argp)
		return -EINVAL;

	switch (cmd) {
	case TOSH_SMM:
		if (copy_from_user(&regs, argp, sizeof(SMMRegisters)))
			return -EFAULT;
		ret = toshiba_acpi_smm_bridge(&regs);
		if (ret)
			return ret;
		if (copy_to_user(argp, &regs, sizeof(SMMRegisters)))
			return -EFAULT;
		break;
	case TOSHIBA_ACPI_SCI:
		if (copy_from_user(&regs, argp, sizeof(SMMRegisters)))
			return -EFAULT;
		/* Ensure we are being called with a SCI_{GET, SET} register */
		if (regs.eax != SCI_GET && regs.eax != SCI_SET)
			return -EINVAL;
		if (!sci_open(toshiba_acpi))
			return -EIO;
		ret = toshiba_acpi_smm_bridge(&regs);
		sci_close(toshiba_acpi);
		if (ret)
			return ret;
		if (copy_to_user(argp, &regs, sizeof(SMMRegisters)))
			return -EFAULT;
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 210 100.00% 1 100.00%
Total 210 100.00% 1 100.00%


static const struct file_operations toshiba_acpi_fops = {
	.owner		= THIS_MODULE,
	.unlocked_ioctl = toshiba_acpi_ioctl,
	.llseek		= noop_llseek,
};

/*
 * WWAN RFKill handlers
 */


static int toshiba_acpi_wwan_set_block(void *data, bool blocked)
{
	struct toshiba_acpi_dev *dev = data;
	int ret;

	ret = toshiba_wireless_status(dev);
	if (ret)
		return ret;

	if (!dev->killswitch)
		return 0;

	return toshiba_wwan_set(dev, !blocked);
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 56 100.00% 1 100.00%
Total 56 100.00% 1 100.00%



static void toshiba_acpi_wwan_poll(struct rfkill *rfkill, void *data)
{
	struct toshiba_acpi_dev *dev = data;

	if (toshiba_wireless_status(dev))
		return;

	rfkill_set_hw_state(dev->wwan_rfk, !dev->killswitch);
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 42 100.00% 1 100.00%
Total 42 100.00% 1 100.00%


static const struct rfkill_ops wwan_rfk_ops = {
	.set_block = toshiba_acpi_wwan_set_block,
	.poll = toshiba_acpi_wwan_poll,
};



static int toshiba_acpi_setup_wwan_rfkill(struct toshiba_acpi_dev *dev)
{
	int ret = toshiba_wireless_status(dev);

	if (ret)
		return ret;

	dev->wwan_rfk = rfkill_alloc("Toshiba WWAN",
				     &dev->acpi_dev->dev,
				     RFKILL_TYPE_WWAN,
				     &wwan_rfk_ops,
				     dev);
	if (!dev->wwan_rfk) {
		pr_err("Unable to allocate WWAN rfkill device\n");
		return -ENOMEM;
	}

	rfkill_set_hw_state(dev->wwan_rfk, !dev->killswitch);

	ret = rfkill_register(dev->wwan_rfk);
	if (ret) {
		pr_err("Unable to register WWAN rfkill device\n");
		rfkill_destroy(dev->wwan_rfk);
	}

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 109 100.00% 1 100.00%
Total 109 100.00% 1 100.00%

/*
 * Hotkeys
 */


static int toshiba_acpi_enable_hotkeys(struct toshiba_acpi_dev *dev)
{
	acpi_status status;
	u32 result;

	status = acpi_evaluate_object(dev->acpi_dev->handle,
				      "ENAB", NULL, NULL);
	if (ACPI_FAILURE(status))
		return -ENODEV;

	/*
         * Enable the "Special Functions" mode only if they are
         * supported and if they are activated.
         */
	if (dev->kbd_function_keys_supported && dev->special_functions)
		result = hci_write(dev, HCI_HOTKEY_EVENT,
				   HCI_HOTKEY_SPECIAL_FUNCTIONS);
	else
		result = hci_write(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE);

	if (result == TOS_FAILURE)
		return -EIO;
	else if (result == TOS_NOT_SUPPORTED)
		return -ENODEV;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 103 100.00% 3 100.00%
Total 103 100.00% 3 100.00%



static bool toshiba_acpi_i8042_filter(unsigned char data, unsigned char str,
				      struct serio *port)
{
	if (str & I8042_STR_AUXDATA)
		return false;

	if (unlikely(data == 0xe0))
		return false;

	if ((data & 0x7f) == TOS1900_FN_SCAN) {
		schedule_work(&toshiba_acpi->hotkey_work);
		return true;
	}

	return false;
}

Contributors
Person Tokens Prop Commits CommitProp
Seth Forshee 50 75.76% 2 33.33%
Matthew Garrett 10 15.15% 1 16.67%
Dmitry Torokhov 3 4.55% 1 16.67%
Holger Macht 2 3.03% 1 16.67%
Giedrius Statkevičius 1 1.52% 1 16.67%
Total 66 100.00% 6 100.00%



static void toshiba_acpi_hotkey_work(struct work_struct *work)
{
	acpi_handle ec_handle = ec_get_handle();
	acpi_status status;

	if (!ec_handle)
		return;

	status = acpi_evaluate_object(ec_handle, "NTFY", NULL, NULL);
	if (ACPI_FAILURE(status))
		pr_err("ACPI NTFY method execution failed\n");
}

Contributors
Person Tokens Prop Commits CommitProp
Seth Forshee 27 52.94% 1 33.33%
Matthew Garrett 23 45.10% 1 33.33%
Dmitry Torokhov 1 1.96% 1 33.33%
Total 51 100.00% 3 100.00%

/*
 * Returns hotkey scancode, or < 0 on failure.
 */


static int toshiba_acpi_query_hotkey(struct toshiba_acpi_dev *dev)
{
	unsigned long long value;
	acpi_status status;

	status = acpi_evaluate_integer(dev->acpi_dev->handle, "INFO",
				      NULL, &value);
	if (ACPI_FAILURE(status)) {
		pr_err("ACPI INFO method execution failed\n");
		return -EIO;
	}

	return value;
}

Contributors
Person Tokens Prop Commits CommitProp
Seth Forshee 39 67.24% 2 40.00%
Matthew Garrett 11 18.97% 1 20.00%
Rui Zhang 6 10.34% 1 20.00%
Dmitry Torokhov 2 3.45% 1 20.00%
Total 58 100.00% 5 100.00%



static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev *dev,
				       int scancode)
{
	if (scancode == 0x100)
		return;

	/* Act on key press; ignore key release */
	if (scancode & 0x80)
		return;

	if (!sparse_keymap_report_event(dev->hotkey_dev, scancode, 1, true))
		pr_info("Unknown key %x\n", scancode);
}

Contributors
Person Tokens Prop Commits CommitProp
Seth Forshee 51 98.08% 1 50.00%
Darren Hart 1 1.92% 1 50.00%
Total 52 100.00% 2 100.00%



static void toshiba_acpi_process_hotkeys(struct toshiba_acpi_dev *dev)
{
	if (dev->info_supported) {
		int scancode = toshiba_acpi_query_hotkey(dev);

		if (scancode < 0) {
			pr_err("Failed to query hotkey event\n");
		} else if (scancode != 0) {
			toshiba_acpi_report_hotkey(dev, scancode);
			dev->key_event_valid = 1;
			dev->last_key_event = scancode;
		}
	} else if (dev->system_event_supported) {
		u32 result;
		u32 value;
		int retries = 3;

		do {
			result = hci_read(dev, HCI_SYSTEM_EVENT, &value);
			switch (result) {
			case TOS_SUCCESS:
				toshiba_acpi_report_hotkey(dev, (int)value);
				dev->key_event_valid = 1;
				dev->last_key_event = value;
				break;
			case TOS_NOT_SUPPORTED:
				/*
                                 * This is a workaround for an unresolved
                                 * issue on some machines where system events
                                 * sporadically become disabled.
                                 */
				result = hci_write(dev, HCI_SYSTEM_EVENT, 1);
				if (result == TOS_SUCCESS)
					pr_notice("Re-enabled hotkeys\n");
				/* Fall through */
			default:
				retries--;
				break;
			}
		} while (retries && result != TOS_FIFO_EMPTY);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 175 99.43% 3 75.00%
Darren Hart 1 0.57% 1 25.00%
Total 176 100.00% 4 100.00%



static int toshiba_acpi_setup_keyboard(struct toshiba_acpi_dev *dev)
{
	const struct key_entry *keymap = toshiba_acpi_keymap;
	acpi_handle ec_handle;
	int error;

	if (disable_hotkeys) {
		pr_info("Hotkeys disabled by module parameter\n");
		return 0;
	}

	if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID)) {
		pr_info("WMI event detected, hotkeys will not be monitored\n");
		return 0;
	}

	error = toshiba_acpi_enable_hotkeys(dev);
	if (error)
		return error;

	if (toshiba_hotkey_event_type_get(dev, &dev->hotkey_event_type))
		pr_notice("Unable to query Hotkey Event Type\n");

	dev->hotkey_dev = input_allocate_device();
	if (!dev->hotkey_dev)
		return -ENOMEM;

	dev->hotkey_dev->name = "Toshiba input device";
	dev->hotkey_dev->phys = "toshiba_acpi/input0";
	dev->hotkey_dev->id.bustype = BUS_HOST;

	if (dev->hotkey_event_type == HCI_SYSTEM_TYPE1 ||
	    !dev->kbd_function_keys_supported)
		keymap = toshiba_acpi_keymap;
	else if (dev->hotkey_event_type == HCI_SYSTEM_TYPE2 ||
		 dev->kbd_function_keys_supported)
		keymap = toshiba_acpi_alt_keymap;
	else
		pr_info("Unknown event type received %x\n",
			dev->hotkey_event_type);
	error = sparse_keymap_setup(dev->hotkey_dev, keymap, NULL);
	if (error)
		goto err_free_dev;

	/*
         * For some machines the SCI responsible for providing hotkey
         * notification doesn't fire. We can trigger the notification
         * whenever the Fn key is pressed using the NTFY method, if
         * supported, so if it's present set up an i8042 key filter
         * for this purpose.
         */
	ec_handle = ec_get_handle();
	if (ec_handle && acpi_has_method(ec_handle, "NTFY")) {
		INIT_WORK(&dev->hotkey_work, toshiba_acpi_hotkey_work);

		error = i8042_install_filter(toshiba_acpi_i8042_filter);
		if (error) {
			pr_err("Error installing key filter\n");
			goto err_free_keymap;
		}

		dev->ntfy_supported = 1;
	}

	/*
         * Determine hotkey query interface. Prefer using the INFO
         * method when it is available.
         */
	if (acpi_has_method(dev->acpi_dev->handle, "INFO"))
		dev->info_supported = 1;
	else if (hci_write(dev, HCI_SYSTEM_EVENT, 1) == TOS_SUCCESS)
		dev->system_event_supported = 1;

	if (!dev->info_supported && !dev->system_event_supported) {
		pr_warn("No hotkey query interface found\n");
		goto err_remove_filter;
	}

	error = input_register_device(dev->hotkey_dev);
	if (error) {
		pr_info("Unable to register input device\n");
		goto err_remove_filter;
	}

	return 0;

 err_remove_filter:
	if (dev->ntfy_supported)
		i8042_remove_filter(toshiba_acpi_i8042_filter);
 err_free_keymap:
	sparse_keymap_free(dev->hotkey_dev);
 err_free_dev:
	input_free_device(dev->hotkey_dev);
	dev->hotkey_dev = NULL;
	return error;
}

Contributors
Person Tokens Prop Commits CommitProp
Seth Forshee 223 58.84% 2 14.29%
Azael Avalos 113 29.82% 8 57.14%
Takashi Iwai 16 4.22% 1 7.14%
Matthew Garrett 13 3.43% 1 7.14%
Dmitry Torokhov 9 2.37% 1 7.14%
Rui Zhang 5 1.32% 1 7.14%
Total 379 100.00% 14 100.00%



static int toshiba_acpi_setup_backlight(struct toshiba_acpi_dev *dev)
{
	struct backlight_properties props;
	int brightness;
	int ret;

	/*
         * Some machines don't support the backlight methods at all, and
         * others support it read-only. Either of these is pretty useless,
         * so only register the backlight device if the backlight method
         * supports both reads and writes.
         */
	brightness = __get_lcd_brightness(dev);
	if (brightness < 0)
		return 0;
	/*
         * If transflective backlight is supported and the brightness is zero
         * (lowest brightness level), the set_lcd_brightness function will
         * activate the transflective backlight, making the LCD appear to be
         * turned off, simply increment the brightness level to avoid that.
         */
	if (dev->tr_backlight_supported && brightness == 0)
		brightness++;
	ret = set_lcd_brightness(dev, brightness);
	if (ret) {
		pr_debug("Backlight method is read-only, disabling backlight support\n");
		return 0;
	}

	/*
         * Tell acpi-video-detect code to prefer vendor backlight on all
         * systems with transflective backlight and on dmi matched systems.
         */
	if (dev->tr_backlight_supported ||
	    dmi_check_system(toshiba_vendor_backlight_dmi))
		acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);

	if (acpi_video_get_backlight_type() != acpi_backlight_vendor)
		return 0;

	memset(&props, 0, sizeof(props));
	props.type = BACKLIGHT_PLATFORM;
	props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1;

	/* Adding an extra level and having 0 change to transflective mode */
	if (dev->tr_backlight_supported)
		props.max_brightness++;

	dev->backlight_dev = backlight_device_register("toshiba",
						       &dev->acpi_dev->dev,
						       dev,
						       &toshiba_backlight_data,
						       &props);
	if (IS_ERR(dev->backlight_dev)) {
		ret = PTR_ERR(dev->backlight_dev);
		pr_err("Could not register toshiba backlight device\n");
		dev->backlight_dev = NULL;
		return ret;
	}

	dev->backlight_dev->props.brightness = brightness;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Seth Forshee 146 68.87% 1 14.29%
Hans de Goede 27 12.74% 2 28.57%
Azael Avalos 14 6.60% 1 14.29%
Matthew Garrett 13 6.13% 1 14.29%
Akio Idehara 11 5.19% 1 14.29%
Darren Hart 1 0.47% 1 14.29%
Total 212 100.00% 7 100.00%



static void print_supported_features(struct toshiba_acpi_dev *dev)
{
	pr_info("Supported laptop features:");

	if (dev->hotkey_dev)
		pr_cont(" hotkeys");
	if (dev->backlight_dev)
		pr_cont(" backlight");
	if (dev->video_supported)
		pr_cont(" video-out");
	if (dev->fan_supported)
		pr_cont(" fan");
	if (dev->tr_backlight_supported)
		pr_cont(" transflective-backlight");
	if (dev->illumination_supported)
		pr_cont(" illumination");
	if (dev->kbd_illum_supported)
		pr_cont(" keyboard-backlight");
	if (dev->touchpad_supported)
		pr_cont(" touchpad");
	if (dev->eco_supported)
		pr_cont(" eco-led");
	if (dev->accelerometer_supported)
		pr_cont(" accelerometer-axes");
	if (dev->usb_sleep_charge_supported)
		pr_cont(" usb-sleep-charge");
	if (dev->usb_rapid_charge_supported)
		pr_cont(" usb-rapid-charge");
	if (dev->usb_sleep_music_supported)
		pr_cont(" usb-sleep-music");
	if (dev->kbd_function_keys_supported)
		pr_cont(" special-function-keys");
	if (dev->panel_power_on_supported)
		pr_cont(" panel-power-on");
	if (dev->usb_three_supported)
		pr_cont(" usb3");
	if (dev->wwan_supported)
		pr_cont(" wwan");
	if (dev->cooling_method_supported)
		pr_cont(" cooling-method");

	pr_cont("\n");
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 219 100.00% 3 100.00%
Total 219 100.00% 3 100.00%



static int toshiba_acpi_remove(struct acpi_device *acpi_dev)
{
	struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);

	misc_deregister(&dev->miscdev);

	remove_toshiba_proc_entries(dev);

	if (dev->accelerometer_supported && dev->indio_dev) {
		iio_device_unregister(dev->indio_dev);
		iio_device_free(dev->indio_dev);
	}

	if (dev->sysfs_created)
		sysfs_remove_group(&dev->acpi_dev->dev.kobj,
				   &toshiba_attr_group);

	if (dev->ntfy_supported) {
		i8042_remove_filter(toshiba_acpi_i8042_filter);
		cancel_work_sync(&dev->hotkey_work);
	}

	if (dev->hotkey_dev) {
		input_unregister_device(dev->hotkey_dev);
		sparse_keymap_free(dev->hotkey_dev);
	}

	backlight_device_unregister(dev->backlight_dev);

	if (dev->illumination_led_registered)
		led_classdev_unregister(&dev->led_dev);

	if (dev->kbd_led_registered)
		led_classdev_unregister(&dev->kbd_led);

	if (dev->eco_led_registered)
		led_classdev_unregister(&dev->eco_led);

	if (dev->wwan_rfk) {
		rfkill_unregister(dev->wwan_rfk);
		rfkill_destroy(dev->wwan_rfk);
	}

	if (toshiba_acpi)
		toshiba_acpi = NULL;

	kfree(dev);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 106 50.24% 6 50.00%
Seth Forshee 71 33.65% 3 25.00%
Matthew Garrett 22 10.43% 1 8.33%
Pierre Ducroquet 6 2.84% 1 8.33%
Dmitry Torokhov 6 2.84% 1 8.33%
Total 211 100.00% 12 100.00%



static const char *find_hci_method(acpi_handle handle)
{
	if (acpi_has_method(handle, "GHCI"))
		return "GHCI";

	if (acpi_has_method(handle, "SPFC"))
		return "SPFC";

	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Seth Forshee 32 84.21% 1 50.00%
Rui Zhang 6 15.79% 1 50.00%
Total 38 100.00% 2 100.00%



static int toshiba_acpi_add(struct acpi_device *acpi_dev)
{
	struct toshiba_acpi_dev *dev;
	const char *hci_method;
	u32 dummy;
	int ret = 0;

	if (toshiba_acpi)
		return -EBUSY;

	pr_info("Toshiba Laptop ACPI Extras version %s\n",
	       TOSHIBA_ACPI_VERSION);

	hci_method = find_hci_method(acpi_dev->handle);
	if (!hci_method) {
		pr_err("HCI interface not found\n");
		return -ENODEV;
	}

	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	if (!dev)
		return -ENOMEM;
	dev->acpi_dev = acpi_dev;
	dev->method_hci = hci_method;
	dev->miscdev.minor = MISC_DYNAMIC_MINOR;
	dev->miscdev.name = "toshiba_acpi";
	dev->miscdev.fops = &toshiba_acpi_fops;

	ret = misc_register(&dev->miscdev);
	if (ret) {
		pr_err("Failed to register miscdevice\n");
		kfree(dev);
		return ret;
	}

	acpi_dev->driver_data = dev;
	dev_set_drvdata(&acpi_dev->dev, dev);

	/* Query the BIOS for supported features */

	/*
         * The "Special Functions" are always supported by the laptops
         * with the new keyboard layout, query for its presence to help
         * determine the keymap layout to use.
         */
	ret = toshiba_function_keys_get(dev, &dev->special_functions);
	dev->kbd_function_keys_supported = !ret;

	dev->hotkey_event_type = 0;
	if (toshiba_acpi_setup_keyboard(dev))
		pr_info("Unable to activate hotkeys\n");

	/* Determine whether or not BIOS supports transflective backlight */
	ret = get_tr_backlight_status(dev, &dummy);
	dev->tr_backlight_supported = !ret;

	ret = toshiba_acpi_setup_backlight(dev);
	if (ret)
		goto error;

	toshiba_illumination_available(dev);
	if (dev->illumination_supported) {
		dev->led_dev.name = "toshiba::illumination";
		dev->led_dev.max_brightness = 1;
		dev->led_dev.brightness_set = toshiba_illumination_set;
		dev->led_dev.brightness_get = toshiba_illumination_get;
		if (!led_classdev_register(&acpi_dev->dev, &dev->led_dev))
			dev->illumination_led_registered = true;
	}

	toshiba_eco_mode_available(dev);
	if (dev->eco_supported) {
		dev->eco_led.name = "toshiba::eco_mode";
		dev->eco_led.max_brightness = 1;
		dev->eco_led.brightness_set = toshiba_eco_mode_set_status;
		dev->eco_led.brightness_get = toshiba_eco_mode_get_status;
		if (!led_classdev_register(&dev->acpi_dev->dev, &dev->eco_led))
			dev->eco_led_registered = true;
	}

	toshiba_kbd_illum_available(dev);
	/*
         * Only register the LED if KBD illumination is supported
         * and the keyboard backlight operation mode is set to FN-Z
         */
	if (dev->kbd_illum_supported && dev->kbd_mode == SCI_KBD_MODE_FNZ) {
		dev->kbd_led.name = "toshiba::kbd_backlight";
		dev->kbd_led.max_brightness = 1;
		dev->kbd_led.brightness_set = toshiba_kbd_backlight_set;
		dev->kbd_led.brightness_get = toshiba_kbd_backlight_get;
		if (!led_classdev_register(&dev->acpi_dev->dev, &dev->kbd_led))
			dev->kbd_led_registered = true;
	}

	ret = toshiba_touchpad_get(dev, &dummy);
	dev->touchpad_supported = !ret;

	toshiba_accelerometer_available(dev);
	if (dev->accelerometer_supported) {
		dev->indio_dev = iio_device_alloc(sizeof(*dev));
		if (!dev->indio_dev) {
			pr_err("Unable to allocate iio device\n");
			goto iio_error;
		}

		pr_info("Registering Toshiba accelerometer iio device\n");

		dev->indio_dev->info = &toshiba_iio_accel_info;
		dev->indio_dev->name = "Toshiba accelerometer";
		dev->indio_dev->dev.parent = &acpi_dev->dev;
		dev->indio_dev->modes = INDIO_DIRECT_MODE;
		dev->indio_dev->channels = toshiba_iio_accel_channels;
		dev->indio_dev->num_channels =
					ARRAY_SIZE(toshiba_iio_accel_channels);

		ret = iio_device_register(dev->indio_dev);
		if (ret < 0) {
			pr_err("Unable to register iio device\n");
			iio_device_free(dev->indio_dev);
		}
	}
iio_error:

	toshiba_usb_sleep_charge_available(dev);

	ret = toshiba_usb_rapid_charge_get(dev, &dummy);
	dev->usb_rapid_charge_supported = !ret;

	ret = toshiba_usb_sleep_music_get(dev, &dummy);
	dev->usb_sleep_music_supported = !ret;

	ret = toshiba_panel_power_on_get(dev, &dummy);
	dev->panel_power_on_supported = !ret;

	ret = toshiba_usb_three_get(dev, &dummy);
	dev->usb_three_supported = !ret;

	ret = get_video_status(dev, &dummy);
	dev->video_supported = !ret;

	ret = get_fan_status(dev, &dummy);
	dev->fan_supported = !ret;

	toshiba_wwan_available(dev);
	if (dev->wwan_supported)
		toshiba_acpi_setup_wwan_rfkill(dev);

	toshiba_cooling_method_available(dev);

	print_supported_features(dev);

	ret = sysfs_create_group(&dev->acpi_dev->dev.kobj,
				 &toshiba_attr_group);
	if (ret) {
		dev->sysfs_created = 0;
		goto error;
	}
	dev->sysfs_created = !ret;

	create_toshiba_proc_entries(dev);

	toshiba_acpi = dev;

	return 0;

error:
	toshiba_acpi_remove(acpi_dev);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 553 68.87% 24 63.16%
Seth Forshee 198 24.66% 6 15.79%
Matthew Garrett 27 3.36% 1 2.63%
Pierre Ducroquet 9 1.12% 1 2.63%
Holger Macht 6 0.75% 1 2.63%
John Belmonte 4 0.50% 1 2.63%
Philip Langdale 2 0.25% 1 2.63%
Andy Grover 2 0.25% 1 2.63%
Joe Perches 1 0.12% 1 2.63%
Andrey Borzenkov 1 0.12% 1 2.63%
Total 803 100.00% 38 100.00%



static void toshiba_acpi_notify(struct acpi_device *acpi_dev, u32 event)
{
	struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);

	switch (event) {
	case 0x80: /* Hotkeys and some system events */
		/*
                 * Machines with this WMI GUID aren't supported due to bugs in
                 * their AML.
                 *
                 * Return silently to avoid triggering a netlink event.
                 */
		if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID))
			return;
		toshiba_acpi_process_hotkeys(dev);
		break;
	case 0x81: /* Dock events */
	case 0x82:
	case 0x83:
		pr_info("Dock event received %x\n", event);
		break;
	case 0x88: /* Thermal events */
		pr_info("Thermal event received\n");
		break;
	case 0x8f: /* LID closed */
	case 0x90: /* LID is closed and Dock has been ejected */
		break;
	case 0x8c: /* SATA power events */
	case 0x8b:
		pr_info("SATA power event received %x\n", event);
		break;
	case 0x92: /* Keyboard backlight mode changed */
		toshiba_acpi->kbd_event_generated = true;
		/* Update sysfs entries */
		if (sysfs_update_group(&acpi_dev->dev.kobj,
				       &toshiba_attr_group))
			pr_err("Unable to update sysfs entries\n");
		break;
	case 0x85: /* Unknown */
	case 0x8d: /* Unknown */
	case 0x8e: /* Unknown */
	case 0x94: /* Unknown */
	case 0x95: /* Unknown */
	default:
		pr_info("Unknown event received %x\n", event);
		break;
	}

	acpi_bus_generate_netlink_event(acpi_dev->pnp.device_class,
					dev_name(&acpi_dev->dev),
					event, (event == 0x80) ?
					dev->last_key_event : 0);
}

Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 151 78.24% 6 75.00%
Seth Forshee 42 21.76% 2 25.00%
Total 193 100.00% 8 100.00%

#ifdef CONFIG_PM_SLEEP


static int toshiba_acpi_suspend(struct device *device)
{
	struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device));

	if (dev->hotkey_dev) {
		u32 result;

		result = hci_write(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_DISABLE);
		if (result != TOS_SUCCESS)
			pr_info("Unable to disable hotkeys\n");
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Seth Forshee 35 58.33% 1 20.00%
Azael Avalos 19 31.67% 3 60.00%
Rafael J. Wysocki 6 10.00% 1 20.00%
Total 60 100.00% 5 100.00%



static int toshiba_acpi_resume(struct device *device)
{
	struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device));

	if (dev->hotkey_dev) {
		if (toshiba_acpi_enable_hotkeys(dev))
			pr_info("Unable to re-enable hotkeys\n");
	}

	if (dev->wwan_rfk) {
		if (!toshiba_wireless_status(dev))
			rfkill_set_hw_state(dev->wwan_rfk, !dev->killswitch);
	}

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 31 41.33% 2 40.00%
Seth Forshee 27 36.00% 1 20.00%
Benjamin Tissoires 11 14.67% 1 20.00%
Rafael J. Wysocki 6 8.00% 1 20.00%
Total 75 100.00% 5 100.00%

#endif

static SIMPLE_DEV_PM_OPS(toshiba_acpi_pm,
			 toshiba_acpi_suspend, toshiba_acpi_resume);


static struct acpi_driver toshiba_acpi_driver = {
	.name	= "Toshiba ACPI driver",
	.owner	= THIS_MODULE,
	.ids	= toshiba_device_ids,
	.flags	= ACPI_DRIVER_ALL_NOTIFY_EVENTS,
	.ops	= {
		.add		= toshiba_acpi_add,
		.remove		= toshiba_acpi_remove,
		.notify		= toshiba_acpi_notify,
        },
	.drv.pm	= &toshiba_acpi_pm,
};



static int __init toshiba_acpi_init(void)
{
	int ret;

	toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir);
	if (!toshiba_proc_dir) {
		pr_err("Unable to create proc dir " PROC_TOSHIBA "\n");
		return -ENODEV;
	}

	ret = acpi_bus_register_driver(&toshiba_acpi_driver);
	if (ret) {
		pr_err("Failed to register ACPI driver: %d\n", ret);
		remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
	}

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Seth Forshee 70 100.00% 1 100.00%
Total 70 100.00% 1 100.00%



static void __exit toshiba_acpi_exit(void)
{
	acpi_bus_unregister_driver(&toshiba_acpi_driver);
	if (toshiba_proc_dir)
		remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
}

Contributors
Person Tokens Prop Commits CommitProp
Seth Forshee 25 96.15% 1 50.00%
Andy Grover 1 3.85% 1 50.00%
Total 26 100.00% 2 100.00%


module_init(toshiba_acpi_init);

module_exit(toshiba_acpi_exit);
Overall Contributors
Person Tokens Prop Commits CommitProp
Azael Avalos 10499 71.71% 74 57.81%
Seth Forshee 1521 10.39% 9 7.03%
Andy Grover 900 6.15% 4 3.12%
Alexey Dobriyan 595 4.06% 1 0.78%
Matthew Garrett 295 2.01% 3 2.34%
Pierre Ducroquet 153 1.05% 1 0.78%
Takashi Iwai 101 0.69% 1 0.78%
Akio Idehara 96 0.66% 1 0.78%
Philip Langdale 83 0.57% 1 0.78%
Dmitry Torokhov 65 0.44% 1 0.78%
Holger Macht 51 0.35% 1 0.78%
Hans de Goede 45 0.31% 2 1.56%
Andrey Borzenkov 35 0.24% 2 1.56%
Rafael J. Wysocki 32 0.22% 2 1.56%
John Belmonte 22 0.15% 1 0.78%
Rui Zhang 19 0.13% 3 2.34%
Darren Hart 18 0.12% 1 0.78%
Al Viro 17 0.12% 3 2.34%
Johannes Berg 13 0.09% 1 0.78%
Dan Carpenter 11 0.08% 2 1.56%
Benjamin Tissoires 11 0.08% 1 0.78%
Jon Dowland 10 0.07% 1 0.78%
Unai Uribarri 10 0.07% 1 0.78%
Joe Perches 9 0.06% 1 0.78%
Len Brown 7 0.05% 2 1.56%
Aristeu Sergio Rozanski Filho 7 0.05% 1 0.78%
Ondrej Zary 6 0.04% 1 0.78%
Axel Lin 4 0.03% 2 1.56%
Tejun Heo 3 0.02% 1 0.78%
Lv Zheng 1 0.01% 1 0.78%
Giedrius Statkevičius 1 0.01% 1 0.78%
Harvey Harrison 1 0.01% 1 0.78%
Greg Kroah-Hartman 0.00% 0 0.00%
Total 14641 100.00% 128 100.00%
Directory: drivers/platform/x86

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Andy Grover	33	97.06%	1	50.00%
Azael Avalos	1	2.94%	1	50.00%
Total	34	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.11 drivers/platform/x86/toshiba_acpi.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors
