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 int 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};
 
316
317static int __init oaktrail_init(void)
318{
319	int ret;
320
321	if (acpi_disabled) {
322		pr_err("ACPI needs to be enabled for this driver to work!\n");
323		return -ENODEV;
324	}
325
326	if (!force && !dmi_check_system(oaktrail_dmi_table)) {
327		pr_err("Platform not recognized (You could try the module's force-parameter)");
328		return -ENODEV;
329	}
330
331	ret = platform_driver_register(&oaktrail_driver);
332	if (ret) {
333		pr_warning("Unable to register platform driver\n");
334		goto err_driver_reg;
335	}
336
337	oaktrail_device = platform_device_alloc(DRIVER_NAME, -1);
338	if (!oaktrail_device) {
339		pr_warning("Unable to allocate platform device\n");
340		ret = -ENOMEM;
341		goto err_device_alloc;
342	}
343
344	ret = platform_device_add(oaktrail_device);
345	if (ret) {
346		pr_warning("Unable to add platform device\n");
347		goto err_device_add;
348	}
349
350	if (!acpi_video_backlight_support()) {
351		ret = oaktrail_backlight_init();
352		if (ret)
353			goto err_backlight;
354
355	} else
356		pr_info("Backlight controlled by ACPI video driver\n");
357
358	ret = oaktrail_rfkill_init();
359	if (ret) {
360		pr_warning("Setup rfkill failed\n");
361		goto err_rfkill;
362	}
363
364	pr_info("Driver "DRIVER_VERSION" successfully loaded\n");
365	return 0;
366
367err_rfkill:
368	oaktrail_backlight_exit();
369err_backlight:
370	platform_device_del(oaktrail_device);
371err_device_add:
372	platform_device_put(oaktrail_device);
373err_device_alloc:
374	platform_driver_unregister(&oaktrail_driver);
375err_driver_reg:
376
377	return ret;
378}
379
380static void __exit oaktrail_cleanup(void)
381{
382	oaktrail_backlight_exit();
383	oaktrail_rfkill_cleanup();
384	platform_device_unregister(oaktrail_device);
385	platform_driver_unregister(&oaktrail_driver);
386
387	pr_info("Driver unloaded\n");
388}
389
390module_init(oaktrail_init);
391module_exit(oaktrail_cleanup);
392
393MODULE_AUTHOR("Yin Kangkai (kangkai.yin@intel.com)");
394MODULE_DESCRIPTION("Intel Oaktrail Platform ACPI Extras");
395MODULE_VERSION(DRIVER_VERSION);
396MODULE_LICENSE("GPL");
397MODULE_ALIAS("dmi:*:svnIntelCorporation:pnOakTrailplatform:*");

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