[mirror_ubuntu-bionic-kernel.git] / drivers / platform / x86 / intel_oaktrail.c

/*
 * 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/video.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/disable, 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 bool 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.type = BACKLIGHT_PLATFORM;
	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)
{
	backlight_device_unregister(oaktrail_bl_device);
}

static int oaktrail_probe(struct platform_device *pdev)
{
	return 0;
}

static int oaktrail_remove(struct platform_device *pdev)
{
	return 0;
}

static struct platform_driver oaktrail_driver = {
	.driver = {
		.name = DRIVER_NAME,
	},
	.probe	= oaktrail_probe,
	.remove	= oaktrail_remove,
};

static int dmi_check_cb(const struct dmi_system_id *id)
{
	pr_info("Identified model '%s'\n", id->ident);
	return 0;
}

static const struct dmi_system_id oaktrail_dmi_table[] __initconst = {
	{
		.ident = "OakTrail platform",
		.matches = {
			DMI_MATCH(DMI_PRODUCT_NAME, "OakTrail platform"),
		},
		.callback = dmi_check_cb
	},
	{ }
};
MODULE_DEVICE_TABLE(dmi, oaktrail_dmi_table);

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_get_backlight_type() == acpi_backlight_vendor) {
		ret = oaktrail_backlight_init();
		if (ret)
			goto err_backlight;
	}

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