microread.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * HCI based Driver for Inside Secure microread NFC Chip
  4. *
  5. * Copyright (C) 2013 Intel Corporation. All rights reserved.
  6. */
  7. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  8. #include <linux/module.h>
  9. #include <linux/delay.h>
  10. #include <linux/slab.h>
  11. #include <linux/crc-ccitt.h>
  12. #include <linux/nfc.h>
  13. #include <net/nfc/nfc.h>
  14. #include <net/nfc/hci.h>
  15. #include "microread.h"
  16. /* Proprietary gates, events, commands and registers */
  17. /* Admin */
  18. #define MICROREAD_GATE_ID_ADM NFC_HCI_ADMIN_GATE
  19. #define MICROREAD_GATE_ID_MGT 0x01
  20. #define MICROREAD_GATE_ID_OS 0x02
  21. #define MICROREAD_GATE_ID_TESTRF 0x03
  22. #define MICROREAD_GATE_ID_LOOPBACK NFC_HCI_LOOPBACK_GATE
  23. #define MICROREAD_GATE_ID_IDT NFC_HCI_ID_MGMT_GATE
  24. #define MICROREAD_GATE_ID_LMS NFC_HCI_LINK_MGMT_GATE
  25. /* Reader */
  26. #define MICROREAD_GATE_ID_MREAD_GEN 0x10
  27. #define MICROREAD_GATE_ID_MREAD_ISO_B NFC_HCI_RF_READER_B_GATE
  28. #define MICROREAD_GATE_ID_MREAD_NFC_T1 0x12
  29. #define MICROREAD_GATE_ID_MREAD_ISO_A NFC_HCI_RF_READER_A_GATE
  30. #define MICROREAD_GATE_ID_MREAD_NFC_T3 0x14
  31. #define MICROREAD_GATE_ID_MREAD_ISO_15_3 0x15
  32. #define MICROREAD_GATE_ID_MREAD_ISO_15_2 0x16
  33. #define MICROREAD_GATE_ID_MREAD_ISO_B_3 0x17
  34. #define MICROREAD_GATE_ID_MREAD_BPRIME 0x18
  35. #define MICROREAD_GATE_ID_MREAD_ISO_A_3 0x19
  36. /* Card */
  37. #define MICROREAD_GATE_ID_MCARD_GEN 0x20
  38. #define MICROREAD_GATE_ID_MCARD_ISO_B 0x21
  39. #define MICROREAD_GATE_ID_MCARD_BPRIME 0x22
  40. #define MICROREAD_GATE_ID_MCARD_ISO_A 0x23
  41. #define MICROREAD_GATE_ID_MCARD_NFC_T3 0x24
  42. #define MICROREAD_GATE_ID_MCARD_ISO_15_3 0x25
  43. #define MICROREAD_GATE_ID_MCARD_ISO_15_2 0x26
  44. #define MICROREAD_GATE_ID_MCARD_ISO_B_2 0x27
  45. #define MICROREAD_GATE_ID_MCARD_ISO_CUSTOM 0x28
  46. #define MICROREAD_GATE_ID_SECURE_ELEMENT 0x2F
  47. /* P2P */
  48. #define MICROREAD_GATE_ID_P2P_GEN 0x30
  49. #define MICROREAD_GATE_ID_P2P_TARGET 0x31
  50. #define MICROREAD_PAR_P2P_TARGET_MODE 0x01
  51. #define MICROREAD_PAR_P2P_TARGET_GT 0x04
  52. #define MICROREAD_GATE_ID_P2P_INITIATOR 0x32
  53. #define MICROREAD_PAR_P2P_INITIATOR_GI 0x01
  54. #define MICROREAD_PAR_P2P_INITIATOR_GT 0x03
  55. /* Those pipes are created/opened by default in the chip */
  56. #define MICROREAD_PIPE_ID_LMS 0x00
  57. #define MICROREAD_PIPE_ID_ADMIN 0x01
  58. #define MICROREAD_PIPE_ID_MGT 0x02
  59. #define MICROREAD_PIPE_ID_OS 0x03
  60. #define MICROREAD_PIPE_ID_HDS_LOOPBACK 0x04
  61. #define MICROREAD_PIPE_ID_HDS_IDT 0x05
  62. #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_B 0x08
  63. #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_BPRIME 0x09
  64. #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_A 0x0A
  65. #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_15_3 0x0B
  66. #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_15_2 0x0C
  67. #define MICROREAD_PIPE_ID_HDS_MCARD_NFC_T3 0x0D
  68. #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_B_2 0x0E
  69. #define MICROREAD_PIPE_ID_HDS_MCARD_CUSTOM 0x0F
  70. #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_B 0x10
  71. #define MICROREAD_PIPE_ID_HDS_MREAD_NFC_T1 0x11
  72. #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_A 0x12
  73. #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_15_3 0x13
  74. #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_15_2 0x14
  75. #define MICROREAD_PIPE_ID_HDS_MREAD_NFC_T3 0x15
  76. #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_B_3 0x16
  77. #define MICROREAD_PIPE_ID_HDS_MREAD_BPRIME 0x17
  78. #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_A_3 0x18
  79. #define MICROREAD_PIPE_ID_HDS_MREAD_GEN 0x1B
  80. #define MICROREAD_PIPE_ID_HDS_STACKED_ELEMENT 0x1C
  81. #define MICROREAD_PIPE_ID_HDS_INSTANCES 0x1D
  82. #define MICROREAD_PIPE_ID_HDS_TESTRF 0x1E
  83. #define MICROREAD_PIPE_ID_HDS_P2P_TARGET 0x1F
  84. #define MICROREAD_PIPE_ID_HDS_P2P_INITIATOR 0x20
  85. /* Events */
  86. #define MICROREAD_EVT_MREAD_DISCOVERY_OCCURED NFC_HCI_EVT_TARGET_DISCOVERED
  87. #define MICROREAD_EVT_MREAD_CARD_FOUND 0x3D
  88. #define MICROREAD_EMCF_A_ATQA 0
  89. #define MICROREAD_EMCF_A_SAK 2
  90. #define MICROREAD_EMCF_A_LEN 3
  91. #define MICROREAD_EMCF_A_UID 4
  92. #define MICROREAD_EMCF_A3_ATQA 0
  93. #define MICROREAD_EMCF_A3_SAK 2
  94. #define MICROREAD_EMCF_A3_LEN 3
  95. #define MICROREAD_EMCF_A3_UID 4
  96. #define MICROREAD_EMCF_B_UID 0
  97. #define MICROREAD_EMCF_T1_ATQA 0
  98. #define MICROREAD_EMCF_T1_UID 4
  99. #define MICROREAD_EMCF_T3_UID 0
  100. #define MICROREAD_EVT_MREAD_DISCOVERY_START NFC_HCI_EVT_READER_REQUESTED
  101. #define MICROREAD_EVT_MREAD_DISCOVERY_START_SOME 0x3E
  102. #define MICROREAD_EVT_MREAD_DISCOVERY_STOP NFC_HCI_EVT_END_OPERATION
  103. #define MICROREAD_EVT_MREAD_SIM_REQUESTS 0x3F
  104. #define MICROREAD_EVT_MCARD_EXCHANGE NFC_HCI_EVT_TARGET_DISCOVERED
  105. #define MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_TO_RF 0x20
  106. #define MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_FROM_RF 0x21
  107. #define MICROREAD_EVT_MCARD_FIELD_ON 0x11
  108. #define MICROREAD_EVT_P2P_TARGET_ACTIVATED 0x13
  109. #define MICROREAD_EVT_P2P_TARGET_DEACTIVATED 0x12
  110. #define MICROREAD_EVT_MCARD_FIELD_OFF 0x14
  111. /* Commands */
  112. #define MICROREAD_CMD_MREAD_EXCHANGE 0x10
  113. #define MICROREAD_CMD_MREAD_SUBSCRIBE 0x3F
  114. /* Hosts IDs */
  115. #define MICROREAD_ELT_ID_HDS NFC_HCI_TERMINAL_HOST_ID
  116. #define MICROREAD_ELT_ID_SIM NFC_HCI_UICC_HOST_ID
  117. #define MICROREAD_ELT_ID_SE1 0x03
  118. #define MICROREAD_ELT_ID_SE2 0x04
  119. #define MICROREAD_ELT_ID_SE3 0x05
  120. static const struct nfc_hci_gate microread_gates[] = {
  121. {MICROREAD_GATE_ID_ADM, MICROREAD_PIPE_ID_ADMIN},
  122. {MICROREAD_GATE_ID_LOOPBACK, MICROREAD_PIPE_ID_HDS_LOOPBACK},
  123. {MICROREAD_GATE_ID_IDT, MICROREAD_PIPE_ID_HDS_IDT},
  124. {MICROREAD_GATE_ID_LMS, MICROREAD_PIPE_ID_LMS},
  125. {MICROREAD_GATE_ID_MREAD_ISO_B, MICROREAD_PIPE_ID_HDS_MREAD_ISO_B},
  126. {MICROREAD_GATE_ID_MREAD_ISO_A, MICROREAD_PIPE_ID_HDS_MREAD_ISO_A},
  127. {MICROREAD_GATE_ID_MREAD_ISO_A_3, MICROREAD_PIPE_ID_HDS_MREAD_ISO_A_3},
  128. {MICROREAD_GATE_ID_MGT, MICROREAD_PIPE_ID_MGT},
  129. {MICROREAD_GATE_ID_OS, MICROREAD_PIPE_ID_OS},
  130. {MICROREAD_GATE_ID_MREAD_NFC_T1, MICROREAD_PIPE_ID_HDS_MREAD_NFC_T1},
  131. {MICROREAD_GATE_ID_MREAD_NFC_T3, MICROREAD_PIPE_ID_HDS_MREAD_NFC_T3},
  132. {MICROREAD_GATE_ID_P2P_TARGET, MICROREAD_PIPE_ID_HDS_P2P_TARGET},
  133. {MICROREAD_GATE_ID_P2P_INITIATOR, MICROREAD_PIPE_ID_HDS_P2P_INITIATOR}
  134. };
  135. /* Largest headroom needed for outgoing custom commands */
  136. #define MICROREAD_CMDS_HEADROOM 2
  137. #define MICROREAD_CMD_TAILROOM 2
  138. struct microread_info {
  139. const struct nfc_phy_ops *phy_ops;
  140. void *phy_id;
  141. struct nfc_hci_dev *hdev;
  142. int async_cb_type;
  143. data_exchange_cb_t async_cb;
  144. void *async_cb_context;
  145. };
  146. static int microread_open(struct nfc_hci_dev *hdev)
  147. {
  148. struct microread_info *info = nfc_hci_get_clientdata(hdev);
  149. return info->phy_ops->enable(info->phy_id);
  150. }
  151. static void microread_close(struct nfc_hci_dev *hdev)
  152. {
  153. struct microread_info *info = nfc_hci_get_clientdata(hdev);
  154. info->phy_ops->disable(info->phy_id);
  155. }
  156. static int microread_hci_ready(struct nfc_hci_dev *hdev)
  157. {
  158. int r;
  159. u8 param[4];
  160. param[0] = 0x03;
  161. r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_ISO_A,
  162. MICROREAD_CMD_MREAD_SUBSCRIBE, param, 1, NULL);
  163. if (r)
  164. return r;
  165. r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_ISO_A_3,
  166. MICROREAD_CMD_MREAD_SUBSCRIBE, NULL, 0, NULL);
  167. if (r)
  168. return r;
  169. param[0] = 0x00;
  170. param[1] = 0x03;
  171. param[2] = 0x00;
  172. r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_ISO_B,
  173. MICROREAD_CMD_MREAD_SUBSCRIBE, param, 3, NULL);
  174. if (r)
  175. return r;
  176. r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_NFC_T1,
  177. MICROREAD_CMD_MREAD_SUBSCRIBE, NULL, 0, NULL);
  178. if (r)
  179. return r;
  180. param[0] = 0xFF;
  181. param[1] = 0xFF;
  182. param[2] = 0x00;
  183. param[3] = 0x00;
  184. r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_NFC_T3,
  185. MICROREAD_CMD_MREAD_SUBSCRIBE, param, 4, NULL);
  186. return r;
  187. }
  188. static int microread_xmit(struct nfc_hci_dev *hdev, struct sk_buff *skb)
  189. {
  190. struct microread_info *info = nfc_hci_get_clientdata(hdev);
  191. return info->phy_ops->write(info->phy_id, skb);
  192. }
  193. static int microread_start_poll(struct nfc_hci_dev *hdev,
  194. u32 im_protocols, u32 tm_protocols)
  195. {
  196. int r;
  197. u8 param[2];
  198. u8 mode;
  199. param[0] = 0x00;
  200. param[1] = 0x00;
  201. if (im_protocols & NFC_PROTO_ISO14443_MASK)
  202. param[0] |= (1 << 2);
  203. if (im_protocols & NFC_PROTO_ISO14443_B_MASK)
  204. param[0] |= 1;
  205. if (im_protocols & NFC_PROTO_MIFARE_MASK)
  206. param[1] |= 1;
  207. if (im_protocols & NFC_PROTO_JEWEL_MASK)
  208. param[0] |= (1 << 1);
  209. if (im_protocols & NFC_PROTO_FELICA_MASK)
  210. param[0] |= (1 << 5);
  211. if (im_protocols & NFC_PROTO_NFC_DEP_MASK)
  212. param[1] |= (1 << 1);
  213. if ((im_protocols | tm_protocols) & NFC_PROTO_NFC_DEP_MASK) {
  214. hdev->gb = nfc_get_local_general_bytes(hdev->ndev,
  215. &hdev->gb_len);
  216. if (hdev->gb == NULL || hdev->gb_len == 0) {
  217. im_protocols &= ~NFC_PROTO_NFC_DEP_MASK;
  218. tm_protocols &= ~NFC_PROTO_NFC_DEP_MASK;
  219. }
  220. }
  221. r = nfc_hci_send_event(hdev, MICROREAD_GATE_ID_MREAD_ISO_A,
  222. MICROREAD_EVT_MREAD_DISCOVERY_STOP, NULL, 0);
  223. if (r)
  224. return r;
  225. mode = 0xff;
  226. r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET,
  227. MICROREAD_PAR_P2P_TARGET_MODE, &mode, 1);
  228. if (r)
  229. return r;
  230. if (im_protocols & NFC_PROTO_NFC_DEP_MASK) {
  231. r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_INITIATOR,
  232. MICROREAD_PAR_P2P_INITIATOR_GI,
  233. hdev->gb, hdev->gb_len);
  234. if (r)
  235. return r;
  236. }
  237. if (tm_protocols & NFC_PROTO_NFC_DEP_MASK) {
  238. r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET,
  239. MICROREAD_PAR_P2P_TARGET_GT,
  240. hdev->gb, hdev->gb_len);
  241. if (r)
  242. return r;
  243. mode = 0x02;
  244. r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET,
  245. MICROREAD_PAR_P2P_TARGET_MODE, &mode, 1);
  246. if (r)
  247. return r;
  248. }
  249. return nfc_hci_send_event(hdev, MICROREAD_GATE_ID_MREAD_ISO_A,
  250. MICROREAD_EVT_MREAD_DISCOVERY_START_SOME,
  251. param, 2);
  252. }
  253. static int microread_dep_link_up(struct nfc_hci_dev *hdev,
  254. struct nfc_target *target, u8 comm_mode,
  255. u8 *gb, size_t gb_len)
  256. {
  257. struct sk_buff *rgb_skb = NULL;
  258. int r;
  259. r = nfc_hci_get_param(hdev, target->hci_reader_gate,
  260. MICROREAD_PAR_P2P_INITIATOR_GT, &rgb_skb);
  261. if (r < 0)
  262. return r;
  263. if (rgb_skb->len == 0 || rgb_skb->len > NFC_GB_MAXSIZE) {
  264. r = -EPROTO;
  265. goto exit;
  266. }
  267. r = nfc_set_remote_general_bytes(hdev->ndev, rgb_skb->data,
  268. rgb_skb->len);
  269. if (r == 0)
  270. r = nfc_dep_link_is_up(hdev->ndev, target->idx, comm_mode,
  271. NFC_RF_INITIATOR);
  272. exit:
  273. kfree_skb(rgb_skb);
  274. return r;
  275. }
  276. static int microread_dep_link_down(struct nfc_hci_dev *hdev)
  277. {
  278. return nfc_hci_send_event(hdev, MICROREAD_GATE_ID_P2P_INITIATOR,
  279. MICROREAD_EVT_MREAD_DISCOVERY_STOP, NULL, 0);
  280. }
  281. static int microread_target_from_gate(struct nfc_hci_dev *hdev, u8 gate,
  282. struct nfc_target *target)
  283. {
  284. switch (gate) {
  285. case MICROREAD_GATE_ID_P2P_INITIATOR:
  286. target->supported_protocols = NFC_PROTO_NFC_DEP_MASK;
  287. break;
  288. default:
  289. return -EPROTO;
  290. }
  291. return 0;
  292. }
  293. static int microread_complete_target_discovered(struct nfc_hci_dev *hdev,
  294. u8 gate,
  295. struct nfc_target *target)
  296. {
  297. return 0;
  298. }
  299. #define MICROREAD_CB_TYPE_READER_ALL 1
  300. static void microread_im_transceive_cb(void *context, struct sk_buff *skb,
  301. int err)
  302. {
  303. const struct microread_info *info = context;
  304. switch (info->async_cb_type) {
  305. case MICROREAD_CB_TYPE_READER_ALL:
  306. if (err == 0) {
  307. if (skb->len == 0) {
  308. kfree_skb(skb);
  309. info->async_cb(info->async_cb_context, NULL,
  310. -EPROTO);
  311. return;
  312. }
  313. if (skb->data[skb->len - 1] != 0) {
  314. err = nfc_hci_result_to_errno(
  315. skb->data[skb->len - 1]);
  316. kfree_skb(skb);
  317. info->async_cb(info->async_cb_context, NULL,
  318. err);
  319. return;
  320. }
  321. skb_trim(skb, skb->len - 1); /* RF Error ind. */
  322. }
  323. info->async_cb(info->async_cb_context, skb, err);
  324. break;
  325. default:
  326. if (err == 0)
  327. kfree_skb(skb);
  328. break;
  329. }
  330. }
  331. /*
  332. * Returns:
  333. * <= 0: driver handled the data exchange
  334. * 1: driver doesn't especially handle, please do standard processing
  335. */
  336. static int microread_im_transceive(struct nfc_hci_dev *hdev,
  337. struct nfc_target *target,
  338. struct sk_buff *skb, data_exchange_cb_t cb,
  339. void *cb_context)
  340. {
  341. struct microread_info *info = nfc_hci_get_clientdata(hdev);
  342. u8 control_bits;
  343. u16 crc;
  344. pr_info("data exchange to gate 0x%x\n", target->hci_reader_gate);
  345. if (target->hci_reader_gate == MICROREAD_GATE_ID_P2P_INITIATOR) {
  346. *(u8 *)skb_push(skb, 1) = 0;
  347. return nfc_hci_send_event(hdev, target->hci_reader_gate,
  348. MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_TO_RF,
  349. skb->data, skb->len);
  350. }
  351. switch (target->hci_reader_gate) {
  352. case MICROREAD_GATE_ID_MREAD_ISO_A:
  353. control_bits = 0xCB;
  354. break;
  355. case MICROREAD_GATE_ID_MREAD_ISO_A_3:
  356. control_bits = 0xCB;
  357. break;
  358. case MICROREAD_GATE_ID_MREAD_ISO_B:
  359. control_bits = 0xCB;
  360. break;
  361. case MICROREAD_GATE_ID_MREAD_NFC_T1:
  362. control_bits = 0x1B;
  363. crc = crc_ccitt(0xffff, skb->data, skb->len);
  364. crc = ~crc;
  365. skb_put_u8(skb, crc & 0xff);
  366. skb_put_u8(skb, crc >> 8);
  367. break;
  368. case MICROREAD_GATE_ID_MREAD_NFC_T3:
  369. control_bits = 0xDB;
  370. break;
  371. default:
  372. pr_info("Abort im_transceive to invalid gate 0x%x\n",
  373. target->hci_reader_gate);
  374. return 1;
  375. }
  376. *(u8 *)skb_push(skb, 1) = control_bits;
  377. info->async_cb_type = MICROREAD_CB_TYPE_READER_ALL;
  378. info->async_cb = cb;
  379. info->async_cb_context = cb_context;
  380. return nfc_hci_send_cmd_async(hdev, target->hci_reader_gate,
  381. MICROREAD_CMD_MREAD_EXCHANGE,
  382. skb->data, skb->len,
  383. microread_im_transceive_cb, info);
  384. }
  385. static int microread_tm_send(struct nfc_hci_dev *hdev, struct sk_buff *skb)
  386. {
  387. int r;
  388. r = nfc_hci_send_event(hdev, MICROREAD_GATE_ID_P2P_TARGET,
  389. MICROREAD_EVT_MCARD_EXCHANGE,
  390. skb->data, skb->len);
  391. kfree_skb(skb);
  392. return r;
  393. }
  394. static void microread_target_discovered(struct nfc_hci_dev *hdev, u8 gate,
  395. struct sk_buff *skb)
  396. {
  397. struct nfc_target *targets;
  398. int r = 0;
  399. pr_info("target discovered to gate 0x%x\n", gate);
  400. targets = kzalloc(sizeof(struct nfc_target), GFP_KERNEL);
  401. if (targets == NULL) {
  402. r = -ENOMEM;
  403. goto exit;
  404. }
  405. targets->hci_reader_gate = gate;
  406. switch (gate) {
  407. case MICROREAD_GATE_ID_MREAD_ISO_A:
  408. targets->supported_protocols =
  409. nfc_hci_sak_to_protocol(skb->data[MICROREAD_EMCF_A_SAK]);
  410. targets->sens_res =
  411. be16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_A_ATQA]);
  412. targets->sel_res = skb->data[MICROREAD_EMCF_A_SAK];
  413. targets->nfcid1_len = skb->data[MICROREAD_EMCF_A_LEN];
  414. if (targets->nfcid1_len > sizeof(targets->nfcid1)) {
  415. r = -EINVAL;
  416. goto exit_free;
  417. }
  418. memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_A_UID],
  419. targets->nfcid1_len);
  420. break;
  421. case MICROREAD_GATE_ID_MREAD_ISO_A_3:
  422. targets->supported_protocols =
  423. nfc_hci_sak_to_protocol(skb->data[MICROREAD_EMCF_A3_SAK]);
  424. targets->sens_res =
  425. be16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_A3_ATQA]);
  426. targets->sel_res = skb->data[MICROREAD_EMCF_A3_SAK];
  427. targets->nfcid1_len = skb->data[MICROREAD_EMCF_A3_LEN];
  428. if (targets->nfcid1_len > sizeof(targets->nfcid1)) {
  429. r = -EINVAL;
  430. goto exit_free;
  431. }
  432. memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_A3_UID],
  433. targets->nfcid1_len);
  434. break;
  435. case MICROREAD_GATE_ID_MREAD_ISO_B:
  436. targets->supported_protocols = NFC_PROTO_ISO14443_B_MASK;
  437. memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_B_UID], 4);
  438. targets->nfcid1_len = 4;
  439. break;
  440. case MICROREAD_GATE_ID_MREAD_NFC_T1:
  441. targets->supported_protocols = NFC_PROTO_JEWEL_MASK;
  442. targets->sens_res =
  443. le16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_T1_ATQA]);
  444. memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_T1_UID], 4);
  445. targets->nfcid1_len = 4;
  446. break;
  447. case MICROREAD_GATE_ID_MREAD_NFC_T3:
  448. targets->supported_protocols = NFC_PROTO_FELICA_MASK;
  449. memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_T3_UID], 8);
  450. targets->nfcid1_len = 8;
  451. break;
  452. default:
  453. pr_info("discard target discovered to gate 0x%x\n", gate);
  454. goto exit_free;
  455. }
  456. r = nfc_targets_found(hdev->ndev, targets, 1);
  457. exit_free:
  458. kfree(targets);
  459. exit:
  460. kfree_skb(skb);
  461. if (r)
  462. pr_err("Failed to handle discovered target err=%d\n", r);
  463. }
  464. static int microread_event_received(struct nfc_hci_dev *hdev, u8 pipe,
  465. u8 event, struct sk_buff *skb)
  466. {
  467. int r;
  468. u8 gate = hdev->pipes[pipe].gate;
  469. u8 mode;
  470. pr_info("Microread received event 0x%x to gate 0x%x\n", event, gate);
  471. switch (event) {
  472. case MICROREAD_EVT_MREAD_CARD_FOUND:
  473. microread_target_discovered(hdev, gate, skb);
  474. return 0;
  475. case MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_FROM_RF:
  476. if (skb->len < 1) {
  477. kfree_skb(skb);
  478. return -EPROTO;
  479. }
  480. if (skb->data[skb->len - 1]) {
  481. kfree_skb(skb);
  482. return -EIO;
  483. }
  484. skb_trim(skb, skb->len - 1);
  485. r = nfc_tm_data_received(hdev->ndev, skb);
  486. break;
  487. case MICROREAD_EVT_MCARD_FIELD_ON:
  488. case MICROREAD_EVT_MCARD_FIELD_OFF:
  489. kfree_skb(skb);
  490. return 0;
  491. case MICROREAD_EVT_P2P_TARGET_ACTIVATED:
  492. r = nfc_tm_activated(hdev->ndev, NFC_PROTO_NFC_DEP_MASK,
  493. NFC_COMM_PASSIVE, skb->data,
  494. skb->len);
  495. kfree_skb(skb);
  496. break;
  497. case MICROREAD_EVT_MCARD_EXCHANGE:
  498. if (skb->len < 1) {
  499. kfree_skb(skb);
  500. return -EPROTO;
  501. }
  502. if (skb->data[skb->len-1]) {
  503. kfree_skb(skb);
  504. return -EIO;
  505. }
  506. skb_trim(skb, skb->len - 1);
  507. r = nfc_tm_data_received(hdev->ndev, skb);
  508. break;
  509. case MICROREAD_EVT_P2P_TARGET_DEACTIVATED:
  510. kfree_skb(skb);
  511. mode = 0xff;
  512. r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET,
  513. MICROREAD_PAR_P2P_TARGET_MODE, &mode, 1);
  514. if (r)
  515. break;
  516. r = nfc_hci_send_event(hdev, gate,
  517. MICROREAD_EVT_MREAD_DISCOVERY_STOP, NULL,
  518. 0);
  519. break;
  520. default:
  521. return 1;
  522. }
  523. return r;
  524. }
  525. static const struct nfc_hci_ops microread_hci_ops = {
  526. .open = microread_open,
  527. .close = microread_close,
  528. .hci_ready = microread_hci_ready,
  529. .xmit = microread_xmit,
  530. .start_poll = microread_start_poll,
  531. .dep_link_up = microread_dep_link_up,
  532. .dep_link_down = microread_dep_link_down,
  533. .target_from_gate = microread_target_from_gate,
  534. .complete_target_discovered = microread_complete_target_discovered,
  535. .im_transceive = microread_im_transceive,
  536. .tm_send = microread_tm_send,
  537. .check_presence = NULL,
  538. .event_received = microread_event_received,
  539. };
  540. int microread_probe(void *phy_id, const struct nfc_phy_ops *phy_ops,
  541. const char *llc_name, int phy_headroom, int phy_tailroom,
  542. int phy_payload, struct nfc_hci_dev **hdev)
  543. {
  544. struct microread_info *info;
  545. unsigned long quirks = 0;
  546. u32 protocols;
  547. struct nfc_hci_init_data init_data;
  548. int r;
  549. info = kzalloc(sizeof(struct microread_info), GFP_KERNEL);
  550. if (!info) {
  551. r = -ENOMEM;
  552. goto err_info_alloc;
  553. }
  554. info->phy_ops = phy_ops;
  555. info->phy_id = phy_id;
  556. init_data.gate_count = ARRAY_SIZE(microread_gates);
  557. memcpy(init_data.gates, microread_gates, sizeof(microread_gates));
  558. strcpy(init_data.session_id, "MICROREA");
  559. set_bit(NFC_HCI_QUIRK_SHORT_CLEAR, &quirks);
  560. protocols = NFC_PROTO_JEWEL_MASK |
  561. NFC_PROTO_MIFARE_MASK |
  562. NFC_PROTO_FELICA_MASK |
  563. NFC_PROTO_ISO14443_MASK |
  564. NFC_PROTO_ISO14443_B_MASK |
  565. NFC_PROTO_NFC_DEP_MASK;
  566. info->hdev = nfc_hci_allocate_device(&microread_hci_ops, &init_data,
  567. quirks, protocols, llc_name,
  568. phy_headroom +
  569. MICROREAD_CMDS_HEADROOM,
  570. phy_tailroom +
  571. MICROREAD_CMD_TAILROOM,
  572. phy_payload);
  573. if (!info->hdev) {
  574. pr_err("Cannot allocate nfc hdev\n");
  575. r = -ENOMEM;
  576. goto err_alloc_hdev;
  577. }
  578. nfc_hci_set_clientdata(info->hdev, info);
  579. r = nfc_hci_register_device(info->hdev);
  580. if (r)
  581. goto err_regdev;
  582. *hdev = info->hdev;
  583. return 0;
  584. err_regdev:
  585. nfc_hci_free_device(info->hdev);
  586. err_alloc_hdev:
  587. kfree(info);
  588. err_info_alloc:
  589. return r;
  590. }
  591. EXPORT_SYMBOL(microread_probe);
  592. void microread_remove(struct nfc_hci_dev *hdev)
  593. {
  594. struct microread_info *info = nfc_hci_get_clientdata(hdev);
  595. nfc_hci_unregister_device(hdev);
  596. nfc_hci_free_device(hdev);
  597. kfree(info);
  598. }
  599. EXPORT_SYMBOL(microread_remove);
  600. MODULE_LICENSE("GPL");
  601. MODULE_DESCRIPTION(DRIVER_DESC);