app_usbd_hid_kbd.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613
  1. /**
  2. * Copyright (c) 2016 - 2020, Nordic Semiconductor ASA
  3. *
  4. * All rights reserved.
  5. *
  6. * Redistribution and use in source and binary forms, with or without modification,
  7. * are permitted provided that the following conditions are met:
  8. *
  9. * 1. Redistributions of source code must retain the above copyright notice, this
  10. * list of conditions and the following disclaimer.
  11. *
  12. * 2. Redistributions in binary form, except as embedded into a Nordic
  13. * Semiconductor ASA integrated circuit in a product or a software update for
  14. * such product, must reproduce the above copyright notice, this list of
  15. * conditions and the following disclaimer in the documentation and/or other
  16. * materials provided with the distribution.
  17. *
  18. * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
  19. * contributors may be used to endorse or promote products derived from this
  20. * software without specific prior written permission.
  21. *
  22. * 4. This software, with or without modification, must only be used with a
  23. * Nordic Semiconductor ASA integrated circuit.
  24. *
  25. * 5. Any software provided in binary form under this license must not be reverse
  26. * engineered, decompiled, modified and/or disassembled.
  27. *
  28. * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
  29. * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  30. * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
  31. * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
  32. * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  33. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  34. * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  35. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  36. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  37. * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  38. *
  39. */
  40. #include "sdk_common.h"
  41. #if NRF_MODULE_ENABLED(APP_USBD_HID_KBD)
  42. #include <string.h>
  43. #include "app_usbd_hid_kbd.h"
  44. #include "app_util_platform.h"
  45. /**
  46. * @defgroup app_usbd_hid_kbd_internals USB HID keyboard internals
  47. * @{
  48. * @ingroup app_usbd_hid_kbd
  49. * @internal
  50. */
  51. STATIC_ASSERT(sizeof(app_usbd_hid_descriptor_t) == 6);
  52. /**
  53. * @brief Auxiliary function to access HID keyboard context data.
  54. *
  55. * @param[in] p_inst class instance data.
  56. *
  57. * @return HID keyboard instance data context.
  58. */
  59. static inline app_usbd_hid_kbd_ctx_t * hid_kbd_ctx_get(app_usbd_hid_kbd_t const * p_kbd)
  60. {
  61. ASSERT(p_kbd != NULL);
  62. ASSERT(p_kbd->specific.p_data != NULL);
  63. return &p_kbd->specific.p_data->ctx;
  64. }
  65. /**
  66. * @brief Auxiliary function to access HID keyboard instance data.
  67. *
  68. * @param[in] p_inst class instance data.
  69. *
  70. * @return HID keyboard instance data.
  71. */
  72. static inline app_usbd_hid_kbd_t const * hid_kbd_get(app_usbd_class_inst_t const * p_inst)
  73. {
  74. ASSERT(p_inst != NULL);
  75. return (app_usbd_hid_kbd_t const *)p_inst;
  76. }
  77. /**
  78. * @brief Returns keyboard report buffer handle.
  79. *
  80. * @param[in] p_kbd HID keyboard instance.
  81. *
  82. * @return HID report buffer.
  83. */
  84. static inline
  85. app_usbd_hid_report_buffer_t const * hid_kbd_rep_buffer_get(app_usbd_hid_kbd_t const * p_kbd)
  86. {
  87. ASSERT(p_kbd != NULL);
  88. app_usbd_hid_inst_t const * p_hinst = &p_kbd->specific.inst.hid_inst;
  89. app_usbd_hid_kbd_ctx_t * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
  90. app_usbd_hid_report_buffer_t * p_rep_buff = app_usbd_hid_rep_buff_in_get(p_hinst);
  91. p_rep_buff->p_buff = p_kbd_ctx->report_buff;
  92. p_rep_buff->size = sizeof(p_kbd_ctx->report_buff);
  93. /*Keyboard has only one report input/output report buffer */
  94. return app_usbd_hid_rep_buff_in_get(p_hinst);
  95. }
  96. /**
  97. * @brief Auxiliary function to prepare report transfer buffer to next transfer.
  98. *
  99. * @param[in] p_kbd HID keyboard instance.
  100. *
  101. * @retval true Next transfer is required.
  102. * @retval false Next transfer is not required.
  103. */
  104. static inline bool hid_kbd_transfer_next(app_usbd_hid_kbd_t const * p_kbd)
  105. {
  106. /*Send report only when state has changed*/
  107. app_usbd_hid_report_buffer_t const * p_rep_buffer = hid_kbd_rep_buffer_get(p_kbd);
  108. app_usbd_hid_kbd_ctx_t * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
  109. if (memcmp(p_rep_buffer->p_buff, &p_kbd_ctx->rep, p_rep_buffer->size))
  110. {
  111. memcpy(p_rep_buffer->p_buff, &p_kbd_ctx->rep, p_rep_buffer->size);
  112. return true;
  113. }
  114. return false;
  115. }
  116. /**
  117. * @brief Triggers IN endpoint transfer.
  118. *
  119. * @param[in] p_kbd HID keyboard instance.
  120. *
  121. * @return Standard error code.
  122. */
  123. static inline ret_code_t hid_kbd_transfer_set(app_usbd_hid_kbd_t const * p_kbd)
  124. {
  125. app_usbd_class_inst_t const * p_inst = (app_usbd_class_inst_t const *)p_kbd;
  126. app_usbd_hid_kbd_ctx_t * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
  127. nrf_drv_usbd_ep_t ep_addr = app_usbd_hid_epin_addr_get(p_inst);
  128. app_usbd_hid_state_flag_clr(&p_kbd_ctx->hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
  129. if (!hid_kbd_transfer_next(p_kbd))
  130. {
  131. /* Transfer buffer hasn't changed since last transfer. No need to setup
  132. * next transfer.
  133. * */
  134. return NRF_SUCCESS;
  135. }
  136. app_usbd_hid_report_buffer_t const * p_rep_buffer = hid_kbd_rep_buffer_get(p_kbd);
  137. NRF_DRV_USBD_TRANSFER_IN(transfer, p_rep_buffer->p_buff, p_rep_buffer->size);
  138. ret_code_t ret;
  139. CRITICAL_REGION_ENTER();
  140. ret = app_usbd_ep_transfer(ep_addr, &transfer);
  141. if (ret == NRF_SUCCESS)
  142. {
  143. app_usbd_hid_state_flag_set(&p_kbd_ctx->hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
  144. }
  145. CRITICAL_REGION_EXIT();
  146. return ret;
  147. }
  148. ret_code_t app_usbd_hid_kbd_modifier_state_set(app_usbd_hid_kbd_t const * p_kbd,
  149. app_usbd_hid_kbd_modifier_t modifier,
  150. bool state)
  151. {
  152. app_usbd_hid_kbd_ctx_t * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
  153. bool actual_state = (p_kbd_ctx->rep.modifier & modifier) != 0;
  154. if (actual_state == state)
  155. {
  156. /*Modifier has already the same state*/
  157. return NRF_SUCCESS;
  158. }
  159. app_usbd_hid_access_lock(&p_kbd_ctx->hid_ctx);
  160. if (state)
  161. {
  162. p_kbd_ctx->rep.modifier |= modifier;
  163. }
  164. else
  165. {
  166. p_kbd_ctx->rep.modifier &= ~modifier;
  167. }
  168. app_usbd_hid_access_unlock(&p_kbd_ctx->hid_ctx);
  169. if (app_usbd_hid_trans_required(&p_kbd_ctx->hid_ctx))
  170. {
  171. /*New transfer need to be triggered*/
  172. return hid_kbd_transfer_set(p_kbd);
  173. }
  174. return NRF_SUCCESS;
  175. }
  176. ret_code_t app_usbd_hid_kbd_key_control(app_usbd_hid_kbd_t const * p_kbd,
  177. app_usbd_hid_kbd_codes_t key,
  178. bool press)
  179. {
  180. app_usbd_hid_kbd_ctx_t * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
  181. uint8_t * destination = NULL;
  182. if (press)
  183. {
  184. for (size_t i = 0; i < ARRAY_SIZE(p_kbd_ctx->rep.key_table); ++i)
  185. {
  186. if (p_kbd_ctx->rep.key_table[i] == key)
  187. {
  188. /*Already pressed*/
  189. return NRF_SUCCESS;
  190. }
  191. if ((destination == NULL) && (p_kbd_ctx->rep.key_table[i] == 0))
  192. {
  193. destination = &p_kbd_ctx->rep.key_table[i];
  194. }
  195. }
  196. if (destination == NULL)
  197. {
  198. return NRF_ERROR_BUSY;
  199. }
  200. }
  201. else
  202. {
  203. /*Find if key is pressed*/
  204. for (size_t i = 0; i < ARRAY_SIZE(p_kbd_ctx->rep.key_table); ++i)
  205. {
  206. if (p_kbd_ctx->rep.key_table[i] == key)
  207. {
  208. destination = &p_kbd_ctx->rep.key_table[i];
  209. break;
  210. }
  211. }
  212. if (destination == NULL)
  213. {
  214. /*Key hasn't been pressed*/
  215. return NRF_SUCCESS;
  216. }
  217. }
  218. /*Save destination*/
  219. app_usbd_hid_access_lock(&p_kbd_ctx->hid_ctx);
  220. *destination = press ? key : 0;
  221. app_usbd_hid_access_unlock(&p_kbd_ctx->hid_ctx);
  222. if (app_usbd_hid_trans_required(&p_kbd_ctx->hid_ctx))
  223. {
  224. /*New transfer need to be triggered*/
  225. return hid_kbd_transfer_set(p_kbd);
  226. }
  227. return NRF_SUCCESS;
  228. }
  229. bool app_usbd_hid_kbd_led_state_get(app_usbd_hid_kbd_t const * p_kbd,
  230. app_usbd_hid_kbd_led_t led)
  231. {
  232. app_usbd_hid_kbd_ctx_t * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
  233. return (p_kbd_ctx->leds_state & led) != 0;
  234. }
  235. const void * app_usbd_hid_kbd_in_report_get(app_usbd_hid_kbd_t const * p_kbd,
  236. size_t * p_size)
  237. {
  238. app_usbd_hid_inst_t const * p_kinst = &p_kbd->specific.inst.hid_inst;
  239. *p_size = p_kinst->p_rep_buffer_in->size;
  240. return p_kinst->p_rep_buffer_in->p_buff;
  241. }
  242. const void * app_usbd_hid_kbd_out_report_get(app_usbd_hid_kbd_t const * p_kbd,
  243. size_t * p_size)
  244. {
  245. app_usbd_hid_inst_t const * p_kinst = &p_kbd->specific.inst.hid_inst;
  246. *p_size = p_kinst->p_rep_buffer_out->size;
  247. return p_kinst->p_rep_buffer_out->p_buff;
  248. }
  249. /**
  250. * @brief @ref app_usbd_hid_interface_t::on_get_report
  251. */
  252. static ret_code_t hid_kbd_on_get_report(app_usbd_class_inst_t const * p_inst,
  253. app_usbd_setup_evt_t const * p_setup_ev)
  254. {
  255. app_usbd_hid_kbd_t const * p_kinst = hid_kbd_get(p_inst);
  256. uint8_t const * p_rep_buffer = NULL;
  257. size_t buffer_size = 0;
  258. if (p_setup_ev->setup.wValue.hb == APP_USBD_HID_REPORT_TYPE_INPUT)
  259. {
  260. p_rep_buffer = app_usbd_hid_kbd_in_report_get(p_kinst, &buffer_size);
  261. }
  262. else if (p_setup_ev->setup.wValue.hb == APP_USBD_HID_REPORT_TYPE_OUTPUT)
  263. {
  264. p_rep_buffer = app_usbd_hid_kbd_out_report_get(p_kinst, &buffer_size);
  265. }
  266. else
  267. {
  268. return NRF_ERROR_NOT_SUPPORTED;
  269. }
  270. /* Return LEDs state (only the second byte) */
  271. return app_usbd_core_setup_rsp(&(p_setup_ev->setup), p_rep_buffer + 1, buffer_size - 1);
  272. }
  273. static ret_code_t hid_kbd_on_set_report_data_cb(nrf_drv_usbd_ep_status_t status, void * p_context)
  274. {
  275. if (status != NRF_USBD_EP_OK)
  276. {
  277. return NRF_ERROR_INTERNAL;
  278. }
  279. app_usbd_hid_kbd_t const * p_kbd = p_context;
  280. app_usbd_hid_report_buffer_t const * p_rep_buff;
  281. p_rep_buff = app_usbd_hid_rep_buff_out_get(&p_kbd->specific.inst.hid_inst);
  282. /*Update LEDs state*/
  283. app_usbd_hid_kbd_ctx_t * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
  284. p_kbd_ctx->leds_state = p_rep_buff->p_buff[1];
  285. app_usbd_hid_user_ev_handler_t handler = p_kbd->specific.inst.hid_inst.user_event_handler;
  286. handler((app_usbd_class_inst_t const *)(p_kbd), APP_USBD_HID_USER_EVT_OUT_REPORT_READY);
  287. return NRF_SUCCESS;
  288. }
  289. /**
  290. * @brief @ref app_usbd_hid_interface_t::hid_kbd_on_set_report
  291. */
  292. static ret_code_t hid_kbd_on_set_report(app_usbd_class_inst_t const * p_inst,
  293. app_usbd_setup_evt_t const * p_setup_ev)
  294. {
  295. app_usbd_hid_kbd_t const * p_kbd = hid_kbd_get(p_inst);
  296. /*Request setup data*/
  297. app_usbd_hid_report_buffer_t const * p_rep_buff;
  298. p_rep_buff = app_usbd_hid_rep_buff_out_get(&p_kbd->specific.inst.hid_inst);
  299. p_rep_buff->p_buff[0] = 0;
  300. NRF_DRV_USBD_TRANSFER_OUT(transfer, p_rep_buff->p_buff + 1, p_rep_buff->size - 1);
  301. ret_code_t ret;
  302. CRITICAL_REGION_ENTER();
  303. ret = app_usbd_ep_transfer(NRF_DRV_USBD_EPOUT0, &transfer);
  304. if (ret == NRF_SUCCESS)
  305. {
  306. app_usbd_core_setup_data_handler_desc_t desc = {
  307. .handler = hid_kbd_on_set_report_data_cb,
  308. .p_context = (app_usbd_hid_kbd_t *)p_kbd
  309. };
  310. ret = app_usbd_core_setup_data_handler_set(NRF_DRV_USBD_EPOUT0, &desc);
  311. }
  312. CRITICAL_REGION_EXIT();
  313. return ret;
  314. }
  315. /**
  316. * @brief @ref app_usbd_hid_interface_t::hid_kbd_ep_transfer_in
  317. */
  318. static ret_code_t hid_kbd_ep_transfer_in(app_usbd_class_inst_t const * p_inst)
  319. {
  320. return hid_kbd_transfer_set((app_usbd_hid_kbd_t const *)p_inst);
  321. }
  322. /**
  323. * @brief @ref app_usbd_class_interface_t::event_handler
  324. */
  325. static ret_code_t hid_kbd_event_handler(app_usbd_class_inst_t const * p_inst,
  326. app_usbd_complex_evt_t const * p_event)
  327. {
  328. ASSERT(p_inst != NULL);
  329. ASSERT(p_event != NULL);
  330. app_usbd_hid_kbd_t const * p_kbd = hid_kbd_get(p_inst);
  331. app_usbd_hid_inst_t const * p_hinst = &p_kbd->specific.inst.hid_inst;
  332. app_usbd_hid_kbd_ctx_t * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
  333. app_usbd_hid_ctx_t * p_hid_ctx = &p_kbd_ctx->hid_ctx;
  334. /*Try handle event by generic HID event handler*/
  335. return app_usbd_hid_event_handler(p_inst, p_hinst, p_hid_ctx, p_event);
  336. }
  337. ret_code_t hid_kbd_clear_buffer(app_usbd_class_inst_t const * p_inst)
  338. {
  339. ASSERT(p_inst != NULL);
  340. app_usbd_hid_kbd_t const * p_kbd = hid_kbd_get(p_inst);
  341. app_usbd_hid_kbd_ctx_t * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
  342. app_usbd_hid_report_buffer_t const * p_rep_buffer = hid_kbd_rep_buffer_get(p_kbd);
  343. memset(p_rep_buffer->p_buff, 0, p_rep_buffer->size);
  344. memset(p_kbd_ctx->report_buff, 0, p_rep_buffer->size);
  345. memset(&p_kbd_ctx->rep, 0, p_rep_buffer->size);
  346. CRITICAL_REGION_ENTER();
  347. nrf_drv_usbd_ep_t ep_addr = app_usbd_hid_epin_addr_get(p_inst);
  348. ASSERT(!NRF_USBD_EPISO_CHECK(ep_addr));
  349. if (NRF_USBD_EPIN_CHECK(ep_addr))
  350. {
  351. nrf_drv_usbd_ep_abort(ep_addr);
  352. }
  353. app_usbd_hid_state_flag_clr(&p_kbd_ctx->hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
  354. CRITICAL_REGION_EXIT();
  355. return NRF_SUCCESS;
  356. }
  357. static uint8_t hid_kbd_get_class_descriptors_count(app_usbd_class_inst_t const * p_inst)
  358. {
  359. app_usbd_hid_kbd_t const * p_kbd = hid_kbd_get(p_inst);
  360. app_usbd_hid_inst_t const * p_hinst = &p_kbd->specific.inst.hid_inst;
  361. return p_hinst->subclass_desc_count;
  362. }
  363. static app_usbd_descriptor_t hid_kbd_get_class_descriptors_type(
  364. app_usbd_class_inst_t const * p_inst,
  365. uint8_t desc_num)
  366. {
  367. app_usbd_hid_kbd_t const * p_kbd = hid_kbd_get(p_inst);
  368. app_usbd_hid_inst_t const * p_hinst = &p_kbd->specific.inst.hid_inst;
  369. return p_hinst->p_subclass_desc[desc_num]->type;
  370. }
  371. static size_t hid_kbd_get_class_descriptors_length(app_usbd_class_inst_t const * p_inst,
  372. uint8_t desc_num)
  373. {
  374. app_usbd_hid_kbd_t const * p_kbd = hid_kbd_get(p_inst);
  375. app_usbd_hid_inst_t const * p_hinst = &p_kbd->specific.inst.hid_inst;
  376. return p_hinst->p_subclass_desc[desc_num]->size;
  377. }
  378. static const uint8_t * hid_kbd_get_class_descriptors_data(app_usbd_class_inst_t const * p_inst,
  379. uint8_t desc_num,
  380. uint32_t cur_byte)
  381. {
  382. app_usbd_hid_kbd_t const * p_kbd = hid_kbd_get(p_inst);
  383. app_usbd_hid_inst_t const * p_hinst = &p_kbd->specific.inst.hid_inst;
  384. const uint8_t * p_byte = &p_hinst->p_subclass_desc[desc_num]->p_data[cur_byte];
  385. return p_byte;
  386. }
  387. static bool hid_kbd_feed_descriptors(app_usbd_class_descriptor_ctx_t * p_ctx,
  388. app_usbd_class_inst_t const * p_inst,
  389. uint8_t * p_buff,
  390. size_t max_size)
  391. {
  392. static uint8_t ifaces = 0;
  393. ifaces = app_usbd_class_iface_count_get(p_inst);
  394. app_usbd_hid_kbd_t const * p_kbd = hid_kbd_get(p_inst);
  395. APP_USBD_CLASS_DESCRIPTOR_BEGIN(p_ctx, p_buff, max_size);
  396. static uint8_t i = 0;
  397. for (i = 0; i < ifaces; i++)
  398. {
  399. /* INTERFACE DESCRIPTOR */
  400. APP_USBD_CLASS_DESCRIPTOR_WRITE(0x09); // bLength
  401. APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_INTERFACE); // bDescriptorType = Interface
  402. static app_usbd_class_iface_conf_t const * p_cur_iface = NULL;
  403. p_cur_iface = app_usbd_class_iface_get(p_inst, i);
  404. APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_iface_number_get(p_cur_iface)); // bInterfaceNumber
  405. APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // bAlternateSetting
  406. APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_iface_ep_count_get(p_cur_iface)); // bNumEndpoints
  407. APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_HID_CLASS); // bInterfaceClass = HID
  408. APP_USBD_CLASS_DESCRIPTOR_WRITE(p_kbd->specific.inst.hid_inst.subclass_boot); // bInterfaceSubclass (Boot Interface)
  409. APP_USBD_CLASS_DESCRIPTOR_WRITE(p_kbd->specific.inst.hid_inst.protocol); // bInterfaceProtocol
  410. APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // iInterface
  411. /* HID DESCRIPTOR */
  412. APP_USBD_CLASS_DESCRIPTOR_WRITE(0x09); // bLength
  413. APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_HID_DESCRIPTOR_HID); // bDescriptorType = HID
  414. APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(APP_USBD_HID_BCD_VER)); // bcdHID LSB
  415. APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(APP_USBD_HID_BCD_VER)); // bcdHID MSB
  416. APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_HID_COUNTRY_NOT_SUPPORTED); // bCountryCode
  417. APP_USBD_CLASS_DESCRIPTOR_WRITE(hid_kbd_get_class_descriptors_count(p_inst)); // bNumDescriptors
  418. static uint8_t class_desc_cnt = 0;
  419. class_desc_cnt = hid_kbd_get_class_descriptors_count(p_inst);
  420. static uint8_t j = 0;
  421. static uint16_t class_desc_len = 0;
  422. for (j = 0; j < class_desc_cnt; j++)
  423. {
  424. APP_USBD_CLASS_DESCRIPTOR_WRITE(hid_kbd_get_class_descriptors_type(p_inst, j)); // bDescriptorType
  425. class_desc_len = hid_kbd_get_class_descriptors_length(p_inst, j);
  426. APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(class_desc_len)); // wDescriptorLength LSB
  427. APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(class_desc_len)); // wDescriptorLength MSB
  428. }
  429. static uint8_t endpoints = 0;
  430. endpoints = app_usbd_class_iface_ep_count_get(p_cur_iface);
  431. for (j = 0; j < endpoints; j++)
  432. {
  433. /* ENDPOINT DESCRIPTOR */
  434. APP_USBD_CLASS_DESCRIPTOR_WRITE(0x07); // bLength
  435. APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_ENDPOINT); // bDescriptorType = Endpoint
  436. static app_usbd_class_ep_conf_t const * p_cur_ep = NULL;
  437. p_cur_ep = app_usbd_class_iface_ep_get(p_cur_iface, j);
  438. APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_ep_address_get(p_cur_ep)); // bEndpointAddress
  439. APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_EP_ATTR_TYPE_INTERRUPT); // bmAttributes
  440. APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(NRF_DRV_USBD_EPSIZE)); // wMaxPacketSize LSB
  441. APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(NRF_DRV_USBD_EPSIZE)); // wMaxPacketSize MSB
  442. APP_USBD_CLASS_DESCRIPTOR_WRITE(p_kbd->specific.inst.hid_inst.p_ep_interval[j]); // bInterval
  443. }
  444. }
  445. APP_USBD_CLASS_DESCRIPTOR_END();
  446. }
  447. ret_code_t hid_kbd_on_set_protocol(app_usbd_hid_kbd_t const * p_kbd, app_usbd_hid_user_event_t ev)
  448. {
  449. app_usbd_hid_kbd_ctx_t * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
  450. if (ev == APP_USBD_HID_USER_EVT_SET_BOOT_PROTO)
  451. {
  452. p_kbd_ctx->hid_ctx.selected_protocol = APP_USBD_HID_PROTO_BOOT;
  453. }
  454. else if (ev == APP_USBD_HID_USER_EVT_SET_REPORT_PROTO)
  455. {
  456. p_kbd_ctx->hid_ctx.selected_protocol = APP_USBD_HID_PROTO_REPORT;
  457. }
  458. else
  459. {
  460. return NRF_ERROR_NOT_SUPPORTED;
  461. }
  462. return NRF_SUCCESS;
  463. }
  464. static ret_code_t hid_kbd_on_idle(app_usbd_class_inst_t const * p_inst, uint8_t report_id)
  465. {
  466. UNUSED_PARAMETER(report_id);
  467. app_usbd_hid_kbd_t const * p_kbd = (app_usbd_hid_kbd_t const *)p_inst;
  468. app_usbd_hid_kbd_ctx_t * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
  469. nrf_drv_usbd_ep_t ep_addr = app_usbd_hid_epin_addr_get(p_inst);
  470. app_usbd_hid_state_flag_clr(&p_kbd_ctx->hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
  471. app_usbd_hid_report_buffer_t const * p_rep_buffer = hid_kbd_rep_buffer_get(p_kbd);
  472. NRF_DRV_USBD_TRANSFER_IN(transfer, p_rep_buffer->p_buff, p_rep_buffer->size);
  473. UNUSED_RETURN_VALUE(hid_kbd_transfer_next(p_kbd));
  474. ret_code_t ret;
  475. CRITICAL_REGION_ENTER();
  476. ret = app_usbd_ep_transfer(ep_addr, &transfer);
  477. if (ret == NRF_SUCCESS)
  478. {
  479. app_usbd_hid_state_flag_set(&p_kbd_ctx->hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
  480. }
  481. CRITICAL_REGION_EXIT();
  482. return NRF_SUCCESS;
  483. }
  484. /** @} */
  485. const app_usbd_hid_methods_t app_usbd_hid_kbd_methods = {
  486. .on_get_report = hid_kbd_on_get_report,
  487. .on_set_report = hid_kbd_on_set_report,
  488. .ep_transfer_in = hid_kbd_ep_transfer_in,
  489. .ep_transfer_out = NULL,
  490. .subclass_count = hid_kbd_get_class_descriptors_count,
  491. .subclass_length = hid_kbd_get_class_descriptors_length,
  492. .subclass_data = hid_kbd_get_class_descriptors_data,
  493. .on_idle = hid_kbd_on_idle,
  494. };
  495. const app_usbd_class_methods_t app_usbd_hid_kbd_class_methods = {
  496. .event_handler = hid_kbd_event_handler,
  497. .feed_descriptors = hid_kbd_feed_descriptors,
  498. };
  499. #endif //NRF_MODULE_ENABLED(APP_USBD_HID_KBD)