ideapad-laptop.c 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * ideapad-laptop.c - Lenovo IdeaPad ACPI Extras
  4. *
  5. * Copyright © 2010 Intel Corporation
  6. * Copyright © 2010 David Woodhouse <dwmw2@infradead.org>
  7. */
  8. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  9. #include <linux/kernel.h>
  10. #include <linux/module.h>
  11. #include <linux/init.h>
  12. #include <linux/types.h>
  13. #include <linux/acpi.h>
  14. #include <linux/rfkill.h>
  15. #include <linux/platform_device.h>
  16. #include <linux/input.h>
  17. #include <linux/input/sparse-keymap.h>
  18. #include <linux/backlight.h>
  19. #include <linux/fb.h>
  20. #include <linux/debugfs.h>
  21. #include <linux/seq_file.h>
  22. #include <linux/i8042.h>
  23. #include <linux/dmi.h>
  24. #include <linux/device.h>
  25. #include <acpi/video.h>
  26. #define IDEAPAD_RFKILL_DEV_NUM (3)
  27. #define BM_CONSERVATION_BIT (5)
  28. #define HA_FNLOCK_BIT (10)
  29. #define CFG_BT_BIT (16)
  30. #define CFG_3G_BIT (17)
  31. #define CFG_WIFI_BIT (18)
  32. #define CFG_CAMERA_BIT (19)
  33. #if IS_ENABLED(CONFIG_ACPI_WMI)
  34. static const char *const ideapad_wmi_fnesc_events[] = {
  35. "26CAB2E5-5CF1-46AE-AAC3-4A12B6BA50E6", /* Yoga 3 */
  36. "56322276-8493-4CE8-A783-98C991274F5E", /* Yoga 700 */
  37. };
  38. #endif
  39. enum {
  40. BMCMD_CONSERVATION_ON = 3,
  41. BMCMD_CONSERVATION_OFF = 5,
  42. HACMD_FNLOCK_ON = 0xe,
  43. HACMD_FNLOCK_OFF = 0xf,
  44. };
  45. enum {
  46. VPCCMD_R_VPC1 = 0x10,
  47. VPCCMD_R_BL_MAX,
  48. VPCCMD_R_BL,
  49. VPCCMD_W_BL,
  50. VPCCMD_R_WIFI,
  51. VPCCMD_W_WIFI,
  52. VPCCMD_R_BT,
  53. VPCCMD_W_BT,
  54. VPCCMD_R_BL_POWER,
  55. VPCCMD_R_NOVO,
  56. VPCCMD_R_VPC2,
  57. VPCCMD_R_TOUCHPAD,
  58. VPCCMD_W_TOUCHPAD,
  59. VPCCMD_R_CAMERA,
  60. VPCCMD_W_CAMERA,
  61. VPCCMD_R_3G,
  62. VPCCMD_W_3G,
  63. VPCCMD_R_ODD, /* 0x21 */
  64. VPCCMD_W_FAN,
  65. VPCCMD_R_RF,
  66. VPCCMD_W_RF,
  67. VPCCMD_R_FAN = 0x2B,
  68. VPCCMD_R_SPECIAL_BUTTONS = 0x31,
  69. VPCCMD_W_BL_POWER = 0x33,
  70. };
  71. struct ideapad_rfk_priv {
  72. int dev;
  73. struct ideapad_private *priv;
  74. };
  75. struct ideapad_private {
  76. struct acpi_device *adev;
  77. struct rfkill *rfk[IDEAPAD_RFKILL_DEV_NUM];
  78. struct ideapad_rfk_priv rfk_priv[IDEAPAD_RFKILL_DEV_NUM];
  79. struct platform_device *platform_device;
  80. struct input_dev *inputdev;
  81. struct backlight_device *blightdev;
  82. struct dentry *debug;
  83. unsigned long cfg;
  84. bool has_hw_rfkill_switch;
  85. bool has_touchpad_switch;
  86. const char *fnesc_guid;
  87. };
  88. static bool no_bt_rfkill;
  89. module_param(no_bt_rfkill, bool, 0444);
  90. MODULE_PARM_DESC(no_bt_rfkill, "No rfkill for bluetooth.");
  91. /*
  92. * ACPI Helpers
  93. */
  94. #define IDEAPAD_EC_TIMEOUT (200) /* in ms */
  95. static int read_method_int(acpi_handle handle, const char *method, int *val)
  96. {
  97. acpi_status status;
  98. unsigned long long result;
  99. status = acpi_evaluate_integer(handle, (char *)method, NULL, &result);
  100. if (ACPI_FAILURE(status)) {
  101. *val = -1;
  102. return -1;
  103. }
  104. *val = result;
  105. return 0;
  106. }
  107. static int method_gbmd(acpi_handle handle, unsigned long *ret)
  108. {
  109. int result, val;
  110. result = read_method_int(handle, "GBMD", &val);
  111. *ret = val;
  112. return result;
  113. }
  114. static int method_int1(acpi_handle handle, char *method, int cmd)
  115. {
  116. acpi_status status;
  117. status = acpi_execute_simple_method(handle, method, cmd);
  118. return ACPI_FAILURE(status) ? -1 : 0;
  119. }
  120. static int method_vpcr(acpi_handle handle, int cmd, int *ret)
  121. {
  122. acpi_status status;
  123. unsigned long long result;
  124. struct acpi_object_list params;
  125. union acpi_object in_obj;
  126. params.count = 1;
  127. params.pointer = &in_obj;
  128. in_obj.type = ACPI_TYPE_INTEGER;
  129. in_obj.integer.value = cmd;
  130. status = acpi_evaluate_integer(handle, "VPCR", &params, &result);
  131. if (ACPI_FAILURE(status)) {
  132. *ret = -1;
  133. return -1;
  134. }
  135. *ret = result;
  136. return 0;
  137. }
  138. static int method_vpcw(acpi_handle handle, int cmd, int data)
  139. {
  140. struct acpi_object_list params;
  141. union acpi_object in_obj[2];
  142. acpi_status status;
  143. params.count = 2;
  144. params.pointer = in_obj;
  145. in_obj[0].type = ACPI_TYPE_INTEGER;
  146. in_obj[0].integer.value = cmd;
  147. in_obj[1].type = ACPI_TYPE_INTEGER;
  148. in_obj[1].integer.value = data;
  149. status = acpi_evaluate_object(handle, "VPCW", &params, NULL);
  150. if (status != AE_OK)
  151. return -1;
  152. return 0;
  153. }
  154. static int read_ec_data(acpi_handle handle, int cmd, unsigned long *data)
  155. {
  156. int val;
  157. unsigned long int end_jiffies;
  158. if (method_vpcw(handle, 1, cmd))
  159. return -1;
  160. for (end_jiffies = jiffies+(HZ)*IDEAPAD_EC_TIMEOUT/1000+1;
  161. time_before(jiffies, end_jiffies);) {
  162. schedule();
  163. if (method_vpcr(handle, 1, &val))
  164. return -1;
  165. if (val == 0) {
  166. if (method_vpcr(handle, 0, &val))
  167. return -1;
  168. *data = val;
  169. return 0;
  170. }
  171. }
  172. pr_err("timeout in %s\n", __func__);
  173. return -1;
  174. }
  175. static int write_ec_cmd(acpi_handle handle, int cmd, unsigned long data)
  176. {
  177. int val;
  178. unsigned long int end_jiffies;
  179. if (method_vpcw(handle, 0, data))
  180. return -1;
  181. if (method_vpcw(handle, 1, cmd))
  182. return -1;
  183. for (end_jiffies = jiffies+(HZ)*IDEAPAD_EC_TIMEOUT/1000+1;
  184. time_before(jiffies, end_jiffies);) {
  185. schedule();
  186. if (method_vpcr(handle, 1, &val))
  187. return -1;
  188. if (val == 0)
  189. return 0;
  190. }
  191. pr_err("timeout in %s\n", __func__);
  192. return -1;
  193. }
  194. /*
  195. * debugfs
  196. */
  197. static int debugfs_status_show(struct seq_file *s, void *data)
  198. {
  199. struct ideapad_private *priv = s->private;
  200. unsigned long value;
  201. if (!priv)
  202. return -EINVAL;
  203. if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL_MAX, &value))
  204. seq_printf(s, "Backlight max:\t%lu\n", value);
  205. if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL, &value))
  206. seq_printf(s, "Backlight now:\t%lu\n", value);
  207. if (!read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &value))
  208. seq_printf(s, "BL power value:\t%s\n", value ? "On" : "Off");
  209. seq_printf(s, "=====================\n");
  210. if (!read_ec_data(priv->adev->handle, VPCCMD_R_RF, &value))
  211. seq_printf(s, "Radio status:\t%s(%lu)\n",
  212. value ? "On" : "Off", value);
  213. if (!read_ec_data(priv->adev->handle, VPCCMD_R_WIFI, &value))
  214. seq_printf(s, "Wifi status:\t%s(%lu)\n",
  215. value ? "On" : "Off", value);
  216. if (!read_ec_data(priv->adev->handle, VPCCMD_R_BT, &value))
  217. seq_printf(s, "BT status:\t%s(%lu)\n",
  218. value ? "On" : "Off", value);
  219. if (!read_ec_data(priv->adev->handle, VPCCMD_R_3G, &value))
  220. seq_printf(s, "3G status:\t%s(%lu)\n",
  221. value ? "On" : "Off", value);
  222. seq_printf(s, "=====================\n");
  223. if (!read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &value))
  224. seq_printf(s, "Touchpad status:%s(%lu)\n",
  225. value ? "On" : "Off", value);
  226. if (!read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &value))
  227. seq_printf(s, "Camera status:\t%s(%lu)\n",
  228. value ? "On" : "Off", value);
  229. seq_puts(s, "=====================\n");
  230. if (!method_gbmd(priv->adev->handle, &value)) {
  231. seq_printf(s, "Conservation mode:\t%s(%lu)\n",
  232. test_bit(BM_CONSERVATION_BIT, &value) ? "On" : "Off",
  233. value);
  234. }
  235. return 0;
  236. }
  237. DEFINE_SHOW_ATTRIBUTE(debugfs_status);
  238. static int debugfs_cfg_show(struct seq_file *s, void *data)
  239. {
  240. struct ideapad_private *priv = s->private;
  241. if (!priv) {
  242. seq_printf(s, "cfg: N/A\n");
  243. } else {
  244. seq_printf(s, "cfg: 0x%.8lX\n\nCapability: ",
  245. priv->cfg);
  246. if (test_bit(CFG_BT_BIT, &priv->cfg))
  247. seq_printf(s, "Bluetooth ");
  248. if (test_bit(CFG_3G_BIT, &priv->cfg))
  249. seq_printf(s, "3G ");
  250. if (test_bit(CFG_WIFI_BIT, &priv->cfg))
  251. seq_printf(s, "Wireless ");
  252. if (test_bit(CFG_CAMERA_BIT, &priv->cfg))
  253. seq_printf(s, "Camera ");
  254. seq_printf(s, "\nGraphic: ");
  255. switch ((priv->cfg)&0x700) {
  256. case 0x100:
  257. seq_printf(s, "Intel");
  258. break;
  259. case 0x200:
  260. seq_printf(s, "ATI");
  261. break;
  262. case 0x300:
  263. seq_printf(s, "Nvidia");
  264. break;
  265. case 0x400:
  266. seq_printf(s, "Intel and ATI");
  267. break;
  268. case 0x500:
  269. seq_printf(s, "Intel and Nvidia");
  270. break;
  271. }
  272. seq_printf(s, "\n");
  273. }
  274. return 0;
  275. }
  276. DEFINE_SHOW_ATTRIBUTE(debugfs_cfg);
  277. static void ideapad_debugfs_init(struct ideapad_private *priv)
  278. {
  279. struct dentry *dir;
  280. dir = debugfs_create_dir("ideapad", NULL);
  281. priv->debug = dir;
  282. debugfs_create_file("cfg", S_IRUGO, dir, priv, &debugfs_cfg_fops);
  283. debugfs_create_file("status", S_IRUGO, dir, priv, &debugfs_status_fops);
  284. }
  285. static void ideapad_debugfs_exit(struct ideapad_private *priv)
  286. {
  287. debugfs_remove_recursive(priv->debug);
  288. priv->debug = NULL;
  289. }
  290. /*
  291. * sysfs
  292. */
  293. static ssize_t show_ideapad_cam(struct device *dev,
  294. struct device_attribute *attr,
  295. char *buf)
  296. {
  297. unsigned long result;
  298. struct ideapad_private *priv = dev_get_drvdata(dev);
  299. if (read_ec_data(priv->adev->handle, VPCCMD_R_CAMERA, &result))
  300. return sprintf(buf, "-1\n");
  301. return sprintf(buf, "%lu\n", result);
  302. }
  303. static ssize_t store_ideapad_cam(struct device *dev,
  304. struct device_attribute *attr,
  305. const char *buf, size_t count)
  306. {
  307. int ret, state;
  308. struct ideapad_private *priv = dev_get_drvdata(dev);
  309. if (!count)
  310. return 0;
  311. if (sscanf(buf, "%i", &state) != 1)
  312. return -EINVAL;
  313. ret = write_ec_cmd(priv->adev->handle, VPCCMD_W_CAMERA, state);
  314. if (ret < 0)
  315. return -EIO;
  316. return count;
  317. }
  318. static DEVICE_ATTR(camera_power, 0644, show_ideapad_cam, store_ideapad_cam);
  319. static ssize_t show_ideapad_fan(struct device *dev,
  320. struct device_attribute *attr,
  321. char *buf)
  322. {
  323. unsigned long result;
  324. struct ideapad_private *priv = dev_get_drvdata(dev);
  325. if (read_ec_data(priv->adev->handle, VPCCMD_R_FAN, &result))
  326. return sprintf(buf, "-1\n");
  327. return sprintf(buf, "%lu\n", result);
  328. }
  329. static ssize_t store_ideapad_fan(struct device *dev,
  330. struct device_attribute *attr,
  331. const char *buf, size_t count)
  332. {
  333. int ret, state;
  334. struct ideapad_private *priv = dev_get_drvdata(dev);
  335. if (!count)
  336. return 0;
  337. if (sscanf(buf, "%i", &state) != 1)
  338. return -EINVAL;
  339. if (state < 0 || state > 4 || state == 3)
  340. return -EINVAL;
  341. ret = write_ec_cmd(priv->adev->handle, VPCCMD_W_FAN, state);
  342. if (ret < 0)
  343. return -EIO;
  344. return count;
  345. }
  346. static DEVICE_ATTR(fan_mode, 0644, show_ideapad_fan, store_ideapad_fan);
  347. static ssize_t touchpad_show(struct device *dev,
  348. struct device_attribute *attr,
  349. char *buf)
  350. {
  351. struct ideapad_private *priv = dev_get_drvdata(dev);
  352. unsigned long result;
  353. if (read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &result))
  354. return sprintf(buf, "-1\n");
  355. return sprintf(buf, "%lu\n", result);
  356. }
  357. /* Switch to RO for now: It might be revisited in the future */
  358. static ssize_t __maybe_unused touchpad_store(struct device *dev,
  359. struct device_attribute *attr,
  360. const char *buf, size_t count)
  361. {
  362. struct ideapad_private *priv = dev_get_drvdata(dev);
  363. bool state;
  364. int ret;
  365. ret = kstrtobool(buf, &state);
  366. if (ret)
  367. return ret;
  368. ret = write_ec_cmd(priv->adev->handle, VPCCMD_W_TOUCHPAD, state);
  369. if (ret < 0)
  370. return -EIO;
  371. return count;
  372. }
  373. static DEVICE_ATTR_RO(touchpad);
  374. static ssize_t conservation_mode_show(struct device *dev,
  375. struct device_attribute *attr,
  376. char *buf)
  377. {
  378. struct ideapad_private *priv = dev_get_drvdata(dev);
  379. unsigned long result;
  380. if (method_gbmd(priv->adev->handle, &result))
  381. return sprintf(buf, "-1\n");
  382. return sprintf(buf, "%u\n", test_bit(BM_CONSERVATION_BIT, &result));
  383. }
  384. static ssize_t conservation_mode_store(struct device *dev,
  385. struct device_attribute *attr,
  386. const char *buf, size_t count)
  387. {
  388. struct ideapad_private *priv = dev_get_drvdata(dev);
  389. bool state;
  390. int ret;
  391. ret = kstrtobool(buf, &state);
  392. if (ret)
  393. return ret;
  394. ret = method_int1(priv->adev->handle, "SBMC", state ?
  395. BMCMD_CONSERVATION_ON :
  396. BMCMD_CONSERVATION_OFF);
  397. if (ret < 0)
  398. return -EIO;
  399. return count;
  400. }
  401. static DEVICE_ATTR_RW(conservation_mode);
  402. static ssize_t fn_lock_show(struct device *dev,
  403. struct device_attribute *attr,
  404. char *buf)
  405. {
  406. struct ideapad_private *priv = dev_get_drvdata(dev);
  407. unsigned long result;
  408. int hals;
  409. int fail = read_method_int(priv->adev->handle, "HALS", &hals);
  410. if (fail)
  411. return sprintf(buf, "-1\n");
  412. result = hals;
  413. return sprintf(buf, "%u\n", test_bit(HA_FNLOCK_BIT, &result));
  414. }
  415. static ssize_t fn_lock_store(struct device *dev,
  416. struct device_attribute *attr,
  417. const char *buf, size_t count)
  418. {
  419. struct ideapad_private *priv = dev_get_drvdata(dev);
  420. bool state;
  421. int ret;
  422. ret = kstrtobool(buf, &state);
  423. if (ret)
  424. return ret;
  425. ret = method_int1(priv->adev->handle, "SALS", state ?
  426. HACMD_FNLOCK_ON :
  427. HACMD_FNLOCK_OFF);
  428. if (ret < 0)
  429. return -EIO;
  430. return count;
  431. }
  432. static DEVICE_ATTR_RW(fn_lock);
  433. static struct attribute *ideapad_attributes[] = {
  434. &dev_attr_camera_power.attr,
  435. &dev_attr_fan_mode.attr,
  436. &dev_attr_touchpad.attr,
  437. &dev_attr_conservation_mode.attr,
  438. &dev_attr_fn_lock.attr,
  439. NULL
  440. };
  441. static umode_t ideapad_is_visible(struct kobject *kobj,
  442. struct attribute *attr,
  443. int idx)
  444. {
  445. struct device *dev = container_of(kobj, struct device, kobj);
  446. struct ideapad_private *priv = dev_get_drvdata(dev);
  447. bool supported;
  448. if (attr == &dev_attr_camera_power.attr)
  449. supported = test_bit(CFG_CAMERA_BIT, &(priv->cfg));
  450. else if (attr == &dev_attr_fan_mode.attr) {
  451. unsigned long value;
  452. supported = !read_ec_data(priv->adev->handle, VPCCMD_R_FAN,
  453. &value);
  454. } else if (attr == &dev_attr_conservation_mode.attr) {
  455. supported = acpi_has_method(priv->adev->handle, "GBMD") &&
  456. acpi_has_method(priv->adev->handle, "SBMC");
  457. } else if (attr == &dev_attr_fn_lock.attr) {
  458. supported = acpi_has_method(priv->adev->handle, "HALS") &&
  459. acpi_has_method(priv->adev->handle, "SALS");
  460. } else if (attr == &dev_attr_touchpad.attr)
  461. supported = priv->has_touchpad_switch;
  462. else
  463. supported = true;
  464. return supported ? attr->mode : 0;
  465. }
  466. static const struct attribute_group ideapad_attribute_group = {
  467. .is_visible = ideapad_is_visible,
  468. .attrs = ideapad_attributes
  469. };
  470. /*
  471. * Rfkill
  472. */
  473. struct ideapad_rfk_data {
  474. char *name;
  475. int cfgbit;
  476. int opcode;
  477. int type;
  478. };
  479. static const struct ideapad_rfk_data ideapad_rfk_data[] = {
  480. { "ideapad_wlan", CFG_WIFI_BIT, VPCCMD_W_WIFI, RFKILL_TYPE_WLAN },
  481. { "ideapad_bluetooth", CFG_BT_BIT, VPCCMD_W_BT, RFKILL_TYPE_BLUETOOTH },
  482. { "ideapad_3g", CFG_3G_BIT, VPCCMD_W_3G, RFKILL_TYPE_WWAN },
  483. };
  484. static int ideapad_rfk_set(void *data, bool blocked)
  485. {
  486. struct ideapad_rfk_priv *priv = data;
  487. int opcode = ideapad_rfk_data[priv->dev].opcode;
  488. return write_ec_cmd(priv->priv->adev->handle, opcode, !blocked);
  489. }
  490. static const struct rfkill_ops ideapad_rfk_ops = {
  491. .set_block = ideapad_rfk_set,
  492. };
  493. static void ideapad_sync_rfk_state(struct ideapad_private *priv)
  494. {
  495. unsigned long hw_blocked = 0;
  496. int i;
  497. if (priv->has_hw_rfkill_switch) {
  498. if (read_ec_data(priv->adev->handle, VPCCMD_R_RF, &hw_blocked))
  499. return;
  500. hw_blocked = !hw_blocked;
  501. }
  502. for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
  503. if (priv->rfk[i])
  504. rfkill_set_hw_state(priv->rfk[i], hw_blocked);
  505. }
  506. static int ideapad_register_rfkill(struct ideapad_private *priv, int dev)
  507. {
  508. int ret;
  509. unsigned long sw_blocked;
  510. if (no_bt_rfkill &&
  511. (ideapad_rfk_data[dev].type == RFKILL_TYPE_BLUETOOTH)) {
  512. /* Force to enable bluetooth when no_bt_rfkill=1 */
  513. write_ec_cmd(priv->adev->handle,
  514. ideapad_rfk_data[dev].opcode, 1);
  515. return 0;
  516. }
  517. priv->rfk_priv[dev].dev = dev;
  518. priv->rfk_priv[dev].priv = priv;
  519. priv->rfk[dev] = rfkill_alloc(ideapad_rfk_data[dev].name,
  520. &priv->platform_device->dev,
  521. ideapad_rfk_data[dev].type,
  522. &ideapad_rfk_ops,
  523. &priv->rfk_priv[dev]);
  524. if (!priv->rfk[dev])
  525. return -ENOMEM;
  526. if (read_ec_data(priv->adev->handle, ideapad_rfk_data[dev].opcode-1,
  527. &sw_blocked)) {
  528. rfkill_init_sw_state(priv->rfk[dev], 0);
  529. } else {
  530. sw_blocked = !sw_blocked;
  531. rfkill_init_sw_state(priv->rfk[dev], sw_blocked);
  532. }
  533. ret = rfkill_register(priv->rfk[dev]);
  534. if (ret) {
  535. rfkill_destroy(priv->rfk[dev]);
  536. return ret;
  537. }
  538. return 0;
  539. }
  540. static void ideapad_unregister_rfkill(struct ideapad_private *priv, int dev)
  541. {
  542. if (!priv->rfk[dev])
  543. return;
  544. rfkill_unregister(priv->rfk[dev]);
  545. rfkill_destroy(priv->rfk[dev]);
  546. }
  547. /*
  548. * Platform device
  549. */
  550. static int ideapad_sysfs_init(struct ideapad_private *priv)
  551. {
  552. return sysfs_create_group(&priv->platform_device->dev.kobj,
  553. &ideapad_attribute_group);
  554. }
  555. static void ideapad_sysfs_exit(struct ideapad_private *priv)
  556. {
  557. sysfs_remove_group(&priv->platform_device->dev.kobj,
  558. &ideapad_attribute_group);
  559. }
  560. /*
  561. * input device
  562. */
  563. static const struct key_entry ideapad_keymap[] = {
  564. { KE_KEY, 6, { KEY_SWITCHVIDEOMODE } },
  565. { KE_KEY, 7, { KEY_CAMERA } },
  566. { KE_KEY, 8, { KEY_MICMUTE } },
  567. { KE_KEY, 11, { KEY_F16 } },
  568. { KE_KEY, 13, { KEY_WLAN } },
  569. { KE_KEY, 16, { KEY_PROG1 } },
  570. { KE_KEY, 17, { KEY_PROG2 } },
  571. { KE_KEY, 64, { KEY_PROG3 } },
  572. { KE_KEY, 65, { KEY_PROG4 } },
  573. { KE_KEY, 66, { KEY_TOUCHPAD_OFF } },
  574. { KE_KEY, 67, { KEY_TOUCHPAD_ON } },
  575. { KE_KEY, 128, { KEY_ESC } },
  576. { KE_END, 0 },
  577. };
  578. static int ideapad_input_init(struct ideapad_private *priv)
  579. {
  580. struct input_dev *inputdev;
  581. int error;
  582. inputdev = input_allocate_device();
  583. if (!inputdev)
  584. return -ENOMEM;
  585. inputdev->name = "Ideapad extra buttons";
  586. inputdev->phys = "ideapad/input0";
  587. inputdev->id.bustype = BUS_HOST;
  588. inputdev->dev.parent = &priv->platform_device->dev;
  589. error = sparse_keymap_setup(inputdev, ideapad_keymap, NULL);
  590. if (error) {
  591. pr_err("Unable to setup input device keymap\n");
  592. goto err_free_dev;
  593. }
  594. error = input_register_device(inputdev);
  595. if (error) {
  596. pr_err("Unable to register input device\n");
  597. goto err_free_dev;
  598. }
  599. priv->inputdev = inputdev;
  600. return 0;
  601. err_free_dev:
  602. input_free_device(inputdev);
  603. return error;
  604. }
  605. static void ideapad_input_exit(struct ideapad_private *priv)
  606. {
  607. input_unregister_device(priv->inputdev);
  608. priv->inputdev = NULL;
  609. }
  610. static void ideapad_input_report(struct ideapad_private *priv,
  611. unsigned long scancode)
  612. {
  613. sparse_keymap_report_event(priv->inputdev, scancode, 1, true);
  614. }
  615. static void ideapad_input_novokey(struct ideapad_private *priv)
  616. {
  617. unsigned long long_pressed;
  618. if (read_ec_data(priv->adev->handle, VPCCMD_R_NOVO, &long_pressed))
  619. return;
  620. if (long_pressed)
  621. ideapad_input_report(priv, 17);
  622. else
  623. ideapad_input_report(priv, 16);
  624. }
  625. static void ideapad_check_special_buttons(struct ideapad_private *priv)
  626. {
  627. unsigned long bit, value;
  628. read_ec_data(priv->adev->handle, VPCCMD_R_SPECIAL_BUTTONS, &value);
  629. for (bit = 0; bit < 16; bit++) {
  630. if (test_bit(bit, &value)) {
  631. switch (bit) {
  632. case 0: /* Z580 */
  633. case 6: /* Z570 */
  634. /* Thermal Management button */
  635. ideapad_input_report(priv, 65);
  636. break;
  637. case 1:
  638. /* OneKey Theater button */
  639. ideapad_input_report(priv, 64);
  640. break;
  641. default:
  642. pr_info("Unknown special button: %lu\n", bit);
  643. break;
  644. }
  645. }
  646. }
  647. }
  648. /*
  649. * backlight
  650. */
  651. static int ideapad_backlight_get_brightness(struct backlight_device *blightdev)
  652. {
  653. struct ideapad_private *priv = bl_get_data(blightdev);
  654. unsigned long now;
  655. if (!priv)
  656. return -EINVAL;
  657. if (read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now))
  658. return -EIO;
  659. return now;
  660. }
  661. static int ideapad_backlight_update_status(struct backlight_device *blightdev)
  662. {
  663. struct ideapad_private *priv = bl_get_data(blightdev);
  664. if (!priv)
  665. return -EINVAL;
  666. if (write_ec_cmd(priv->adev->handle, VPCCMD_W_BL,
  667. blightdev->props.brightness))
  668. return -EIO;
  669. if (write_ec_cmd(priv->adev->handle, VPCCMD_W_BL_POWER,
  670. blightdev->props.power == FB_BLANK_POWERDOWN ? 0 : 1))
  671. return -EIO;
  672. return 0;
  673. }
  674. static const struct backlight_ops ideapad_backlight_ops = {
  675. .get_brightness = ideapad_backlight_get_brightness,
  676. .update_status = ideapad_backlight_update_status,
  677. };
  678. static int ideapad_backlight_init(struct ideapad_private *priv)
  679. {
  680. struct backlight_device *blightdev;
  681. struct backlight_properties props;
  682. unsigned long max, now, power;
  683. if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_MAX, &max))
  684. return -EIO;
  685. if (read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now))
  686. return -EIO;
  687. if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power))
  688. return -EIO;
  689. memset(&props, 0, sizeof(struct backlight_properties));
  690. props.max_brightness = max;
  691. props.type = BACKLIGHT_PLATFORM;
  692. blightdev = backlight_device_register("ideapad",
  693. &priv->platform_device->dev,
  694. priv,
  695. &ideapad_backlight_ops,
  696. &props);
  697. if (IS_ERR(blightdev)) {
  698. pr_err("Could not register backlight device\n");
  699. return PTR_ERR(blightdev);
  700. }
  701. priv->blightdev = blightdev;
  702. blightdev->props.brightness = now;
  703. blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
  704. backlight_update_status(blightdev);
  705. return 0;
  706. }
  707. static void ideapad_backlight_exit(struct ideapad_private *priv)
  708. {
  709. backlight_device_unregister(priv->blightdev);
  710. priv->blightdev = NULL;
  711. }
  712. static void ideapad_backlight_notify_power(struct ideapad_private *priv)
  713. {
  714. unsigned long power;
  715. struct backlight_device *blightdev = priv->blightdev;
  716. if (!blightdev)
  717. return;
  718. if (read_ec_data(priv->adev->handle, VPCCMD_R_BL_POWER, &power))
  719. return;
  720. blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
  721. }
  722. static void ideapad_backlight_notify_brightness(struct ideapad_private *priv)
  723. {
  724. unsigned long now;
  725. /* if we control brightness via acpi video driver */
  726. if (priv->blightdev == NULL) {
  727. read_ec_data(priv->adev->handle, VPCCMD_R_BL, &now);
  728. return;
  729. }
  730. backlight_force_update(priv->blightdev, BACKLIGHT_UPDATE_HOTKEY);
  731. }
  732. /*
  733. * module init/exit
  734. */
  735. static void ideapad_sync_touchpad_state(struct ideapad_private *priv)
  736. {
  737. unsigned long value;
  738. if (!priv->has_touchpad_switch)
  739. return;
  740. /* Without reading from EC touchpad LED doesn't switch state */
  741. if (!read_ec_data(priv->adev->handle, VPCCMD_R_TOUCHPAD, &value)) {
  742. /* Some IdeaPads don't really turn off touchpad - they only
  743. * switch the LED state. We (de)activate KBC AUX port to turn
  744. * touchpad off and on. We send KEY_TOUCHPAD_OFF and
  745. * KEY_TOUCHPAD_ON to not to get out of sync with LED */
  746. unsigned char param;
  747. i8042_command(&param, value ? I8042_CMD_AUX_ENABLE :
  748. I8042_CMD_AUX_DISABLE);
  749. ideapad_input_report(priv, value ? 67 : 66);
  750. }
  751. }
  752. static void ideapad_acpi_notify(acpi_handle handle, u32 event, void *data)
  753. {
  754. struct ideapad_private *priv = data;
  755. unsigned long vpc1, vpc2, vpc_bit;
  756. if (read_ec_data(handle, VPCCMD_R_VPC1, &vpc1))
  757. return;
  758. if (read_ec_data(handle, VPCCMD_R_VPC2, &vpc2))
  759. return;
  760. vpc1 = (vpc2 << 8) | vpc1;
  761. for (vpc_bit = 0; vpc_bit < 16; vpc_bit++) {
  762. if (test_bit(vpc_bit, &vpc1)) {
  763. switch (vpc_bit) {
  764. case 9:
  765. ideapad_sync_rfk_state(priv);
  766. break;
  767. case 13:
  768. case 11:
  769. case 8:
  770. case 7:
  771. case 6:
  772. ideapad_input_report(priv, vpc_bit);
  773. break;
  774. case 5:
  775. ideapad_sync_touchpad_state(priv);
  776. break;
  777. case 4:
  778. ideapad_backlight_notify_brightness(priv);
  779. break;
  780. case 3:
  781. ideapad_input_novokey(priv);
  782. break;
  783. case 2:
  784. ideapad_backlight_notify_power(priv);
  785. break;
  786. case 0:
  787. ideapad_check_special_buttons(priv);
  788. break;
  789. case 1:
  790. /* Some IdeaPads report event 1 every ~20
  791. * seconds while on battery power; some
  792. * report this when changing to/from tablet
  793. * mode. Squelch this event.
  794. */
  795. break;
  796. default:
  797. pr_info("Unknown event: %lu\n", vpc_bit);
  798. }
  799. }
  800. }
  801. }
  802. #if IS_ENABLED(CONFIG_ACPI_WMI)
  803. static void ideapad_wmi_notify(u32 value, void *context)
  804. {
  805. switch (value) {
  806. case 128:
  807. ideapad_input_report(context, value);
  808. break;
  809. default:
  810. pr_info("Unknown WMI event %u\n", value);
  811. }
  812. }
  813. #endif
  814. /*
  815. * Some ideapads have a hardware rfkill switch, but most do not have one.
  816. * Reading VPCCMD_R_RF always results in 0 on models without a hardware rfkill,
  817. * switch causing ideapad_laptop to wrongly report all radios as hw-blocked.
  818. * There used to be a long list of DMI ids for models without a hw rfkill
  819. * switch here, but that resulted in playing whack a mole.
  820. * More importantly wrongly reporting the wifi radio as hw-blocked, results in
  821. * non working wifi. Whereas not reporting it hw-blocked, when it actually is
  822. * hw-blocked results in an empty SSID list, which is a much more benign
  823. * failure mode.
  824. * So the default now is the much safer option of assuming there is no
  825. * hardware rfkill switch. This default also actually matches most hardware,
  826. * since having a hw rfkill switch is quite rare on modern hardware, so this
  827. * also leads to a much shorter list.
  828. */
  829. static const struct dmi_system_id hw_rfkill_list[] = {
  830. {}
  831. };
  832. static int ideapad_acpi_add(struct platform_device *pdev)
  833. {
  834. int ret, i;
  835. int cfg;
  836. struct ideapad_private *priv;
  837. struct acpi_device *adev;
  838. ret = acpi_bus_get_device(ACPI_HANDLE(&pdev->dev), &adev);
  839. if (ret)
  840. return -ENODEV;
  841. if (read_method_int(adev->handle, "_CFG", &cfg))
  842. return -ENODEV;
  843. priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
  844. if (!priv)
  845. return -ENOMEM;
  846. dev_set_drvdata(&pdev->dev, priv);
  847. priv->cfg = cfg;
  848. priv->adev = adev;
  849. priv->platform_device = pdev;
  850. priv->has_hw_rfkill_switch = dmi_check_system(hw_rfkill_list);
  851. /* Most ideapads with ELAN0634 touchpad don't use EC touchpad switch */
  852. priv->has_touchpad_switch = !acpi_dev_present("ELAN0634", NULL, -1);
  853. ret = ideapad_sysfs_init(priv);
  854. if (ret)
  855. return ret;
  856. ideapad_debugfs_init(priv);
  857. ret = ideapad_input_init(priv);
  858. if (ret)
  859. goto input_failed;
  860. /*
  861. * On some models without a hw-switch (the yoga 2 13 at least)
  862. * VPCCMD_W_RF must be explicitly set to 1 for the wifi to work.
  863. */
  864. if (!priv->has_hw_rfkill_switch)
  865. write_ec_cmd(priv->adev->handle, VPCCMD_W_RF, 1);
  866. /* The same for Touchpad */
  867. if (!priv->has_touchpad_switch)
  868. write_ec_cmd(priv->adev->handle, VPCCMD_W_TOUCHPAD, 1);
  869. for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
  870. if (test_bit(ideapad_rfk_data[i].cfgbit, &priv->cfg))
  871. ideapad_register_rfkill(priv, i);
  872. ideapad_sync_rfk_state(priv);
  873. ideapad_sync_touchpad_state(priv);
  874. if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
  875. ret = ideapad_backlight_init(priv);
  876. if (ret && ret != -ENODEV)
  877. goto backlight_failed;
  878. }
  879. ret = acpi_install_notify_handler(adev->handle,
  880. ACPI_DEVICE_NOTIFY, ideapad_acpi_notify, priv);
  881. if (ret)
  882. goto notification_failed;
  883. #if IS_ENABLED(CONFIG_ACPI_WMI)
  884. for (i = 0; i < ARRAY_SIZE(ideapad_wmi_fnesc_events); i++) {
  885. ret = wmi_install_notify_handler(ideapad_wmi_fnesc_events[i],
  886. ideapad_wmi_notify, priv);
  887. if (ret == AE_OK) {
  888. priv->fnesc_guid = ideapad_wmi_fnesc_events[i];
  889. break;
  890. }
  891. }
  892. if (ret != AE_OK && ret != AE_NOT_EXIST)
  893. goto notification_failed_wmi;
  894. #endif
  895. return 0;
  896. #if IS_ENABLED(CONFIG_ACPI_WMI)
  897. notification_failed_wmi:
  898. acpi_remove_notify_handler(priv->adev->handle,
  899. ACPI_DEVICE_NOTIFY, ideapad_acpi_notify);
  900. #endif
  901. notification_failed:
  902. ideapad_backlight_exit(priv);
  903. backlight_failed:
  904. for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
  905. ideapad_unregister_rfkill(priv, i);
  906. ideapad_input_exit(priv);
  907. input_failed:
  908. ideapad_debugfs_exit(priv);
  909. ideapad_sysfs_exit(priv);
  910. return ret;
  911. }
  912. static int ideapad_acpi_remove(struct platform_device *pdev)
  913. {
  914. struct ideapad_private *priv = dev_get_drvdata(&pdev->dev);
  915. int i;
  916. #if IS_ENABLED(CONFIG_ACPI_WMI)
  917. if (priv->fnesc_guid)
  918. wmi_remove_notify_handler(priv->fnesc_guid);
  919. #endif
  920. acpi_remove_notify_handler(priv->adev->handle,
  921. ACPI_DEVICE_NOTIFY, ideapad_acpi_notify);
  922. ideapad_backlight_exit(priv);
  923. for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
  924. ideapad_unregister_rfkill(priv, i);
  925. ideapad_input_exit(priv);
  926. ideapad_debugfs_exit(priv);
  927. ideapad_sysfs_exit(priv);
  928. dev_set_drvdata(&pdev->dev, NULL);
  929. return 0;
  930. }
  931. #ifdef CONFIG_PM_SLEEP
  932. static int ideapad_acpi_resume(struct device *device)
  933. {
  934. struct ideapad_private *priv;
  935. if (!device)
  936. return -EINVAL;
  937. priv = dev_get_drvdata(device);
  938. ideapad_sync_rfk_state(priv);
  939. ideapad_sync_touchpad_state(priv);
  940. return 0;
  941. }
  942. #endif
  943. static SIMPLE_DEV_PM_OPS(ideapad_pm, NULL, ideapad_acpi_resume);
  944. static const struct acpi_device_id ideapad_device_ids[] = {
  945. { "VPC2004", 0},
  946. { "", 0},
  947. };
  948. MODULE_DEVICE_TABLE(acpi, ideapad_device_ids);
  949. static struct platform_driver ideapad_acpi_driver = {
  950. .probe = ideapad_acpi_add,
  951. .remove = ideapad_acpi_remove,
  952. .driver = {
  953. .name = "ideapad_acpi",
  954. .pm = &ideapad_pm,
  955. .acpi_match_table = ACPI_PTR(ideapad_device_ids),
  956. },
  957. };
  958. module_platform_driver(ideapad_acpi_driver);
  959. MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
  960. MODULE_DESCRIPTION("IdeaPad ACPI Extras");
  961. MODULE_LICENSE("GPL");