platform/oaktrail: ACPI EC Extra driver for Oaktrail

This driver implements an Extra ACPI EC driver for products based on Intel
Oaktrail platform.

This driver does below things:
1. registers itself in the Linux backlight control in
   /sys/class/backlight/intel_oaktrail/

2. registers in the rfkill subsystem here: /sys/class/rfkill/rfkillX/
   for these components: wifi, bluetooth, wwan (3g), gps

Signed-off-by: Yin Kangkai <kangkai.yin@linux.intel.com>

[Extracted from a bigger patch by Yin Kangkai, this version leaves out some
 sysfs bits that probably want to be driver managed, and ACPI i2c enumeration]

Signed-off-by: Alan Cox <alan@linux.intel.com>
Signed-off-by: Matthew Garrett <mjg@redhat.com>

3 files changed, 406 insertions, 0 deletions

diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index 5cb999b50f95..83c2411acb5b 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -760,4 +760,13 @@ config MXM_WMI
           MXM is a standard for laptop graphics cards, the WMI interface
           is required for switchable nvidia graphics machines
 
+config INTEL_OAKTRAIL
+        tristate "Intel Oaktrail Platform Extras"
+        depends on ACPI
+        depends on RFKILL && BACKLIGHT_CLASS_DEVICE && ACPI
+        ---help---
+          Intel Oaktrail platform need this driver to provide interfaces to
+          enable/disable the Camera, WiFi, BT etc. devices. If in doubt, say Y
+          here; it will only load on supported platforms.
+
 endif # X86_PLATFORM_DEVICES
diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
index a7ab3bc7b3a1..af683fb5a807 100644
--- a/drivers/platform/x86/Makefile
+++ b/drivers/platform/x86/Makefile
@@ -43,3 +43,4 @@ obj-$(CONFIG_IBM_RTL)		+= ibm_rtl.o
 obj-$(CONFIG_SAMSUNG_LAPTOP)    += samsung-laptop.o
 obj-$(CONFIG_INTEL_MFLD_THERMAL)        += intel_mid_thermal.o
 obj-$(CONFIG_MXM_WMI)           += mxm-wmi.o
+obj-$(CONFIG_INTEL_OAKTRAIL)    += intel_oaktrail.o
diff --git a/drivers/platform/x86/intel_oaktrail.c b/drivers/platform/x86/intel_oaktrail.c
new file mode 100644
index 000000000000..e936364a609d
--- /dev/null
+++ b/drivers/platform/x86/intel_oaktrail.c
@@ -0,0 +1,396 @@
+/*
+ * intel_oaktrail.c - Intel OakTrail Platform support.
+ *
+ * Copyright (C) 2010-2011 Intel Corporation
+ * Author: Yin Kangkai (kangkai.yin@intel.com)
+ *
+ * based on Compal driver, Copyright (C) 2008 Cezary Jackiewicz
+ * <cezary.jackiewicz (at) gmail.com>, based on MSI driver
+ * Copyright (C) 2006 Lennart Poettering <mzxreary (at) 0pointer (dot) de>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but
+ *  WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ *  02110-1301, USA.
+ *
+ * This driver does below things:
+ * 1. registers itself in the Linux backlight control in
+ *    /sys/class/backlight/intel_oaktrail/
+ *
+ * 2. registers in the rfkill subsystem here: /sys/class/rfkill/rfkillX/
+ *    for these components: wifi, bluetooth, wwan (3g), gps
+ *
+ * This driver might work on other products based on Oaktrail. If you
+ * want to try it you can pass force=1 as argument to the module which
+ * will force it to load even when the DMI data doesn't identify the
+ * product as compatible.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/acpi.h>
+#include <linux/fb.h>
+#include <linux/mutex.h>
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/backlight.h>
+#include <linux/platform_device.h>
+#include <linux/dmi.h>
+#include <linux/rfkill.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+
+
+#define DRIVER_NAME     "intel_oaktrail"
+#define DRIVER_VERSION  "0.4ac1"
+
+/*
+ * This is the devices status address in EC space, and the control bits
+ * definition:
+ *
+ * (1 << 0):    Camera enable/disable, RW.
+ * (1 << 1):    Bluetooth enable/disable, RW.
+ * (1 << 2):    GPS enable/disable, RW.
+ * (1 << 3):    WiFi enable/disable, RW.
+ * (1 << 4):    WWAN (3G) enable/disalbe, RW.
+ * (1 << 5):    Touchscreen enable/disable, Read Only.
+ */
+#define OT_EC_DEVICE_STATE_ADDRESS      0xD6
+
+#define OT_EC_CAMERA_MASK       (1 << 0)
+#define OT_EC_BT_MASK           (1 << 1)
+#define OT_EC_GPS_MASK          (1 << 2)
+#define OT_EC_WIFI_MASK         (1 << 3)
+#define OT_EC_WWAN_MASK         (1 << 4)
+#define OT_EC_TS_MASK           (1 << 5)
+
+/*
+ * This is the address in EC space and commands used to control LCD backlight:
+ *
+ * Two steps needed to change the LCD backlight:
+ *   1. write the backlight percentage into OT_EC_BL_BRIGHTNESS_ADDRESS;
+ *   2. write OT_EC_BL_CONTROL_ON_DATA into OT_EC_BL_CONTROL_ADDRESS.
+ *
+ * To read the LCD back light, just read out the value from
+ * OT_EC_BL_BRIGHTNESS_ADDRESS.
+ *
+ * LCD backlight brightness range: 0 - 100 (OT_EC_BL_BRIGHTNESS_MAX)
+ */
+#define OT_EC_BL_BRIGHTNESS_ADDRESS     0x44
+#define OT_EC_BL_BRIGHTNESS_MAX         100
+#define OT_EC_BL_CONTROL_ADDRESS        0x3A
+#define OT_EC_BL_CONTROL_ON_DATA        0x1A
+
+
+static int force;
+module_param(force, bool, 0);
+MODULE_PARM_DESC(force, "Force driver load, ignore DMI data");
+
+static struct platform_device *oaktrail_device;
+static struct backlight_device *oaktrail_bl_device;
+static struct rfkill *bt_rfkill;
+static struct rfkill *gps_rfkill;
+static struct rfkill *wifi_rfkill;
+static struct rfkill *wwan_rfkill;
+
+
+/* rfkill */
+static int oaktrail_rfkill_set(void *data, bool blocked)
+{
+        u8 value;
+        u8 result;
+        unsigned long radio = (unsigned long) data;
+
+        ec_read(OT_EC_DEVICE_STATE_ADDRESS, &result);
+
+        if (!blocked)
+                value = (u8) (result | radio);
+        else
+                value = (u8) (result & ~radio);
+
+        ec_write(OT_EC_DEVICE_STATE_ADDRESS, value);
+
+        return 0;
+}
+
+static const struct rfkill_ops oaktrail_rfkill_ops = {
+        .set_block = oaktrail_rfkill_set,
+};
+
+static struct rfkill *oaktrail_rfkill_new(char *name, enum rfkill_type type,
+                                          unsigned long mask)
+{
+        struct rfkill *rfkill_dev;
+        u8 value;
+        int err;
+
+        rfkill_dev = rfkill_alloc(name, &oaktrail_device->dev, type,
+                                  &oaktrail_rfkill_ops, (void *)mask);
+        if (!rfkill_dev)
+                return ERR_PTR(-ENOMEM);
+
+        ec_read(OT_EC_DEVICE_STATE_ADDRESS, &value);
+        rfkill_init_sw_state(rfkill_dev, (value & mask) != 1);
+
+        err = rfkill_register(rfkill_dev);
+        if (err) {
+                rfkill_destroy(rfkill_dev);
+                return ERR_PTR(err);
+        }
+
+        return rfkill_dev;
+}
+
+static inline void __oaktrail_rfkill_cleanup(struct rfkill *rf)
+{
+        if (rf) {
+                rfkill_unregister(rf);
+                rfkill_destroy(rf);
+        }
+}
+
+static void oaktrail_rfkill_cleanup(void)
+{
+        __oaktrail_rfkill_cleanup(wifi_rfkill);
+        __oaktrail_rfkill_cleanup(bt_rfkill);
+        __oaktrail_rfkill_cleanup(gps_rfkill);
+        __oaktrail_rfkill_cleanup(wwan_rfkill);
+}
+
+static int oaktrail_rfkill_init(void)
+{
+        int ret;
+
+        wifi_rfkill = oaktrail_rfkill_new("oaktrail-wifi",
+                                          RFKILL_TYPE_WLAN,
+                                          OT_EC_WIFI_MASK);
+        if (IS_ERR(wifi_rfkill)) {
+                ret = PTR_ERR(wifi_rfkill);
+                wifi_rfkill = NULL;
+                goto cleanup;
+        }
+
+        bt_rfkill = oaktrail_rfkill_new("oaktrail-bluetooth",
+                                        RFKILL_TYPE_BLUETOOTH,
+                                        OT_EC_BT_MASK);
+        if (IS_ERR(bt_rfkill)) {
+                ret = PTR_ERR(bt_rfkill);
+                bt_rfkill = NULL;
+                goto cleanup;
+        }
+
+        gps_rfkill = oaktrail_rfkill_new("oaktrail-gps",
+                                         RFKILL_TYPE_GPS,
+                                         OT_EC_GPS_MASK);
+        if (IS_ERR(gps_rfkill)) {
+                ret = PTR_ERR(gps_rfkill);
+                gps_rfkill = NULL;
+                goto cleanup;
+        }
+
+        wwan_rfkill = oaktrail_rfkill_new("oaktrail-wwan",
+                                          RFKILL_TYPE_WWAN,
+                                          OT_EC_WWAN_MASK);
+        if (IS_ERR(wwan_rfkill)) {
+                ret = PTR_ERR(wwan_rfkill);
+                wwan_rfkill = NULL;
+                goto cleanup;
+        }
+
+        return 0;
+
+cleanup:
+        oaktrail_rfkill_cleanup();
+        return ret;
+}
+
+
+/* backlight */
+static int get_backlight_brightness(struct backlight_device *b)
+{
+        u8 value;
+        ec_read(OT_EC_BL_BRIGHTNESS_ADDRESS, &value);
+
+        return value;
+}
+
+static int set_backlight_brightness(struct backlight_device *b)
+{
+        u8 percent = (u8) b->props.brightness;
+        if (percent < 0 || percent > OT_EC_BL_BRIGHTNESS_MAX)
+                return -EINVAL;
+
+        ec_write(OT_EC_BL_BRIGHTNESS_ADDRESS, percent);
+        ec_write(OT_EC_BL_CONTROL_ADDRESS, OT_EC_BL_CONTROL_ON_DATA);
+
+        return 0;
+}
+
+static const struct backlight_ops oaktrail_bl_ops = {
+        .get_brightness = get_backlight_brightness,
+        .update_status  = set_backlight_brightness,
+};
+
+static int oaktrail_backlight_init(void)
+{
+        struct backlight_device *bd;
+        struct backlight_properties props;
+
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = OT_EC_BL_BRIGHTNESS_MAX;
+        bd = backlight_device_register(DRIVER_NAME,
+                                       &oaktrail_device->dev, NULL,
+                                       &oaktrail_bl_ops,
+                                       &props);
+
+        if (IS_ERR(bd)) {
+                oaktrail_bl_device = NULL;
+                pr_warning("Unable to register backlight device\n");
+                return PTR_ERR(bd);
+        }
+
+        oaktrail_bl_device = bd;
+
+        bd->props.brightness = get_backlight_brightness(bd);
+        bd->props.power = FB_BLANK_UNBLANK;
+        backlight_update_status(bd);
+
+        return 0;
+}
+
+static void oaktrail_backlight_exit(void)
+{
+        if (oaktrail_bl_device)
+                backlight_device_unregister(oaktrail_bl_device);
+}
+
+static int __devinit oaktrail_probe(struct platform_device *pdev)
+{
+        return 0;
+}
+
+static int __devexit oaktrail_remove(struct platform_device *pdev)
+{
+        return 0;
+}
+
+static struct platform_driver oaktrail_driver = {
+        .driver = {
+                .name = DRIVER_NAME,
+                .owner = THIS_MODULE,
+        },
+        .probe  = oaktrail_probe,
+        .remove = __devexit_p(oaktrail_remove)
+};
+
+static int dmi_check_cb(const struct dmi_system_id *id)
+{
+        pr_info("Identified model '%s'\n", id->ident);
+        return 0;
+}
+
+static struct dmi_system_id __initdata oaktrail_dmi_table[] = {
+        {
+                .ident = "OakTrail platform",
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "OakTrail platform"),
+                },
+                .callback = dmi_check_cb
+        },
+        { }
+};
+
+static int __init oaktrail_init(void)
+{
+        int ret;
+
+        if (acpi_disabled) {
+                pr_err("ACPI needs to be enabled for this driver to work!\n");
+                return -ENODEV;
+        }
+
+        if (!force && !dmi_check_system(oaktrail_dmi_table)) {
+                pr_err("Platform not recognized (You could try the module's force-parameter)");
+                return -ENODEV;
+        }
+
+        ret = platform_driver_register(&oaktrail_driver);
+        if (ret) {
+                pr_warning("Unable to register platform driver\n");
+                goto err_driver_reg;
+        }
+
+        oaktrail_device = platform_device_alloc(DRIVER_NAME, -1);
+        if (!oaktrail_device) {
+                pr_warning("Unable to allocate platform device\n");
+                ret = -ENOMEM;
+                goto err_device_alloc;
+        }
+
+        ret = platform_device_add(oaktrail_device);
+        if (ret) {
+                pr_warning("Unable to add platform device\n");
+                goto err_device_add;
+        }
+
+        if (!acpi_video_backlight_support()) {
+                ret = oaktrail_backlight_init();
+                if (ret)
+                        goto err_backlight;
+
+        } else
+                pr_info("Backlight controlled by ACPI video driver\n");
+
+        ret = oaktrail_rfkill_init();
+        if (ret) {
+                pr_warning("Setup rfkill failed\n");
+                goto err_rfkill;
+        }
+
+        pr_info("Driver "DRIVER_VERSION" successfully loaded\n");
+        return 0;
+
+err_rfkill:
+        oaktrail_backlight_exit();
+err_backlight:
+        platform_device_del(oaktrail_device);
+err_device_add:
+        platform_device_put(oaktrail_device);
+err_device_alloc:
+        platform_driver_unregister(&oaktrail_driver);
+err_driver_reg:
+
+        return ret;
+}
+
+static void __exit oaktrail_cleanup(void)
+{
+        oaktrail_backlight_exit();
+        oaktrail_rfkill_cleanup();
+        platform_device_unregister(oaktrail_device);
+        platform_driver_unregister(&oaktrail_driver);
+
+        pr_info("Driver unloaded\n");
+}
+
+module_init(oaktrail_init);
+module_exit(oaktrail_cleanup);
+
+MODULE_AUTHOR("Yin Kangkai (kangkai.yin@intel.com)");
+MODULE_DESCRIPTION("Intel Oaktrail Platform ACPI Extras");
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("dmi:*:svnIntelCorporation:pnOakTrailplatform:*");