hp-wmi.c 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929
  1. /*
  2. * HP WMI hotkeys
  3. *
  4. * Copyright (C) 2008 Red Hat <mjg@redhat.com>
  5. * Copyright (C) 2010, 2011 Anssi Hannula <anssi.hannula@iki.fi>
  6. *
  7. * Portions based on wistron_btns.c:
  8. * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
  9. * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
  10. * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
  11. *
  12. * This program is free software; you can redistribute it and/or modify
  13. * it under the terms of the GNU General Public License as published by
  14. * the Free Software Foundation; either version 2 of the License, or
  15. * (at your option) any later version.
  16. *
  17. * This program is distributed in the hope that it will be useful,
  18. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20. * GNU General Public License for more details.
  21. *
  22. * You should have received a copy of the GNU General Public License
  23. * along with this program; if not, write to the Free Software
  24. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  25. */
  26. #include <linux/kernel.h>
  27. #include <linux/module.h>
  28. #include <linux/init.h>
  29. #include <linux/slab.h>
  30. #include <linux/types.h>
  31. #include <linux/input.h>
  32. #include <linux/input/sparse-keymap.h>
  33. #include <linux/platform_device.h>
  34. #include <linux/acpi.h>
  35. #include <linux/rfkill.h>
  36. #include <linux/string.h>
  37. MODULE_AUTHOR("Matthew Garrett <mjg59@srcf.ucam.org>");
  38. MODULE_DESCRIPTION("HP laptop WMI hotkeys driver");
  39. MODULE_LICENSE("GPL");
  40. MODULE_ALIAS("wmi:95F24279-4D7B-4334-9387-ACCDC67EF61C");
  41. MODULE_ALIAS("wmi:5FB7F034-2C63-45e9-BE91-3D44E2C707E4");
  42. #define HPWMI_EVENT_GUID "95F24279-4D7B-4334-9387-ACCDC67EF61C"
  43. #define HPWMI_BIOS_GUID "5FB7F034-2C63-45e9-BE91-3D44E2C707E4"
  44. #define HPWMI_DISPLAY_QUERY 0x1
  45. #define HPWMI_HDDTEMP_QUERY 0x2
  46. #define HPWMI_ALS_QUERY 0x3
  47. #define HPWMI_HARDWARE_QUERY 0x4
  48. #define HPWMI_WIRELESS_QUERY 0x5
  49. #define HPWMI_HOTKEY_QUERY 0xc
  50. #define HPWMI_WIRELESS2_QUERY 0x1b
  51. #define PREFIX "HP WMI: "
  52. #define UNIMP "Unimplemented "
  53. enum hp_wmi_radio {
  54. HPWMI_WIFI = 0,
  55. HPWMI_BLUETOOTH = 1,
  56. HPWMI_WWAN = 2,
  57. };
  58. enum hp_wmi_event_ids {
  59. HPWMI_DOCK_EVENT = 1,
  60. HPWMI_PARK_HDD = 2,
  61. HPWMI_SMART_ADAPTER = 3,
  62. HPWMI_BEZEL_BUTTON = 4,
  63. HPWMI_WIRELESS = 5,
  64. HPWMI_CPU_BATTERY_THROTTLE = 6,
  65. HPWMI_LOCK_SWITCH = 7,
  66. };
  67. static int __devinit hp_wmi_bios_setup(struct platform_device *device);
  68. static int __exit hp_wmi_bios_remove(struct platform_device *device);
  69. static int hp_wmi_resume_handler(struct device *device);
  70. struct bios_args {
  71. u32 signature;
  72. u32 command;
  73. u32 commandtype;
  74. u32 datasize;
  75. u32 data;
  76. };
  77. struct bios_return {
  78. u32 sigpass;
  79. u32 return_code;
  80. };
  81. enum hp_return_value {
  82. HPWMI_RET_WRONG_SIGNATURE = 0x02,
  83. HPWMI_RET_UNKNOWN_COMMAND = 0x03,
  84. HPWMI_RET_UNKNOWN_CMDTYPE = 0x04,
  85. HPWMI_RET_INVALID_PARAMETERS = 0x05,
  86. };
  87. enum hp_wireless2_bits {
  88. HPWMI_POWER_STATE = 0x01,
  89. HPWMI_POWER_SOFT = 0x02,
  90. HPWMI_POWER_BIOS = 0x04,
  91. HPWMI_POWER_HARD = 0x08,
  92. };
  93. #define IS_HWBLOCKED(x) ((x & (HPWMI_POWER_BIOS | HPWMI_POWER_HARD)) \
  94. != (HPWMI_POWER_BIOS | HPWMI_POWER_HARD))
  95. #define IS_SWBLOCKED(x) !(x & HPWMI_POWER_SOFT)
  96. struct bios_rfkill2_device_state {
  97. u8 radio_type;
  98. u8 bus_type;
  99. u16 vendor_id;
  100. u16 product_id;
  101. u16 subsys_vendor_id;
  102. u16 subsys_product_id;
  103. u8 rfkill_id;
  104. u8 power;
  105. u8 unknown[4];
  106. };
  107. /* 7 devices fit into the 128 byte buffer */
  108. #define HPWMI_MAX_RFKILL2_DEVICES 7
  109. struct bios_rfkill2_state {
  110. u8 unknown[7];
  111. u8 count;
  112. u8 pad[8];
  113. struct bios_rfkill2_device_state device[HPWMI_MAX_RFKILL2_DEVICES];
  114. };
  115. static const struct key_entry hp_wmi_keymap[] = {
  116. { KE_KEY, 0x02, { KEY_BRIGHTNESSUP } },
  117. { KE_KEY, 0x03, { KEY_BRIGHTNESSDOWN } },
  118. { KE_KEY, 0x20e6, { KEY_PROG1 } },
  119. { KE_KEY, 0x20e8, { KEY_MEDIA } },
  120. { KE_KEY, 0x2142, { KEY_MEDIA } },
  121. { KE_KEY, 0x213b, { KEY_INFO } },
  122. { KE_KEY, 0x2169, { KEY_DIRECTION } },
  123. { KE_KEY, 0x231b, { KEY_HELP } },
  124. { KE_END, 0 }
  125. };
  126. static struct input_dev *hp_wmi_input_dev;
  127. static struct platform_device *hp_wmi_platform_dev;
  128. static struct rfkill *wifi_rfkill;
  129. static struct rfkill *bluetooth_rfkill;
  130. static struct rfkill *wwan_rfkill;
  131. struct rfkill2_device {
  132. u8 id;
  133. int num;
  134. struct rfkill *rfkill;
  135. };
  136. static int rfkill2_count;
  137. static struct rfkill2_device rfkill2[HPWMI_MAX_RFKILL2_DEVICES];
  138. static const struct dev_pm_ops hp_wmi_pm_ops = {
  139. .resume = hp_wmi_resume_handler,
  140. .restore = hp_wmi_resume_handler,
  141. };
  142. static struct platform_driver hp_wmi_driver = {
  143. .driver = {
  144. .name = "hp-wmi",
  145. .owner = THIS_MODULE,
  146. .pm = &hp_wmi_pm_ops,
  147. },
  148. .probe = hp_wmi_bios_setup,
  149. .remove = hp_wmi_bios_remove,
  150. };
  151. /*
  152. * hp_wmi_perform_query
  153. *
  154. * query: The commandtype -> What should be queried
  155. * write: The command -> 0 read, 1 write, 3 ODM specific
  156. * buffer: Buffer used as input and/or output
  157. * insize: Size of input buffer
  158. * outsize: Size of output buffer
  159. *
  160. * returns zero on success
  161. * an HP WMI query specific error code (which is positive)
  162. * -EINVAL if the query was not successful at all
  163. * -EINVAL if the output buffer size exceeds buffersize
  164. *
  165. * Note: The buffersize must at least be the maximum of the input and output
  166. * size. E.g. Battery info query (0x7) is defined to have 1 byte input
  167. * and 128 byte output. The caller would do:
  168. * buffer = kzalloc(128, GFP_KERNEL);
  169. * ret = hp_wmi_perform_query(0x7, 0, buffer, 1, 128)
  170. */
  171. static int hp_wmi_perform_query(int query, int write, void *buffer,
  172. int insize, int outsize)
  173. {
  174. struct bios_return *bios_return;
  175. int actual_outsize;
  176. union acpi_object *obj;
  177. struct bios_args args = {
  178. .signature = 0x55434553,
  179. .command = write ? 0x2 : 0x1,
  180. .commandtype = query,
  181. .datasize = insize,
  182. .data = 0,
  183. };
  184. struct acpi_buffer input = { sizeof(struct bios_args), &args };
  185. struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
  186. if (WARN_ON(insize > sizeof(args.data)))
  187. return -EINVAL;
  188. memcpy(&args.data, buffer, insize);
  189. wmi_evaluate_method(HPWMI_BIOS_GUID, 0, 0x3, &input, &output);
  190. obj = output.pointer;
  191. if (!obj)
  192. return -EINVAL;
  193. else if (obj->type != ACPI_TYPE_BUFFER) {
  194. kfree(obj);
  195. return -EINVAL;
  196. }
  197. bios_return = (struct bios_return *)obj->buffer.pointer;
  198. if (bios_return->return_code) {
  199. if (bios_return->return_code != HPWMI_RET_UNKNOWN_CMDTYPE)
  200. printk(KERN_WARNING PREFIX "query 0x%x returned "
  201. "error 0x%x\n",
  202. query, bios_return->return_code);
  203. kfree(obj);
  204. return bios_return->return_code;
  205. }
  206. if (!outsize) {
  207. /* ignore output data */
  208. kfree(obj);
  209. return 0;
  210. }
  211. actual_outsize = min(outsize, (int)(obj->buffer.length - sizeof(*bios_return)));
  212. memcpy(buffer, obj->buffer.pointer + sizeof(*bios_return), actual_outsize);
  213. memset(buffer + actual_outsize, 0, outsize - actual_outsize);
  214. kfree(obj);
  215. return 0;
  216. }
  217. static int hp_wmi_display_state(void)
  218. {
  219. int state = 0;
  220. int ret = hp_wmi_perform_query(HPWMI_DISPLAY_QUERY, 0, &state,
  221. sizeof(state), sizeof(state));
  222. if (ret)
  223. return -EINVAL;
  224. return state;
  225. }
  226. static int hp_wmi_hddtemp_state(void)
  227. {
  228. int state = 0;
  229. int ret = hp_wmi_perform_query(HPWMI_HDDTEMP_QUERY, 0, &state,
  230. sizeof(state), sizeof(state));
  231. if (ret)
  232. return -EINVAL;
  233. return state;
  234. }
  235. static int hp_wmi_als_state(void)
  236. {
  237. int state = 0;
  238. int ret = hp_wmi_perform_query(HPWMI_ALS_QUERY, 0, &state,
  239. sizeof(state), sizeof(state));
  240. if (ret)
  241. return -EINVAL;
  242. return state;
  243. }
  244. static int hp_wmi_dock_state(void)
  245. {
  246. int state = 0;
  247. int ret = hp_wmi_perform_query(HPWMI_HARDWARE_QUERY, 0, &state,
  248. sizeof(state), sizeof(state));
  249. if (ret)
  250. return -EINVAL;
  251. return state & 0x1;
  252. }
  253. static int hp_wmi_tablet_state(void)
  254. {
  255. int state = 0;
  256. int ret = hp_wmi_perform_query(HPWMI_HARDWARE_QUERY, 0, &state,
  257. sizeof(state), sizeof(state));
  258. if (ret)
  259. return ret;
  260. return (state & 0x4) ? 1 : 0;
  261. }
  262. static int hp_wmi_set_block(void *data, bool blocked)
  263. {
  264. enum hp_wmi_radio r = (enum hp_wmi_radio) data;
  265. int query = BIT(r + 8) | ((!blocked) << r);
  266. int ret;
  267. ret = hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1,
  268. &query, sizeof(query), 0);
  269. if (ret)
  270. return -EINVAL;
  271. return 0;
  272. }
  273. static const struct rfkill_ops hp_wmi_rfkill_ops = {
  274. .set_block = hp_wmi_set_block,
  275. };
  276. static bool hp_wmi_get_sw_state(enum hp_wmi_radio r)
  277. {
  278. int wireless = 0;
  279. int mask;
  280. hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 0,
  281. &wireless, sizeof(wireless),
  282. sizeof(wireless));
  283. /* TBD: Pass error */
  284. mask = 0x200 << (r * 8);
  285. if (wireless & mask)
  286. return false;
  287. else
  288. return true;
  289. }
  290. static bool hp_wmi_get_hw_state(enum hp_wmi_radio r)
  291. {
  292. int wireless = 0;
  293. int mask;
  294. hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 0,
  295. &wireless, sizeof(wireless),
  296. sizeof(wireless));
  297. /* TBD: Pass error */
  298. mask = 0x800 << (r * 8);
  299. if (wireless & mask)
  300. return false;
  301. else
  302. return true;
  303. }
  304. static int hp_wmi_rfkill2_set_block(void *data, bool blocked)
  305. {
  306. int rfkill_id = (int)(long)data;
  307. char buffer[4] = { 0x01, 0x00, rfkill_id, !blocked };
  308. if (hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, 1,
  309. buffer, sizeof(buffer), 0))
  310. return -EINVAL;
  311. return 0;
  312. }
  313. static const struct rfkill_ops hp_wmi_rfkill2_ops = {
  314. .set_block = hp_wmi_rfkill2_set_block,
  315. };
  316. static int hp_wmi_rfkill2_refresh(void)
  317. {
  318. int err, i;
  319. struct bios_rfkill2_state state;
  320. err = hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, 0, &state,
  321. 0, sizeof(state));
  322. if (err)
  323. return err;
  324. for (i = 0; i < rfkill2_count; i++) {
  325. int num = rfkill2[i].num;
  326. struct bios_rfkill2_device_state *devstate;
  327. devstate = &state.device[num];
  328. if (num >= state.count ||
  329. devstate->rfkill_id != rfkill2[i].id) {
  330. printk(KERN_WARNING PREFIX "power configuration of "
  331. "the wireless devices unexpectedly changed\n");
  332. continue;
  333. }
  334. rfkill_set_states(rfkill2[i].rfkill,
  335. IS_SWBLOCKED(devstate->power),
  336. IS_HWBLOCKED(devstate->power));
  337. }
  338. return 0;
  339. }
  340. static ssize_t show_display(struct device *dev, struct device_attribute *attr,
  341. char *buf)
  342. {
  343. int value = hp_wmi_display_state();
  344. if (value < 0)
  345. return -EINVAL;
  346. return sprintf(buf, "%d\n", value);
  347. }
  348. static ssize_t show_hddtemp(struct device *dev, struct device_attribute *attr,
  349. char *buf)
  350. {
  351. int value = hp_wmi_hddtemp_state();
  352. if (value < 0)
  353. return -EINVAL;
  354. return sprintf(buf, "%d\n", value);
  355. }
  356. static ssize_t show_als(struct device *dev, struct device_attribute *attr,
  357. char *buf)
  358. {
  359. int value = hp_wmi_als_state();
  360. if (value < 0)
  361. return -EINVAL;
  362. return sprintf(buf, "%d\n", value);
  363. }
  364. static ssize_t show_dock(struct device *dev, struct device_attribute *attr,
  365. char *buf)
  366. {
  367. int value = hp_wmi_dock_state();
  368. if (value < 0)
  369. return -EINVAL;
  370. return sprintf(buf, "%d\n", value);
  371. }
  372. static ssize_t show_tablet(struct device *dev, struct device_attribute *attr,
  373. char *buf)
  374. {
  375. int value = hp_wmi_tablet_state();
  376. if (value < 0)
  377. return -EINVAL;
  378. return sprintf(buf, "%d\n", value);
  379. }
  380. static ssize_t set_als(struct device *dev, struct device_attribute *attr,
  381. const char *buf, size_t count)
  382. {
  383. u32 tmp = simple_strtoul(buf, NULL, 10);
  384. int ret = hp_wmi_perform_query(HPWMI_ALS_QUERY, 1, &tmp,
  385. sizeof(tmp), sizeof(tmp));
  386. if (ret)
  387. return -EINVAL;
  388. return count;
  389. }
  390. static DEVICE_ATTR(display, S_IRUGO, show_display, NULL);
  391. static DEVICE_ATTR(hddtemp, S_IRUGO, show_hddtemp, NULL);
  392. static DEVICE_ATTR(als, S_IRUGO | S_IWUSR, show_als, set_als);
  393. static DEVICE_ATTR(dock, S_IRUGO, show_dock, NULL);
  394. static DEVICE_ATTR(tablet, S_IRUGO, show_tablet, NULL);
  395. static void hp_wmi_notify(u32 value, void *context)
  396. {
  397. struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
  398. union acpi_object *obj;
  399. u32 event_id, event_data;
  400. int key_code = 0, ret;
  401. u32 *location;
  402. acpi_status status;
  403. status = wmi_get_event_data(value, &response);
  404. if (status != AE_OK) {
  405. printk(KERN_INFO PREFIX "bad event status 0x%x\n", status);
  406. return;
  407. }
  408. obj = (union acpi_object *)response.pointer;
  409. if (!obj)
  410. return;
  411. if (obj->type != ACPI_TYPE_BUFFER) {
  412. printk(KERN_INFO "hp-wmi: Unknown response received %d\n",
  413. obj->type);
  414. kfree(obj);
  415. return;
  416. }
  417. /*
  418. * Depending on ACPI version the concatenation of id and event data
  419. * inside _WED function will result in a 8 or 16 byte buffer.
  420. */
  421. location = (u32 *)obj->buffer.pointer;
  422. if (obj->buffer.length == 8) {
  423. event_id = *location;
  424. event_data = *(location + 1);
  425. } else if (obj->buffer.length == 16) {
  426. event_id = *location;
  427. event_data = *(location + 2);
  428. } else {
  429. printk(KERN_INFO "hp-wmi: Unknown buffer length %d\n",
  430. obj->buffer.length);
  431. kfree(obj);
  432. return;
  433. }
  434. kfree(obj);
  435. switch (event_id) {
  436. case HPWMI_DOCK_EVENT:
  437. input_report_switch(hp_wmi_input_dev, SW_DOCK,
  438. hp_wmi_dock_state());
  439. input_report_switch(hp_wmi_input_dev, SW_TABLET_MODE,
  440. hp_wmi_tablet_state());
  441. input_sync(hp_wmi_input_dev);
  442. break;
  443. case HPWMI_PARK_HDD:
  444. break;
  445. case HPWMI_SMART_ADAPTER:
  446. break;
  447. case HPWMI_BEZEL_BUTTON:
  448. ret = hp_wmi_perform_query(HPWMI_HOTKEY_QUERY, 0,
  449. &key_code,
  450. sizeof(key_code),
  451. sizeof(key_code));
  452. if (ret)
  453. break;
  454. if (!sparse_keymap_report_event(hp_wmi_input_dev,
  455. key_code, 1, true))
  456. printk(KERN_INFO PREFIX "Unknown key code - 0x%x\n",
  457. key_code);
  458. break;
  459. case HPWMI_WIRELESS:
  460. if (rfkill2_count) {
  461. hp_wmi_rfkill2_refresh();
  462. break;
  463. }
  464. if (wifi_rfkill)
  465. rfkill_set_states(wifi_rfkill,
  466. hp_wmi_get_sw_state(HPWMI_WIFI),
  467. hp_wmi_get_hw_state(HPWMI_WIFI));
  468. if (bluetooth_rfkill)
  469. rfkill_set_states(bluetooth_rfkill,
  470. hp_wmi_get_sw_state(HPWMI_BLUETOOTH),
  471. hp_wmi_get_hw_state(HPWMI_BLUETOOTH));
  472. if (wwan_rfkill)
  473. rfkill_set_states(wwan_rfkill,
  474. hp_wmi_get_sw_state(HPWMI_WWAN),
  475. hp_wmi_get_hw_state(HPWMI_WWAN));
  476. break;
  477. case HPWMI_CPU_BATTERY_THROTTLE:
  478. printk(KERN_INFO PREFIX UNIMP "CPU throttle because of 3 Cell"
  479. " battery event detected\n");
  480. break;
  481. case HPWMI_LOCK_SWITCH:
  482. break;
  483. default:
  484. printk(KERN_INFO PREFIX "Unknown event_id - %d - 0x%x\n",
  485. event_id, event_data);
  486. break;
  487. }
  488. }
  489. static int __init hp_wmi_input_setup(void)
  490. {
  491. acpi_status status;
  492. int err;
  493. hp_wmi_input_dev = input_allocate_device();
  494. if (!hp_wmi_input_dev)
  495. return -ENOMEM;
  496. hp_wmi_input_dev->name = "HP WMI hotkeys";
  497. hp_wmi_input_dev->phys = "wmi/input0";
  498. hp_wmi_input_dev->id.bustype = BUS_HOST;
  499. __set_bit(EV_SW, hp_wmi_input_dev->evbit);
  500. __set_bit(SW_DOCK, hp_wmi_input_dev->swbit);
  501. __set_bit(SW_TABLET_MODE, hp_wmi_input_dev->swbit);
  502. err = sparse_keymap_setup(hp_wmi_input_dev, hp_wmi_keymap, NULL);
  503. if (err)
  504. goto err_free_dev;
  505. /* Set initial hardware state */
  506. input_report_switch(hp_wmi_input_dev, SW_DOCK, hp_wmi_dock_state());
  507. input_report_switch(hp_wmi_input_dev, SW_TABLET_MODE,
  508. hp_wmi_tablet_state());
  509. input_sync(hp_wmi_input_dev);
  510. status = wmi_install_notify_handler(HPWMI_EVENT_GUID, hp_wmi_notify, NULL);
  511. if (ACPI_FAILURE(status)) {
  512. err = -EIO;
  513. goto err_free_keymap;
  514. }
  515. err = input_register_device(hp_wmi_input_dev);
  516. if (err)
  517. goto err_uninstall_notifier;
  518. return 0;
  519. err_uninstall_notifier:
  520. wmi_remove_notify_handler(HPWMI_EVENT_GUID);
  521. err_free_keymap:
  522. sparse_keymap_free(hp_wmi_input_dev);
  523. err_free_dev:
  524. input_free_device(hp_wmi_input_dev);
  525. return err;
  526. }
  527. static void hp_wmi_input_destroy(void)
  528. {
  529. wmi_remove_notify_handler(HPWMI_EVENT_GUID);
  530. sparse_keymap_free(hp_wmi_input_dev);
  531. input_unregister_device(hp_wmi_input_dev);
  532. }
  533. static void cleanup_sysfs(struct platform_device *device)
  534. {
  535. device_remove_file(&device->dev, &dev_attr_display);
  536. device_remove_file(&device->dev, &dev_attr_hddtemp);
  537. device_remove_file(&device->dev, &dev_attr_als);
  538. device_remove_file(&device->dev, &dev_attr_dock);
  539. device_remove_file(&device->dev, &dev_attr_tablet);
  540. }
  541. static int __devinit hp_wmi_rfkill_setup(struct platform_device *device)
  542. {
  543. int err;
  544. int wireless = 0;
  545. err = hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 0, &wireless,
  546. sizeof(wireless), sizeof(wireless));
  547. if (err)
  548. return err;
  549. if (wireless & 0x1) {
  550. wifi_rfkill = rfkill_alloc("hp-wifi", &device->dev,
  551. RFKILL_TYPE_WLAN,
  552. &hp_wmi_rfkill_ops,
  553. (void *) HPWMI_WIFI);
  554. rfkill_init_sw_state(wifi_rfkill,
  555. hp_wmi_get_sw_state(HPWMI_WIFI));
  556. rfkill_set_hw_state(wifi_rfkill,
  557. hp_wmi_get_hw_state(HPWMI_WIFI));
  558. err = rfkill_register(wifi_rfkill);
  559. if (err)
  560. goto register_wifi_error;
  561. }
  562. if (wireless & 0x2) {
  563. bluetooth_rfkill = rfkill_alloc("hp-bluetooth", &device->dev,
  564. RFKILL_TYPE_BLUETOOTH,
  565. &hp_wmi_rfkill_ops,
  566. (void *) HPWMI_BLUETOOTH);
  567. rfkill_init_sw_state(bluetooth_rfkill,
  568. hp_wmi_get_sw_state(HPWMI_BLUETOOTH));
  569. rfkill_set_hw_state(bluetooth_rfkill,
  570. hp_wmi_get_hw_state(HPWMI_BLUETOOTH));
  571. err = rfkill_register(bluetooth_rfkill);
  572. if (err)
  573. goto register_bluetooth_error;
  574. }
  575. if (wireless & 0x4) {
  576. wwan_rfkill = rfkill_alloc("hp-wwan", &device->dev,
  577. RFKILL_TYPE_WWAN,
  578. &hp_wmi_rfkill_ops,
  579. (void *) HPWMI_WWAN);
  580. rfkill_init_sw_state(wwan_rfkill,
  581. hp_wmi_get_sw_state(HPWMI_WWAN));
  582. rfkill_set_hw_state(wwan_rfkill,
  583. hp_wmi_get_hw_state(HPWMI_WWAN));
  584. err = rfkill_register(wwan_rfkill);
  585. if (err)
  586. goto register_wwan_err;
  587. }
  588. return 0;
  589. register_wwan_err:
  590. rfkill_destroy(wwan_rfkill);
  591. wwan_rfkill = NULL;
  592. if (bluetooth_rfkill)
  593. rfkill_unregister(bluetooth_rfkill);
  594. register_bluetooth_error:
  595. rfkill_destroy(bluetooth_rfkill);
  596. bluetooth_rfkill = NULL;
  597. if (wifi_rfkill)
  598. rfkill_unregister(wifi_rfkill);
  599. register_wifi_error:
  600. rfkill_destroy(wifi_rfkill);
  601. wifi_rfkill = NULL;
  602. return err;
  603. }
  604. static int __devinit hp_wmi_rfkill2_setup(struct platform_device *device)
  605. {
  606. int err, i;
  607. struct bios_rfkill2_state state;
  608. err = hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, 0, &state,
  609. 0, sizeof(state));
  610. if (err)
  611. return err;
  612. if (state.count > HPWMI_MAX_RFKILL2_DEVICES) {
  613. printk(KERN_WARNING PREFIX "unable to parse 0x1b query output\n");
  614. return -EINVAL;
  615. }
  616. for (i = 0; i < state.count; i++) {
  617. struct rfkill *rfkill;
  618. enum rfkill_type type;
  619. char *name;
  620. switch (state.device[i].radio_type) {
  621. case HPWMI_WIFI:
  622. type = RFKILL_TYPE_WLAN;
  623. name = "hp-wifi";
  624. break;
  625. case HPWMI_BLUETOOTH:
  626. type = RFKILL_TYPE_BLUETOOTH;
  627. name = "hp-bluetooth";
  628. break;
  629. case HPWMI_WWAN:
  630. type = RFKILL_TYPE_WWAN;
  631. name = "hp-wwan";
  632. break;
  633. default:
  634. printk(KERN_WARNING PREFIX "unknown device type 0x%x\n",
  635. state.device[i].radio_type);
  636. continue;
  637. }
  638. if (!state.device[i].vendor_id) {
  639. printk(KERN_WARNING PREFIX "zero device %d while %d "
  640. "reported\n", i, state.count);
  641. continue;
  642. }
  643. rfkill = rfkill_alloc(name, &device->dev, type,
  644. &hp_wmi_rfkill2_ops, (void *)(long)i);
  645. if (!rfkill) {
  646. err = -ENOMEM;
  647. goto fail;
  648. }
  649. rfkill2[rfkill2_count].id = state.device[i].rfkill_id;
  650. rfkill2[rfkill2_count].num = i;
  651. rfkill2[rfkill2_count].rfkill = rfkill;
  652. rfkill_init_sw_state(rfkill,
  653. IS_SWBLOCKED(state.device[i].power));
  654. rfkill_set_hw_state(rfkill,
  655. IS_HWBLOCKED(state.device[i].power));
  656. if (!(state.device[i].power & HPWMI_POWER_BIOS))
  657. printk(KERN_INFO PREFIX "device %s blocked by BIOS\n",
  658. name);
  659. err = rfkill_register(rfkill);
  660. if (err) {
  661. rfkill_destroy(rfkill);
  662. goto fail;
  663. }
  664. rfkill2_count++;
  665. }
  666. return 0;
  667. fail:
  668. for (; rfkill2_count > 0; rfkill2_count--) {
  669. rfkill_unregister(rfkill2[rfkill2_count - 1].rfkill);
  670. rfkill_destroy(rfkill2[rfkill2_count - 1].rfkill);
  671. }
  672. return err;
  673. }
  674. static int __devinit hp_wmi_bios_setup(struct platform_device *device)
  675. {
  676. int err;
  677. /* clear detected rfkill devices */
  678. wifi_rfkill = NULL;
  679. bluetooth_rfkill = NULL;
  680. wwan_rfkill = NULL;
  681. rfkill2_count = 0;
  682. if (hp_wmi_rfkill_setup(device))
  683. hp_wmi_rfkill2_setup(device);
  684. err = device_create_file(&device->dev, &dev_attr_display);
  685. if (err)
  686. goto add_sysfs_error;
  687. err = device_create_file(&device->dev, &dev_attr_hddtemp);
  688. if (err)
  689. goto add_sysfs_error;
  690. err = device_create_file(&device->dev, &dev_attr_als);
  691. if (err)
  692. goto add_sysfs_error;
  693. err = device_create_file(&device->dev, &dev_attr_dock);
  694. if (err)
  695. goto add_sysfs_error;
  696. err = device_create_file(&device->dev, &dev_attr_tablet);
  697. if (err)
  698. goto add_sysfs_error;
  699. return 0;
  700. add_sysfs_error:
  701. cleanup_sysfs(device);
  702. return err;
  703. }
  704. static int __exit hp_wmi_bios_remove(struct platform_device *device)
  705. {
  706. int i;
  707. cleanup_sysfs(device);
  708. for (i = 0; i < rfkill2_count; i++) {
  709. rfkill_unregister(rfkill2[i].rfkill);
  710. rfkill_destroy(rfkill2[i].rfkill);
  711. }
  712. if (wifi_rfkill) {
  713. rfkill_unregister(wifi_rfkill);
  714. rfkill_destroy(wifi_rfkill);
  715. }
  716. if (bluetooth_rfkill) {
  717. rfkill_unregister(bluetooth_rfkill);
  718. rfkill_destroy(bluetooth_rfkill);
  719. }
  720. if (wwan_rfkill) {
  721. rfkill_unregister(wwan_rfkill);
  722. rfkill_destroy(wwan_rfkill);
  723. }
  724. return 0;
  725. }
  726. static int hp_wmi_resume_handler(struct device *device)
  727. {
  728. /*
  729. * Hardware state may have changed while suspended, so trigger
  730. * input events for the current state. As this is a switch,
  731. * the input layer will only actually pass it on if the state
  732. * changed.
  733. */
  734. if (hp_wmi_input_dev) {
  735. input_report_switch(hp_wmi_input_dev, SW_DOCK,
  736. hp_wmi_dock_state());
  737. input_report_switch(hp_wmi_input_dev, SW_TABLET_MODE,
  738. hp_wmi_tablet_state());
  739. input_sync(hp_wmi_input_dev);
  740. }
  741. if (rfkill2_count)
  742. hp_wmi_rfkill2_refresh();
  743. if (wifi_rfkill)
  744. rfkill_set_states(wifi_rfkill,
  745. hp_wmi_get_sw_state(HPWMI_WIFI),
  746. hp_wmi_get_hw_state(HPWMI_WIFI));
  747. if (bluetooth_rfkill)
  748. rfkill_set_states(bluetooth_rfkill,
  749. hp_wmi_get_sw_state(HPWMI_BLUETOOTH),
  750. hp_wmi_get_hw_state(HPWMI_BLUETOOTH));
  751. if (wwan_rfkill)
  752. rfkill_set_states(wwan_rfkill,
  753. hp_wmi_get_sw_state(HPWMI_WWAN),
  754. hp_wmi_get_hw_state(HPWMI_WWAN));
  755. return 0;
  756. }
  757. static int __init hp_wmi_init(void)
  758. {
  759. int err;
  760. int event_capable = wmi_has_guid(HPWMI_EVENT_GUID);
  761. int bios_capable = wmi_has_guid(HPWMI_BIOS_GUID);
  762. if (event_capable) {
  763. err = hp_wmi_input_setup();
  764. if (err)
  765. return err;
  766. }
  767. if (bios_capable) {
  768. err = platform_driver_register(&hp_wmi_driver);
  769. if (err)
  770. goto err_driver_reg;
  771. hp_wmi_platform_dev = platform_device_alloc("hp-wmi", -1);
  772. if (!hp_wmi_platform_dev) {
  773. err = -ENOMEM;
  774. goto err_device_alloc;
  775. }
  776. err = platform_device_add(hp_wmi_platform_dev);
  777. if (err)
  778. goto err_device_add;
  779. }
  780. if (!bios_capable && !event_capable)
  781. return -ENODEV;
  782. return 0;
  783. err_device_add:
  784. platform_device_put(hp_wmi_platform_dev);
  785. err_device_alloc:
  786. platform_driver_unregister(&hp_wmi_driver);
  787. err_driver_reg:
  788. if (event_capable)
  789. hp_wmi_input_destroy();
  790. return err;
  791. }
  792. static void __exit hp_wmi_exit(void)
  793. {
  794. if (wmi_has_guid(HPWMI_EVENT_GUID))
  795. hp_wmi_input_destroy();
  796. if (hp_wmi_platform_dev) {
  797. platform_device_unregister(hp_wmi_platform_dev);
  798. platform_driver_unregister(&hp_wmi_driver);
  799. }
  800. }
  801. module_init(hp_wmi_init);
  802. module_exit(hp_wmi_exit);