LXR linux/drivers/platform/x86/intel

   1/*
   2 * intel_oaktrail.c - Intel OakTrail Platform support.
   3 *
   4 * Copyright (C) 2010-2011 Intel Corporation
   5 * Author: Yin Kangkai (kangkai.yin@intel.com)
   6 *
   7 * based on Compal driver, Copyright (C) 2008 Cezary Jackiewicz
   8 * <cezary.jackiewicz (at) gmail.com>, based on MSI driver
   9 * Copyright (C) 2006 Lennart Poettering <mzxreary (at) 0pointer (dot) de>
  10 *
  11 *  This program is free software; you can redistribute it and/or modify
  12 *  it under the terms of the GNU General Public License as published by
  13 *  the Free Software Foundation; either version 2 of the License, or
  14 *  (at your option) any later version.
  15 *
  16 *  This program is distributed in the hope that it will be useful, but
  17 *  WITHOUT ANY WARRANTY; without even the implied warranty of
  18 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19 *  General Public License for more details.
  20 *
  21 *  You should have received a copy of the GNU General Public License
  22 *  along with this program; if not, write to the Free Software
  23 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  24 *  02110-1301, USA.
  25 *
  26 * This driver does below things:
  27 * 1. registers itself in the Linux backlight control in
  28 *    /sys/class/backlight/intel_oaktrail/
  29 *
  30 * 2. registers in the rfkill subsystem here: /sys/class/rfkill/rfkillX/
  31 *    for these components: wifi, bluetooth, wwan (3g), gps
  32 *
  33 * This driver might work on other products based on Oaktrail. If you
  34 * want to try it you can pass force=1 as argument to the module which
  35 * will force it to load even when the DMI data doesn't identify the
  36 * product as compatible.
  37 */
  38
  39#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  40
  41#include <linux/module.h>
  42#include <linux/kernel.h>
  43#include <linux/init.h>
  44#include <linux/acpi.h>
  45#include <linux/fb.h>
  46#include <linux/mutex.h>
  47#include <linux/err.h>
  48#include <linux/i2c.h>
  49#include <linux/backlight.h>
  50#include <linux/platform_device.h>
  51#include <linux/dmi.h>
  52#include <linux/rfkill.h>
  53#include <acpi/acpi_bus.h>
  54#include <acpi/acpi_drivers.h>
  55
  56
  57#define DRIVER_NAME     "intel_oaktrail"
  58#define DRIVER_VERSION  "0.4ac1"
  59
  60/*
  61 * This is the devices status address in EC space, and the control bits
  62 * definition:
  63 *
  64 * (1 << 0):    Camera enable/disable, RW.
  65 * (1 << 1):    Bluetooth enable/disable, RW.
  66 * (1 << 2):    GPS enable/disable, RW.
  67 * (1 << 3):    WiFi enable/disable, RW.
  68 * (1 << 4):    WWAN (3G) enable/disalbe, RW.
  69 * (1 << 5):    Touchscreen enable/disable, Read Only.
  70 */
  71#define OT_EC_DEVICE_STATE_ADDRESS      0xD6
  72
  73#define OT_EC_CAMERA_MASK       (1 << 0)
  74#define OT_EC_BT_MASK           (1 << 1)
  75#define OT_EC_GPS_MASK          (1 << 2)
  76#define OT_EC_WIFI_MASK         (1 << 3)
  77#define OT_EC_WWAN_MASK         (1 << 4)
  78#define OT_EC_TS_MASK           (1 << 5)
  79
  80/*
  81 * This is the address in EC space and commands used to control LCD backlight:
  82 *
  83 * Two steps needed to change the LCD backlight:
  84 *   1. write the backlight percentage into OT_EC_BL_BRIGHTNESS_ADDRESS;
  85 *   2. write OT_EC_BL_CONTROL_ON_DATA into OT_EC_BL_CONTROL_ADDRESS.
  86 *
  87 * To read the LCD back light, just read out the value from
  88 * OT_EC_BL_BRIGHTNESS_ADDRESS.
  89 *
  90 * LCD backlight brightness range: 0 - 100 (OT_EC_BL_BRIGHTNESS_MAX)
  91 */
  92#define OT_EC_BL_BRIGHTNESS_ADDRESS     0x44
  93#define OT_EC_BL_BRIGHTNESS_MAX         100
  94#define OT_EC_BL_CONTROL_ADDRESS        0x3A
  95#define OT_EC_BL_CONTROL_ON_DATA        0x1A
  96
  97
  98static bool force;
  99module_param(force, bool, 0);
 100MODULE_PARM_DESC(force, "Force driver load, ignore DMI data");
 101
 102static struct platform_device *oaktrail_device;
 103static struct backlight_device *oaktrail_bl_device;
 104static struct rfkill *bt_rfkill;
 105static struct rfkill *gps_rfkill;
 106static struct rfkill *wifi_rfkill;
 107static struct rfkill *wwan_rfkill;
 108
 109
 110/* rfkill */
 111static int oaktrail_rfkill_set(void *data, bool blocked)
 112{
 113        u8 value;
 114        u8 result;
 115        unsigned long radio = (unsigned long) data;
 116
 117        ec_read(OT_EC_DEVICE_STATE_ADDRESS, &result);
 118
 119        if (!blocked)
 120                value = (u8) (result | radio);
 121        else
 122                value = (u8) (result & ~radio);
 123
 124        ec_write(OT_EC_DEVICE_STATE_ADDRESS, value);
 125
 126        return 0;
 127}
 128
 129static const struct rfkill_ops oaktrail_rfkill_ops = {
 130        .set_block = oaktrail_rfkill_set,
 131};
 132
 133static struct rfkill *oaktrail_rfkill_new(char *name, enum rfkill_type type,
 134                                          unsigned long mask)
 135{
 136        struct rfkill *rfkill_dev;
 137        u8 value;
 138        int err;
 139
 140        rfkill_dev = rfkill_alloc(name, &oaktrail_device->dev, type,
 141                                  &oaktrail_rfkill_ops, (void *)mask);
 142        if (!rfkill_dev)
 143                return ERR_PTR(-ENOMEM);
 144
 145        ec_read(OT_EC_DEVICE_STATE_ADDRESS, &value);
 146        rfkill_init_sw_state(rfkill_dev, (value & mask) != 1);
 147
 148        err = rfkill_register(rfkill_dev);
 149        if (err) {
 150                rfkill_destroy(rfkill_dev);
 151                return ERR_PTR(err);
 152        }
 153
 154        return rfkill_dev;
 155}
 156
 157static inline void __oaktrail_rfkill_cleanup(struct rfkill *rf)
 158{
 159        if (rf) {
 160                rfkill_unregister(rf);
 161                rfkill_destroy(rf);
 162        }
 163}
 164
 165static void oaktrail_rfkill_cleanup(void)
 166{
 167        __oaktrail_rfkill_cleanup(wifi_rfkill);
 168        __oaktrail_rfkill_cleanup(bt_rfkill);
 169        __oaktrail_rfkill_cleanup(gps_rfkill);
 170        __oaktrail_rfkill_cleanup(wwan_rfkill);
 171}
 172
 173static int oaktrail_rfkill_init(void)
 174{
 175        int ret;
 176
 177        wifi_rfkill = oaktrail_rfkill_new("oaktrail-wifi",
 178                                          RFKILL_TYPE_WLAN,
 179                                          OT_EC_WIFI_MASK);
 180        if (IS_ERR(wifi_rfkill)) {
 181                ret = PTR_ERR(wifi_rfkill);
 182                wifi_rfkill = NULL;
 183                goto cleanup;
 184        }
 185
 186        bt_rfkill = oaktrail_rfkill_new("oaktrail-bluetooth",
 187                                        RFKILL_TYPE_BLUETOOTH,
 188                                        OT_EC_BT_MASK);
 189        if (IS_ERR(bt_rfkill)) {
 190                ret = PTR_ERR(bt_rfkill);
 191                bt_rfkill = NULL;
 192                goto cleanup;
 193        }
 194
 195        gps_rfkill = oaktrail_rfkill_new("oaktrail-gps",
 196                                         RFKILL_TYPE_GPS,
 197                                         OT_EC_GPS_MASK);
 198        if (IS_ERR(gps_rfkill)) {
 199                ret = PTR_ERR(gps_rfkill);
 200                gps_rfkill = NULL;
 201                goto cleanup;
 202        }
 203
 204        wwan_rfkill = oaktrail_rfkill_new("oaktrail-wwan",
 205                                          RFKILL_TYPE_WWAN,
 206                                          OT_EC_WWAN_MASK);
 207        if (IS_ERR(wwan_rfkill)) {
 208                ret = PTR_ERR(wwan_rfkill);
 209                wwan_rfkill = NULL;
 210                goto cleanup;
 211        }
 212
 213        return 0;
 214
 215cleanup:
 216        oaktrail_rfkill_cleanup();
 217        return ret;
 218}
 219
 220
 221/* backlight */
 222static int get_backlight_brightness(struct backlight_device *b)
 223{
 224        u8 value;
 225        ec_read(OT_EC_BL_BRIGHTNESS_ADDRESS, &value);
 226
 227        return value;
 228}
 229
 230static int set_backlight_brightness(struct backlight_device *b)
 231{
 232        u8 percent = (u8) b->props.brightness;
 233        if (percent < 0 || percent > OT_EC_BL_BRIGHTNESS_MAX)
 234                return -EINVAL;
 235
 236        ec_write(OT_EC_BL_BRIGHTNESS_ADDRESS, percent);
 237        ec_write(OT_EC_BL_CONTROL_ADDRESS, OT_EC_BL_CONTROL_ON_DATA);
 238
 239        return 0;
 240}
 241
 242static const struct backlight_ops oaktrail_bl_ops = {
 243        .get_brightness = get_backlight_brightness,
 244        .update_status  = set_backlight_brightness,
 245};
 246
 247static int oaktrail_backlight_init(void)
 248{
 249        struct backlight_device *bd;
 250        struct backlight_properties props;
 251
 252        memset(&props, 0, sizeof(struct backlight_properties));
 253        props.type = BACKLIGHT_PLATFORM;
 254        props.max_brightness = OT_EC_BL_BRIGHTNESS_MAX;
 255        bd = backlight_device_register(DRIVER_NAME,
 256                                       &oaktrail_device->dev, NULL,
 257                                       &oaktrail_bl_ops,
 258                                       &props);
 259
 260        if (IS_ERR(bd)) {
 261                oaktrail_bl_device = NULL;
 262                pr_warning("Unable to register backlight device\n");
 263                return PTR_ERR(bd);
 264        }
 265
 266        oaktrail_bl_device = bd;
 267
 268        bd->props.brightness = get_backlight_brightness(bd);
 269        bd->props.power = FB_BLANK_UNBLANK;
 270        backlight_update_status(bd);
 271
 272        return 0;
 273}
 274
 275static void oaktrail_backlight_exit(void)
 276{
 277        if (oaktrail_bl_device)
 278                backlight_device_unregister(oaktrail_bl_device);
 279}
 280
 281static int oaktrail_probe(struct platform_device *pdev)
 282{
 283        return 0;
 284}
 285
 286static int oaktrail_remove(struct platform_device *pdev)
 287{
 288        return 0;
 289}
 290
 291static struct platform_driver oaktrail_driver = {
 292        .driver = {
 293                .name = DRIVER_NAME,
 294                .owner = THIS_MODULE,
 295        },
 296        .probe  = oaktrail_probe,
 297        .remove = oaktrail_remove,
 298};
 299
 300static int dmi_check_cb(const struct dmi_system_id *id)
 301{
 302        pr_info("Identified model '%s'\n", id->ident);
 303        return 0;
 304}
 305
 306static struct dmi_system_id __initdata oaktrail_dmi_table[] = {
 307        {
 308                .ident = "OakTrail platform",
 309                .matches = {
 310                        DMI_MATCH(DMI_PRODUCT_NAME, "OakTrail platform"),
 311                },
 312                .callback = dmi_check_cb
 313        },
 314        { }
 315};
 316MODULE_DEVICE_TABLE(dmi, oaktrail_dmi_table);
 317
 318static int __init oaktrail_init(void)
 319{
 320        int ret;
 321
 322        if (acpi_disabled) {
 323                pr_err("ACPI needs to be enabled for this driver to work!\n");
 324                return -ENODEV;
 325        }
 326
 327        if (!force && !dmi_check_system(oaktrail_dmi_table)) {
 328                pr_err("Platform not recognized (You could try the module's force-parameter)");
 329                return -ENODEV;
 330        }
 331
 332        ret = platform_driver_register(&oaktrail_driver);
 333        if (ret) {
 334                pr_warning("Unable to register platform driver\n");
 335                goto err_driver_reg;
 336        }
 337
 338        oaktrail_device = platform_device_alloc(DRIVER_NAME, -1);
 339        if (!oaktrail_device) {
 340                pr_warning("Unable to allocate platform device\n");
 341                ret = -ENOMEM;
 342                goto err_device_alloc;
 343        }
 344
 345        ret = platform_device_add(oaktrail_device);
 346        if (ret) {
 347                pr_warning("Unable to add platform device\n");
 348                goto err_device_add;
 349        }
 350
 351        if (!acpi_video_backlight_support()) {
 352                ret = oaktrail_backlight_init();
 353                if (ret)
 354                        goto err_backlight;
 355
 356        } else
 357                pr_info("Backlight controlled by ACPI video driver\n");
 358
 359        ret = oaktrail_rfkill_init();
 360        if (ret) {
 361                pr_warning("Setup rfkill failed\n");
 362                goto err_rfkill;
 363        }
 364
 365        pr_info("Driver "DRIVER_VERSION" successfully loaded\n");
 366        return 0;
 367
 368err_rfkill:
 369        oaktrail_backlight_exit();
 370err_backlight:
 371        platform_device_del(oaktrail_device);
 372err_device_add:
 373        platform_device_put(oaktrail_device);
 374err_device_alloc:
 375        platform_driver_unregister(&oaktrail_driver);
 376err_driver_reg:
 377
 378        return ret;
 379}
 380
 381static void __exit oaktrail_cleanup(void)
 382{
 383        oaktrail_backlight_exit();
 384        oaktrail_rfkill_cleanup();
 385        platform_device_unregister(oaktrail_device);
 386        platform_driver_unregister(&oaktrail_driver);
 387
 388        pr_info("Driver unloaded\n");
 389}
 390
 391module_init(oaktrail_init);
 392module_exit(oaktrail_cleanup);
 393
 394MODULE_AUTHOR("Yin Kangkai (kangkai.yin@intel.com)");
 395MODULE_DESCRIPTION("Intel Oaktrail Platform ACPI Extras");
 396MODULE_VERSION(DRIVER_VERSION);
 397MODULE_LICENSE("GPL");
 398