mei_phy.c 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (c) 2013, Intel Corporation.
  4. *
  5. * MEI Library for mei bus nfc device access
  6. */
  7. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  8. #include <linux/module.h>
  9. #include <linux/slab.h>
  10. #include <linux/nfc.h>
  11. #include "mei_phy.h"
  12. struct mei_nfc_hdr {
  13. u8 cmd;
  14. u8 status;
  15. u16 req_id;
  16. u32 reserved;
  17. u16 data_size;
  18. } __packed;
  19. struct mei_nfc_cmd {
  20. struct mei_nfc_hdr hdr;
  21. u8 sub_command;
  22. u8 data[];
  23. } __packed;
  24. struct mei_nfc_reply {
  25. struct mei_nfc_hdr hdr;
  26. u8 sub_command;
  27. u8 reply_status;
  28. u8 data[];
  29. } __packed;
  30. struct mei_nfc_if_version {
  31. u8 radio_version_sw[3];
  32. u8 reserved[3];
  33. u8 radio_version_hw[3];
  34. u8 i2c_addr;
  35. u8 fw_ivn;
  36. u8 vendor_id;
  37. u8 radio_type;
  38. } __packed;
  39. struct mei_nfc_connect {
  40. u8 fw_ivn;
  41. u8 vendor_id;
  42. } __packed;
  43. struct mei_nfc_connect_resp {
  44. u8 fw_ivn;
  45. u8 vendor_id;
  46. u16 me_major;
  47. u16 me_minor;
  48. u16 me_hotfix;
  49. u16 me_build;
  50. } __packed;
  51. #define MEI_NFC_CMD_MAINTENANCE 0x00
  52. #define MEI_NFC_CMD_HCI_SEND 0x01
  53. #define MEI_NFC_CMD_HCI_RECV 0x02
  54. #define MEI_NFC_SUBCMD_CONNECT 0x00
  55. #define MEI_NFC_SUBCMD_IF_VERSION 0x01
  56. #define MEI_NFC_MAX_READ (MEI_NFC_HEADER_SIZE + MEI_NFC_MAX_HCI_PAYLOAD)
  57. #define MEI_DUMP_SKB_IN(info, skb) \
  58. do { \
  59. pr_debug("%s:\n", info); \
  60. print_hex_dump_debug("mei in : ", DUMP_PREFIX_OFFSET, \
  61. 16, 1, (skb)->data, (skb)->len, false); \
  62. } while (0)
  63. #define MEI_DUMP_SKB_OUT(info, skb) \
  64. do { \
  65. pr_debug("%s:\n", info); \
  66. print_hex_dump_debug("mei out: ", DUMP_PREFIX_OFFSET, \
  67. 16, 1, (skb)->data, (skb)->len, false); \
  68. } while (0)
  69. #define MEI_DUMP_NFC_HDR(info, _hdr) \
  70. do { \
  71. pr_debug("%s:\n", info); \
  72. pr_debug("cmd=%02d status=%d req_id=%d rsvd=%d size=%d\n", \
  73. (_hdr)->cmd, (_hdr)->status, (_hdr)->req_id, \
  74. (_hdr)->reserved, (_hdr)->data_size); \
  75. } while (0)
  76. static int mei_nfc_if_version(struct nfc_mei_phy *phy)
  77. {
  78. struct mei_nfc_cmd cmd;
  79. struct mei_nfc_reply *reply = NULL;
  80. struct mei_nfc_if_version *version;
  81. size_t if_version_length;
  82. int bytes_recv, r;
  83. pr_info("%s\n", __func__);
  84. memset(&cmd, 0, sizeof(struct mei_nfc_cmd));
  85. cmd.hdr.cmd = MEI_NFC_CMD_MAINTENANCE;
  86. cmd.hdr.data_size = 1;
  87. cmd.sub_command = MEI_NFC_SUBCMD_IF_VERSION;
  88. MEI_DUMP_NFC_HDR("version", &cmd.hdr);
  89. r = mei_cldev_send(phy->cldev, (u8 *)&cmd, sizeof(struct mei_nfc_cmd));
  90. if (r < 0) {
  91. pr_err("Could not send IF version cmd\n");
  92. return r;
  93. }
  94. /* to be sure on the stack we alloc memory */
  95. if_version_length = sizeof(struct mei_nfc_reply) +
  96. sizeof(struct mei_nfc_if_version);
  97. reply = kzalloc(if_version_length, GFP_KERNEL);
  98. if (!reply)
  99. return -ENOMEM;
  100. bytes_recv = mei_cldev_recv(phy->cldev, (u8 *)reply, if_version_length);
  101. if (bytes_recv < 0 || bytes_recv < if_version_length) {
  102. pr_err("Could not read IF version\n");
  103. r = -EIO;
  104. goto err;
  105. }
  106. version = (struct mei_nfc_if_version *)reply->data;
  107. phy->fw_ivn = version->fw_ivn;
  108. phy->vendor_id = version->vendor_id;
  109. phy->radio_type = version->radio_type;
  110. err:
  111. kfree(reply);
  112. return r;
  113. }
  114. static int mei_nfc_connect(struct nfc_mei_phy *phy)
  115. {
  116. struct mei_nfc_cmd *cmd, *reply;
  117. struct mei_nfc_connect *connect;
  118. struct mei_nfc_connect_resp *connect_resp;
  119. size_t connect_length, connect_resp_length;
  120. int bytes_recv, r;
  121. pr_info("%s\n", __func__);
  122. connect_length = sizeof(struct mei_nfc_cmd) +
  123. sizeof(struct mei_nfc_connect);
  124. connect_resp_length = sizeof(struct mei_nfc_cmd) +
  125. sizeof(struct mei_nfc_connect_resp);
  126. cmd = kzalloc(connect_length, GFP_KERNEL);
  127. if (!cmd)
  128. return -ENOMEM;
  129. connect = (struct mei_nfc_connect *)cmd->data;
  130. reply = kzalloc(connect_resp_length, GFP_KERNEL);
  131. if (!reply) {
  132. kfree(cmd);
  133. return -ENOMEM;
  134. }
  135. connect_resp = (struct mei_nfc_connect_resp *)reply->data;
  136. cmd->hdr.cmd = MEI_NFC_CMD_MAINTENANCE;
  137. cmd->hdr.data_size = 3;
  138. cmd->sub_command = MEI_NFC_SUBCMD_CONNECT;
  139. connect->fw_ivn = phy->fw_ivn;
  140. connect->vendor_id = phy->vendor_id;
  141. MEI_DUMP_NFC_HDR("connect request", &cmd->hdr);
  142. r = mei_cldev_send(phy->cldev, (u8 *)cmd, connect_length);
  143. if (r < 0) {
  144. pr_err("Could not send connect cmd %d\n", r);
  145. goto err;
  146. }
  147. bytes_recv = mei_cldev_recv(phy->cldev, (u8 *)reply,
  148. connect_resp_length);
  149. if (bytes_recv < 0) {
  150. r = bytes_recv;
  151. pr_err("Could not read connect response %d\n", r);
  152. goto err;
  153. }
  154. MEI_DUMP_NFC_HDR("connect reply", &reply->hdr);
  155. pr_info("IVN 0x%x Vendor ID 0x%x\n",
  156. connect_resp->fw_ivn, connect_resp->vendor_id);
  157. pr_info("ME FW %d.%d.%d.%d\n",
  158. connect_resp->me_major, connect_resp->me_minor,
  159. connect_resp->me_hotfix, connect_resp->me_build);
  160. r = 0;
  161. err:
  162. kfree(reply);
  163. kfree(cmd);
  164. return r;
  165. }
  166. static int mei_nfc_send(struct nfc_mei_phy *phy, u8 *buf, size_t length)
  167. {
  168. struct mei_nfc_hdr *hdr;
  169. u8 *mei_buf;
  170. int err;
  171. err = -ENOMEM;
  172. mei_buf = kzalloc(length + MEI_NFC_HEADER_SIZE, GFP_KERNEL);
  173. if (!mei_buf)
  174. goto out;
  175. hdr = (struct mei_nfc_hdr *)mei_buf;
  176. hdr->cmd = MEI_NFC_CMD_HCI_SEND;
  177. hdr->status = 0;
  178. hdr->req_id = phy->req_id;
  179. hdr->reserved = 0;
  180. hdr->data_size = length;
  181. MEI_DUMP_NFC_HDR("send", hdr);
  182. memcpy(mei_buf + MEI_NFC_HEADER_SIZE, buf, length);
  183. err = mei_cldev_send(phy->cldev, mei_buf, length + MEI_NFC_HEADER_SIZE);
  184. if (err < 0)
  185. goto out;
  186. if (!wait_event_interruptible_timeout(phy->send_wq,
  187. phy->recv_req_id == phy->req_id, HZ)) {
  188. pr_err("NFC MEI command timeout\n");
  189. err = -ETIME;
  190. } else {
  191. phy->req_id++;
  192. }
  193. out:
  194. kfree(mei_buf);
  195. return err;
  196. }
  197. /*
  198. * Writing a frame must not return the number of written bytes.
  199. * It must return either zero for success, or <0 for error.
  200. * In addition, it must not alter the skb
  201. */
  202. static int nfc_mei_phy_write(void *phy_id, struct sk_buff *skb)
  203. {
  204. struct nfc_mei_phy *phy = phy_id;
  205. int r;
  206. MEI_DUMP_SKB_OUT("mei frame sent", skb);
  207. r = mei_nfc_send(phy, skb->data, skb->len);
  208. if (r > 0)
  209. r = 0;
  210. return r;
  211. }
  212. static int mei_nfc_recv(struct nfc_mei_phy *phy, u8 *buf, size_t length)
  213. {
  214. struct mei_nfc_hdr *hdr;
  215. int received_length;
  216. received_length = mei_cldev_recv(phy->cldev, buf, length);
  217. if (received_length < 0)
  218. return received_length;
  219. hdr = (struct mei_nfc_hdr *) buf;
  220. MEI_DUMP_NFC_HDR("receive", hdr);
  221. if (hdr->cmd == MEI_NFC_CMD_HCI_SEND) {
  222. phy->recv_req_id = hdr->req_id;
  223. wake_up(&phy->send_wq);
  224. return 0;
  225. }
  226. return received_length;
  227. }
  228. static void nfc_mei_rx_cb(struct mei_cl_device *cldev)
  229. {
  230. struct nfc_mei_phy *phy = mei_cldev_get_drvdata(cldev);
  231. struct sk_buff *skb;
  232. int reply_size;
  233. if (!phy)
  234. return;
  235. if (phy->hard_fault != 0)
  236. return;
  237. skb = alloc_skb(MEI_NFC_MAX_READ, GFP_KERNEL);
  238. if (!skb)
  239. return;
  240. reply_size = mei_nfc_recv(phy, skb->data, MEI_NFC_MAX_READ);
  241. if (reply_size < MEI_NFC_HEADER_SIZE) {
  242. kfree_skb(skb);
  243. return;
  244. }
  245. skb_put(skb, reply_size);
  246. skb_pull(skb, MEI_NFC_HEADER_SIZE);
  247. MEI_DUMP_SKB_IN("mei frame read", skb);
  248. nfc_hci_recv_frame(phy->hdev, skb);
  249. }
  250. static int nfc_mei_phy_enable(void *phy_id)
  251. {
  252. int r;
  253. struct nfc_mei_phy *phy = phy_id;
  254. pr_info("%s\n", __func__);
  255. if (phy->powered == 1)
  256. return 0;
  257. r = mei_cldev_enable(phy->cldev);
  258. if (r < 0) {
  259. pr_err("Could not enable device %d\n", r);
  260. return r;
  261. }
  262. r = mei_nfc_if_version(phy);
  263. if (r < 0) {
  264. pr_err("Could not enable device %d\n", r);
  265. goto err;
  266. }
  267. r = mei_nfc_connect(phy);
  268. if (r < 0) {
  269. pr_err("Could not connect to device %d\n", r);
  270. goto err;
  271. }
  272. r = mei_cldev_register_rx_cb(phy->cldev, nfc_mei_rx_cb);
  273. if (r) {
  274. pr_err("Event cb registration failed %d\n", r);
  275. goto err;
  276. }
  277. phy->powered = 1;
  278. return 0;
  279. err:
  280. phy->powered = 0;
  281. mei_cldev_disable(phy->cldev);
  282. return r;
  283. }
  284. static void nfc_mei_phy_disable(void *phy_id)
  285. {
  286. struct nfc_mei_phy *phy = phy_id;
  287. pr_info("%s\n", __func__);
  288. mei_cldev_disable(phy->cldev);
  289. phy->powered = 0;
  290. }
  291. struct nfc_phy_ops mei_phy_ops = {
  292. .write = nfc_mei_phy_write,
  293. .enable = nfc_mei_phy_enable,
  294. .disable = nfc_mei_phy_disable,
  295. };
  296. EXPORT_SYMBOL_GPL(mei_phy_ops);
  297. struct nfc_mei_phy *nfc_mei_phy_alloc(struct mei_cl_device *cldev)
  298. {
  299. struct nfc_mei_phy *phy;
  300. phy = kzalloc(sizeof(struct nfc_mei_phy), GFP_KERNEL);
  301. if (!phy)
  302. return NULL;
  303. phy->cldev = cldev;
  304. init_waitqueue_head(&phy->send_wq);
  305. mei_cldev_set_drvdata(cldev, phy);
  306. return phy;
  307. }
  308. EXPORT_SYMBOL_GPL(nfc_mei_phy_alloc);
  309. void nfc_mei_phy_free(struct nfc_mei_phy *phy)
  310. {
  311. mei_cldev_disable(phy->cldev);
  312. kfree(phy);
  313. }
  314. EXPORT_SYMBOL_GPL(nfc_mei_phy_free);
  315. MODULE_LICENSE("GPL");
  316. MODULE_DESCRIPTION("mei bus NFC device interface");