Commit | Line | Data |
---|---|---|
5411552c CJ |
1 | /*-*-linux-c-*-*/ |
2 | ||
3 | /* | |
4 | Copyright (C) 2008 Cezary Jackiewicz <cezary.jackiewicz (at) gmail.com> | |
5 | ||
6 | based on MSI driver | |
7 | ||
8 | Copyright (C) 2006 Lennart Poettering <mzxreary (at) 0pointer (dot) de> | |
9 | ||
10 | This program is free software; you can redistribute it and/or modify | |
11 | it under the terms of the GNU General Public License as published by | |
12 | the Free Software Foundation; either version 2 of the License, or | |
13 | (at your option) any later version. | |
14 | ||
15 | This program is distributed in the hope that it will be useful, but | |
16 | WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
18 | General Public License for more details. | |
19 | ||
20 | You should have received a copy of the GNU General Public License | |
21 | along with this program; if not, write to the Free Software | |
22 | Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
23 | 02110-1301, USA. | |
24 | */ | |
25 | ||
26 | /* | |
9be0fcb5 RF |
27 | * compal-laptop.c - Compal laptop support. |
28 | * | |
29 | * This driver exports a few files in /sys/devices/platform/compal-laptop/: | |
30 | * wake_up_XXX Whether or not we listen to such wake up events (rw) | |
31 | * | |
32 | * In addition to these platform device attributes the driver | |
33 | * registers itself in the Linux backlight control, power_supply, rfkill | |
34 | * and hwmon subsystem and is available to userspace under: | |
35 | * | |
36 | * /sys/class/backlight/compal-laptop/ | |
37 | * /sys/class/power_supply/compal-laptop/ | |
38 | * /sys/class/rfkill/rfkillX/ | |
39 | * /sys/class/hwmon/hwmonX/ | |
40 | * | |
41 | * Notes on the power_supply battery interface: | |
42 | * - the "minimum" design voltage is *the* design voltage | |
43 | * - the ambient temperature is the average battery temperature | |
44 | * and the value is an educated guess (see commented code below) | |
5411552c | 45 | * |
5411552c CJ |
46 | * |
47 | * This driver might work on other laptops produced by Compal. If you | |
48 | * want to try it you can pass force=1 as argument to the module which | |
49 | * will force it to load even when the DMI data doesn't identify the | |
9be0fcb5 RF |
50 | * laptop as compatible. |
51 | * | |
52 | * Lots of data available at: | |
53 | * http://service1.marasst.com/Compal/JHL90_91/Service%20Manual/ | |
54 | * JHL90%20service%20manual-Final-0725.pdf | |
55 | * | |
56 | * | |
57 | * | |
58 | * Support for the Compal JHL90 added by Roald Frederickx | |
59 | * (roald.frederickx@gmail.com): | |
60 | * Driver got large revision. Added functionalities: backlight | |
61 | * power, wake_on_XXX, a hwmon and power_supply interface. | |
62 | * | |
63 | * In case this gets merged into the kernel source: I want to dedicate this | |
64 | * to Kasper Meerts, the awesome guy who showed me Linux and C! | |
5411552c CJ |
65 | */ |
66 | ||
9be0fcb5 RF |
67 | /* NOTE: currently the wake_on_XXX, hwmon and power_supply interfaces are |
68 | * only enabled on a JHL90 board until it is verified that they work on the | |
69 | * other boards too. See the extra_features variable. */ | |
70 | ||
b4a4bc0b JP |
71 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
72 | ||
5411552c CJ |
73 | #include <linux/module.h> |
74 | #include <linux/kernel.h> | |
75 | #include <linux/init.h> | |
76 | #include <linux/acpi.h> | |
77 | #include <linux/dmi.h> | |
78 | #include <linux/backlight.h> | |
79 | #include <linux/platform_device.h> | |
493e9143 | 80 | #include <linux/rfkill.h> |
9be0fcb5 RF |
81 | #include <linux/hwmon.h> |
82 | #include <linux/hwmon-sysfs.h> | |
83 | #include <linux/power_supply.h> | |
84 | #include <linux/fb.h> | |
85 | ||
86 | ||
87 | /* ======= */ | |
88 | /* Defines */ | |
89 | /* ======= */ | |
90 | #define DRIVER_NAME "compal-laptop" | |
91 | #define DRIVER_VERSION "0.2.7" | |
92 | ||
93 | #define BACKLIGHT_LEVEL_ADDR 0xB9 | |
94 | #define BACKLIGHT_LEVEL_MAX 7 | |
95 | #define BACKLIGHT_STATE_ADDR 0x59 | |
96 | #define BACKLIGHT_STATE_ON_DATA 0xE1 | |
97 | #define BACKLIGHT_STATE_OFF_DATA 0xE2 | |
98 | ||
99 | #define WAKE_UP_ADDR 0xA4 | |
100 | #define WAKE_UP_PME (1 << 0) | |
101 | #define WAKE_UP_MODEM (1 << 1) | |
102 | #define WAKE_UP_LAN (1 << 2) | |
103 | #define WAKE_UP_WLAN (1 << 4) | |
104 | #define WAKE_UP_KEY (1 << 6) | |
105 | #define WAKE_UP_MOUSE (1 << 7) | |
106 | ||
107 | #define WIRELESS_ADDR 0xBB | |
108 | #define WIRELESS_WLAN (1 << 0) | |
109 | #define WIRELESS_BT (1 << 1) | |
110 | #define WIRELESS_WLAN_EXISTS (1 << 2) | |
111 | #define WIRELESS_BT_EXISTS (1 << 3) | |
112 | #define WIRELESS_KILLSWITCH (1 << 4) | |
113 | ||
114 | #define PWM_ADDRESS 0x46 | |
115 | #define PWM_DISABLE_ADDR 0x59 | |
116 | #define PWM_DISABLE_DATA 0xA5 | |
117 | #define PWM_ENABLE_ADDR 0x59 | |
118 | #define PWM_ENABLE_DATA 0xA8 | |
119 | ||
120 | #define FAN_ADDRESS 0x46 | |
121 | #define FAN_DATA 0x81 | |
122 | #define FAN_FULL_ON_CMD 0x59 /* Doesn't seem to work. Just */ | |
123 | #define FAN_FULL_ON_ENABLE 0x76 /* force the pwm signal to its */ | |
124 | #define FAN_FULL_ON_DISABLE 0x77 /* maximum value instead */ | |
125 | ||
126 | #define TEMP_CPU 0xB0 | |
127 | #define TEMP_CPU_LOCAL 0xB1 | |
128 | #define TEMP_CPU_DTS 0xB5 | |
129 | #define TEMP_NORTHBRIDGE 0xB6 | |
130 | #define TEMP_VGA 0xB4 | |
131 | #define TEMP_SKIN 0xB2 | |
132 | ||
133 | #define BAT_MANUFACTURER_NAME_ADDR 0x10 | |
134 | #define BAT_MANUFACTURER_NAME_LEN 9 | |
135 | #define BAT_MODEL_NAME_ADDR 0x19 | |
136 | #define BAT_MODEL_NAME_LEN 6 | |
137 | #define BAT_SERIAL_NUMBER_ADDR 0xC4 | |
138 | #define BAT_SERIAL_NUMBER_LEN 5 | |
139 | #define BAT_CHARGE_NOW 0xC2 | |
140 | #define BAT_CHARGE_DESIGN 0xCA | |
141 | #define BAT_VOLTAGE_NOW 0xC6 | |
142 | #define BAT_VOLTAGE_DESIGN 0xC8 | |
143 | #define BAT_CURRENT_NOW 0xD0 | |
144 | #define BAT_CURRENT_AVG 0xD2 | |
145 | #define BAT_POWER 0xD4 | |
146 | #define BAT_CAPACITY 0xCE | |
147 | #define BAT_TEMP 0xD6 | |
148 | #define BAT_TEMP_AVG 0xD7 | |
149 | #define BAT_STATUS0 0xC1 | |
150 | #define BAT_STATUS1 0xF0 | |
151 | #define BAT_STATUS2 0xF1 | |
152 | #define BAT_STOP_CHARGE1 0xF2 | |
153 | #define BAT_STOP_CHARGE2 0xF3 | |
154 | ||
155 | #define BAT_S0_DISCHARGE (1 << 0) | |
156 | #define BAT_S0_DISCHRG_CRITICAL (1 << 2) | |
157 | #define BAT_S0_LOW (1 << 3) | |
158 | #define BAT_S0_CHARGING (1 << 1) | |
159 | #define BAT_S0_AC (1 << 7) | |
160 | #define BAT_S1_EXISTS (1 << 0) | |
161 | #define BAT_S1_FULL (1 << 1) | |
162 | #define BAT_S1_EMPTY (1 << 2) | |
163 | #define BAT_S1_LiION_OR_NiMH (1 << 7) | |
164 | #define BAT_S2_LOW_LOW (1 << 0) | |
165 | #define BAT_STOP_CHRG1_BAD_CELL (1 << 1) | |
166 | #define BAT_STOP_CHRG1_COMM_FAIL (1 << 2) | |
167 | #define BAT_STOP_CHRG1_OVERVOLTAGE (1 << 6) | |
168 | #define BAT_STOP_CHRG1_OVERTEMPERATURE (1 << 7) | |
169 | ||
170 | ||
171 | /* ======= */ | |
172 | /* Structs */ | |
173 | /* ======= */ | |
174 | struct compal_data{ | |
175 | /* Fan control */ | |
c2be45f0 | 176 | int pwm_enable; /* 0:full on, 1:set by pwm1, 2:control by motherboard */ |
9be0fcb5 RF |
177 | unsigned char curr_pwm; |
178 | ||
179 | /* Power supply */ | |
297d716f | 180 | struct power_supply *psy; |
9be0fcb5 RF |
181 | struct power_supply_info psy_info; |
182 | char bat_model_name[BAT_MODEL_NAME_LEN + 1]; | |
183 | char bat_manufacturer_name[BAT_MANUFACTURER_NAME_LEN + 1]; | |
184 | char bat_serial_number[BAT_SERIAL_NUMBER_LEN + 1]; | |
185 | }; | |
5411552c | 186 | |
5411552c | 187 | |
9be0fcb5 RF |
188 | /* =============== */ |
189 | /* General globals */ | |
190 | /* =============== */ | |
90ab5ee9 | 191 | static bool force; |
9be0fcb5 RF |
192 | module_param(force, bool, 0); |
193 | MODULE_PARM_DESC(force, "Force driver load, ignore DMI data"); | |
5411552c | 194 | |
9be0fcb5 RF |
195 | /* Support for the wake_on_XXX, hwmon and power_supply interface. Currently |
196 | * only gets enabled on a JHL90 board. Might work with the others too */ | |
197 | static bool extra_features; | |
198 | ||
199 | /* Nasty stuff. For some reason the fan control is very un-linear. I've | |
200 | * come up with these values by looping through the possible inputs and | |
201 | * watching the output of address 0x4F (do an ec_transaction writing 0x33 | |
202 | * into 0x4F and read a few bytes from the output, like so: | |
203 | * u8 writeData = 0x33; | |
1cb7b1e0 | 204 | * ec_transaction(0x4F, &writeData, 1, buffer, 32); |
751516f0 | 205 | * That address is labeled "fan1 table information" in the service manual. |
9be0fcb5 RF |
206 | * It should be clear which value in 'buffer' changes). This seems to be |
207 | * related to fan speed. It isn't a proper 'realtime' fan speed value | |
208 | * though, because physically stopping or speeding up the fan doesn't | |
209 | * change it. It might be the average voltage or current of the pwm output. | |
210 | * Nevertheless, it is more fine-grained than the actual RPM reading */ | |
211 | static const unsigned char pwm_lookup_table[256] = { | |
212 | 0, 0, 0, 1, 1, 1, 2, 253, 254, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, | |
213 | 7, 7, 7, 8, 86, 86, 9, 9, 9, 10, 10, 10, 11, 92, 92, 12, 12, 95, | |
214 | 13, 66, 66, 14, 14, 98, 15, 15, 15, 16, 16, 67, 17, 17, 72, 18, 70, | |
215 | 75, 19, 90, 90, 73, 73, 73, 21, 21, 91, 91, 91, 96, 23, 94, 94, 94, | |
216 | 94, 94, 94, 94, 94, 94, 94, 141, 141, 238, 223, 192, 139, 139, 139, | |
217 | 139, 139, 142, 142, 142, 142, 142, 78, 78, 78, 78, 78, 76, 76, 76, | |
218 | 76, 76, 79, 79, 79, 79, 79, 79, 79, 20, 20, 20, 20, 20, 22, 22, 22, | |
219 | 22, 22, 24, 24, 24, 24, 24, 24, 219, 219, 219, 219, 219, 219, 219, | |
220 | 219, 27, 27, 188, 188, 28, 28, 28, 29, 186, 186, 186, 186, 186, | |
221 | 186, 186, 186, 186, 186, 31, 31, 31, 31, 31, 32, 32, 32, 41, 33, | |
222 | 33, 33, 33, 33, 252, 252, 34, 34, 34, 43, 35, 35, 35, 36, 36, 38, | |
223 | 206, 206, 206, 206, 206, 206, 206, 206, 206, 37, 37, 37, 46, 46, | |
224 | 47, 47, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 48, 48, | |
225 | 48, 48, 48, 40, 40, 40, 49, 42, 42, 42, 42, 42, 42, 42, 42, 44, | |
226 | 189, 189, 189, 189, 54, 54, 45, 45, 45, 45, 45, 45, 45, 45, 251, | |
227 | 191, 199, 199, 199, 199, 199, 215, 215, 215, 215, 187, 187, 187, | |
228 | 187, 187, 193, 50 | |
229 | }; | |
5411552c | 230 | |
5411552c | 231 | |
493e9143 | 232 | |
5411552c | 233 | |
9be0fcb5 RF |
234 | /* ========================= */ |
235 | /* Hardware access functions */ | |
236 | /* ========================= */ | |
237 | /* General access */ | |
238 | static u8 ec_read_u8(u8 addr) | |
239 | { | |
240 | u8 value; | |
241 | ec_read(addr, &value); | |
242 | return value; | |
243 | } | |
244 | ||
245 | static s8 ec_read_s8(u8 addr) | |
246 | { | |
247 | return (s8)ec_read_u8(addr); | |
248 | } | |
249 | ||
250 | static u16 ec_read_u16(u8 addr) | |
251 | { | |
252 | int hi, lo; | |
253 | lo = ec_read_u8(addr); | |
254 | hi = ec_read_u8(addr + 1); | |
255 | return (hi << 8) + lo; | |
256 | } | |
257 | ||
258 | static s16 ec_read_s16(u8 addr) | |
259 | { | |
260 | return (s16) ec_read_u16(addr); | |
261 | } | |
5411552c | 262 | |
9be0fcb5 | 263 | static void ec_read_sequence(u8 addr, u8 *buf, int len) |
5411552c | 264 | { |
9be0fcb5 RF |
265 | int i; |
266 | for (i = 0; i < len; i++) | |
267 | ec_read(addr + i, buf + i); | |
268 | } | |
269 | ||
270 | ||
271 | /* Backlight access */ | |
272 | static int set_backlight_level(int level) | |
273 | { | |
274 | if (level < 0 || level > BACKLIGHT_LEVEL_MAX) | |
5411552c CJ |
275 | return -EINVAL; |
276 | ||
9be0fcb5 | 277 | ec_write(BACKLIGHT_LEVEL_ADDR, level); |
5411552c | 278 | |
0e4510f7 | 279 | return 0; |
5411552c CJ |
280 | } |
281 | ||
9be0fcb5 RF |
282 | static int get_backlight_level(void) |
283 | { | |
284 | return (int) ec_read_u8(BACKLIGHT_LEVEL_ADDR); | |
285 | } | |
286 | ||
287 | static void set_backlight_state(bool on) | |
288 | { | |
289 | u8 data = on ? BACKLIGHT_STATE_ON_DATA : BACKLIGHT_STATE_OFF_DATA; | |
1cb7b1e0 | 290 | ec_transaction(BACKLIGHT_STATE_ADDR, &data, 1, NULL, 0); |
9be0fcb5 RF |
291 | } |
292 | ||
293 | ||
294 | /* Fan control access */ | |
295 | static void pwm_enable_control(void) | |
296 | { | |
297 | unsigned char writeData = PWM_ENABLE_DATA; | |
1cb7b1e0 | 298 | ec_transaction(PWM_ENABLE_ADDR, &writeData, 1, NULL, 0); |
9be0fcb5 RF |
299 | } |
300 | ||
301 | static void pwm_disable_control(void) | |
5411552c | 302 | { |
9be0fcb5 | 303 | unsigned char writeData = PWM_DISABLE_DATA; |
1cb7b1e0 | 304 | ec_transaction(PWM_DISABLE_ADDR, &writeData, 1, NULL, 0); |
9be0fcb5 | 305 | } |
5411552c | 306 | |
9be0fcb5 RF |
307 | static void set_pwm(int pwm) |
308 | { | |
1cb7b1e0 | 309 | ec_transaction(PWM_ADDRESS, &pwm_lookup_table[pwm], 1, NULL, 0); |
9be0fcb5 RF |
310 | } |
311 | ||
312 | static int get_fan_rpm(void) | |
313 | { | |
314 | u8 value, data = FAN_DATA; | |
1cb7b1e0 | 315 | ec_transaction(FAN_ADDRESS, &data, 1, &value, 1); |
9be0fcb5 RF |
316 | return 100 * (int)value; |
317 | } | |
318 | ||
319 | ||
320 | ||
321 | ||
322 | /* =================== */ | |
323 | /* Interface functions */ | |
324 | /* =================== */ | |
325 | ||
326 | /* Backlight interface */ | |
327 | static int bl_get_brightness(struct backlight_device *b) | |
328 | { | |
329 | return get_backlight_level(); | |
330 | } | |
331 | ||
332 | static int bl_update_status(struct backlight_device *b) | |
333 | { | |
334 | int ret = set_backlight_level(b->props.brightness); | |
335 | if (ret) | |
336 | return ret; | |
5411552c | 337 | |
9be0fcb5 RF |
338 | set_backlight_state((b->props.power == FB_BLANK_UNBLANK) |
339 | && !(b->props.state & BL_CORE_SUSPENDED) | |
340 | && !(b->props.state & BL_CORE_FBBLANK)); | |
341 | return 0; | |
5411552c CJ |
342 | } |
343 | ||
9be0fcb5 RF |
344 | static const struct backlight_ops compalbl_ops = { |
345 | .get_brightness = bl_get_brightness, | |
346 | .update_status = bl_update_status, | |
347 | }; | |
348 | ||
349 | ||
350 | /* Wireless interface */ | |
493e9143 | 351 | static int compal_rfkill_set(void *data, bool blocked) |
5411552c | 352 | { |
493e9143 | 353 | unsigned long radio = (unsigned long) data; |
9be0fcb5 RF |
354 | u8 result = ec_read_u8(WIRELESS_ADDR); |
355 | u8 value; | |
5411552c | 356 | |
493e9143 ML |
357 | if (!blocked) |
358 | value = (u8) (result | radio); | |
359 | else | |
360 | value = (u8) (result & ~radio); | |
9be0fcb5 | 361 | ec_write(WIRELESS_ADDR, value); |
5411552c CJ |
362 | |
363 | return 0; | |
364 | } | |
365 | ||
493e9143 | 366 | static void compal_rfkill_poll(struct rfkill *rfkill, void *data) |
5411552c | 367 | { |
9be0fcb5 RF |
368 | u8 result = ec_read_u8(WIRELESS_ADDR); |
369 | bool hw_blocked = !(result & WIRELESS_KILLSWITCH); | |
493e9143 | 370 | rfkill_set_hw_state(rfkill, hw_blocked); |
5411552c CJ |
371 | } |
372 | ||
493e9143 ML |
373 | static const struct rfkill_ops compal_rfkill_ops = { |
374 | .poll = compal_rfkill_poll, | |
375 | .set_block = compal_rfkill_set, | |
376 | }; | |
377 | ||
9be0fcb5 RF |
378 | |
379 | /* Wake_up interface */ | |
380 | #define SIMPLE_MASKED_STORE_SHOW(NAME, ADDR, MASK) \ | |
381 | static ssize_t NAME##_show(struct device *dev, \ | |
382 | struct device_attribute *attr, char *buf) \ | |
383 | { \ | |
384 | return sprintf(buf, "%d\n", ((ec_read_u8(ADDR) & MASK) != 0)); \ | |
385 | } \ | |
386 | static ssize_t NAME##_store(struct device *dev, \ | |
387 | struct device_attribute *attr, const char *buf, size_t count) \ | |
388 | { \ | |
389 | int state; \ | |
390 | u8 old_val = ec_read_u8(ADDR); \ | |
391 | if (sscanf(buf, "%d", &state) != 1 || (state < 0 || state > 1)) \ | |
392 | return -EINVAL; \ | |
393 | ec_write(ADDR, state ? (old_val | MASK) : (old_val & ~MASK)); \ | |
394 | return count; \ | |
395 | } | |
396 | ||
397 | SIMPLE_MASKED_STORE_SHOW(wake_up_pme, WAKE_UP_ADDR, WAKE_UP_PME) | |
398 | SIMPLE_MASKED_STORE_SHOW(wake_up_modem, WAKE_UP_ADDR, WAKE_UP_MODEM) | |
399 | SIMPLE_MASKED_STORE_SHOW(wake_up_lan, WAKE_UP_ADDR, WAKE_UP_LAN) | |
400 | SIMPLE_MASKED_STORE_SHOW(wake_up_wlan, WAKE_UP_ADDR, WAKE_UP_WLAN) | |
401 | SIMPLE_MASKED_STORE_SHOW(wake_up_key, WAKE_UP_ADDR, WAKE_UP_KEY) | |
402 | SIMPLE_MASKED_STORE_SHOW(wake_up_mouse, WAKE_UP_ADDR, WAKE_UP_MOUSE) | |
403 | ||
9be0fcb5 RF |
404 | /* Fan control interface */ |
405 | static ssize_t pwm_enable_show(struct device *dev, | |
406 | struct device_attribute *attr, char *buf) | |
407 | { | |
408 | struct compal_data *data = dev_get_drvdata(dev); | |
409 | return sprintf(buf, "%d\n", data->pwm_enable); | |
410 | } | |
5411552c | 411 | |
9be0fcb5 RF |
412 | static ssize_t pwm_enable_store(struct device *dev, |
413 | struct device_attribute *attr, const char *buf, size_t count) | |
414 | { | |
415 | struct compal_data *data = dev_get_drvdata(dev); | |
416 | long val; | |
417 | int err; | |
0db7fd96 JH |
418 | |
419 | err = kstrtol(buf, 10, &val); | |
9be0fcb5 RF |
420 | if (err) |
421 | return err; | |
422 | if (val < 0) | |
423 | return -EINVAL; | |
424 | ||
425 | data->pwm_enable = val; | |
426 | ||
427 | switch (val) { | |
428 | case 0: /* Full speed */ | |
429 | pwm_enable_control(); | |
430 | set_pwm(255); | |
431 | break; | |
432 | case 1: /* As set by pwm1 */ | |
433 | pwm_enable_control(); | |
434 | set_pwm(data->curr_pwm); | |
435 | break; | |
436 | default: /* Control by motherboard */ | |
437 | pwm_disable_control(); | |
438 | break; | |
5411552c CJ |
439 | } |
440 | ||
9be0fcb5 RF |
441 | return count; |
442 | } | |
493e9143 | 443 | |
9be0fcb5 RF |
444 | static ssize_t pwm_show(struct device *dev, struct device_attribute *attr, |
445 | char *buf) | |
446 | { | |
447 | struct compal_data *data = dev_get_drvdata(dev); | |
448 | return sprintf(buf, "%hhu\n", data->curr_pwm); | |
449 | } | |
493e9143 | 450 | |
9be0fcb5 RF |
451 | static ssize_t pwm_store(struct device *dev, struct device_attribute *attr, |
452 | const char *buf, size_t count) | |
453 | { | |
454 | struct compal_data *data = dev_get_drvdata(dev); | |
455 | long val; | |
456 | int err; | |
0db7fd96 JH |
457 | |
458 | err = kstrtol(buf, 10, &val); | |
9be0fcb5 RF |
459 | if (err) |
460 | return err; | |
461 | if (val < 0 || val > 255) | |
462 | return -EINVAL; | |
493e9143 | 463 | |
9be0fcb5 | 464 | data->curr_pwm = val; |
493e9143 | 465 | |
9be0fcb5 RF |
466 | if (data->pwm_enable != 1) |
467 | return count; | |
468 | set_pwm(val); | |
469 | ||
470 | return count; | |
5411552c CJ |
471 | } |
472 | ||
9be0fcb5 RF |
473 | static ssize_t fan_show(struct device *dev, struct device_attribute *attr, |
474 | char *buf) | |
475 | { | |
476 | return sprintf(buf, "%d\n", get_fan_rpm()); | |
477 | } | |
5411552c | 478 | |
9be0fcb5 RF |
479 | |
480 | /* Temperature interface */ | |
481 | #define TEMPERATURE_SHOW_TEMP_AND_LABEL(POSTFIX, ADDRESS, LABEL) \ | |
482 | static ssize_t temp_##POSTFIX(struct device *dev, \ | |
483 | struct device_attribute *attr, char *buf) \ | |
484 | { \ | |
485 | return sprintf(buf, "%d\n", 1000 * (int)ec_read_s8(ADDRESS)); \ | |
486 | } \ | |
487 | static ssize_t label_##POSTFIX(struct device *dev, \ | |
488 | struct device_attribute *attr, char *buf) \ | |
489 | { \ | |
490 | return sprintf(buf, "%s\n", LABEL); \ | |
491 | } | |
492 | ||
493 | /* Labels as in service guide */ | |
494 | TEMPERATURE_SHOW_TEMP_AND_LABEL(cpu, TEMP_CPU, "CPU_TEMP"); | |
495 | TEMPERATURE_SHOW_TEMP_AND_LABEL(cpu_local, TEMP_CPU_LOCAL, "CPU_TEMP_LOCAL"); | |
496 | TEMPERATURE_SHOW_TEMP_AND_LABEL(cpu_DTS, TEMP_CPU_DTS, "CPU_DTS"); | |
497 | TEMPERATURE_SHOW_TEMP_AND_LABEL(northbridge,TEMP_NORTHBRIDGE,"NorthBridge"); | |
498 | TEMPERATURE_SHOW_TEMP_AND_LABEL(vga, TEMP_VGA, "VGA_TEMP"); | |
499 | TEMPERATURE_SHOW_TEMP_AND_LABEL(SKIN, TEMP_SKIN, "SKIN_TEMP90"); | |
500 | ||
501 | ||
502 | /* Power supply interface */ | |
503 | static int bat_status(void) | |
5411552c | 504 | { |
9be0fcb5 RF |
505 | u8 status0 = ec_read_u8(BAT_STATUS0); |
506 | u8 status1 = ec_read_u8(BAT_STATUS1); | |
507 | ||
508 | if (status0 & BAT_S0_CHARGING) | |
509 | return POWER_SUPPLY_STATUS_CHARGING; | |
510 | if (status0 & BAT_S0_DISCHARGE) | |
511 | return POWER_SUPPLY_STATUS_DISCHARGING; | |
512 | if (status1 & BAT_S1_FULL) | |
513 | return POWER_SUPPLY_STATUS_FULL; | |
514 | return POWER_SUPPLY_STATUS_NOT_CHARGING; | |
5411552c CJ |
515 | } |
516 | ||
9be0fcb5 RF |
517 | static int bat_health(void) |
518 | { | |
519 | u8 status = ec_read_u8(BAT_STOP_CHARGE1); | |
520 | ||
521 | if (status & BAT_STOP_CHRG1_OVERTEMPERATURE) | |
522 | return POWER_SUPPLY_HEALTH_OVERHEAT; | |
523 | if (status & BAT_STOP_CHRG1_OVERVOLTAGE) | |
524 | return POWER_SUPPLY_HEALTH_OVERVOLTAGE; | |
525 | if (status & BAT_STOP_CHRG1_BAD_CELL) | |
526 | return POWER_SUPPLY_HEALTH_DEAD; | |
527 | if (status & BAT_STOP_CHRG1_COMM_FAIL) | |
528 | return POWER_SUPPLY_HEALTH_UNKNOWN; | |
529 | return POWER_SUPPLY_HEALTH_GOOD; | |
530 | } | |
5411552c | 531 | |
9be0fcb5 | 532 | static int bat_is_present(void) |
5411552c | 533 | { |
9be0fcb5 RF |
534 | u8 status = ec_read_u8(BAT_STATUS2); |
535 | return ((status & BAT_S1_EXISTS) != 0); | |
536 | } | |
537 | ||
538 | static int bat_technology(void) | |
539 | { | |
540 | u8 status = ec_read_u8(BAT_STATUS1); | |
541 | ||
542 | if (status & BAT_S1_LiION_OR_NiMH) | |
543 | return POWER_SUPPLY_TECHNOLOGY_LION; | |
544 | return POWER_SUPPLY_TECHNOLOGY_NiMH; | |
545 | } | |
546 | ||
547 | static int bat_capacity_level(void) | |
548 | { | |
549 | u8 status0 = ec_read_u8(BAT_STATUS0); | |
550 | u8 status1 = ec_read_u8(BAT_STATUS1); | |
551 | u8 status2 = ec_read_u8(BAT_STATUS2); | |
552 | ||
553 | if (status0 & BAT_S0_DISCHRG_CRITICAL | |
554 | || status1 & BAT_S1_EMPTY | |
555 | || status2 & BAT_S2_LOW_LOW) | |
556 | return POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL; | |
557 | if (status0 & BAT_S0_LOW) | |
558 | return POWER_SUPPLY_CAPACITY_LEVEL_LOW; | |
559 | if (status1 & BAT_S1_FULL) | |
560 | return POWER_SUPPLY_CAPACITY_LEVEL_FULL; | |
561 | return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL; | |
562 | } | |
563 | ||
564 | static int bat_get_property(struct power_supply *psy, | |
565 | enum power_supply_property psp, | |
566 | union power_supply_propval *val) | |
567 | { | |
297d716f | 568 | struct compal_data *data = power_supply_get_drvdata(psy); |
9be0fcb5 RF |
569 | |
570 | switch (psp) { | |
571 | case POWER_SUPPLY_PROP_STATUS: | |
572 | val->intval = bat_status(); | |
573 | break; | |
574 | case POWER_SUPPLY_PROP_HEALTH: | |
575 | val->intval = bat_health(); | |
576 | break; | |
577 | case POWER_SUPPLY_PROP_PRESENT: | |
578 | val->intval = bat_is_present(); | |
579 | break; | |
580 | case POWER_SUPPLY_PROP_TECHNOLOGY: | |
581 | val->intval = bat_technology(); | |
582 | break; | |
583 | case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: /* THE design voltage... */ | |
584 | val->intval = ec_read_u16(BAT_VOLTAGE_DESIGN) * 1000; | |
585 | break; | |
586 | case POWER_SUPPLY_PROP_VOLTAGE_NOW: | |
587 | val->intval = ec_read_u16(BAT_VOLTAGE_NOW) * 1000; | |
588 | break; | |
589 | case POWER_SUPPLY_PROP_CURRENT_NOW: | |
590 | val->intval = ec_read_s16(BAT_CURRENT_NOW) * 1000; | |
591 | break; | |
592 | case POWER_SUPPLY_PROP_CURRENT_AVG: | |
593 | val->intval = ec_read_s16(BAT_CURRENT_AVG) * 1000; | |
594 | break; | |
595 | case POWER_SUPPLY_PROP_POWER_NOW: | |
596 | val->intval = ec_read_u8(BAT_POWER) * 1000000; | |
597 | break; | |
598 | case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: | |
599 | val->intval = ec_read_u16(BAT_CHARGE_DESIGN) * 1000; | |
600 | break; | |
601 | case POWER_SUPPLY_PROP_CHARGE_NOW: | |
602 | val->intval = ec_read_u16(BAT_CHARGE_NOW) * 1000; | |
603 | break; | |
604 | case POWER_SUPPLY_PROP_CAPACITY: | |
605 | val->intval = ec_read_u8(BAT_CAPACITY); | |
606 | break; | |
607 | case POWER_SUPPLY_PROP_CAPACITY_LEVEL: | |
608 | val->intval = bat_capacity_level(); | |
609 | break; | |
610 | /* It smees that BAT_TEMP_AVG is a (2's complement?) value showing | |
611 | * the number of degrees, whereas BAT_TEMP is somewhat more | |
612 | * complicated. It looks like this is a negative nember with a | |
613 | * 100/256 divider and an offset of 222. Both were determined | |
614 | * experimentally by comparing BAT_TEMP and BAT_TEMP_AVG. */ | |
615 | case POWER_SUPPLY_PROP_TEMP: | |
616 | val->intval = ((222 - (int)ec_read_u8(BAT_TEMP)) * 1000) >> 8; | |
617 | break; | |
618 | case POWER_SUPPLY_PROP_TEMP_AMBIENT: /* Ambient, Avg, ... same thing */ | |
619 | val->intval = ec_read_s8(BAT_TEMP_AVG) * 10; | |
620 | break; | |
621 | /* Neither the model name nor manufacturer name work for me. */ | |
622 | case POWER_SUPPLY_PROP_MODEL_NAME: | |
623 | val->strval = data->bat_model_name; | |
624 | break; | |
625 | case POWER_SUPPLY_PROP_MANUFACTURER: | |
626 | val->strval = data->bat_manufacturer_name; | |
627 | break; | |
628 | case POWER_SUPPLY_PROP_SERIAL_NUMBER: | |
629 | val->strval = data->bat_serial_number; | |
630 | break; | |
631 | default: | |
632 | break; | |
633 | } | |
634 | return 0; | |
5411552c CJ |
635 | } |
636 | ||
5411552c | 637 | |
5411552c | 638 | |
5411552c | 639 | |
9be0fcb5 RF |
640 | |
641 | /* ============== */ | |
642 | /* Driver Globals */ | |
643 | /* ============== */ | |
644 | static DEVICE_ATTR(wake_up_pme, | |
645 | 0644, wake_up_pme_show, wake_up_pme_store); | |
646 | static DEVICE_ATTR(wake_up_modem, | |
647 | 0644, wake_up_modem_show, wake_up_modem_store); | |
648 | static DEVICE_ATTR(wake_up_lan, | |
649 | 0644, wake_up_lan_show, wake_up_lan_store); | |
650 | static DEVICE_ATTR(wake_up_wlan, | |
651 | 0644, wake_up_wlan_show, wake_up_wlan_store); | |
652 | static DEVICE_ATTR(wake_up_key, | |
653 | 0644, wake_up_key_show, wake_up_key_store); | |
654 | static DEVICE_ATTR(wake_up_mouse, | |
655 | 0644, wake_up_mouse_show, wake_up_mouse_store); | |
656 | ||
4e062581 GR |
657 | static DEVICE_ATTR(fan1_input, S_IRUGO, fan_show, NULL); |
658 | static DEVICE_ATTR(temp1_input, S_IRUGO, temp_cpu, NULL); | |
659 | static DEVICE_ATTR(temp2_input, S_IRUGO, temp_cpu_local, NULL); | |
660 | static DEVICE_ATTR(temp3_input, S_IRUGO, temp_cpu_DTS, NULL); | |
661 | static DEVICE_ATTR(temp4_input, S_IRUGO, temp_northbridge, NULL); | |
662 | static DEVICE_ATTR(temp5_input, S_IRUGO, temp_vga, NULL); | |
663 | static DEVICE_ATTR(temp6_input, S_IRUGO, temp_SKIN, NULL); | |
664 | static DEVICE_ATTR(temp1_label, S_IRUGO, label_cpu, NULL); | |
665 | static DEVICE_ATTR(temp2_label, S_IRUGO, label_cpu_local, NULL); | |
666 | static DEVICE_ATTR(temp3_label, S_IRUGO, label_cpu_DTS, NULL); | |
667 | static DEVICE_ATTR(temp4_label, S_IRUGO, label_northbridge, NULL); | |
668 | static DEVICE_ATTR(temp5_label, S_IRUGO, label_vga, NULL); | |
669 | static DEVICE_ATTR(temp6_label, S_IRUGO, label_SKIN, NULL); | |
670 | static DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, pwm_show, pwm_store); | |
671 | static DEVICE_ATTR(pwm1_enable, | |
672 | S_IRUGO | S_IWUSR, pwm_enable_show, pwm_enable_store); | |
9be0fcb5 | 673 | |
c2be45f0 | 674 | static struct attribute *compal_platform_attrs[] = { |
9be0fcb5 RF |
675 | &dev_attr_wake_up_pme.attr, |
676 | &dev_attr_wake_up_modem.attr, | |
677 | &dev_attr_wake_up_lan.attr, | |
678 | &dev_attr_wake_up_wlan.attr, | |
679 | &dev_attr_wake_up_key.attr, | |
680 | &dev_attr_wake_up_mouse.attr, | |
c2be45f0 GR |
681 | NULL |
682 | }; | |
683 | static struct attribute_group compal_platform_attr_group = { | |
684 | .attrs = compal_platform_attrs | |
685 | }; | |
686 | ||
687 | static struct attribute *compal_hwmon_attrs[] = { | |
4e062581 GR |
688 | &dev_attr_pwm1_enable.attr, |
689 | &dev_attr_pwm1.attr, | |
690 | &dev_attr_fan1_input.attr, | |
691 | &dev_attr_temp1_input.attr, | |
692 | &dev_attr_temp2_input.attr, | |
693 | &dev_attr_temp3_input.attr, | |
694 | &dev_attr_temp4_input.attr, | |
695 | &dev_attr_temp5_input.attr, | |
696 | &dev_attr_temp6_input.attr, | |
697 | &dev_attr_temp1_label.attr, | |
698 | &dev_attr_temp2_label.attr, | |
699 | &dev_attr_temp3_label.attr, | |
700 | &dev_attr_temp4_label.attr, | |
701 | &dev_attr_temp5_label.attr, | |
702 | &dev_attr_temp6_label.attr, | |
9be0fcb5 RF |
703 | NULL |
704 | }; | |
c2be45f0 | 705 | ATTRIBUTE_GROUPS(compal_hwmon); |
9be0fcb5 | 706 | |
b859f159 GKH |
707 | static int compal_probe(struct platform_device *); |
708 | static int compal_remove(struct platform_device *); | |
5411552c CJ |
709 | static struct platform_driver compal_driver = { |
710 | .driver = { | |
9be0fcb5 | 711 | .name = DRIVER_NAME, |
9be0fcb5 RF |
712 | }, |
713 | .probe = compal_probe, | |
b859f159 | 714 | .remove = compal_remove, |
9be0fcb5 RF |
715 | }; |
716 | ||
717 | static enum power_supply_property compal_bat_properties[] = { | |
718 | POWER_SUPPLY_PROP_STATUS, | |
719 | POWER_SUPPLY_PROP_HEALTH, | |
720 | POWER_SUPPLY_PROP_PRESENT, | |
721 | POWER_SUPPLY_PROP_TECHNOLOGY, | |
722 | POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, | |
723 | POWER_SUPPLY_PROP_VOLTAGE_NOW, | |
724 | POWER_SUPPLY_PROP_CURRENT_NOW, | |
725 | POWER_SUPPLY_PROP_CURRENT_AVG, | |
726 | POWER_SUPPLY_PROP_POWER_NOW, | |
727 | POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, | |
728 | POWER_SUPPLY_PROP_CHARGE_NOW, | |
729 | POWER_SUPPLY_PROP_CAPACITY, | |
730 | POWER_SUPPLY_PROP_CAPACITY_LEVEL, | |
731 | POWER_SUPPLY_PROP_TEMP, | |
732 | POWER_SUPPLY_PROP_TEMP_AMBIENT, | |
733 | POWER_SUPPLY_PROP_MODEL_NAME, | |
734 | POWER_SUPPLY_PROP_MANUFACTURER, | |
735 | POWER_SUPPLY_PROP_SERIAL_NUMBER, | |
5411552c CJ |
736 | }; |
737 | ||
9be0fcb5 RF |
738 | static struct backlight_device *compalbl_device; |
739 | ||
740 | static struct platform_device *compal_device; | |
741 | ||
742 | static struct rfkill *wifi_rfkill; | |
743 | static struct rfkill *bt_rfkill; | |
744 | ||
745 | ||
746 | ||
747 | ||
748 | ||
749 | /* =================================== */ | |
750 | /* Initialization & clean-up functions */ | |
751 | /* =================================== */ | |
5411552c CJ |
752 | |
753 | static int dmi_check_cb(const struct dmi_system_id *id) | |
754 | { | |
b4a4bc0b | 755 | pr_info("Identified laptop model '%s'\n", id->ident); |
9be0fcb5 | 756 | extra_features = false; |
0e4510f7 | 757 | return 1; |
9be0fcb5 | 758 | } |
5411552c | 759 | |
9be0fcb5 RF |
760 | static int dmi_check_cb_extra(const struct dmi_system_id *id) |
761 | { | |
b4a4bc0b | 762 | pr_info("Identified laptop model '%s', enabling extra features\n", |
9be0fcb5 RF |
763 | id->ident); |
764 | extra_features = true; | |
0e4510f7 | 765 | return 1; |
5411552c CJ |
766 | } |
767 | ||
768 | static struct dmi_system_id __initdata compal_dmi_table[] = { | |
769 | { | |
770 | .ident = "FL90/IFL90", | |
771 | .matches = { | |
772 | DMI_MATCH(DMI_BOARD_NAME, "IFL90"), | |
773 | DMI_MATCH(DMI_BOARD_VERSION, "IFT00"), | |
774 | }, | |
775 | .callback = dmi_check_cb | |
776 | }, | |
777 | { | |
778 | .ident = "FL90/IFL90", | |
779 | .matches = { | |
780 | DMI_MATCH(DMI_BOARD_NAME, "IFL90"), | |
781 | DMI_MATCH(DMI_BOARD_VERSION, "REFERENCE"), | |
782 | }, | |
783 | .callback = dmi_check_cb | |
784 | }, | |
785 | { | |
786 | .ident = "FL91/IFL91", | |
787 | .matches = { | |
788 | DMI_MATCH(DMI_BOARD_NAME, "IFL91"), | |
789 | DMI_MATCH(DMI_BOARD_VERSION, "IFT00"), | |
790 | }, | |
791 | .callback = dmi_check_cb | |
792 | }, | |
793 | { | |
794 | .ident = "FL92/JFL92", | |
795 | .matches = { | |
796 | DMI_MATCH(DMI_BOARD_NAME, "JFL92"), | |
797 | DMI_MATCH(DMI_BOARD_VERSION, "IFT00"), | |
798 | }, | |
799 | .callback = dmi_check_cb | |
800 | }, | |
801 | { | |
802 | .ident = "FT00/IFT00", | |
803 | .matches = { | |
804 | DMI_MATCH(DMI_BOARD_NAME, "IFT00"), | |
805 | DMI_MATCH(DMI_BOARD_VERSION, "IFT00"), | |
806 | }, | |
807 | .callback = dmi_check_cb | |
808 | }, | |
34325b9d ML |
809 | { |
810 | .ident = "Dell Mini 9", | |
811 | .matches = { | |
812 | DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), | |
813 | DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 910"), | |
814 | }, | |
815 | .callback = dmi_check_cb | |
816 | }, | |
817 | { | |
818 | .ident = "Dell Mini 10", | |
819 | .matches = { | |
820 | DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), | |
821 | DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1010"), | |
822 | }, | |
823 | .callback = dmi_check_cb | |
824 | }, | |
825 | { | |
826 | .ident = "Dell Mini 10v", | |
827 | .matches = { | |
828 | DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), | |
829 | DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1011"), | |
830 | }, | |
831 | .callback = dmi_check_cb | |
832 | }, | |
c3f755e3 VE |
833 | { |
834 | .ident = "Dell Mini 1012", | |
835 | .matches = { | |
836 | DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), | |
837 | DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1012"), | |
838 | }, | |
839 | .callback = dmi_check_cb | |
840 | }, | |
34325b9d ML |
841 | { |
842 | .ident = "Dell Inspiron 11z", | |
843 | .matches = { | |
844 | DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), | |
845 | DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1110"), | |
846 | }, | |
847 | .callback = dmi_check_cb | |
848 | }, | |
849 | { | |
850 | .ident = "Dell Mini 12", | |
851 | .matches = { | |
852 | DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), | |
853 | DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1210"), | |
854 | }, | |
855 | .callback = dmi_check_cb | |
856 | }, | |
9be0fcb5 RF |
857 | { |
858 | .ident = "JHL90", | |
859 | .matches = { | |
860 | DMI_MATCH(DMI_BOARD_NAME, "JHL90"), | |
861 | DMI_MATCH(DMI_BOARD_VERSION, "REFERENCE"), | |
862 | }, | |
863 | .callback = dmi_check_cb_extra | |
864 | }, | |
4a198be7 AAC |
865 | { |
866 | .ident = "KHLB2", | |
867 | .matches = { | |
868 | DMI_MATCH(DMI_BOARD_NAME, "KHLB2"), | |
869 | DMI_MATCH(DMI_BOARD_VERSION, "REFERENCE"), | |
870 | }, | |
871 | .callback = dmi_check_cb_extra | |
872 | }, | |
5411552c CJ |
873 | { } |
874 | }; | |
4585aba7 | 875 | MODULE_DEVICE_TABLE(dmi, compal_dmi_table); |
5411552c | 876 | |
297d716f KK |
877 | static const struct power_supply_desc psy_bat_desc = { |
878 | .name = DRIVER_NAME, | |
879 | .type = POWER_SUPPLY_TYPE_BATTERY, | |
880 | .properties = compal_bat_properties, | |
881 | .num_properties = ARRAY_SIZE(compal_bat_properties), | |
882 | .get_property = bat_get_property, | |
883 | }; | |
884 | ||
9be0fcb5 RF |
885 | static void initialize_power_supply_data(struct compal_data *data) |
886 | { | |
9be0fcb5 RF |
887 | |
888 | ec_read_sequence(BAT_MANUFACTURER_NAME_ADDR, | |
889 | data->bat_manufacturer_name, | |
890 | BAT_MANUFACTURER_NAME_LEN); | |
891 | data->bat_manufacturer_name[BAT_MANUFACTURER_NAME_LEN] = 0; | |
892 | ||
893 | ec_read_sequence(BAT_MODEL_NAME_ADDR, | |
894 | data->bat_model_name, | |
895 | BAT_MODEL_NAME_LEN); | |
896 | data->bat_model_name[BAT_MODEL_NAME_LEN] = 0; | |
897 | ||
898 | scnprintf(data->bat_serial_number, BAT_SERIAL_NUMBER_LEN + 1, "%d", | |
899 | ec_read_u16(BAT_SERIAL_NUMBER_ADDR)); | |
900 | } | |
901 | ||
902 | static void initialize_fan_control_data(struct compal_data *data) | |
903 | { | |
904 | data->pwm_enable = 2; /* Keep motherboard in control for now */ | |
905 | data->curr_pwm = 255; /* Try not to cause a CPU_on_fire exception | |
906 | if we take over... */ | |
907 | } | |
908 | ||
909 | static int setup_rfkill(void) | |
910 | { | |
911 | int ret; | |
912 | ||
913 | wifi_rfkill = rfkill_alloc("compal-wifi", &compal_device->dev, | |
914 | RFKILL_TYPE_WLAN, &compal_rfkill_ops, | |
915 | (void *) WIRELESS_WLAN); | |
916 | if (!wifi_rfkill) | |
917 | return -ENOMEM; | |
918 | ||
919 | ret = rfkill_register(wifi_rfkill); | |
920 | if (ret) | |
921 | goto err_wifi; | |
922 | ||
923 | bt_rfkill = rfkill_alloc("compal-bluetooth", &compal_device->dev, | |
924 | RFKILL_TYPE_BLUETOOTH, &compal_rfkill_ops, | |
925 | (void *) WIRELESS_BT); | |
926 | if (!bt_rfkill) { | |
927 | ret = -ENOMEM; | |
928 | goto err_allocate_bt; | |
929 | } | |
930 | ret = rfkill_register(bt_rfkill); | |
931 | if (ret) | |
932 | goto err_register_bt; | |
933 | ||
934 | return 0; | |
935 | ||
936 | err_register_bt: | |
937 | rfkill_destroy(bt_rfkill); | |
938 | ||
939 | err_allocate_bt: | |
940 | rfkill_unregister(wifi_rfkill); | |
941 | ||
942 | err_wifi: | |
943 | rfkill_destroy(wifi_rfkill); | |
944 | ||
945 | return ret; | |
946 | } | |
947 | ||
5411552c CJ |
948 | static int __init compal_init(void) |
949 | { | |
950 | int ret; | |
951 | ||
9be0fcb5 | 952 | if (acpi_disabled) { |
b4a4bc0b | 953 | pr_err("ACPI needs to be enabled for this driver to work!\n"); |
5411552c | 954 | return -ENODEV; |
9be0fcb5 | 955 | } |
5411552c | 956 | |
9be0fcb5 | 957 | if (!force && !dmi_check_system(compal_dmi_table)) { |
b4a4bc0b | 958 | pr_err("Motherboard not recognized (You could try the module's force-parameter)\n"); |
5411552c | 959 | return -ENODEV; |
9be0fcb5 | 960 | } |
5411552c | 961 | |
29454f17 | 962 | if (!acpi_video_backlight_support()) { |
a19a6ee6 MG |
963 | struct backlight_properties props; |
964 | memset(&props, 0, sizeof(struct backlight_properties)); | |
bb7ca747 | 965 | props.type = BACKLIGHT_PLATFORM; |
9be0fcb5 RF |
966 | props.max_brightness = BACKLIGHT_LEVEL_MAX; |
967 | compalbl_device = backlight_device_register(DRIVER_NAME, | |
a19a6ee6 MG |
968 | NULL, NULL, |
969 | &compalbl_ops, | |
970 | &props); | |
29454f17 TR |
971 | if (IS_ERR(compalbl_device)) |
972 | return PTR_ERR(compalbl_device); | |
29454f17 | 973 | } |
5411552c CJ |
974 | |
975 | ret = platform_driver_register(&compal_driver); | |
976 | if (ret) | |
9be0fcb5 | 977 | goto err_backlight; |
5411552c | 978 | |
9be0fcb5 | 979 | compal_device = platform_device_alloc(DRIVER_NAME, -1); |
5411552c CJ |
980 | if (!compal_device) { |
981 | ret = -ENOMEM; | |
9be0fcb5 | 982 | goto err_platform_driver; |
5411552c CJ |
983 | } |
984 | ||
9be0fcb5 | 985 | ret = platform_device_add(compal_device); /* This calls compal_probe */ |
5411552c | 986 | if (ret) |
9be0fcb5 | 987 | goto err_platform_device; |
5411552c | 988 | |
493e9143 | 989 | ret = setup_rfkill(); |
5411552c | 990 | if (ret) |
9be0fcb5 | 991 | goto err_rfkill; |
5411552c | 992 | |
b4a4bc0b | 993 | pr_info("Driver " DRIVER_VERSION " successfully loaded\n"); |
5411552c CJ |
994 | return 0; |
995 | ||
9be0fcb5 | 996 | err_rfkill: |
5411552c CJ |
997 | platform_device_del(compal_device); |
998 | ||
9be0fcb5 | 999 | err_platform_device: |
5411552c CJ |
1000 | platform_device_put(compal_device); |
1001 | ||
9be0fcb5 | 1002 | err_platform_driver: |
5411552c CJ |
1003 | platform_driver_unregister(&compal_driver); |
1004 | ||
9be0fcb5 | 1005 | err_backlight: |
5411552c CJ |
1006 | backlight_device_unregister(compalbl_device); |
1007 | ||
1008 | return ret; | |
1009 | } | |
1010 | ||
b859f159 | 1011 | static int compal_probe(struct platform_device *pdev) |
5411552c | 1012 | { |
9be0fcb5 RF |
1013 | int err; |
1014 | struct compal_data *data; | |
c2be45f0 | 1015 | struct device *hwmon_dev; |
297d716f | 1016 | struct power_supply_config psy_cfg = {}; |
9be0fcb5 RF |
1017 | |
1018 | if (!extra_features) | |
1019 | return 0; | |
1020 | ||
1021 | /* Fan control */ | |
cf508f44 | 1022 | data = devm_kzalloc(&pdev->dev, sizeof(struct compal_data), GFP_KERNEL); |
9be0fcb5 RF |
1023 | if (!data) |
1024 | return -ENOMEM; | |
1025 | ||
1026 | initialize_fan_control_data(data); | |
1027 | ||
c2be45f0 | 1028 | err = sysfs_create_group(&pdev->dev.kobj, &compal_platform_attr_group); |
cf508f44 | 1029 | if (err) |
9be0fcb5 RF |
1030 | return err; |
1031 | ||
ad774702 KK |
1032 | hwmon_dev = devm_hwmon_device_register_with_groups(&pdev->dev, |
1033 | "compal", data, | |
1034 | compal_hwmon_groups); | |
c2be45f0 GR |
1035 | if (IS_ERR(hwmon_dev)) { |
1036 | err = PTR_ERR(hwmon_dev); | |
1037 | goto remove; | |
9be0fcb5 RF |
1038 | } |
1039 | ||
1040 | /* Power supply */ | |
1041 | initialize_power_supply_data(data); | |
297d716f KK |
1042 | psy_cfg.drv_data = data; |
1043 | data->psy = power_supply_register(&compal_device->dev, &psy_bat_desc, | |
1044 | &psy_cfg); | |
1045 | if (IS_ERR(data->psy)) { | |
1046 | err = PTR_ERR(data->psy); | |
1915a718 | 1047 | goto remove; |
297d716f | 1048 | } |
9be0fcb5 RF |
1049 | |
1050 | platform_set_drvdata(pdev, data); | |
1051 | ||
1052 | return 0; | |
c2be45f0 GR |
1053 | |
1054 | remove: | |
1055 | sysfs_remove_group(&pdev->dev.kobj, &compal_platform_attr_group); | |
1056 | return err; | |
9be0fcb5 | 1057 | } |
5411552c | 1058 | |
9be0fcb5 RF |
1059 | static void __exit compal_cleanup(void) |
1060 | { | |
5411552c CJ |
1061 | platform_device_unregister(compal_device); |
1062 | platform_driver_unregister(&compal_driver); | |
1063 | backlight_device_unregister(compalbl_device); | |
493e9143 | 1064 | rfkill_unregister(wifi_rfkill); |
493e9143 | 1065 | rfkill_unregister(bt_rfkill); |
9be0fcb5 | 1066 | rfkill_destroy(wifi_rfkill); |
493e9143 | 1067 | rfkill_destroy(bt_rfkill); |
5411552c | 1068 | |
b4a4bc0b | 1069 | pr_info("Driver unloaded\n"); |
5411552c CJ |
1070 | } |
1071 | ||
b859f159 | 1072 | static int compal_remove(struct platform_device *pdev) |
9be0fcb5 RF |
1073 | { |
1074 | struct compal_data *data; | |
1075 | ||
1076 | if (!extra_features) | |
1077 | return 0; | |
1078 | ||
b4a4bc0b | 1079 | pr_info("Unloading: resetting fan control to motherboard\n"); |
9be0fcb5 RF |
1080 | pwm_disable_control(); |
1081 | ||
1082 | data = platform_get_drvdata(pdev); | |
297d716f | 1083 | power_supply_unregister(data->psy); |
9be0fcb5 | 1084 | |
c2be45f0 | 1085 | sysfs_remove_group(&pdev->dev.kobj, &compal_platform_attr_group); |
9be0fcb5 RF |
1086 | |
1087 | return 0; | |
1088 | } | |
1089 | ||
1090 | ||
5411552c CJ |
1091 | module_init(compal_init); |
1092 | module_exit(compal_cleanup); | |
1093 | ||
1094 | MODULE_AUTHOR("Cezary Jackiewicz"); | |
9be0fcb5 | 1095 | MODULE_AUTHOR("Roald Frederickx (roald.frederickx@gmail.com)"); |
5411552c | 1096 | MODULE_DESCRIPTION("Compal Laptop Support"); |
9be0fcb5 | 1097 | MODULE_VERSION(DRIVER_VERSION); |
5411552c | 1098 | MODULE_LICENSE("GPL"); |