drivers/platform/x86/intel_oaktrail.c

   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
  54 #define DRIVER_NAME     "intel_oaktrail"
  55 #define DRIVER_VERSION  "0.4ac1"
  56
  57 /*
  58  * This is the devices status address in EC space, and the control bits
  59  * definition:
  60  *
  61  * (1 << 0):    Camera enable/disable, RW.
  62  * (1 << 1):    Bluetooth enable/disable, RW.
  63  * (1 << 2):    GPS enable/disable, RW.
  64  * (1 << 3):    WiFi enable/disable, RW.
  65  * (1 << 4):    WWAN (3G) enable/disalbe, RW.
  66  * (1 << 5):    Touchscreen enable/disable, Read Only.
  67  */
  68 #define OT_EC_DEVICE_STATE_ADDRESS      0xD6
  69
  70 #define OT_EC_CAMERA_MASK       (1 << 0)
  71 #define OT_EC_BT_MASK           (1 << 1)
  72 #define OT_EC_GPS_MASK          (1 << 2)
  73 #define OT_EC_WIFI_MASK         (1 << 3)
  74 #define OT_EC_WWAN_MASK         (1 << 4)
  75 #define OT_EC_TS_MASK           (1 << 5)
  76
  77 /*
  78  * This is the address in EC space and commands used to control LCD backlight:
  79  *
  80  * Two steps needed to change the LCD backlight:
  81  *   1. write the backlight percentage into OT_EC_BL_BRIGHTNESS_ADDRESS;
  82  *   2. write OT_EC_BL_CONTROL_ON_DATA into OT_EC_BL_CONTROL_ADDRESS.
  83  *
  84  * To read the LCD back light, just read out the value from
  85  * OT_EC_BL_BRIGHTNESS_ADDRESS.
  86  *
  87  * LCD backlight brightness range: 0 - 100 (OT_EC_BL_BRIGHTNESS_MAX)
  88  */
  89 #define OT_EC_BL_BRIGHTNESS_ADDRESS     0x44
  90 #define OT_EC_BL_BRIGHTNESS_MAX         100
  91 #define OT_EC_BL_CONTROL_ADDRESS        0x3A
  92 #define OT_EC_BL_CONTROL_ON_DATA        0x1A
  93
  94
  95 static bool force;
  96 module_param(force, bool, 0);
  97 MODULE_PARM_DESC(force, "Force driver load, ignore DMI data");
  98
  99 static struct platform_device *oaktrail_device;
 100 static struct backlight_device *oaktrail_bl_device;
 101 static struct rfkill *bt_rfkill;
 102 static struct rfkill *gps_rfkill;
 103 static struct rfkill *wifi_rfkill;
 104 static struct rfkill *wwan_rfkill;
 105
 106
 107 /* rfkill */
 108 static int oaktrail_rfkill_set(void *data, bool blocked)
 109 {
 110         u8 value;
 111         u8 result;
 112         unsigned long radio = (unsigned long) data;
 113
 114         ec_read(OT_EC_DEVICE_STATE_ADDRESS, &result);
 115
 116         if (!blocked)
 117                 value = (u8) (result | radio);
 118         else
 119                 value = (u8) (result & ~radio);
 120
 121         ec_write(OT_EC_DEVICE_STATE_ADDRESS, value);
 122
 123         return 0;
 124 }
 125
 126 static const struct rfkill_ops oaktrail_rfkill_ops = {
 127         .set_block = oaktrail_rfkill_set,
 128 };
 129
 130 static struct rfkill *oaktrail_rfkill_new(char *name, enum rfkill_type type,
 131                                           unsigned long mask)
 132 {
 133         struct rfkill *rfkill_dev;
 134         u8 value;
 135         int err;
 136
 137         rfkill_dev = rfkill_alloc(name, &oaktrail_device->dev, type,
 138                                   &oaktrail_rfkill_ops, (void *)mask);
 139         if (!rfkill_dev)
 140                 return ERR_PTR(-ENOMEM);
 141
 142         ec_read(OT_EC_DEVICE_STATE_ADDRESS, &value);
 143         rfkill_init_sw_state(rfkill_dev, (value & mask) != 1);
 144
 145         err = rfkill_register(rfkill_dev);
 146         if (err) {
 147                 rfkill_destroy(rfkill_dev);
 148                 return ERR_PTR(err);
 149         }
 150
 151         return rfkill_dev;
 152 }
 153
 154 static inline void __oaktrail_rfkill_cleanup(struct rfkill *rf)
 155 {
 156         if (rf) {
 157                 rfkill_unregister(rf);
 158                 rfkill_destroy(rf);
 159         }
 160 }
 161
 162 static void oaktrail_rfkill_cleanup(void)
 163 {
 164         __oaktrail_rfkill_cleanup(wifi_rfkill);
 165         __oaktrail_rfkill_cleanup(bt_rfkill);
 166         __oaktrail_rfkill_cleanup(gps_rfkill);
 167         __oaktrail_rfkill_cleanup(wwan_rfkill);
 168 }
 169
 170 static int oaktrail_rfkill_init(void)
 171 {
 172         int ret;
 173
 174         wifi_rfkill = oaktrail_rfkill_new("oaktrail-wifi",
 175                                           RFKILL_TYPE_WLAN,
 176                                           OT_EC_WIFI_MASK);
 177         if (IS_ERR(wifi_rfkill)) {
 178                 ret = PTR_ERR(wifi_rfkill);
 179                 wifi_rfkill = NULL;
 180                 goto cleanup;
 181         }
 182
 183         bt_rfkill = oaktrail_rfkill_new("oaktrail-bluetooth",
 184                                         RFKILL_TYPE_BLUETOOTH,
 185                                         OT_EC_BT_MASK);
 186         if (IS_ERR(bt_rfkill)) {
 187                 ret = PTR_ERR(bt_rfkill);
 188                 bt_rfkill = NULL;
 189                 goto cleanup;
 190         }
 191
 192         gps_rfkill = oaktrail_rfkill_new("oaktrail-gps",
 193                                          RFKILL_TYPE_GPS,
 194                                          OT_EC_GPS_MASK);
 195         if (IS_ERR(gps_rfkill)) {
 196                 ret = PTR_ERR(gps_rfkill);
 197                 gps_rfkill = NULL;
 198                 goto cleanup;
 199         }
 200
 201         wwan_rfkill = oaktrail_rfkill_new("oaktrail-wwan",
 202                                           RFKILL_TYPE_WWAN,
 203                                           OT_EC_WWAN_MASK);
 204         if (IS_ERR(wwan_rfkill)) {
 205                 ret = PTR_ERR(wwan_rfkill);
 206                 wwan_rfkill = NULL;
 207                 goto cleanup;
 208         }
 209
 210         return 0;
 211
 212 cleanup:
 213         oaktrail_rfkill_cleanup();
 214         return ret;
 215 }
 216
 217
 218 /* backlight */
 219 static int get_backlight_brightness(struct backlight_device *b)
 220 {
 221         u8 value;
 222         ec_read(OT_EC_BL_BRIGHTNESS_ADDRESS, &value);
 223
 224         return value;
 225 }
 226
 227 static int set_backlight_brightness(struct backlight_device *b)
 228 {
 229         u8 percent = (u8) b->props.brightness;
 230         if (percent < 0 || percent > OT_EC_BL_BRIGHTNESS_MAX)
 231                 return -EINVAL;
 232
 233         ec_write(OT_EC_BL_BRIGHTNESS_ADDRESS, percent);
 234         ec_write(OT_EC_BL_CONTROL_ADDRESS, OT_EC_BL_CONTROL_ON_DATA);
 235
 236         return 0;
 237 }
 238
 239 static const struct backlight_ops oaktrail_bl_ops = {
 240         .get_brightness = get_backlight_brightness,
 241         .update_status  = set_backlight_brightness,
 242 };
 243
 244 static int oaktrail_backlight_init(void)
 245 {
 246         struct backlight_device *bd;
 247         struct backlight_properties props;
 248
 249         memset(&props, 0, sizeof(struct backlight_properties));
 250         props.type = BACKLIGHT_PLATFORM;
 251         props.max_brightness = OT_EC_BL_BRIGHTNESS_MAX;
 252         bd = backlight_device_register(DRIVER_NAME,
 253                                        &oaktrail_device->dev, NULL,
 254                                        &oaktrail_bl_ops,
 255                                        &props);
 256
 257         if (IS_ERR(bd)) {
 258                 oaktrail_bl_device = NULL;
 259                 pr_warning("Unable to register backlight device\n");
 260                 return PTR_ERR(bd);
 261         }
 262
 263         oaktrail_bl_device = bd;
 264
 265         bd->props.brightness = get_backlight_brightness(bd);
 266         bd->props.power = FB_BLANK_UNBLANK;
 267         backlight_update_status(bd);
 268
 269         return 0;
 270 }
 271
 272 static void oaktrail_backlight_exit(void)
 273 {
 274         if (oaktrail_bl_device)
 275                 backlight_device_unregister(oaktrail_bl_device);
 276 }
 277
 278 static int oaktrail_probe(struct platform_device *pdev)
 279 {
 280         return 0;
 281 }
 282
 283 static int oaktrail_remove(struct platform_device *pdev)
 284 {
 285         return 0;
 286 }
 287
 288 static struct platform_driver oaktrail_driver = {
 289         .driver = {
 290                 .name = DRIVER_NAME,
 291                 .owner = THIS_MODULE,
 292         },
 293         .probe  = oaktrail_probe,
 294         .remove = oaktrail_remove,
 295 };
 296
 297 static int dmi_check_cb(const struct dmi_system_id *id)
 298 {
 299         pr_info("Identified model '%s'\n", id->ident);
 300         return 0;
 301 }
 302
 303 static struct dmi_system_id __initdata oaktrail_dmi_table[] = {
 304         {
 305                 .ident = "OakTrail platform",
 306                 .matches = {
 307                         DMI_MATCH(DMI_PRODUCT_NAME, "OakTrail platform"),
 308                 },
 309                 .callback = dmi_check_cb
 310         },
 311         { }
 312 };
 313 MODULE_DEVICE_TABLE(dmi, oaktrail_dmi_table);
 314
 315 static int __init oaktrail_init(void)
 316 {
 317         int ret;
 318
 319         if (acpi_disabled) {
 320                 pr_err("ACPI needs to be enabled for this driver to work!\n");
 321                 return -ENODEV;
 322         }
 323
 324         if (!force && !dmi_check_system(oaktrail_dmi_table)) {
 325                 pr_err("Platform not recognized (You could try the module's force-parameter)");
 326                 return -ENODEV;
 327         }
 328
 329         ret = platform_driver_register(&oaktrail_driver);
 330         if (ret) {
 331                 pr_warning("Unable to register platform driver\n");
 332                 goto err_driver_reg;
 333         }
 334
 335         oaktrail_device = platform_device_alloc(DRIVER_NAME, -1);
 336         if (!oaktrail_device) {
 337                 pr_warning("Unable to allocate platform device\n");
 338                 ret = -ENOMEM;
 339                 goto err_device_alloc;
 340         }
 341
 342         ret = platform_device_add(oaktrail_device);
 343         if (ret) {
 344                 pr_warning("Unable to add platform device\n");
 345                 goto err_device_add;
 346         }
 347
 348         if (!acpi_video_backlight_support()) {
 349                 ret = oaktrail_backlight_init();
 350                 if (ret)
 351                         goto err_backlight;
 352
 353         } else
 354                 pr_info("Backlight controlled by ACPI video driver\n");
 355
 356         ret = oaktrail_rfkill_init();
 357         if (ret) {
 358                 pr_warning("Setup rfkill failed\n");
 359                 goto err_rfkill;
 360         }
 361
 362         pr_info("Driver "DRIVER_VERSION" successfully loaded\n");
 363         return 0;
 364
 365 err_rfkill:
 366         oaktrail_backlight_exit();
 367 err_backlight:
 368         platform_device_del(oaktrail_device);
 369 err_device_add:
 370         platform_device_put(oaktrail_device);
 371 err_device_alloc:
 372         platform_driver_unregister(&oaktrail_driver);
 373 err_driver_reg:
 374
 375         return ret;
 376 }
 377
 378 static void __exit oaktrail_cleanup(void)
 379 {
 380         oaktrail_backlight_exit();
 381         oaktrail_rfkill_cleanup();
 382         platform_device_unregister(oaktrail_device);
 383         platform_driver_unregister(&oaktrail_driver);
 384
 385         pr_info("Driver unloaded\n");
 386 }
 387
 388 module_init(oaktrail_init);
 389 module_exit(oaktrail_cleanup);
 390
 391 MODULE_AUTHOR("Yin Kangkai (kangkai.yin@intel.com)");
 392 MODULE_DESCRIPTION("Intel Oaktrail Platform ACPI Extras");
 393 MODULE_VERSION(DRIVER_VERSION);
 394 MODULE_LICENSE("GPL");