digital_technology.c 26 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * NFC Digital Protocol stack
  4. * Copyright (c) 2013, Intel Corporation.
  5. */
  6. #define pr_fmt(fmt) "digital: %s: " fmt, __func__
  7. #include "digital.h"
  8. #define DIGITAL_CMD_SENS_REQ 0x26
  9. #define DIGITAL_CMD_ALL_REQ 0x52
  10. #define DIGITAL_CMD_SEL_REQ_CL1 0x93
  11. #define DIGITAL_CMD_SEL_REQ_CL2 0x95
  12. #define DIGITAL_CMD_SEL_REQ_CL3 0x97
  13. #define DIGITAL_SDD_REQ_SEL_PAR 0x20
  14. #define DIGITAL_SDD_RES_CT 0x88
  15. #define DIGITAL_SDD_RES_LEN 5
  16. #define DIGITAL_SEL_RES_LEN 1
  17. #define DIGITAL_SEL_RES_NFCID1_COMPLETE(sel_res) (!((sel_res) & 0x04))
  18. #define DIGITAL_SEL_RES_IS_T2T(sel_res) (!((sel_res) & 0x60))
  19. #define DIGITAL_SEL_RES_IS_T4T(sel_res) ((sel_res) & 0x20)
  20. #define DIGITAL_SEL_RES_IS_NFC_DEP(sel_res) ((sel_res) & 0x40)
  21. #define DIGITAL_SENS_RES_IS_T1T(sens_res) (((sens_res) & 0x0C00) == 0x0C00)
  22. #define DIGITAL_SENS_RES_IS_VALID(sens_res) \
  23. ((!((sens_res) & 0x001F) && (((sens_res) & 0x0C00) == 0x0C00)) || \
  24. (((sens_res) & 0x001F) && ((sens_res) & 0x0C00) != 0x0C00))
  25. #define DIGITAL_MIFARE_READ_RES_LEN 16
  26. #define DIGITAL_MIFARE_ACK_RES 0x0A
  27. #define DIGITAL_CMD_SENSB_REQ 0x05
  28. #define DIGITAL_SENSB_ADVANCED BIT(5)
  29. #define DIGITAL_SENSB_EXTENDED BIT(4)
  30. #define DIGITAL_SENSB_ALLB_REQ BIT(3)
  31. #define DIGITAL_SENSB_N(n) ((n) & 0x7)
  32. #define DIGITAL_CMD_SENSB_RES 0x50
  33. #define DIGITAL_CMD_ATTRIB_REQ 0x1D
  34. #define DIGITAL_ATTRIB_P1_TR0_DEFAULT (0x0 << 6)
  35. #define DIGITAL_ATTRIB_P1_TR1_DEFAULT (0x0 << 4)
  36. #define DIGITAL_ATTRIB_P1_SUPRESS_EOS BIT(3)
  37. #define DIGITAL_ATTRIB_P1_SUPRESS_SOS BIT(2)
  38. #define DIGITAL_ATTRIB_P2_LISTEN_POLL_1 (0x0 << 6)
  39. #define DIGITAL_ATTRIB_P2_POLL_LISTEN_1 (0x0 << 4)
  40. #define DIGITAL_ATTRIB_P2_MAX_FRAME_256 0x8
  41. #define DIGITAL_ATTRIB_P4_DID(n) ((n) & 0xf)
  42. #define DIGITAL_CMD_SENSF_REQ 0x00
  43. #define DIGITAL_CMD_SENSF_RES 0x01
  44. #define DIGITAL_SENSF_RES_MIN_LENGTH 17
  45. #define DIGITAL_SENSF_RES_RD_AP_B1 0x00
  46. #define DIGITAL_SENSF_RES_RD_AP_B2 0x8F
  47. #define DIGITAL_SENSF_REQ_RC_NONE 0
  48. #define DIGITAL_SENSF_REQ_RC_SC 1
  49. #define DIGITAL_SENSF_REQ_RC_AP 2
  50. #define DIGITAL_CMD_ISO15693_INVENTORY_REQ 0x01
  51. #define DIGITAL_ISO15693_REQ_FLAG_DATA_RATE BIT(1)
  52. #define DIGITAL_ISO15693_REQ_FLAG_INVENTORY BIT(2)
  53. #define DIGITAL_ISO15693_REQ_FLAG_NB_SLOTS BIT(5)
  54. #define DIGITAL_ISO15693_RES_FLAG_ERROR BIT(0)
  55. #define DIGITAL_ISO15693_RES_IS_VALID(flags) \
  56. (!((flags) & DIGITAL_ISO15693_RES_FLAG_ERROR))
  57. #define DIGITAL_ISO_DEP_I_PCB 0x02
  58. #define DIGITAL_ISO_DEP_PNI(pni) ((pni) & 0x01)
  59. #define DIGITAL_ISO_DEP_PCB_TYPE(pcb) ((pcb) & 0xC0)
  60. #define DIGITAL_ISO_DEP_I_BLOCK 0x00
  61. #define DIGITAL_ISO_DEP_BLOCK_HAS_DID(pcb) ((pcb) & 0x08)
  62. static const u8 digital_ats_fsc[] = {
  63. 16, 24, 32, 40, 48, 64, 96, 128,
  64. };
  65. #define DIGITAL_ATS_FSCI(t0) ((t0) & 0x0F)
  66. #define DIGITAL_SENSB_FSCI(pi2) (((pi2) & 0xF0) >> 4)
  67. #define DIGITAL_ATS_MAX_FSC 256
  68. #define DIGITAL_RATS_BYTE1 0xE0
  69. #define DIGITAL_RATS_PARAM 0x80
  70. struct digital_sdd_res {
  71. u8 nfcid1[4];
  72. u8 bcc;
  73. } __packed;
  74. struct digital_sel_req {
  75. u8 sel_cmd;
  76. u8 b2;
  77. u8 nfcid1[4];
  78. u8 bcc;
  79. } __packed;
  80. struct digital_sensb_req {
  81. u8 cmd;
  82. u8 afi;
  83. u8 param;
  84. } __packed;
  85. struct digital_sensb_res {
  86. u8 cmd;
  87. u8 nfcid0[4];
  88. u8 app_data[4];
  89. u8 proto_info[3];
  90. } __packed;
  91. struct digital_attrib_req {
  92. u8 cmd;
  93. u8 nfcid0[4];
  94. u8 param1;
  95. u8 param2;
  96. u8 param3;
  97. u8 param4;
  98. } __packed;
  99. struct digital_attrib_res {
  100. u8 mbli_did;
  101. } __packed;
  102. struct digital_sensf_req {
  103. u8 cmd;
  104. u8 sc1;
  105. u8 sc2;
  106. u8 rc;
  107. u8 tsn;
  108. } __packed;
  109. struct digital_sensf_res {
  110. u8 cmd;
  111. u8 nfcid2[8];
  112. u8 pad0[2];
  113. u8 pad1[3];
  114. u8 mrti_check;
  115. u8 mrti_update;
  116. u8 pad2;
  117. u8 rd[2];
  118. } __packed;
  119. struct digital_iso15693_inv_req {
  120. u8 flags;
  121. u8 cmd;
  122. u8 mask_len;
  123. u64 mask;
  124. } __packed;
  125. struct digital_iso15693_inv_res {
  126. u8 flags;
  127. u8 dsfid;
  128. u64 uid;
  129. } __packed;
  130. static int digital_in_send_sdd_req(struct nfc_digital_dev *ddev,
  131. struct nfc_target *target);
  132. int digital_in_iso_dep_pull_sod(struct nfc_digital_dev *ddev,
  133. struct sk_buff *skb)
  134. {
  135. u8 pcb;
  136. u8 block_type;
  137. if (skb->len < 1)
  138. return -EIO;
  139. pcb = *skb->data;
  140. block_type = DIGITAL_ISO_DEP_PCB_TYPE(pcb);
  141. /* No support fo R-block nor S-block */
  142. if (block_type != DIGITAL_ISO_DEP_I_BLOCK) {
  143. pr_err("ISO_DEP R-block and S-block not supported\n");
  144. return -EIO;
  145. }
  146. if (DIGITAL_ISO_DEP_BLOCK_HAS_DID(pcb)) {
  147. pr_err("DID field in ISO_DEP PCB not supported\n");
  148. return -EIO;
  149. }
  150. skb_pull(skb, 1);
  151. return 0;
  152. }
  153. int digital_in_iso_dep_push_sod(struct nfc_digital_dev *ddev,
  154. struct sk_buff *skb)
  155. {
  156. /*
  157. * Chaining not supported so skb->len + 1 PCB byte + 2 CRC bytes must
  158. * not be greater than remote FSC
  159. */
  160. if (skb->len + 3 > ddev->target_fsc)
  161. return -EIO;
  162. skb_push(skb, 1);
  163. *skb->data = DIGITAL_ISO_DEP_I_PCB | ddev->curr_nfc_dep_pni;
  164. ddev->curr_nfc_dep_pni =
  165. DIGITAL_ISO_DEP_PNI(ddev->curr_nfc_dep_pni + 1);
  166. return 0;
  167. }
  168. static void digital_in_recv_ats(struct nfc_digital_dev *ddev, void *arg,
  169. struct sk_buff *resp)
  170. {
  171. struct nfc_target *target = arg;
  172. u8 fsdi;
  173. int rc;
  174. if (IS_ERR(resp)) {
  175. rc = PTR_ERR(resp);
  176. resp = NULL;
  177. goto exit;
  178. }
  179. if (resp->len < 2) {
  180. rc = -EIO;
  181. goto exit;
  182. }
  183. fsdi = DIGITAL_ATS_FSCI(resp->data[1]);
  184. if (fsdi >= 8)
  185. ddev->target_fsc = DIGITAL_ATS_MAX_FSC;
  186. else
  187. ddev->target_fsc = digital_ats_fsc[fsdi];
  188. ddev->curr_nfc_dep_pni = 0;
  189. rc = digital_target_found(ddev, target, NFC_PROTO_ISO14443);
  190. exit:
  191. dev_kfree_skb(resp);
  192. kfree(target);
  193. if (rc)
  194. digital_poll_next_tech(ddev);
  195. }
  196. static int digital_in_send_rats(struct nfc_digital_dev *ddev,
  197. struct nfc_target *target)
  198. {
  199. int rc;
  200. struct sk_buff *skb;
  201. skb = digital_skb_alloc(ddev, 2);
  202. if (!skb)
  203. return -ENOMEM;
  204. skb_put_u8(skb, DIGITAL_RATS_BYTE1);
  205. skb_put_u8(skb, DIGITAL_RATS_PARAM);
  206. rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_ats,
  207. target);
  208. if (rc)
  209. kfree_skb(skb);
  210. return rc;
  211. }
  212. static void digital_in_recv_sel_res(struct nfc_digital_dev *ddev, void *arg,
  213. struct sk_buff *resp)
  214. {
  215. struct nfc_target *target = arg;
  216. int rc;
  217. u8 sel_res;
  218. u8 nfc_proto;
  219. if (IS_ERR(resp)) {
  220. rc = PTR_ERR(resp);
  221. resp = NULL;
  222. goto exit;
  223. }
  224. if (!DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
  225. rc = digital_skb_check_crc_a(resp);
  226. if (rc) {
  227. PROTOCOL_ERR("4.4.1.3");
  228. goto exit;
  229. }
  230. }
  231. if (resp->len != DIGITAL_SEL_RES_LEN) {
  232. rc = -EIO;
  233. goto exit;
  234. }
  235. sel_res = resp->data[0];
  236. if (!DIGITAL_SEL_RES_NFCID1_COMPLETE(sel_res)) {
  237. rc = digital_in_send_sdd_req(ddev, target);
  238. if (rc)
  239. goto exit;
  240. goto exit_free_skb;
  241. }
  242. target->sel_res = sel_res;
  243. if (DIGITAL_SEL_RES_IS_T2T(sel_res)) {
  244. nfc_proto = NFC_PROTO_MIFARE;
  245. } else if (DIGITAL_SEL_RES_IS_NFC_DEP(sel_res)) {
  246. nfc_proto = NFC_PROTO_NFC_DEP;
  247. } else if (DIGITAL_SEL_RES_IS_T4T(sel_res)) {
  248. rc = digital_in_send_rats(ddev, target);
  249. if (rc)
  250. goto exit;
  251. /*
  252. * Skip target_found and don't free it for now. This will be
  253. * done when receiving the ATS
  254. */
  255. goto exit_free_skb;
  256. } else {
  257. rc = -EOPNOTSUPP;
  258. goto exit;
  259. }
  260. rc = digital_target_found(ddev, target, nfc_proto);
  261. exit:
  262. kfree(target);
  263. exit_free_skb:
  264. dev_kfree_skb(resp);
  265. if (rc)
  266. digital_poll_next_tech(ddev);
  267. }
  268. static int digital_in_send_sel_req(struct nfc_digital_dev *ddev,
  269. struct nfc_target *target,
  270. struct digital_sdd_res *sdd_res)
  271. {
  272. struct sk_buff *skb;
  273. struct digital_sel_req *sel_req;
  274. u8 sel_cmd;
  275. int rc;
  276. skb = digital_skb_alloc(ddev, sizeof(struct digital_sel_req));
  277. if (!skb)
  278. return -ENOMEM;
  279. skb_put(skb, sizeof(struct digital_sel_req));
  280. sel_req = (struct digital_sel_req *)skb->data;
  281. if (target->nfcid1_len <= 4)
  282. sel_cmd = DIGITAL_CMD_SEL_REQ_CL1;
  283. else if (target->nfcid1_len < 10)
  284. sel_cmd = DIGITAL_CMD_SEL_REQ_CL2;
  285. else
  286. sel_cmd = DIGITAL_CMD_SEL_REQ_CL3;
  287. sel_req->sel_cmd = sel_cmd;
  288. sel_req->b2 = 0x70;
  289. memcpy(sel_req->nfcid1, sdd_res->nfcid1, 4);
  290. sel_req->bcc = sdd_res->bcc;
  291. if (DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
  292. rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
  293. NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A);
  294. if (rc)
  295. goto exit;
  296. } else {
  297. digital_skb_add_crc_a(skb);
  298. }
  299. rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sel_res,
  300. target);
  301. exit:
  302. if (rc)
  303. kfree_skb(skb);
  304. return rc;
  305. }
  306. static void digital_in_recv_sdd_res(struct nfc_digital_dev *ddev, void *arg,
  307. struct sk_buff *resp)
  308. {
  309. struct nfc_target *target = arg;
  310. struct digital_sdd_res *sdd_res;
  311. int rc;
  312. u8 offset, size;
  313. u8 i, bcc;
  314. if (IS_ERR(resp)) {
  315. rc = PTR_ERR(resp);
  316. resp = NULL;
  317. goto exit;
  318. }
  319. if (resp->len < DIGITAL_SDD_RES_LEN) {
  320. PROTOCOL_ERR("4.7.2.8");
  321. rc = -EINVAL;
  322. goto exit;
  323. }
  324. sdd_res = (struct digital_sdd_res *)resp->data;
  325. for (i = 0, bcc = 0; i < 4; i++)
  326. bcc ^= sdd_res->nfcid1[i];
  327. if (bcc != sdd_res->bcc) {
  328. PROTOCOL_ERR("4.7.2.6");
  329. rc = -EINVAL;
  330. goto exit;
  331. }
  332. if (sdd_res->nfcid1[0] == DIGITAL_SDD_RES_CT) {
  333. offset = 1;
  334. size = 3;
  335. } else {
  336. offset = 0;
  337. size = 4;
  338. }
  339. memcpy(target->nfcid1 + target->nfcid1_len, sdd_res->nfcid1 + offset,
  340. size);
  341. target->nfcid1_len += size;
  342. rc = digital_in_send_sel_req(ddev, target, sdd_res);
  343. exit:
  344. dev_kfree_skb(resp);
  345. if (rc) {
  346. kfree(target);
  347. digital_poll_next_tech(ddev);
  348. }
  349. }
  350. static int digital_in_send_sdd_req(struct nfc_digital_dev *ddev,
  351. struct nfc_target *target)
  352. {
  353. int rc;
  354. struct sk_buff *skb;
  355. u8 sel_cmd;
  356. rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
  357. NFC_DIGITAL_FRAMING_NFCA_STANDARD);
  358. if (rc)
  359. return rc;
  360. skb = digital_skb_alloc(ddev, 2);
  361. if (!skb)
  362. return -ENOMEM;
  363. if (target->nfcid1_len == 0)
  364. sel_cmd = DIGITAL_CMD_SEL_REQ_CL1;
  365. else if (target->nfcid1_len == 3)
  366. sel_cmd = DIGITAL_CMD_SEL_REQ_CL2;
  367. else
  368. sel_cmd = DIGITAL_CMD_SEL_REQ_CL3;
  369. skb_put_u8(skb, sel_cmd);
  370. skb_put_u8(skb, DIGITAL_SDD_REQ_SEL_PAR);
  371. rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sdd_res,
  372. target);
  373. if (rc)
  374. kfree_skb(skb);
  375. return rc;
  376. }
  377. static void digital_in_recv_sens_res(struct nfc_digital_dev *ddev, void *arg,
  378. struct sk_buff *resp)
  379. {
  380. struct nfc_target *target = NULL;
  381. int rc;
  382. if (IS_ERR(resp)) {
  383. rc = PTR_ERR(resp);
  384. resp = NULL;
  385. goto exit;
  386. }
  387. if (resp->len < sizeof(u16)) {
  388. rc = -EIO;
  389. goto exit;
  390. }
  391. target = kzalloc(sizeof(struct nfc_target), GFP_KERNEL);
  392. if (!target) {
  393. rc = -ENOMEM;
  394. goto exit;
  395. }
  396. target->sens_res = __le16_to_cpu(*(__le16 *)resp->data);
  397. if (!DIGITAL_SENS_RES_IS_VALID(target->sens_res)) {
  398. PROTOCOL_ERR("4.6.3.3");
  399. rc = -EINVAL;
  400. goto exit;
  401. }
  402. if (DIGITAL_SENS_RES_IS_T1T(target->sens_res))
  403. rc = digital_target_found(ddev, target, NFC_PROTO_JEWEL);
  404. else
  405. rc = digital_in_send_sdd_req(ddev, target);
  406. exit:
  407. dev_kfree_skb(resp);
  408. if (rc) {
  409. kfree(target);
  410. digital_poll_next_tech(ddev);
  411. }
  412. }
  413. int digital_in_send_sens_req(struct nfc_digital_dev *ddev, u8 rf_tech)
  414. {
  415. struct sk_buff *skb;
  416. int rc;
  417. rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
  418. NFC_DIGITAL_RF_TECH_106A);
  419. if (rc)
  420. return rc;
  421. rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
  422. NFC_DIGITAL_FRAMING_NFCA_SHORT);
  423. if (rc)
  424. return rc;
  425. skb = digital_skb_alloc(ddev, 1);
  426. if (!skb)
  427. return -ENOMEM;
  428. skb_put_u8(skb, DIGITAL_CMD_SENS_REQ);
  429. rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sens_res, NULL);
  430. if (rc)
  431. kfree_skb(skb);
  432. return rc;
  433. }
  434. int digital_in_recv_mifare_res(struct sk_buff *resp)
  435. {
  436. /* Successful READ command response is 16 data bytes + 2 CRC bytes long.
  437. * Since the driver can't differentiate a ACK/NACK response from a valid
  438. * READ response, the CRC calculation must be handled at digital level
  439. * even if the driver supports it for this technology.
  440. */
  441. if (resp->len == DIGITAL_MIFARE_READ_RES_LEN + DIGITAL_CRC_LEN) {
  442. if (digital_skb_check_crc_a(resp)) {
  443. PROTOCOL_ERR("9.4.1.2");
  444. return -EIO;
  445. }
  446. return 0;
  447. }
  448. /* ACK response (i.e. successful WRITE). */
  449. if (resp->len == 1 && resp->data[0] == DIGITAL_MIFARE_ACK_RES) {
  450. resp->data[0] = 0;
  451. return 0;
  452. }
  453. /* NACK and any other responses are treated as error. */
  454. return -EIO;
  455. }
  456. static void digital_in_recv_attrib_res(struct nfc_digital_dev *ddev, void *arg,
  457. struct sk_buff *resp)
  458. {
  459. struct nfc_target *target = arg;
  460. struct digital_attrib_res *attrib_res;
  461. int rc;
  462. if (IS_ERR(resp)) {
  463. rc = PTR_ERR(resp);
  464. resp = NULL;
  465. goto exit;
  466. }
  467. if (resp->len < sizeof(*attrib_res)) {
  468. PROTOCOL_ERR("12.6.2");
  469. rc = -EIO;
  470. goto exit;
  471. }
  472. attrib_res = (struct digital_attrib_res *)resp->data;
  473. if (attrib_res->mbli_did & 0x0f) {
  474. PROTOCOL_ERR("12.6.2.1");
  475. rc = -EIO;
  476. goto exit;
  477. }
  478. rc = digital_target_found(ddev, target, NFC_PROTO_ISO14443_B);
  479. exit:
  480. dev_kfree_skb(resp);
  481. kfree(target);
  482. if (rc)
  483. digital_poll_next_tech(ddev);
  484. }
  485. static int digital_in_send_attrib_req(struct nfc_digital_dev *ddev,
  486. struct nfc_target *target,
  487. struct digital_sensb_res *sensb_res)
  488. {
  489. struct digital_attrib_req *attrib_req;
  490. struct sk_buff *skb;
  491. int rc;
  492. skb = digital_skb_alloc(ddev, sizeof(*attrib_req));
  493. if (!skb)
  494. return -ENOMEM;
  495. attrib_req = skb_put(skb, sizeof(*attrib_req));
  496. attrib_req->cmd = DIGITAL_CMD_ATTRIB_REQ;
  497. memcpy(attrib_req->nfcid0, sensb_res->nfcid0,
  498. sizeof(attrib_req->nfcid0));
  499. attrib_req->param1 = DIGITAL_ATTRIB_P1_TR0_DEFAULT |
  500. DIGITAL_ATTRIB_P1_TR1_DEFAULT;
  501. attrib_req->param2 = DIGITAL_ATTRIB_P2_LISTEN_POLL_1 |
  502. DIGITAL_ATTRIB_P2_POLL_LISTEN_1 |
  503. DIGITAL_ATTRIB_P2_MAX_FRAME_256;
  504. attrib_req->param3 = sensb_res->proto_info[1] & 0x07;
  505. attrib_req->param4 = DIGITAL_ATTRIB_P4_DID(0);
  506. rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_attrib_res,
  507. target);
  508. if (rc)
  509. kfree_skb(skb);
  510. return rc;
  511. }
  512. static void digital_in_recv_sensb_res(struct nfc_digital_dev *ddev, void *arg,
  513. struct sk_buff *resp)
  514. {
  515. struct nfc_target *target = NULL;
  516. struct digital_sensb_res *sensb_res;
  517. u8 fsci;
  518. int rc;
  519. if (IS_ERR(resp)) {
  520. rc = PTR_ERR(resp);
  521. resp = NULL;
  522. goto exit;
  523. }
  524. if (resp->len != sizeof(*sensb_res)) {
  525. PROTOCOL_ERR("5.6.2.1");
  526. rc = -EIO;
  527. goto exit;
  528. }
  529. sensb_res = (struct digital_sensb_res *)resp->data;
  530. if (sensb_res->cmd != DIGITAL_CMD_SENSB_RES) {
  531. PROTOCOL_ERR("5.6.2");
  532. rc = -EIO;
  533. goto exit;
  534. }
  535. if (!(sensb_res->proto_info[1] & BIT(0))) {
  536. PROTOCOL_ERR("5.6.2.12");
  537. rc = -EIO;
  538. goto exit;
  539. }
  540. if (sensb_res->proto_info[1] & BIT(3)) {
  541. PROTOCOL_ERR("5.6.2.16");
  542. rc = -EIO;
  543. goto exit;
  544. }
  545. fsci = DIGITAL_SENSB_FSCI(sensb_res->proto_info[1]);
  546. if (fsci >= 8)
  547. ddev->target_fsc = DIGITAL_ATS_MAX_FSC;
  548. else
  549. ddev->target_fsc = digital_ats_fsc[fsci];
  550. target = kzalloc(sizeof(struct nfc_target), GFP_KERNEL);
  551. if (!target) {
  552. rc = -ENOMEM;
  553. goto exit;
  554. }
  555. rc = digital_in_send_attrib_req(ddev, target, sensb_res);
  556. exit:
  557. dev_kfree_skb(resp);
  558. if (rc) {
  559. kfree(target);
  560. digital_poll_next_tech(ddev);
  561. }
  562. }
  563. int digital_in_send_sensb_req(struct nfc_digital_dev *ddev, u8 rf_tech)
  564. {
  565. struct digital_sensb_req *sensb_req;
  566. struct sk_buff *skb;
  567. int rc;
  568. rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
  569. NFC_DIGITAL_RF_TECH_106B);
  570. if (rc)
  571. return rc;
  572. rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
  573. NFC_DIGITAL_FRAMING_NFCB);
  574. if (rc)
  575. return rc;
  576. skb = digital_skb_alloc(ddev, sizeof(*sensb_req));
  577. if (!skb)
  578. return -ENOMEM;
  579. sensb_req = skb_put(skb, sizeof(*sensb_req));
  580. sensb_req->cmd = DIGITAL_CMD_SENSB_REQ;
  581. sensb_req->afi = 0x00; /* All families and sub-families */
  582. sensb_req->param = DIGITAL_SENSB_N(0);
  583. rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sensb_res,
  584. NULL);
  585. if (rc)
  586. kfree_skb(skb);
  587. return rc;
  588. }
  589. static void digital_in_recv_sensf_res(struct nfc_digital_dev *ddev, void *arg,
  590. struct sk_buff *resp)
  591. {
  592. int rc;
  593. u8 proto;
  594. struct nfc_target target;
  595. struct digital_sensf_res *sensf_res;
  596. if (IS_ERR(resp)) {
  597. rc = PTR_ERR(resp);
  598. resp = NULL;
  599. goto exit;
  600. }
  601. if (resp->len < DIGITAL_SENSF_RES_MIN_LENGTH) {
  602. rc = -EIO;
  603. goto exit;
  604. }
  605. if (!DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
  606. rc = digital_skb_check_crc_f(resp);
  607. if (rc) {
  608. PROTOCOL_ERR("6.4.1.8");
  609. goto exit;
  610. }
  611. }
  612. skb_pull(resp, 1);
  613. memset(&target, 0, sizeof(struct nfc_target));
  614. sensf_res = (struct digital_sensf_res *)resp->data;
  615. memcpy(target.sensf_res, sensf_res, resp->len);
  616. target.sensf_res_len = resp->len;
  617. memcpy(target.nfcid2, sensf_res->nfcid2, NFC_NFCID2_MAXSIZE);
  618. target.nfcid2_len = NFC_NFCID2_MAXSIZE;
  619. if (target.nfcid2[0] == DIGITAL_SENSF_NFCID2_NFC_DEP_B1 &&
  620. target.nfcid2[1] == DIGITAL_SENSF_NFCID2_NFC_DEP_B2)
  621. proto = NFC_PROTO_NFC_DEP;
  622. else
  623. proto = NFC_PROTO_FELICA;
  624. rc = digital_target_found(ddev, &target, proto);
  625. exit:
  626. dev_kfree_skb(resp);
  627. if (rc)
  628. digital_poll_next_tech(ddev);
  629. }
  630. int digital_in_send_sensf_req(struct nfc_digital_dev *ddev, u8 rf_tech)
  631. {
  632. struct digital_sensf_req *sensf_req;
  633. struct sk_buff *skb;
  634. int rc;
  635. u8 size;
  636. rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
  637. if (rc)
  638. return rc;
  639. rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
  640. NFC_DIGITAL_FRAMING_NFCF);
  641. if (rc)
  642. return rc;
  643. size = sizeof(struct digital_sensf_req);
  644. skb = digital_skb_alloc(ddev, size);
  645. if (!skb)
  646. return -ENOMEM;
  647. skb_put(skb, size);
  648. sensf_req = (struct digital_sensf_req *)skb->data;
  649. sensf_req->cmd = DIGITAL_CMD_SENSF_REQ;
  650. sensf_req->sc1 = 0xFF;
  651. sensf_req->sc2 = 0xFF;
  652. sensf_req->rc = 0;
  653. sensf_req->tsn = 0;
  654. *(u8 *)skb_push(skb, 1) = size + 1;
  655. if (!DIGITAL_DRV_CAPS_IN_CRC(ddev))
  656. digital_skb_add_crc_f(skb);
  657. rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sensf_res,
  658. NULL);
  659. if (rc)
  660. kfree_skb(skb);
  661. return rc;
  662. }
  663. static void digital_in_recv_iso15693_inv_res(struct nfc_digital_dev *ddev,
  664. void *arg, struct sk_buff *resp)
  665. {
  666. struct digital_iso15693_inv_res *res;
  667. struct nfc_target *target = NULL;
  668. int rc;
  669. if (IS_ERR(resp)) {
  670. rc = PTR_ERR(resp);
  671. resp = NULL;
  672. goto out_free_skb;
  673. }
  674. if (resp->len != sizeof(*res)) {
  675. rc = -EIO;
  676. goto out_free_skb;
  677. }
  678. res = (struct digital_iso15693_inv_res *)resp->data;
  679. if (!DIGITAL_ISO15693_RES_IS_VALID(res->flags)) {
  680. PROTOCOL_ERR("ISO15693 - 10.3.1");
  681. rc = -EINVAL;
  682. goto out_free_skb;
  683. }
  684. target = kzalloc(sizeof(*target), GFP_KERNEL);
  685. if (!target) {
  686. rc = -ENOMEM;
  687. goto out_free_skb;
  688. }
  689. target->is_iso15693 = 1;
  690. target->iso15693_dsfid = res->dsfid;
  691. memcpy(target->iso15693_uid, &res->uid, sizeof(target->iso15693_uid));
  692. rc = digital_target_found(ddev, target, NFC_PROTO_ISO15693);
  693. kfree(target);
  694. out_free_skb:
  695. dev_kfree_skb(resp);
  696. if (rc)
  697. digital_poll_next_tech(ddev);
  698. }
  699. int digital_in_send_iso15693_inv_req(struct nfc_digital_dev *ddev, u8 rf_tech)
  700. {
  701. struct digital_iso15693_inv_req *req;
  702. struct sk_buff *skb;
  703. int rc;
  704. rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
  705. NFC_DIGITAL_RF_TECH_ISO15693);
  706. if (rc)
  707. return rc;
  708. rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
  709. NFC_DIGITAL_FRAMING_ISO15693_INVENTORY);
  710. if (rc)
  711. return rc;
  712. skb = digital_skb_alloc(ddev, sizeof(*req));
  713. if (!skb)
  714. return -ENOMEM;
  715. skb_put(skb, sizeof(*req) - sizeof(req->mask)); /* No mask */
  716. req = (struct digital_iso15693_inv_req *)skb->data;
  717. /* Single sub-carrier, high data rate, no AFI, single slot
  718. * Inventory command
  719. */
  720. req->flags = DIGITAL_ISO15693_REQ_FLAG_DATA_RATE |
  721. DIGITAL_ISO15693_REQ_FLAG_INVENTORY |
  722. DIGITAL_ISO15693_REQ_FLAG_NB_SLOTS;
  723. req->cmd = DIGITAL_CMD_ISO15693_INVENTORY_REQ;
  724. req->mask_len = 0;
  725. rc = digital_in_send_cmd(ddev, skb, 30,
  726. digital_in_recv_iso15693_inv_res, NULL);
  727. if (rc)
  728. kfree_skb(skb);
  729. return rc;
  730. }
  731. static int digital_tg_send_sel_res(struct nfc_digital_dev *ddev)
  732. {
  733. struct sk_buff *skb;
  734. int rc;
  735. skb = digital_skb_alloc(ddev, 1);
  736. if (!skb)
  737. return -ENOMEM;
  738. skb_put_u8(skb, DIGITAL_SEL_RES_NFC_DEP);
  739. if (!DIGITAL_DRV_CAPS_TG_CRC(ddev))
  740. digital_skb_add_crc_a(skb);
  741. rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
  742. NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE);
  743. if (rc) {
  744. kfree_skb(skb);
  745. return rc;
  746. }
  747. rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_atr_req,
  748. NULL);
  749. if (rc)
  750. kfree_skb(skb);
  751. return rc;
  752. }
  753. static void digital_tg_recv_sel_req(struct nfc_digital_dev *ddev, void *arg,
  754. struct sk_buff *resp)
  755. {
  756. int rc;
  757. if (IS_ERR(resp)) {
  758. rc = PTR_ERR(resp);
  759. resp = NULL;
  760. goto exit;
  761. }
  762. if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
  763. rc = digital_skb_check_crc_a(resp);
  764. if (rc) {
  765. PROTOCOL_ERR("4.4.1.3");
  766. goto exit;
  767. }
  768. }
  769. /* Silently ignore SEL_REQ content and send a SEL_RES for NFC-DEP */
  770. rc = digital_tg_send_sel_res(ddev);
  771. exit:
  772. if (rc)
  773. digital_poll_next_tech(ddev);
  774. dev_kfree_skb(resp);
  775. }
  776. static int digital_tg_send_sdd_res(struct nfc_digital_dev *ddev)
  777. {
  778. struct sk_buff *skb;
  779. struct digital_sdd_res *sdd_res;
  780. int rc, i;
  781. skb = digital_skb_alloc(ddev, sizeof(struct digital_sdd_res));
  782. if (!skb)
  783. return -ENOMEM;
  784. skb_put(skb, sizeof(struct digital_sdd_res));
  785. sdd_res = (struct digital_sdd_res *)skb->data;
  786. sdd_res->nfcid1[0] = 0x08;
  787. get_random_bytes(sdd_res->nfcid1 + 1, 3);
  788. sdd_res->bcc = 0;
  789. for (i = 0; i < 4; i++)
  790. sdd_res->bcc ^= sdd_res->nfcid1[i];
  791. rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
  792. NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A);
  793. if (rc) {
  794. kfree_skb(skb);
  795. return rc;
  796. }
  797. rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_sel_req,
  798. NULL);
  799. if (rc)
  800. kfree_skb(skb);
  801. return rc;
  802. }
  803. static void digital_tg_recv_sdd_req(struct nfc_digital_dev *ddev, void *arg,
  804. struct sk_buff *resp)
  805. {
  806. u8 *sdd_req;
  807. int rc;
  808. if (IS_ERR(resp)) {
  809. rc = PTR_ERR(resp);
  810. resp = NULL;
  811. goto exit;
  812. }
  813. sdd_req = resp->data;
  814. if (resp->len < 2 || sdd_req[0] != DIGITAL_CMD_SEL_REQ_CL1 ||
  815. sdd_req[1] != DIGITAL_SDD_REQ_SEL_PAR) {
  816. rc = -EINVAL;
  817. goto exit;
  818. }
  819. rc = digital_tg_send_sdd_res(ddev);
  820. exit:
  821. if (rc)
  822. digital_poll_next_tech(ddev);
  823. dev_kfree_skb(resp);
  824. }
  825. static int digital_tg_send_sens_res(struct nfc_digital_dev *ddev)
  826. {
  827. struct sk_buff *skb;
  828. u8 *sens_res;
  829. int rc;
  830. skb = digital_skb_alloc(ddev, 2);
  831. if (!skb)
  832. return -ENOMEM;
  833. sens_res = skb_put(skb, 2);
  834. sens_res[0] = (DIGITAL_SENS_RES_NFC_DEP >> 8) & 0xFF;
  835. sens_res[1] = DIGITAL_SENS_RES_NFC_DEP & 0xFF;
  836. rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
  837. NFC_DIGITAL_FRAMING_NFCA_STANDARD);
  838. if (rc) {
  839. kfree_skb(skb);
  840. return rc;
  841. }
  842. rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_sdd_req,
  843. NULL);
  844. if (rc)
  845. kfree_skb(skb);
  846. return rc;
  847. }
  848. void digital_tg_recv_sens_req(struct nfc_digital_dev *ddev, void *arg,
  849. struct sk_buff *resp)
  850. {
  851. u8 sens_req;
  852. int rc;
  853. if (IS_ERR(resp)) {
  854. rc = PTR_ERR(resp);
  855. resp = NULL;
  856. goto exit;
  857. }
  858. sens_req = resp->data[0];
  859. if (!resp->len || (sens_req != DIGITAL_CMD_SENS_REQ &&
  860. sens_req != DIGITAL_CMD_ALL_REQ)) {
  861. rc = -EINVAL;
  862. goto exit;
  863. }
  864. rc = digital_tg_send_sens_res(ddev);
  865. exit:
  866. if (rc)
  867. digital_poll_next_tech(ddev);
  868. dev_kfree_skb(resp);
  869. }
  870. static void digital_tg_recv_atr_or_sensf_req(struct nfc_digital_dev *ddev,
  871. void *arg, struct sk_buff *resp)
  872. {
  873. if (!IS_ERR(resp) && (resp->len >= 2) &&
  874. (resp->data[1] == DIGITAL_CMD_SENSF_REQ))
  875. digital_tg_recv_sensf_req(ddev, arg, resp);
  876. else
  877. digital_tg_recv_atr_req(ddev, arg, resp);
  878. return;
  879. }
  880. static int digital_tg_send_sensf_res(struct nfc_digital_dev *ddev,
  881. struct digital_sensf_req *sensf_req)
  882. {
  883. struct sk_buff *skb;
  884. u8 size;
  885. int rc;
  886. struct digital_sensf_res *sensf_res;
  887. size = sizeof(struct digital_sensf_res);
  888. if (sensf_req->rc == DIGITAL_SENSF_REQ_RC_NONE)
  889. size -= sizeof(sensf_res->rd);
  890. skb = digital_skb_alloc(ddev, size);
  891. if (!skb)
  892. return -ENOMEM;
  893. skb_put(skb, size);
  894. sensf_res = (struct digital_sensf_res *)skb->data;
  895. memset(sensf_res, 0, size);
  896. sensf_res->cmd = DIGITAL_CMD_SENSF_RES;
  897. sensf_res->nfcid2[0] = DIGITAL_SENSF_NFCID2_NFC_DEP_B1;
  898. sensf_res->nfcid2[1] = DIGITAL_SENSF_NFCID2_NFC_DEP_B2;
  899. get_random_bytes(&sensf_res->nfcid2[2], 6);
  900. switch (sensf_req->rc) {
  901. case DIGITAL_SENSF_REQ_RC_SC:
  902. sensf_res->rd[0] = sensf_req->sc1;
  903. sensf_res->rd[1] = sensf_req->sc2;
  904. break;
  905. case DIGITAL_SENSF_REQ_RC_AP:
  906. sensf_res->rd[0] = DIGITAL_SENSF_RES_RD_AP_B1;
  907. sensf_res->rd[1] = DIGITAL_SENSF_RES_RD_AP_B2;
  908. break;
  909. }
  910. *(u8 *)skb_push(skb, sizeof(u8)) = size + 1;
  911. if (!DIGITAL_DRV_CAPS_TG_CRC(ddev))
  912. digital_skb_add_crc_f(skb);
  913. rc = digital_tg_send_cmd(ddev, skb, 300,
  914. digital_tg_recv_atr_or_sensf_req, NULL);
  915. if (rc)
  916. kfree_skb(skb);
  917. return rc;
  918. }
  919. void digital_tg_recv_sensf_req(struct nfc_digital_dev *ddev, void *arg,
  920. struct sk_buff *resp)
  921. {
  922. struct digital_sensf_req *sensf_req;
  923. int rc;
  924. if (IS_ERR(resp)) {
  925. rc = PTR_ERR(resp);
  926. resp = NULL;
  927. goto exit;
  928. }
  929. if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
  930. rc = digital_skb_check_crc_f(resp);
  931. if (rc) {
  932. PROTOCOL_ERR("6.4.1.8");
  933. goto exit;
  934. }
  935. }
  936. if (resp->len != sizeof(struct digital_sensf_req) + 1) {
  937. rc = -EINVAL;
  938. goto exit;
  939. }
  940. skb_pull(resp, 1);
  941. sensf_req = (struct digital_sensf_req *)resp->data;
  942. if (sensf_req->cmd != DIGITAL_CMD_SENSF_REQ) {
  943. rc = -EINVAL;
  944. goto exit;
  945. }
  946. rc = digital_tg_send_sensf_res(ddev, sensf_req);
  947. exit:
  948. if (rc)
  949. digital_poll_next_tech(ddev);
  950. dev_kfree_skb(resp);
  951. }
  952. static int digital_tg_config_nfca(struct nfc_digital_dev *ddev)
  953. {
  954. int rc;
  955. rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
  956. NFC_DIGITAL_RF_TECH_106A);
  957. if (rc)
  958. return rc;
  959. return digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
  960. NFC_DIGITAL_FRAMING_NFCA_NFC_DEP);
  961. }
  962. int digital_tg_listen_nfca(struct nfc_digital_dev *ddev, u8 rf_tech)
  963. {
  964. int rc;
  965. rc = digital_tg_config_nfca(ddev);
  966. if (rc)
  967. return rc;
  968. return digital_tg_listen(ddev, 300, digital_tg_recv_sens_req, NULL);
  969. }
  970. static int digital_tg_config_nfcf(struct nfc_digital_dev *ddev, u8 rf_tech)
  971. {
  972. int rc;
  973. rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
  974. if (rc)
  975. return rc;
  976. return digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
  977. NFC_DIGITAL_FRAMING_NFCF_NFC_DEP);
  978. }
  979. int digital_tg_listen_nfcf(struct nfc_digital_dev *ddev, u8 rf_tech)
  980. {
  981. int rc;
  982. rc = digital_tg_config_nfcf(ddev, rf_tech);
  983. if (rc)
  984. return rc;
  985. return digital_tg_listen(ddev, 300, digital_tg_recv_sensf_req, NULL);
  986. }
  987. void digital_tg_recv_md_req(struct nfc_digital_dev *ddev, void *arg,
  988. struct sk_buff *resp)
  989. {
  990. u8 rf_tech;
  991. int rc;
  992. if (IS_ERR(resp)) {
  993. resp = NULL;
  994. goto exit_free_skb;
  995. }
  996. rc = ddev->ops->tg_get_rf_tech(ddev, &rf_tech);
  997. if (rc)
  998. goto exit_free_skb;
  999. switch (rf_tech) {
  1000. case NFC_DIGITAL_RF_TECH_106A:
  1001. rc = digital_tg_config_nfca(ddev);
  1002. if (rc)
  1003. goto exit_free_skb;
  1004. digital_tg_recv_sens_req(ddev, arg, resp);
  1005. break;
  1006. case NFC_DIGITAL_RF_TECH_212F:
  1007. case NFC_DIGITAL_RF_TECH_424F:
  1008. rc = digital_tg_config_nfcf(ddev, rf_tech);
  1009. if (rc)
  1010. goto exit_free_skb;
  1011. digital_tg_recv_sensf_req(ddev, arg, resp);
  1012. break;
  1013. default:
  1014. goto exit_free_skb;
  1015. }
  1016. return;
  1017. exit_free_skb:
  1018. digital_poll_next_tech(ddev);
  1019. dev_kfree_skb(resp);
  1020. }