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> | |
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 | ||
90ab5ee9 | 98 | static bool force; |
bb3ce202 YK |
99 | module_param(force, bool, 0); |
100 | MODULE_PARM_DESC(force, "Force driver load, ignore DMI data"); | |
101 | ||
102 | static struct platform_device *oaktrail_device; | |
103 | static struct backlight_device *oaktrail_bl_device; | |
104 | static struct rfkill *bt_rfkill; | |
105 | static struct rfkill *gps_rfkill; | |
106 | static struct rfkill *wifi_rfkill; | |
107 | static struct rfkill *wwan_rfkill; | |
108 | ||
109 | ||
110 | /* rfkill */ | |
111 | static 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 | ||
129 | static const struct rfkill_ops oaktrail_rfkill_ops = { | |
130 | .set_block = oaktrail_rfkill_set, | |
131 | }; | |
132 | ||
133 | static 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 | ||
157 | static inline void __oaktrail_rfkill_cleanup(struct rfkill *rf) | |
158 | { | |
159 | if (rf) { | |
160 | rfkill_unregister(rf); | |
161 | rfkill_destroy(rf); | |
162 | } | |
163 | } | |
164 | ||
165 | static 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 | ||
173 | static 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 | ||
215 | cleanup: | |
216 | oaktrail_rfkill_cleanup(); | |
217 | return ret; | |
218 | } | |
219 | ||
220 | ||
221 | /* backlight */ | |
222 | static 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 | ||
230 | static 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 | ||
242 | static const struct backlight_ops oaktrail_bl_ops = { | |
243 | .get_brightness = get_backlight_brightness, | |
244 | .update_status = set_backlight_brightness, | |
245 | }; | |
246 | ||
247 | static 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)); | |
60cfa098 | 253 | props.type = BACKLIGHT_PLATFORM; |
bb3ce202 YK |
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 | ||
275 | static void oaktrail_backlight_exit(void) | |
276 | { | |
277 | if (oaktrail_bl_device) | |
278 | backlight_device_unregister(oaktrail_bl_device); | |
279 | } | |
280 | ||
b859f159 | 281 | static int oaktrail_probe(struct platform_device *pdev) |
bb3ce202 YK |
282 | { |
283 | return 0; | |
284 | } | |
285 | ||
b859f159 | 286 | static int oaktrail_remove(struct platform_device *pdev) |
bb3ce202 YK |
287 | { |
288 | return 0; | |
289 | } | |
290 | ||
291 | static struct platform_driver oaktrail_driver = { | |
292 | .driver = { | |
293 | .name = DRIVER_NAME, | |
294 | .owner = THIS_MODULE, | |
295 | }, | |
296 | .probe = oaktrail_probe, | |
b859f159 | 297 | .remove = oaktrail_remove, |
bb3ce202 YK |
298 | }; |
299 | ||
300 | static 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 | ||
306 | static 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 | }; | |
dc2cbb3b | 316 | MODULE_DEVICE_TABLE(dmi, oaktrail_dmi_table); |
bb3ce202 YK |
317 | |
318 | static 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 | ||
368 | err_rfkill: | |
369 | oaktrail_backlight_exit(); | |
370 | err_backlight: | |
371 | platform_device_del(oaktrail_device); | |
372 | err_device_add: | |
373 | platform_device_put(oaktrail_device); | |
374 | err_device_alloc: | |
375 | platform_driver_unregister(&oaktrail_driver); | |
376 | err_driver_reg: | |
377 | ||
378 | return ret; | |
379 | } | |
380 | ||
381 | static 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 | ||
391 | module_init(oaktrail_init); | |
392 | module_exit(oaktrail_cleanup); | |
393 | ||
394 | MODULE_AUTHOR("Yin Kangkai (kangkai.yin@intel.com)"); | |
395 | MODULE_DESCRIPTION("Intel Oaktrail Platform ACPI Extras"); | |
396 | MODULE_VERSION(DRIVER_VERSION); | |
397 | MODULE_LICENSE("GPL"); |