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 __devinit oaktrail_probe(struct platform_device *pdev) 282{ 283 return 0; 284} 285 286static int __devexit 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 = __devexit_p(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