1. /*
  2. * tuxedo-wmi.c
  3. *
  4. * Copyright (C) 2013-2014 Christoph Jaeger <[email protected]>
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License as published by
  8. * the Free Software Foundation; either version 2 of the License, or (at
  9. * your option) any later version.
  10. *
  11. * This program is distributed in the hope that it will be useful, but
  12. * WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14. * General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU General Public License
  17. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  18. */
  20. #define TUXEDO_DRIVER_NAME KBUILD_MODNAME
  21. #define pr_fmt(fmt) TUXEDO_DRIVER_NAME ": " fmt
  23. #include "/usr/src/sys/contrib/dev/acpica/include/acpi.h"
  24. #include <linux/acpi.h>
  25. #include <linux/delay.h>
  26. #include <linux/dmi.h>
  27. #include <linux/input.h>
  28. #include <linux/kernel.h>
  29. #include <linux/kthread.h>
  30. #include <linux/leds.h>
  31. #include <linux/module.h>
  32. #include <linux/mutex.h>
  33. #include <linux/platform_device.h>
  34. #include <linux/rfkill.h>
  35. #include <linux/stringify.h>
  36. #include <linux/version.h>
  37. #include <linux/workqueue.h>
  39. #define __TUXEDO_PR(lvl, fmt, ...) do { pr_##lvl(fmt, ##__VA_ARGS__); } while (0)
  40. #define TUXEDO_INFO(fmt, ...) __TUXEDO_PR(info, fmt, ##__VA_ARGS__)
  41. #define TUXEDO_ERROR(fmt, ...) __TUXEDO_PR(err, fmt, ##__VA_ARGS__)
  42. #define TUXEDO_DEBUG(fmt, ...) __TUXEDO_PR(debug, "[%s:%u] " fmt, __func__, __LINE__, ##__VA_ARGS__)
  44. #define CLEVO_EVENT_GUID "ABBC0F6B-8EA1-11D1-00A0-C90629100000"
  45. #define CLEVO_EMAIL_GUID "ABBC0F6C-8EA1-11D1-00A0-C90629100000"
  46. #define CLEVO_GET_GUID "ABBC0F6D-8EA1-11D1-00A0-C90629100000"
  48. /* method IDs for CLEVO_GET */
  49. #define GET_EVENT 0x01 /* 1 */
  50. #define GET_POWER_STATE_FOR_3G 0x0A /* 10 */
  51. #define GET_AP 0x46 /* 70 */
  52. #define SET_3G 0x4C /* 76 */
  53. #define SET_KB_LED 0x67 /* 103 */
  54. #define AIRPLANE_BUTTON 0x6D /* 109 */ /* or 0x6C (?) */
  55. #define TALK_BIOS_3G 0x78 /* 120 */
  57. #define COLORS { C(black, 0x000000), C(blue, 0x0000FF), \
  58. C(red, 0xFF0000), C(magenta, 0xFF00FF), \
  59. C(green, 0x00FF00), C(cyan, 0x00FFFF), \
  60. C(yellow, 0xFFFF00), C(white, 0xFFFFFF), }
  61. #undef C
  63. #define C(n, v) KB_COLOR_##n
  64. enum kb_color COLORS;
  65. #undef C
  67. union kb_rgb_color {
  68. u32 rgb;
  69. struct { u32 b:8, g:8, r:8, :8; };
  70. };
  72. #define C(n, v) { .name = #n, .value = { .rgb = v, }, }
  73. struct {
  74. const char *const name;
  75. union kb_rgb_color value;
  76. } kb_colors[] = COLORS;
  77. #undef C
  79. #define KB_COLOR_DEFAULT KB_COLOR_blue
  80. #define KB_BRIGHTNESS_MAX 10
  81. #define KB_BRIGHTNESS_DEFAULT KB_BRIGHTNESS_MAX
  83. static int param_set_kb_color(const char *val, const struct kernel_param *kp)
  84. {
  85. size_t i;
  87. if (!val)
  88. return -EINVAL;
  90. if (!val[0]) {
  91. *((enum kb_color *) kp->arg) = KB_COLOR_black;
  92. return 0;
  93. }
  95. for (i = 0; i < ARRAY_SIZE(kb_colors); i++) {
  96. if (!strcmp(val, kb_colors[i].name)) {
  97. *((enum kb_color *) kp->arg) = i;
  98. return 0;
  99. }
  100. }
  102. return -EINVAL;
  103. }
  105. static int param_get_kb_color(char *buffer, const struct kernel_param *kp)
  106. {
  107. return sprintf(buffer, "%s", kb_colors[*((enum kb_color *) kp->arg)].name);
  108. }
  110. static const struct kernel_param_ops param_ops_kb_color = {
  111. .set = param_set_kb_color,
  112. .get = param_get_kb_color,
  113. };
  115. static enum kb_color param_kb_color[] = { [0 ... 2] = KB_COLOR_DEFAULT };
  116. static int param_kb_color_num;
  117. #define param_check_kb_color(name, p) __param_check(name, p, enum kb_color)
  118. module_param_array_named(kb_color, param_kb_color, kb_color,
  119. &param_kb_color_num, S_IRUSR);
  120. MODULE_PARM_DESC(kb_color, "Set the color(s) of the keyboard (sections)");
  123. static int param_set_kb_brightness(const char *val, const struct kernel_param *kp)
  124. {
  125. int ret;
  127. ret = param_set_byte(val, kp);
  129. if (!ret && *((unsigned char *) kp->arg) > KB_BRIGHTNESS_MAX)
  130. return -EINVAL;
  132. return ret;
  133. }
  135. #if LINUX_VERSION_CODE < KERNEL_VERSION(3,12,0)
  136. static int param_get_kb_brightness(char *buffer, const struct kernel_param *kp)
  137. {
  138. /* due to a bug in the kernel, we do this ourselves */
  139. return sprintf(buffer, "%hhu", *((unsigned char *) kp->arg));
  140. }
  141. #endif
  143. static const struct kernel_param_ops param_ops_kb_brightness = {
  144. .set = param_set_kb_brightness,
  145. #if LINUX_VERSION_CODE < KERNEL_VERSION(3,12,0)
  146. .get = param_get_kb_brightness,
  147. #else
  148. .get = param_get_byte,
  149. #endif
  150. };
  152. static unsigned char param_kb_brightness = KB_BRIGHTNESS_DEFAULT;
  153. #define param_check_kb_brightness param_check_byte
  154. module_param_named(kb_brightness, param_kb_brightness, kb_brightness, S_IRUSR);
  155. MODULE_PARM_DESC(kb_brightness, "Set the brightness of the keyboard backlight");
  158. static bool param_kb_off = false;
  159. module_param_named(kb_off, param_kb_off, bool, S_IRUSR);
  160. MODULE_PARM_DESC(kb_off, "Switch keyboard backlight off");
  163. #define POLL_FREQ_MIN 1
  164. #define POLL_FREQ_MAX 20
  165. #define POLL_FREQ_DEFAULT 5
  167. static int param_set_poll_freq(const char *val, const struct kernel_param *kp)
  168. {
  169. int ret;
  171. ret = param_set_byte(val, kp);
  173. if (!ret)
  174. *((unsigned char *) kp->arg) = clamp_t(unsigned char, *((unsigned char *) kp->arg),
  175. POLL_FREQ_MIN, POLL_FREQ_MAX);
  177. return ret;
  178. }
  180. #if LINUX_VERSION_CODE < KERNEL_VERSION(3,12,0)
  181. static int param_get_poll_freq(char *buffer, const struct kernel_param *kp)
  182. {
  183. /* due to a bug in the kernel, we do this ourselves */
  184. return sprintf(buffer, "%hhu", *((unsigned char *) kp->arg));
  185. }
  186. #endif
  188. static const struct kernel_param_ops param_ops_poll_freq = {
  189. .set = param_set_poll_freq,
  190. #if LINUX_VERSION_CODE < KERNEL_VERSION(3,12,0)
  191. .get = param_get_poll_freq,
  192. #else
  193. .get = param_get_byte,
  194. #endif
  195. };
  197. static unsigned char param_poll_freq = POLL_FREQ_DEFAULT;
  198. #define param_check_poll_freq param_check_byte
  199. module_param_named(poll_freq, param_poll_freq, poll_freq, S_IRUSR);
  200. MODULE_PARM_DESC(poll_freq, "Set polling frequency");
  203. struct platform_device *tuxedo_platform_device;
  205. /* input sub-driver */
  207. static struct input_dev *tuxedo_input_device;
  208. static DEFINE_MUTEX(tuxedo_input_report_mutex);
  210. static unsigned int global_report_cnt = 0;
  212. /* call with tuxedo_input_report_mutex held */
  213. static void tuxedo_input_report_key(unsigned int code)
  214. {
  215. input_report_key(tuxedo_input_device, code, 1);
  216. input_report_key(tuxedo_input_device, code, 0);
  217. input_sync(tuxedo_input_device);
  219. global_report_cnt++;
  220. }
  222. static struct task_struct *tuxedo_input_polling_task;
  224. static int tuxedo_input_polling_thread(void *data)
  225. {
  226. unsigned int report_cnt = 0;
  228. TUXEDO_INFO("Polling thread started (PID: %i), polling at %i Hz\n",
  229. current->pid, param_poll_freq);
  231. while (!kthread_should_stop()) {
  233. u8 byte;
  235. ec_read(0xDB, &byte);
  236. if (byte & 0x40) {
  237. ec_write(0xDB, byte & ~0x40);
  239. TUXEDO_DEBUG("Airplane-Mode Hotkey pressed\n");
  241. mutex_lock(&tuxedo_input_report_mutex);
  243. if (global_report_cnt > report_cnt) {
  244. mutex_unlock(&tuxedo_input_report_mutex);
  245. break;
  246. }
  248. tuxedo_input_report_key(KEY_RFKILL);
  249. report_cnt++;
  251. mutex_unlock(&tuxedo_input_report_mutex);
  252. }
  253. msleep_interruptible(1000 / param_poll_freq);
  254. }
  256. TUXEDO_INFO("Polling thread exiting\n");
  258. return 0;
  259. }
  261. static int tuxedo_input_open(struct input_dev *dev)
  262. {
  263. tuxedo_input_polling_task = kthread_run(tuxedo_input_polling_thread,
  264. NULL, "tuxedo-polld");
  266. if (unlikely(IS_ERR(tuxedo_input_polling_task))) {
  267. tuxedo_input_polling_task = NULL;
  268. TUXEDO_ERROR("Could not create polling thread\n");
  269. return PTR_ERR(tuxedo_input_polling_task);
  270. }
  272. return 0;
  273. }
  275. static void tuxedo_input_close(struct input_dev *dev)
  276. {
  277. if (unlikely(IS_ERR_OR_NULL(tuxedo_input_polling_task)))
  278. return;
  280. kthread_stop(tuxedo_input_polling_task);
  281. tuxedo_input_polling_task = NULL;
  282. }
  284. static int __init tuxedo_input_init(void)
  285. {
  286. int err;
  287. u8 byte;
  289. tuxedo_input_device = input_allocate_device();
  290. if (unlikely(!tuxedo_input_device)) {
  291. TUXEDO_ERROR("Error allocating input device\n");
  292. return -ENOMEM;
  293. }
  295. tuxedo_input_device->name = "Clevo Airplane-Mode Hotkey";
  296. tuxedo_input_device->phys = TUXEDO_DRIVER_NAME "/input0";
  297. tuxedo_input_device->id.bustype = BUS_HOST;
  298. tuxedo_input_device->dev.parent = &tuxedo_platform_device->dev;
  300. tuxedo_input_device->open = tuxedo_input_open;
  301. tuxedo_input_device->close = tuxedo_input_close;
  303. set_bit(EV_KEY, tuxedo_input_device->evbit);
  304. set_bit(KEY_RFKILL, tuxedo_input_device->keybit);
  306. ec_read(0xDB, &byte);
  307. ec_write(0xDB, byte & ~0x40);
  309. err = input_register_device(tuxedo_input_device);
  310. if (unlikely(err)) {
  311. TUXEDO_ERROR("Error registering input device\n");
  312. goto err_free_input_device;
  313. }
  315. return 0;
  317. err_free_input_device:
  318. input_free_device(tuxedo_input_device);
  320. return err;
  321. }
  323. static void __exit tuxedo_input_exit(void)
  324. {
  325. if (unlikely(!tuxedo_input_device))
  326. return;
  328. input_unregister_device(tuxedo_input_device);
  329. tuxedo_input_device = NULL;
  330. }
  333. static int tuxedo_wmi_evaluate_wmbb_method(u32 method_id, u32 arg, u32 *retval)
  334. {
  335. struct acpi_buffer in = { (acpi_size) sizeof(arg), &arg };
  336. struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
  337. union acpi_object *obj;
  338. acpi_status status;
  339. u32 tmp;
  341. TUXEDO_DEBUG("%0#4x IN : %0#6x\n", method_id, arg);
  343. status = wmi_evaluate_method(CLEVO_GET_GUID, 0x01,
  344. method_id, &in, &out);
  346. if (unlikely(ACPI_FAILURE(status)))
  347. goto exit;
  349. obj = (union acpi_object *) out.pointer;
  350. if (obj && obj->type == ACPI_TYPE_INTEGER)
  351. tmp = (u32) obj->integer.value;
  352. else
  353. tmp = 0;
  355. TUXEDO_DEBUG("%0#4x OUT: %0#6x (IN: %0#6x)\n", method_id, tmp, arg);
  357. if (likely(retval))
  358. *retval = tmp;
  360. kfree(obj);
  362. exit:
  363. if (unlikely(ACPI_FAILURE(status)))
  364. return -EIO;
  366. return 0;
  367. }
  370. static struct {
  372. enum kb_state {
  373. KB_STATE_OFF,
  374. KB_STATE_ON,
  375. } state;
  377. struct {
  378. unsigned left;
  379. unsigned center;
  380. unsigned right;
  381. } color;
  383. unsigned brightness;
  385. enum kb_mode {
  386. KB_MODE_RANDOM_COLOR,
  387. KB_MODE_CUSTOM,
  388. KB_MODE_BREATHE,
  389. KB_MODE_CYCLE,
  390. KB_MODE_WAVE,
  391. KB_MODE_DANCE,
  392. KB_MODE_TEMPO,
  393. KB_MODE_FLASH,
  394. } mode;
  396. struct kb_backlight_ops {
  397. void (*set_state)(enum kb_state state);
  398. void (*set_color)(unsigned left, unsigned center, unsigned right);
  399. void (*set_brightness)(unsigned brightness);
  400. void (*set_mode)(enum kb_mode);
  401. void (*init)(void);
  402. } *ops;
  404. } kb_backlight = { .ops = NULL, };
  407. static void kb_dec_brightness(void)
  408. {
  409. if (kb_backlight.state == KB_STATE_OFF || kb_backlight.mode != KB_MODE_CUSTOM)
  410. return;
  411. if (kb_backlight.brightness == 0)
  412. return;
  414. TUXEDO_DEBUG();
  416. kb_backlight.ops->set_brightness(kb_backlight.brightness - 1);
  417. }
  419. static void kb_inc_brightness(void)
  420. {
  421. if (kb_backlight.state == KB_STATE_OFF || kb_backlight.mode != KB_MODE_CUSTOM)
  422. return;
  424. TUXEDO_DEBUG();
  426. kb_backlight.ops->set_brightness(kb_backlight.brightness + 1);
  427. }
  429. static void kb_toggle_state(void)
  430. {
  431. switch (kb_backlight.state) {
  432. case KB_STATE_OFF:
  433. kb_backlight.ops->set_state(KB_STATE_ON);
  434. break;
  435. case KB_STATE_ON:
  436. kb_backlight.ops->set_state(KB_STATE_OFF);
  437. break;
  438. default:
  439. BUG();
  440. }
  441. }
  443. static void kb_next_mode(void)
  444. {
  445. static enum kb_mode modes[] = {
  446. KB_MODE_RANDOM_COLOR,
  447. KB_MODE_DANCE,
  448. KB_MODE_TEMPO,
  449. KB_MODE_FLASH,
  450. KB_MODE_WAVE,
  451. KB_MODE_BREATHE,
  452. KB_MODE_CYCLE,
  453. KB_MODE_CUSTOM,
  454. };
  456. size_t i;
  458. if (kb_backlight.state == KB_STATE_OFF)
  459. return;
  461. for (i = 0; i < ARRAY_SIZE(modes); i++) {
  462. if (modes[i] == kb_backlight.mode)
  463. break;
  464. }
  466. BUG_ON(i == ARRAY_SIZE(modes));
  468. kb_backlight.ops->set_mode(modes[(i + 1) % ARRAY_SIZE(modes)]);
  469. }
  472. /* full color backlight keyboard */
  474. static void kb_full_color__set_color(unsigned left, unsigned center, unsigned right)
  475. {
  476. u32 cmd;
  478. cmd = 0xF0000000;
  479. cmd |= kb_colors[left].value.b << 16;
  480. cmd |= kb_colors[left].value.r << 8;
  481. cmd |= kb_colors[left].value.g << 0;
  483. if (!tuxedo_wmi_evaluate_wmbb_method(SET_KB_LED, cmd, NULL))
  484. kb_backlight.color.left = left;
  486. cmd = 0xF1000000;
  487. cmd |= kb_colors[center].value.b << 16;
  488. cmd |= kb_colors[center].value.r << 8;
  489. cmd |= kb_colors[center].value.g << 0;
  491. if (!tuxedo_wmi_evaluate_wmbb_method(SET_KB_LED, cmd, NULL))
  492. kb_backlight.color.center = center;
  494. cmd = 0xF2000000;
  495. cmd |= kb_colors[right].value.b << 16;
  496. cmd |= kb_colors[right].value.r << 8;
  497. cmd |= kb_colors[right].value.g << 0;
  499. if (!tuxedo_wmi_evaluate_wmbb_method(SET_KB_LED, cmd, NULL))
  500. kb_backlight.color.right = right;
  502. kb_backlight.mode = KB_MODE_CUSTOM;
  503. }
  505. static void kb_full_color__set_brightness(unsigned i)
  506. {
  507. u8 lvl_to_raw[] = { 63, 126, 189, 252 };
  509. i = clamp_t(unsigned, i, 0, ARRAY_SIZE(lvl_to_raw) - 1);
  511. if (!tuxedo_wmi_evaluate_wmbb_method(SET_KB_LED, 0xF4000000 | lvl_to_raw[i], NULL))
  512. kb_backlight.brightness = i;
  513. }
  515. static void kb_full_color__set_mode(unsigned mode)
  516. {
  517. static u32 cmds[] = {
  518. [KB_MODE_BREATHE] = 0x1002a000,
  519. [KB_MODE_CUSTOM] = 0,
  520. [KB_MODE_CYCLE] = 0x33010000,
  521. [KB_MODE_DANCE] = 0x80000000,
  522. [KB_MODE_FLASH] = 0xA0000000,
  523. [KB_MODE_RANDOM_COLOR] = 0x70000000,
  524. [KB_MODE_TEMPO] = 0x90000000,
  525. [KB_MODE_WAVE] = 0xB0000000,
  526. };
  528. BUG_ON(mode >= ARRAY_SIZE(cmds));
  530. tuxedo_wmi_evaluate_wmbb_method(SET_KB_LED, 0x10000000, NULL);
  532. if (mode == KB_MODE_CUSTOM) {
  533. kb_full_color__set_color(kb_backlight.color.left,
  534. kb_backlight.color.center,
  535. kb_backlight.color.right);
  536. kb_full_color__set_brightness(kb_backlight.brightness);
  537. return;
  538. }
  540. if (!tuxedo_wmi_evaluate_wmbb_method(SET_KB_LED, cmds[mode], NULL))
  541. kb_backlight.mode = mode;
  542. }
  544. static void kb_full_color__set_state(enum kb_state state)
  545. {
  546. u32 cmd = 0xE0000000;
  548. TUXEDO_DEBUG("State: %d\n", state);
  550. switch (state) {
  551. case KB_STATE_OFF:
  552. cmd |= 0x003001;
  553. break;
  554. case KB_STATE_ON:
  555. cmd |= 0x07F001;
  556. break;
  557. default:
  558. BUG();
  559. }
  561. if (!tuxedo_wmi_evaluate_wmbb_method(SET_KB_LED, cmd, NULL))
  562. kb_backlight.state = state;
  563. }
  565. static void kb_full_color__init(void)
  566. {
  567. TUXEDO_DEBUG();
  569. kb_full_color__set_state(param_kb_off ? KB_STATE_OFF : KB_STATE_ON);
  570. kb_full_color__set_color(param_kb_color[0], param_kb_color[1], param_kb_color[2]);
  571. kb_full_color__set_brightness(param_kb_brightness);
  572. }
  574. static struct kb_backlight_ops kb_full_color_ops = {
  575. .set_state = kb_full_color__set_state,
  576. .set_color = kb_full_color__set_color,
  577. .set_brightness = kb_full_color__set_brightness,
  578. .set_mode = kb_full_color__set_mode,
  579. .init = kb_full_color__init,
  580. };
  583. /* 8 color backlight keyboard */
  585. static void kb_8_color__set_color(unsigned left, unsigned center, unsigned right)
  586. {
  587. u32 cmd = 0x02010000;
  589. cmd |= kb_backlight.brightness << 12;
  590. cmd |= right << 8;
  591. cmd |= center << 4;
  592. cmd |= left;
  594. if (!tuxedo_wmi_evaluate_wmbb_method(SET_KB_LED, cmd, NULL)) {
  595. kb_backlight.color.left = left;
  596. kb_backlight.color.center = center;
  597. kb_backlight.color.right = right;
  598. }
  600. kb_backlight.mode = KB_MODE_CUSTOM;
  601. }
  603. static void kb_8_color__set_brightness(unsigned i)
  604. {
  605. u32 cmd = 0xD2010000;
  607. i = clamp_t(unsigned, i, 0, KB_BRIGHTNESS_MAX);
  609. cmd |= i << 12;
  610. cmd |= kb_backlight.color.right << 8;
  611. cmd |= kb_backlight.color.center << 4;
  612. cmd |= kb_backlight.color.left;
  614. if (!tuxedo_wmi_evaluate_wmbb_method(SET_KB_LED, cmd, NULL))
  615. kb_backlight.brightness = i;
  616. }
  618. static void kb_8_color__set_mode(unsigned mode)
  619. {
  620. static u32 cmds[] = {
  621. [KB_MODE_BREATHE] = 0x12010000,
  622. [KB_MODE_CUSTOM] = 0,
  623. [KB_MODE_CYCLE] = 0x32010000,
  624. [KB_MODE_DANCE] = 0x80000000,
  625. [KB_MODE_FLASH] = 0xA0000000,
  626. [KB_MODE_RANDOM_COLOR] = 0x70000000,
  627. [KB_MODE_TEMPO] = 0x90000000,
  628. [KB_MODE_WAVE] = 0xB0000000,
  629. };
  631. BUG_ON(mode >= ARRAY_SIZE(cmds));
  633. tuxedo_wmi_evaluate_wmbb_method(SET_KB_LED, 0x20000000, NULL);
  635. if (mode == KB_MODE_CUSTOM){
  636. kb_8_color__set_color(kb_backlight.color.left,
  637. kb_backlight.color.center,
  638. kb_backlight.color.right);
  639. kb_8_color__set_brightness(kb_backlight.brightness);
  640. return;
  641. }
  643. if (!tuxedo_wmi_evaluate_wmbb_method(SET_KB_LED, cmds[mode], NULL))
  644. kb_backlight.mode = mode;
  645. }
  647. static void kb_8_color__set_state(enum kb_state state)
  648. {
  649. TUXEDO_DEBUG("State: %d\n", state);
  651. switch (state) {
  652. case KB_STATE_OFF:
  653. if (!tuxedo_wmi_evaluate_wmbb_method(SET_KB_LED, 0x22010000, NULL))
  654. kb_backlight.state = state;
  655. break;
  656. case KB_STATE_ON:
  657. kb_8_color__set_mode(kb_backlight.mode);
  658. kb_backlight.state = state;
  659. break;
  660. default:
  661. BUG();
  662. }
  663. }
  665. static void kb_8_color__init(void)
  666. {
  667. TUXEDO_DEBUG();
  669. /* well, that's an uglymoron ... */
  671. kb_8_color__set_state(KB_STATE_OFF);
  673. kb_backlight.color.left = param_kb_color[0];
  674. kb_backlight.color.center = param_kb_color[1];
  675. kb_backlight.color.right = param_kb_color[2];
  677. kb_backlight.brightness = param_kb_brightness;
  678. kb_backlight.mode = KB_MODE_CUSTOM;
  680. if (!param_kb_off) {
  681. kb_8_color__set_color(kb_backlight.color.left,
  682. kb_backlight.color.center,
  683. kb_backlight.color.right);
  684. kb_8_color__set_brightness(kb_backlight.brightness);
  685. kb_8_color__set_state(KB_STATE_ON);
  686. }
  687. }
  689. static struct kb_backlight_ops kb_8_color_ops = {
  690. .set_state = kb_8_color__set_state,
  691. .set_color = kb_8_color__set_color,
  692. .set_brightness = kb_8_color__set_brightness,
  693. .set_mode = kb_8_color__set_mode,
  694. .init = kb_8_color__init,
  695. };
  698. static void tuxedo_wmi_notify(u32 value, void *context)
  699. {
  700. static unsigned int report_cnt = 0;
  702. u32 event;
  704. if (value != 0xD0) {
  705. TUXEDO_INFO("Unexpected WMI event (%0#6x)\n", value);
  706. return;
  707. }
  709. tuxedo_wmi_evaluate_wmbb_method(GET_EVENT, 0, &event);
  711. switch (event) {
  712. case 0xF4:
  713. TUXEDO_DEBUG("Airplane-Mode Hotkey pressed\n");
  715. if (tuxedo_input_polling_task) {
  716. TUXEDO_INFO("Stopping polling thread\n");
  717. kthread_stop(tuxedo_input_polling_task);
  718. tuxedo_input_polling_task = NULL;
  719. }
  721. mutex_lock(&tuxedo_input_report_mutex);
  723. if (global_report_cnt > report_cnt) {
  724. mutex_unlock(&tuxedo_input_report_mutex);
  725. break;
  726. }
  728. tuxedo_input_report_key(KEY_RFKILL);
  729. report_cnt++;
  731. mutex_unlock(&tuxedo_input_report_mutex);
  732. break;
  733. default:
  734. if (!kb_backlight.ops)
  735. break;
  737. switch (event) {
  738. case 0x81:
  739. kb_dec_brightness();
  740. break;
  741. case 0x82:
  742. kb_inc_brightness();
  743. break;
  744. case 0x83:
  745. kb_next_mode();
  746. break;
  747. case 0x9F:
  748. kb_toggle_state();
  749. break;
  750. }
  751. break;
  752. }
  753. }
  755. static int tuxedo_wmi_probe(struct platform_device *dev)
  756. {
  757. int status;
  759. status = wmi_install_notify_handler(CLEVO_EVENT_GUID,
  760. tuxedo_wmi_notify, NULL);
  761. if (unlikely(ACPI_FAILURE(status))) {
  762. TUXEDO_ERROR("Could not register WMI notify handler (%0#6x)\n",
  763. status);
  764. return -EIO;
  765. }
  767. tuxedo_wmi_evaluate_wmbb_method(GET_AP, 0, NULL);
  769. if (kb_backlight.ops)
  770. kb_backlight.ops->init();
  772. return 0;
  773. }
  775. static int tuxedo_wmi_remove(struct platform_device *dev)
  776. {
  777. wmi_remove_notify_handler(CLEVO_EVENT_GUID);
  778. return 0;
  779. }
  781. static int tuxedo_wmi_resume(struct platform_device *dev)
  782. {
  783. tuxedo_wmi_evaluate_wmbb_method(GET_AP, 0, NULL);
  785. if (kb_backlight.ops && kb_backlight.state == KB_STATE_ON)
  786. kb_backlight.ops->set_mode(kb_backlight.mode);
  788. return 0;
  789. }
  791. static struct platform_driver tuxedo_platform_driver = {
  792. .remove = tuxedo_wmi_remove,
  793. .resume = tuxedo_wmi_resume,
  794. .driver = {
  795. .name = TUXEDO_DRIVER_NAME,
  796. .owner = THIS_MODULE,
  797. },
  798. };
  801. /* LED sub-driver */
  803. static bool param_led_invert = false;
  804. module_param_named(led_invert, param_led_invert, bool, 0);
  805. MODULE_PARM_DESC(led_invert, "Invert airplane mode LED state.");
  807. static struct workqueue_struct *led_workqueue;
  809. static struct _led_work {
  810. struct work_struct work;
  811. int wk;
  812. } led_work;
  814. static void airplane_led_update(struct work_struct *work)
  815. {
  816. u8 byte;
  817. struct _led_work *w;
  819. w = container_of(work, struct _led_work, work);
  821. ec_read(0xD9, &byte);
  823. if (param_led_invert)
  824. ec_write(0xD9, w->wk ? byte & ~0x40 : byte | 0x40);
  825. else
  826. ec_write(0xD9, w->wk ? byte | 0x40 : byte & ~0x40);
  828. /* wmbb 0x6C 1 (?) */
  829. }
  831. static enum led_brightness airplane_led_get(struct led_classdev *led_cdev)
  832. {
  833. u8 byte;
  835. ec_read(0xD9, &byte);
  837. if (param_led_invert)
  838. return byte & 0x40 ? LED_OFF : LED_FULL;
  839. else
  840. return byte & 0x40 ? LED_FULL : LED_OFF;
  841. }
  843. /* must not sleep */
  844. static void airplane_led_set(struct led_classdev *led_cdev,
  845. enum led_brightness value)
  846. {
  847. led_work.wk = value;
  848. queue_work(led_workqueue, &led_work.work);
  849. }
  851. static struct led_classdev airplane_led = {
  852. .name = "tuxedo::airplane",
  853. .brightness_get = airplane_led_get,
  854. .brightness_set = airplane_led_set,
  855. .max_brightness = 1,
  856. };
  858. static int __init tuxedo_led_init(void)
  859. {
  860. int err;
  862. led_workqueue = create_singlethread_workqueue("led_workqueue");
  863. if (unlikely(!led_workqueue))
  864. return -ENOMEM;
  866. INIT_WORK(&led_work.work, airplane_led_update);
  868. err = led_classdev_register(&tuxedo_platform_device->dev, &airplane_led);
  869. if (unlikely(err))
  870. goto err_destroy_workqueue;
  872. return 0;
  874. err_destroy_workqueue:
  875. destroy_workqueue(led_workqueue);
  876. led_workqueue = NULL;
  878. return err;
  879. }
  881. static void __exit tuxedo_led_exit(void)
  882. {
  883. if (!IS_ERR_OR_NULL(airplane_led.dev))
  884. led_classdev_unregister(&airplane_led);
  885. if (led_workqueue)
  886. destroy_workqueue(led_workqueue);
  887. }
  890. /* RFKILL sub-driver */
  892. static bool param_rfkill = false;
  893. module_param_named(rfkill, param_rfkill, bool, 0);
  894. MODULE_PARM_DESC(rfkill, "Enable WWAN-RFKILL capability.");
  896. static struct rfkill *tuxedo_wwan_rfkill_device;
  898. static int tuxedo_wwan_rfkill_set_block(void *data, bool blocked)
  899. {
  900. TUXEDO_DEBUG("blocked=%i\n", blocked);
  902. if (tuxedo_wmi_evaluate_wmbb_method(SET_3G, !blocked, NULL))
  903. TUXEDO_ERROR("Setting 3G power state failed!\n");
  904. return 0;
  905. }
  907. static const struct rfkill_ops tuxedo_wwan_rfkill_ops = {
  908. .set_block = tuxedo_wwan_rfkill_set_block,
  909. };
  911. static int __init tuxedo_rfkill_init(void)
  912. {
  913. int err;
  914. u32 unblocked = 0;
  916. if (!param_rfkill)
  917. return 0;
  919. tuxedo_wmi_evaluate_wmbb_method(TALK_BIOS_3G, 1, NULL);
  921. tuxedo_wwan_rfkill_device = rfkill_alloc("tuxedo-wwan",
  922. &tuxedo_platform_device->dev,
  923. RFKILL_TYPE_WWAN,
  924. &tuxedo_wwan_rfkill_ops, NULL);
  925. if (unlikely(!tuxedo_wwan_rfkill_device))
  926. return -ENOMEM;
  928. err = rfkill_register(tuxedo_wwan_rfkill_device);
  929. if (unlikely(err))
  930. goto err_destroy_wwan;
  932. if (tuxedo_wmi_evaluate_wmbb_method(GET_POWER_STATE_FOR_3G, 0, &unblocked))
  933. TUXEDO_ERROR("Could not get 3G power state!\n");
  934. else
  935. rfkill_set_sw_state(tuxedo_wwan_rfkill_device, !unblocked);
  937. return 0;
  939. err_destroy_wwan:
  940. rfkill_destroy(tuxedo_wwan_rfkill_device);
  941. tuxedo_wmi_evaluate_wmbb_method(TALK_BIOS_3G, 0, NULL);
  942. return err;
  943. }
  945. static void __exit tuxedo_rfkill_exit(void)
  946. {
  947. if (!tuxedo_wwan_rfkill_device)
  948. return;
  950. tuxedo_wmi_evaluate_wmbb_method(TALK_BIOS_3G, 0, NULL);
  952. rfkill_unregister(tuxedo_wwan_rfkill_device);
  953. rfkill_destroy(tuxedo_wwan_rfkill_device);
  954. }
  957. static int __init tuxedo_dmi_matched(const struct dmi_system_id *id)
  958. {
  959. TUXEDO_INFO("Model %s found\n", id->ident);
  960. kb_backlight.ops = id->driver_data;
  962. return 1;
  963. }
  965. static struct dmi_system_id __initdata tuxedo_dmi_table[] = {
  966. {
  967. .ident = "Clevo P370SM-A",
  968. .matches = {
  969. DMI_MATCH(DMI_SYS_VENDOR, "Notebook"),
  970. DMI_MATCH(DMI_PRODUCT_NAME, "P370SM-A"),
  971. },
  972. .callback = tuxedo_dmi_matched,
  973. .driver_data = &kb_full_color_ops,
  974. },
  975. {
  976. .ident = "Clevo P17xSM-A",
  977. .matches = {
  978. DMI_MATCH(DMI_SYS_VENDOR, "Notebook"),
  979. DMI_MATCH(DMI_PRODUCT_NAME, "P17SM-A"),
  980. },
  981. .callback = tuxedo_dmi_matched,
  982. .driver_data = &kb_full_color_ops,
  983. },
  984. {
  985. .ident = "Clevo P15xSM-A/P15xSM1-A",
  986. .matches = {
  987. DMI_MATCH(DMI_SYS_VENDOR, "Notebook"),
  988. DMI_MATCH(DMI_PRODUCT_NAME, "P15SM-A/SM1-A"),
  989. },
  990. .callback = tuxedo_dmi_matched,
  991. .driver_data = &kb_full_color_ops,
  992. },
  993. {
  994. .ident = "Clevo P17xSM",
  995. .matches = {
  996. DMI_MATCH(DMI_SYS_VENDOR, "Notebook"),
  997. DMI_MATCH(DMI_PRODUCT_NAME, "P17SM"),
  998. },
  999. .callback = tuxedo_dmi_matched,
  1000. .driver_data = &kb_8_color_ops,
  1001. },
  1002. {
  1003. .ident = "Clevo P15xSM",
  1004. .matches = {
  1005. DMI_MATCH(DMI_SYS_VENDOR, "Notebook"),
  1006. DMI_MATCH(DMI_PRODUCT_NAME, "P15SM"),
  1007. },
  1008. .callback = tuxedo_dmi_matched,
  1009. .driver_data = &kb_8_color_ops,
  1010. },
  1011. {
  1012. /* terminating NULL entry */
  1013. },
  1014. };
  1016. MODULE_DEVICE_TABLE(dmi, tuxedo_dmi_table);
  1018. static int __init tuxedo_init(void)
  1019. {
  1020. int err;
  1022. switch (param_kb_color_num) {
  1023. case 1:
  1024. param_kb_color[1] = param_kb_color[2] = param_kb_color[0];
  1025. break;
  1026. case 2:
  1027. return -EINVAL;
  1028. }
  1030. dmi_check_system(tuxedo_dmi_table);
  1032. if (!wmi_has_guid(CLEVO_EVENT_GUID)) {
  1033. TUXEDO_INFO("No known WMI event notification GUID found\n");
  1034. return -ENODEV;
  1035. }
  1037. if (!wmi_has_guid(CLEVO_GET_GUID)) {
  1038. TUXEDO_INFO("No known WMI control method GUID found\n");
  1039. return -ENODEV;
  1040. }
  1042. tuxedo_platform_device =
  1043. platform_create_bundle(&tuxedo_platform_driver,
  1044. tuxedo_wmi_probe, NULL, 0, NULL, 0);
  1046. if (unlikely(IS_ERR(tuxedo_platform_device)))
  1047. return PTR_ERR(tuxedo_platform_device);
  1049. err = tuxedo_rfkill_init();
  1050. if (unlikely(err))
  1051. TUXEDO_ERROR("Could not register rfkill device\n");
  1053. err = tuxedo_input_init();
  1054. if (unlikely(err))
  1055. TUXEDO_ERROR("Could not register input device\n");
  1057. err = tuxedo_led_init();
  1058. if (unlikely(err))
  1059. TUXEDO_ERROR("Could not register LED device\n");
  1061. return 0;
  1062. }
  1064. static void __exit tuxedo_exit(void)
  1065. {
  1066. tuxedo_led_exit();
  1067. tuxedo_input_exit();
  1068. tuxedo_rfkill_exit();
  1070. platform_device_unregister(tuxedo_platform_device);
  1071. platform_driver_unregister(&tuxedo_platform_driver);
  1072. }
  1074. module_init(tuxedo_init);
  1075. module_exit(tuxedo_exit);
  1077. MODULE_AUTHOR("Christoph Jaeger <[email protected]>");
  1078. MODULE_DESCRIPTION("Tuxedo/Clevo laptop driver.");
  1079. MODULE_LICENSE("GPL");
  1080. MODULE_VERSION("1.5.1");