1 files changed, 893 insertions, 132 deletions

diff --git a/drivers/platform/x86/toshiba_acpi.c b/drivers/platform/x86/toshiba_acpi.c
index fc34a71866ed..dbcb7a8915b8 100644
--- a/drivers/platform/x86/toshiba_acpi.c
+++ b/drivers/platform/x86/toshiba_acpi.c
@@ -1,11 +1,10 @@
 /*
  *  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 Azael Avalos
+ *  Copyright (C) 2014-2015 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
@@ -17,10 +16,8 @@
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
+ *  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.
@@ -30,15 +27,11 @@
  *              engineering the Windows drivers
  *      Yasushi Nagato - changes for linux kernel 2.4 -> 2.5
  *      Rob Miller - TV out and hotkeys help
- *
- *
- *  TODO
- *
  */
 
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
-#define TOSHIBA_ACPI_VERSION    "0.20"
+#define TOSHIBA_ACPI_VERSION    "0.21"
 #define PROC_INTERFACE_VERSION  1
 
 #include <linux/kernel.h>
@@ -57,7 +50,7 @@
 #include <linux/i8042.h>
 #include <linux/acpi.h>
 #include <linux/dmi.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 
 MODULE_AUTHOR("John Belmonte");
 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
@@ -71,7 +64,8 @@ MODULE_LICENSE("GPL");
 /* Toshiba ACPI method paths */
 #define METHOD_VIDEO_OUT        "\\_SB_.VALX.DSSX"
 
-/* The Toshiba configuration interface is composed of the HCI and the SCI,
+/*
+ * 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
@@ -108,6 +102,7 @@ MODULE_LICENSE("GPL");
 #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
@@ -121,9 +116,14 @@ MODULE_LICENSE("GPL");
 #define HCI_KBD_ILLUMINATION            0x0095
 #define HCI_ECO_MODE                    0x0097
 #define HCI_ACCELEROMETER2              0x00a6
+#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
@@ -146,6 +146,15 @@ MODULE_LICENSE("GPL");
 #define SCI_KBD_MODE_ON                 0x8
 #define SCI_KBD_MODE_OFF                0x10
 #define SCI_KBD_TIME_MAX                0x3c001a
+#define SCI_USB_CHARGE_MODE_MASK        0xff
+#define SCI_USB_CHARGE_DISABLED         0x30000
+#define SCI_USB_CHARGE_ALTERNATE        0x30009
+#define SCI_USB_CHARGE_AUTO             0x30021
+#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;
@@ -164,6 +173,7 @@ struct toshiba_acpi_dev {
         int kbd_type;
         int kbd_mode;
         int kbd_time;
+        int usbsc_bat_level;
 
         unsigned int illumination_supported:1;
         unsigned int video_supported:1;
@@ -177,6 +187,12 @@ struct toshiba_acpi_dev {
         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 sysfs_created:1;
 
         struct mutex mutex;
@@ -264,15 +280,17 @@ static const struct key_entry toshiba_acpi_alt_keymap[] = {
         { KE_END, 0 },
 };
 
-/* utility
+/*
+ * Utility
  */
 
-static __inline__ void _set_bit(u32 * word, u32 mask, int value)
+static inline void _set_bit(u32 *word, u32 mask, int value)
 {
         *word = (*word & ~mask) | (mask * value);
 }
 
-/* acpi interface wrappers
+/*
+ * ACPI interface wrappers
  */
 
 static int write_acpi_int(const char *methodName, int val)
@@ -283,7 +301,8 @@ static int write_acpi_int(const char *methodName, int val)
         return (status == AE_OK) ? 0 : -EIO;
 }
 
-/* Perform a raw configuration call.  Here we don't care about input or output
+/*
+ * 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,
@@ -310,15 +329,15 @@ static acpi_status tci_raw(struct toshiba_acpi_dev *dev,
                                       (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) {
+                for (i = 0; i < out_objs->package.count; ++i)
                         out[i] = out_objs->package.elements[i].integer.value;
-                }
         }
 
         return status;
 }
 
-/* common hci tasks (get or set one or two value)
+/*
+ * Common hci tasks (get or set one or two value)
  *
  * In addition to the ACPI status, the HCI system returns a result which
  * may be useful (such as "not supported").
@@ -338,6 +357,7 @@ static u32 hci_read1(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;
 
@@ -355,11 +375,13 @@ static u32 hci_write2(struct toshiba_acpi_dev *dev, u32 reg, u32 in1, u32 in2)
         return ACPI_SUCCESS(status) ? out[0] : TOS_FAILURE;
 }
 
-static u32 hci_read2(struct toshiba_acpi_dev *dev, u32 reg, u32 *out1, u32 *out2)
+static u32 hci_read2(struct toshiba_acpi_dev *dev,
+                     u32 reg, u32 *out1, u32 *out2)
 {
         u32 in[TCI_WORDS] = { HCI_GET, reg, *out1, *out2, 0, 0 };
         u32 out[TCI_WORDS];
         acpi_status status = tci_raw(dev, in, out);
+
         if (ACPI_FAILURE(status))
                 return TOS_FAILURE;
 
@@ -369,7 +391,8 @@ static u32 hci_read2(struct toshiba_acpi_dev *dev, u32 reg, u32 *out1, u32 *out2
         return out[0];
 }
 
-/* common sci tasks
+/*
+ * Common sci tasks
  */
 
 static int sci_open(struct toshiba_acpi_dev *dev)
@@ -389,6 +412,20 @@ static int sci_open(struct toshiba_acpi_dev *dev)
         } 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");
         }
@@ -421,6 +458,7 @@ 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;
 
@@ -529,10 +567,11 @@ static int toshiba_kbd_illum_available(struct toshiba_acpi_dev *dev)
                 return 0;
         }
 
-        /* Check for keyboard backlight timeout max value,
+        /*
+         * 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
+         * to 0x3c001a, use this to distinguish between them.
          */
         if (out[3] == SCI_KBD_TIME_MAX)
                 dev->kbd_type = 2;
@@ -667,19 +706,37 @@ static int toshiba_touchpad_get(struct toshiba_acpi_dev *dev, u32 *state)
 static int toshiba_eco_mode_available(struct toshiba_acpi_dev *dev)
 {
         acpi_status status;
-        u32 in[TCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 1, 0, 0 };
+        u32 in[TCI_WORDS] = { HCI_GET, HCI_ECO_MODE, 0, 0, 0, 0 };
         u32 out[TCI_WORDS];
 
         status = tci_raw(dev, in, out);
-        if (ACPI_FAILURE(status) || out[0] == TOS_INPUT_DATA_ERROR) {
-                pr_info("ACPI call to get ECO led failed\n");
-                return 0;
+        if (ACPI_FAILURE(status) || out[0] == TOS_FAILURE) {
+                pr_err("ACPI call to get ECO led failed\n");
+        } else if (out[0] == TOS_NOT_INSTALLED) {
+                pr_info("ECO led not installed");
+        } else 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) || out[0] == TOS_FAILURE)
+                        pr_err("ACPI call to get ECO led failed\n");
+                else if (out[0] == TOS_SUCCESS)
+                        return 1;
         }
 
-        return 1;
+        return 0;
 }
 
-static enum led_brightness toshiba_eco_mode_get_status(struct led_classdev *cdev)
+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);
@@ -721,7 +778,8 @@ static int toshiba_accelerometer_supported(struct toshiba_acpi_dev *dev)
         u32 out[TCI_WORDS];
         acpi_status status;
 
-        /* Check if the accelerometer call exists,
+        /*
+         * Check if the accelerometer call exists,
          * this call also serves as initialization
          */
         status = tci_raw(dev, in, out);
@@ -760,6 +818,337 @@ static int toshiba_accelerometer_get(struct toshiba_acpi_dev *dev,
         return 0;
 }
 
+/* Sleep (Charge and Music) utilities support */
+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");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("USB Sleep and Charge not supported\n");
+                return -ENODEV;
+        } else if (result == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+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");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("USB Sleep and Charge not supported\n");
+                return -ENODEV;
+        } else if (result == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+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) || out[0] == TOS_FAILURE) {
+                pr_err("ACPI call to get USB S&C battery level failed\n");
+                return -EIO;
+        } else if (out[0] == TOS_NOT_SUPPORTED) {
+                pr_info("USB Sleep and Charge not supported\n");
+                return -ENODEV;
+        } else if (out[0] == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        *mode = out[2];
+
+        return 0;
+}
+
+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) || out[0] == TOS_FAILURE) {
+                pr_err("ACPI call to set USB S&C battery level failed\n");
+                return -EIO;
+        } else if (out[0] == TOS_NOT_SUPPORTED) {
+                pr_info("USB Sleep and Charge not supported\n");
+                return -ENODEV;
+        } else if (out[0] == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+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) || out[0] == TOS_FAILURE) {
+                pr_err("ACPI call to get USB S&C battery level failed\n");
+                return -EIO;
+        } else if (out[0] == TOS_NOT_SUPPORTED ||
+                   out[0] == TOS_INPUT_DATA_ERROR) {
+                pr_info("USB Sleep and Charge not supported\n");
+                return -ENODEV;
+        }
+
+        *state = out[2];
+
+        return 0;
+}
+
+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) || out[0] == TOS_FAILURE) {
+                pr_err("ACPI call to set USB S&C battery level failed\n");
+                return -EIO;
+        } else if (out[0] == TOS_NOT_SUPPORTED) {
+                pr_info("USB Sleep and Charge not supported\n");
+                return -ENODEV;
+        } else if (out[0] == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+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 set USB S&C mode failed\n");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("USB Sleep and Charge not supported\n");
+                return -ENODEV;
+        } else if (result == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+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 USB S&C mode failed\n");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("USB Sleep and Charge not supported\n");
+                return -ENODEV;
+        } else if (result == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+/* 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 || result == TOS_INPUT_DATA_ERROR) {
+                pr_err("ACPI call to get KBD function keys failed\n");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("KBD function keys not supported\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+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 || result == TOS_INPUT_DATA_ERROR) {
+                pr_err("ACPI call to set KBD function keys failed\n");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("KBD function keys not supported\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+/* 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");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("Panel Power on not supported\n");
+                return -ENODEV;
+        } else if (result == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+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");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("Panel Power ON not supported\n");
+                return -ENODEV;
+        } else if (result == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+/* 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");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("USB 3 not supported\n");
+                return -ENODEV;
+        } else if (result == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
+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");
+                return -EIO;
+        } else if (result == TOS_NOT_SUPPORTED) {
+                pr_info("USB 3 not supported\n");
+                return -ENODEV;
+        } else if (result == TOS_INPUT_DATA_ERROR) {
+                return -EIO;
+        }
+
+        return 0;
+}
+
 /* Bluetooth rfkill handlers */
 
 static u32 hci_get_bt_present(struct toshiba_acpi_dev *dev, bool *present)
@@ -870,7 +1259,7 @@ static int set_tr_backlight_status(struct toshiba_acpi_dev *dev, bool enable)
         return hci_result == TOS_SUCCESS ? 0 : -EIO;
 }
 
-static struct proc_dir_entry *toshiba_proc_dir /*= 0*/ ;
+static struct proc_dir_entry *toshiba_proc_dir /*= 0*/;
 
 static int __get_lcd_brightness(struct toshiba_acpi_dev *dev)
 {
@@ -881,6 +1270,7 @@ static int __get_lcd_brightness(struct toshiba_acpi_dev *dev)
         if (dev->tr_backlight_supported) {
                 bool enabled;
                 int ret = get_tr_backlight_status(dev, &enabled);
+
                 if (ret)
                         return ret;
                 if (enabled)
@@ -898,6 +1288,7 @@ static int __get_lcd_brightness(struct toshiba_acpi_dev *dev)
 static int get_lcd_brightness(struct backlight_device *bd)
 {
         struct toshiba_acpi_dev *dev = bl_get_data(bd);
+
         return __get_lcd_brightness(dev);
 }
 
@@ -934,6 +1325,7 @@ static int set_lcd_brightness(struct toshiba_acpi_dev *dev, int value)
         if (dev->tr_backlight_supported) {
                 bool enable = !value;
                 int ret = set_tr_backlight_status(dev, enable);
+
                 if (ret)
                         return ret;
                 if (value)
@@ -948,6 +1340,7 @@ static int set_lcd_brightness(struct toshiba_acpi_dev *dev, int value)
 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);
 }
 
@@ -1005,6 +1398,7 @@ static int video_proc_show(struct seq_file *m, void *v)
                 int is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0;
                 int is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0;
                 int 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);
@@ -1042,9 +1436,9 @@ static ssize_t video_proc_write(struct file *file, const char __user *buf,
 
         buffer = cmd;
 
-        /* scan expression.  Multiple expressions may be delimited with ;
-         *
-         *  NOTE: to keep scanning simple, invalid fields are ignored
+        /*
+         * 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)
@@ -1053,12 +1447,11 @@ static ssize_t video_proc_write(struct file *file, const char __user *buf,
                         crt_out = value & 1;
                 else if (sscanf(buffer, " tv_out : %i", &value) == 1)
                         tv_out = value & 1;
-                /* advance to one character past the next ; */
+                /* Advance to one character past the next ; */
                 do {
                         ++buffer;
                         --remain;
-                }
-                while (remain && *(buffer - 1) != ';');
+                } while (remain && *(buffer - 1) != ';');
         }
 
         kfree(cmd);
@@ -1066,13 +1459,15 @@ static ssize_t video_proc_write(struct file *file, const char __user *buf,
         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
+                /*
+                 * 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);
@@ -1135,10 +1530,10 @@ static ssize_t fan_proc_write(struct file *file, const char __user *buf,
         if (sscanf(cmd, " force_on : %i", &value) == 1 &&
             value >= 0 && value <= 1) {
                 hci_result = hci_write1(dev, HCI_FAN, value);
-                if (hci_result != TOS_SUCCESS)
-                        return -EIO;
-                else
+                if (hci_result == TOS_SUCCESS)
                         dev->force_fan = value;
+                else
+                        return -EIO;
         } else {
                 return -EINVAL;
         }
@@ -1167,11 +1562,13 @@ static int keys_proc_show(struct seq_file *m, void *v)
                         dev->key_event_valid = 1;
                         dev->last_key_event = value;
                 } else if (hci_result == TOS_FIFO_EMPTY) {
-                        /* better luck next time */
+                        /* Better luck next time */
                 } else if (hci_result == TOS_NOT_SUPPORTED) {
-                        /* This is a workaround for an unresolved issue on
+                        /*
+                         * This is a workaround for an unresolved issue on
                          * some machines where system events sporadically
-                         * become disabled. */
+                         * become disabled.
+                         */
                         hci_result = hci_write1(dev, HCI_SYSTEM_EVENT, 1);
                         pr_notice("Re-enabled hotkeys\n");
                 } else {
@@ -1203,11 +1600,10 @@ static ssize_t keys_proc_write(struct file *file, const char __user *buf,
                 return -EFAULT;
         cmd[len] = '\0';
 
-        if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0) {
+        if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0)
                 dev->key_event_valid = 0;
-        } else {
+        else
                 return -EINVAL;
-        }
 
         return count;
 }
@@ -1241,7 +1637,8 @@ static const struct file_operations version_proc_fops = {
         .release        = single_release,
 };
 
-/* proc and module init
+/*
+ * Proc and module init
  */
 
 #define PROC_TOSHIBA            "toshiba"
@@ -1286,66 +1683,56 @@ static const struct backlight_ops toshiba_backlight_data = {
 /*
  * Sysfs files
  */
-static ssize_t toshiba_kbd_bl_mode_store(struct device *dev,
-                                         struct device_attribute *attr,
-                                         const char *buf, size_t count);
-static ssize_t toshiba_kbd_bl_mode_show(struct device *dev,
-                                        struct device_attribute *attr,
-                                        char *buf);
-static ssize_t toshiba_kbd_type_show(struct device *dev,
-                                     struct device_attribute *attr,
-                                     char *buf);
-static ssize_t toshiba_available_kbd_modes_show(struct device *dev,
-                                        struct device_attribute *attr,
-                                        char *buf);
-static ssize_t toshiba_kbd_bl_timeout_store(struct device *dev,
-                                            struct device_attribute *attr,
-                                            const char *buf, size_t count);
-static ssize_t toshiba_kbd_bl_timeout_show(struct device *dev,
-                                           struct device_attribute *attr,
-                                           char *buf);
-static ssize_t toshiba_touchpad_store(struct device *dev,
-                                      struct device_attribute *attr,
-                                      const char *buf, size_t count);
-static ssize_t toshiba_touchpad_show(struct device *dev,
-                                     struct device_attribute *attr,
-                                     char *buf);
-static ssize_t toshiba_position_show(struct device *dev,
-                                     struct device_attribute *attr,
-                                     char *buf);
-
-static DEVICE_ATTR(kbd_backlight_mode, S_IRUGO | S_IWUSR,
-                   toshiba_kbd_bl_mode_show, toshiba_kbd_bl_mode_store);
-static DEVICE_ATTR(kbd_type, S_IRUGO, toshiba_kbd_type_show, NULL);
-static DEVICE_ATTR(available_kbd_modes, S_IRUGO,
-                   toshiba_available_kbd_modes_show, NULL);
-static DEVICE_ATTR(kbd_backlight_timeout, S_IRUGO | S_IWUSR,
-                   toshiba_kbd_bl_timeout_show, toshiba_kbd_bl_timeout_store);
-static DEVICE_ATTR(touchpad, S_IRUGO | S_IWUSR,
-                   toshiba_touchpad_show, toshiba_touchpad_store);
-static DEVICE_ATTR(position, S_IRUGO, toshiba_position_show, NULL);
+static ssize_t version_show(struct device *dev,
+                            struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "%s\n", TOSHIBA_ACPI_VERSION);
+}
+static DEVICE_ATTR_RO(version);
 
-static struct attribute *toshiba_attributes[] = {
-        &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_position.attr,
-        NULL,
-};
+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);
+        u32 result;
+        int state;
+        int ret;
 
-static umode_t toshiba_sysfs_is_visible(struct kobject *,
-                                        struct attribute *, int);
+        ret = kstrtoint(buf, 0, &state);
+        if (ret)
+                return ret;
 
-static struct attribute_group toshiba_attr_group = {
-        .is_visible = toshiba_sysfs_is_visible,
-        .attrs = toshiba_attributes,
-};
+        if (state != 0 && state != 1)
+                return -EINVAL;
 
-static ssize_t toshiba_kbd_bl_mode_store(struct device *dev,
-                                         struct device_attribute *attr,
-                                         const char *buf, size_t count)
+        result = hci_write1(toshiba, HCI_FAN, state);
+        if (result == TOS_FAILURE)
+                return -EIO;
+        else if (result == TOS_NOT_SUPPORTED)
+                return -ENODEV;
+
+        return count;
+}
+
+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);
+}
+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;
@@ -1369,7 +1756,8 @@ static ssize_t toshiba_kbd_bl_mode_store(struct device *dev,
                         return -EINVAL;
         }
 
-        /* Set the Keyboard Backlight Mode where:
+        /*
+         * 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
@@ -1400,9 +1788,9 @@ static ssize_t toshiba_kbd_bl_mode_store(struct device *dev,
         return count;
 }
 
-static ssize_t toshiba_kbd_bl_mode_show(struct device *dev,
-                                        struct device_attribute *attr,
-                                        char *buf)
+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;
@@ -1412,19 +1800,20 @@ static ssize_t toshiba_kbd_bl_mode_show(struct device *dev,
 
         return sprintf(buf, "%i\n", time & SCI_KBD_MODE_MASK);
 }
+static DEVICE_ATTR_RW(kbd_backlight_mode);
 
-static ssize_t toshiba_kbd_type_show(struct device *dev,
-                                     struct device_attribute *attr,
-                                     char *buf)
+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);
 }
+static DEVICE_ATTR_RO(kbd_type);
 
-static ssize_t toshiba_available_kbd_modes_show(struct device *dev,
-                                                struct device_attribute *attr,
-                                                char *buf)
+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);
 
@@ -1435,10 +1824,11 @@ static ssize_t toshiba_available_kbd_modes_show(struct device *dev,
         return sprintf(buf, "%x %x %x\n",
                        SCI_KBD_MODE_AUTO, SCI_KBD_MODE_ON, SCI_KBD_MODE_OFF);
 }
+static DEVICE_ATTR_RO(available_kbd_modes);
 
-static ssize_t toshiba_kbd_bl_timeout_store(struct device *dev,
-                                            struct device_attribute *attr,
-                                            const char *buf, size_t count)
+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;
@@ -1479,9 +1869,9 @@ static ssize_t toshiba_kbd_bl_timeout_store(struct device *dev,
         return count;
 }
 
-static ssize_t toshiba_kbd_bl_timeout_show(struct device *dev,
-                                           struct device_attribute *attr,
-                                           char *buf)
+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;
@@ -1491,10 +1881,11 @@ static ssize_t toshiba_kbd_bl_timeout_show(struct device *dev,
 
         return sprintf(buf, "%i\n", time >> HCI_MISC_SHIFT);
 }
+static DEVICE_ATTR_RW(kbd_backlight_timeout);
 
-static ssize_t toshiba_touchpad_store(struct device *dev,
-                                      struct device_attribute *attr,
-                                      const char *buf, size_t count)
+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;
@@ -1514,8 +1905,8 @@ static ssize_t toshiba_touchpad_store(struct device *dev,
         return count;
 }
 
-static ssize_t toshiba_touchpad_show(struct device *dev,
-                                     struct device_attribute *attr, char *buf)
+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;
@@ -1527,9 +1918,10 @@ static ssize_t toshiba_touchpad_show(struct device *dev,
 
         return sprintf(buf, "%i\n", state);
 }
+static DEVICE_ATTR_RW(touchpad);
 
-static ssize_t toshiba_position_show(struct device *dev,
-                                     struct device_attribute *attr, char *buf)
+static ssize_t position_show(struct device *dev,
+                             struct device_attribute *attr, char *buf)
 {
         struct toshiba_acpi_dev *toshiba = dev_get_drvdata(dev);
         u32 xyval, zval, tmp;
@@ -1548,6 +1940,336 @@ static ssize_t toshiba_position_show(struct device *dev,
 
         return sprintf(buf, "%d %d %d\n", x, y, z);
 }
+static DEVICE_ATTR_RO(position);
+
+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);
+}
+
+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);
+        u32 mode;
+        int state;
+        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)
+         */
+        if (state != 0 && state != 1 && state != 2)
+                return -EINVAL;
+
+        /* Set the USB charging mode to internal value */
+        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;
+
+        ret = toshiba_usb_sleep_charge_set(toshiba, mode);
+        if (ret)
+                return ret;
+
+        return count;
+}
+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);
+        u32 state;
+        int bat_lvl;
+        int status;
+        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);
+}
+
+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;
+}
+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);
+}
+
+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;
+}
+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);
+}
+
+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;
+}
+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);
+}
+
+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;
+}
+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);
+}
+
+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;
+}
+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);
+}
+
+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;
+}
+static DEVICE_ATTR_RW(usb_three);
+
+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_position.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,
+        NULL,
+};
 
 static umode_t toshiba_sysfs_is_visible(struct kobject *kobj,
                                         struct attribute *attr, int idx)
@@ -1556,7 +2278,9 @@ static umode_t toshiba_sysfs_is_visible(struct kobject *kobj,
         struct toshiba_acpi_dev *drv = dev_get_drvdata(dev);
         bool exists = true;
 
-        if (attr == &dev_attr_kbd_backlight_mode.attr)
+        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;
@@ -1564,10 +2288,29 @@ static umode_t toshiba_sysfs_is_visible(struct kobject *kobj,
                 exists = (drv->touchpad_supported) ? true : false;
         else if (attr == &dev_attr_position.attr)
                 exists = (drv->accelerometer_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;
 
         return exists ? attr->mode : 0;
 }
 
+static struct attribute_group toshiba_attr_group = {
+        .is_visible = toshiba_sysfs_is_visible,
+        .attrs = toshiba_attributes,
+};
+
 /*
  * Hotkeys
  */
@@ -1644,7 +2387,7 @@ static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev *dev,
         if (scancode == 0x100)
                 return;
 
-        /* act on key press; ignore key release */
+        /* Act on key press; ignore key release */
         if (scancode & 0x80)
                 return;
 
@@ -1680,7 +2423,7 @@ static void toshiba_acpi_process_hotkeys(struct toshiba_acpi_dev *dev)
                                 hci_result =
                                         hci_write1(dev, HCI_SYSTEM_EVENT, 1);
                                 pr_notice("Re-enabled hotkeys\n");
-                                /* fall through */
+                                /* Fall through */
                         default:
                                 retries--;
                                 break;
@@ -1802,7 +2545,7 @@ static int toshiba_acpi_setup_backlight(struct toshiba_acpi_dev *dev)
         props.type = BACKLIGHT_PLATFORM;
         props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1;
 
-        /* adding an extra level and having 0 change to transflective mode */
+        /* Adding an extra level and having 0 change to transflective mode */
         if (dev->tr_backlight_supported)
                 props.max_brightness++;
 
@@ -1973,6 +2716,24 @@ static int toshiba_acpi_add(struct acpi_device *acpi_dev)
         ret = toshiba_accelerometer_supported(dev);
         dev->accelerometer_supported = !ret;
 
+        ret = toshiba_usb_sleep_charge_get(dev, &dummy);
+        dev->usb_sleep_charge_supported = !ret;
+
+        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_function_keys_get(dev, &dummy);
+        dev->kbd_function_keys_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;
+
         /* Determine whether or not BIOS supports fan and video interfaces */
 
         ret = get_video_status(dev, &dummy);