i2c.c 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * HCI based Driver for Inside Secure microread NFC Chip - i2c layer
  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/i2c.h>
  10. #include <linux/delay.h>
  11. #include <linux/slab.h>
  12. #include <linux/interrupt.h>
  13. #include <linux/gpio.h>
  14. #include <linux/nfc.h>
  15. #include <net/nfc/hci.h>
  16. #include <net/nfc/llc.h>
  17. #include "microread.h"
  18. #define MICROREAD_I2C_DRIVER_NAME "microread"
  19. #define MICROREAD_I2C_FRAME_HEADROOM 1
  20. #define MICROREAD_I2C_FRAME_TAILROOM 1
  21. /* framing in HCI mode */
  22. #define MICROREAD_I2C_LLC_LEN 1
  23. #define MICROREAD_I2C_LLC_CRC 1
  24. #define MICROREAD_I2C_LLC_LEN_CRC (MICROREAD_I2C_LLC_LEN + \
  25. MICROREAD_I2C_LLC_CRC)
  26. #define MICROREAD_I2C_LLC_MIN_SIZE (1 + MICROREAD_I2C_LLC_LEN_CRC)
  27. #define MICROREAD_I2C_LLC_MAX_PAYLOAD 29
  28. #define MICROREAD_I2C_LLC_MAX_SIZE (MICROREAD_I2C_LLC_LEN_CRC + 1 + \
  29. MICROREAD_I2C_LLC_MAX_PAYLOAD)
  30. struct microread_i2c_phy {
  31. struct i2c_client *i2c_dev;
  32. struct nfc_hci_dev *hdev;
  33. int hard_fault; /*
  34. * < 0 if hardware error occured (e.g. i2c err)
  35. * and prevents normal operation.
  36. */
  37. };
  38. #define I2C_DUMP_SKB(info, skb) \
  39. do { \
  40. pr_debug("%s:\n", info); \
  41. print_hex_dump(KERN_DEBUG, "i2c: ", DUMP_PREFIX_OFFSET, \
  42. 16, 1, (skb)->data, (skb)->len, 0); \
  43. } while (0)
  44. static void microread_i2c_add_len_crc(struct sk_buff *skb)
  45. {
  46. int i;
  47. u8 crc = 0;
  48. int len;
  49. len = skb->len;
  50. *(u8 *)skb_push(skb, 1) = len;
  51. for (i = 0; i < skb->len; i++)
  52. crc = crc ^ skb->data[i];
  53. skb_put_u8(skb, crc);
  54. }
  55. static void microread_i2c_remove_len_crc(struct sk_buff *skb)
  56. {
  57. skb_pull(skb, MICROREAD_I2C_FRAME_HEADROOM);
  58. skb_trim(skb, MICROREAD_I2C_FRAME_TAILROOM);
  59. }
  60. static int check_crc(const struct sk_buff *skb)
  61. {
  62. int i;
  63. u8 crc = 0;
  64. for (i = 0; i < skb->len - 1; i++)
  65. crc = crc ^ skb->data[i];
  66. if (crc != skb->data[skb->len-1]) {
  67. pr_err("CRC error 0x%x != 0x%x\n", crc, skb->data[skb->len-1]);
  68. pr_info("%s: BAD CRC\n", __func__);
  69. return -EPERM;
  70. }
  71. return 0;
  72. }
  73. static int microread_i2c_enable(void *phy_id)
  74. {
  75. return 0;
  76. }
  77. static void microread_i2c_disable(void *phy_id)
  78. {
  79. return;
  80. }
  81. static int microread_i2c_write(void *phy_id, struct sk_buff *skb)
  82. {
  83. int r;
  84. struct microread_i2c_phy *phy = phy_id;
  85. struct i2c_client *client = phy->i2c_dev;
  86. if (phy->hard_fault != 0)
  87. return phy->hard_fault;
  88. usleep_range(3000, 6000);
  89. microread_i2c_add_len_crc(skb);
  90. I2C_DUMP_SKB("i2c frame written", skb);
  91. r = i2c_master_send(client, skb->data, skb->len);
  92. if (r == -EREMOTEIO) { /* Retry, chip was in standby */
  93. usleep_range(6000, 10000);
  94. r = i2c_master_send(client, skb->data, skb->len);
  95. }
  96. if (r >= 0) {
  97. if (r != skb->len)
  98. r = -EREMOTEIO;
  99. else
  100. r = 0;
  101. }
  102. microread_i2c_remove_len_crc(skb);
  103. return r;
  104. }
  105. static int microread_i2c_read(struct microread_i2c_phy *phy,
  106. struct sk_buff **skb)
  107. {
  108. int r;
  109. u8 len;
  110. u8 tmp[MICROREAD_I2C_LLC_MAX_SIZE - 1];
  111. struct i2c_client *client = phy->i2c_dev;
  112. r = i2c_master_recv(client, &len, 1);
  113. if (r != 1) {
  114. nfc_err(&client->dev, "cannot read len byte\n");
  115. return -EREMOTEIO;
  116. }
  117. if ((len < MICROREAD_I2C_LLC_MIN_SIZE) ||
  118. (len > MICROREAD_I2C_LLC_MAX_SIZE)) {
  119. nfc_err(&client->dev, "invalid len byte\n");
  120. r = -EBADMSG;
  121. goto flush;
  122. }
  123. *skb = alloc_skb(1 + len, GFP_KERNEL);
  124. if (*skb == NULL) {
  125. r = -ENOMEM;
  126. goto flush;
  127. }
  128. skb_put_u8(*skb, len);
  129. r = i2c_master_recv(client, skb_put(*skb, len), len);
  130. if (r != len) {
  131. kfree_skb(*skb);
  132. return -EREMOTEIO;
  133. }
  134. I2C_DUMP_SKB("cc frame read", *skb);
  135. r = check_crc(*skb);
  136. if (r != 0) {
  137. kfree_skb(*skb);
  138. r = -EBADMSG;
  139. goto flush;
  140. }
  141. skb_pull(*skb, 1);
  142. skb_trim(*skb, (*skb)->len - MICROREAD_I2C_FRAME_TAILROOM);
  143. usleep_range(3000, 6000);
  144. return 0;
  145. flush:
  146. if (i2c_master_recv(client, tmp, sizeof(tmp)) < 0)
  147. r = -EREMOTEIO;
  148. usleep_range(3000, 6000);
  149. return r;
  150. }
  151. static irqreturn_t microread_i2c_irq_thread_fn(int irq, void *phy_id)
  152. {
  153. struct microread_i2c_phy *phy = phy_id;
  154. struct sk_buff *skb = NULL;
  155. int r;
  156. if (!phy || irq != phy->i2c_dev->irq) {
  157. WARN_ON_ONCE(1);
  158. return IRQ_NONE;
  159. }
  160. if (phy->hard_fault != 0)
  161. return IRQ_HANDLED;
  162. r = microread_i2c_read(phy, &skb);
  163. if (r == -EREMOTEIO) {
  164. phy->hard_fault = r;
  165. nfc_hci_recv_frame(phy->hdev, NULL);
  166. return IRQ_HANDLED;
  167. } else if ((r == -ENOMEM) || (r == -EBADMSG)) {
  168. return IRQ_HANDLED;
  169. }
  170. nfc_hci_recv_frame(phy->hdev, skb);
  171. return IRQ_HANDLED;
  172. }
  173. static const struct nfc_phy_ops i2c_phy_ops = {
  174. .write = microread_i2c_write,
  175. .enable = microread_i2c_enable,
  176. .disable = microread_i2c_disable,
  177. };
  178. static int microread_i2c_probe(struct i2c_client *client,
  179. const struct i2c_device_id *id)
  180. {
  181. struct microread_i2c_phy *phy;
  182. int r;
  183. phy = devm_kzalloc(&client->dev, sizeof(struct microread_i2c_phy),
  184. GFP_KERNEL);
  185. if (!phy)
  186. return -ENOMEM;
  187. i2c_set_clientdata(client, phy);
  188. phy->i2c_dev = client;
  189. r = request_threaded_irq(client->irq, NULL, microread_i2c_irq_thread_fn,
  190. IRQF_TRIGGER_RISING | IRQF_ONESHOT,
  191. MICROREAD_I2C_DRIVER_NAME, phy);
  192. if (r) {
  193. nfc_err(&client->dev, "Unable to register IRQ handler\n");
  194. return r;
  195. }
  196. r = microread_probe(phy, &i2c_phy_ops, LLC_SHDLC_NAME,
  197. MICROREAD_I2C_FRAME_HEADROOM,
  198. MICROREAD_I2C_FRAME_TAILROOM,
  199. MICROREAD_I2C_LLC_MAX_PAYLOAD, &phy->hdev);
  200. if (r < 0)
  201. goto err_irq;
  202. return 0;
  203. err_irq:
  204. free_irq(client->irq, phy);
  205. return r;
  206. }
  207. static void microread_i2c_remove(struct i2c_client *client)
  208. {
  209. struct microread_i2c_phy *phy = i2c_get_clientdata(client);
  210. microread_remove(phy->hdev);
  211. free_irq(client->irq, phy);
  212. }
  213. static const struct i2c_device_id microread_i2c_id[] = {
  214. { MICROREAD_I2C_DRIVER_NAME, 0},
  215. { }
  216. };
  217. MODULE_DEVICE_TABLE(i2c, microread_i2c_id);
  218. static struct i2c_driver microread_i2c_driver = {
  219. .driver = {
  220. .name = MICROREAD_I2C_DRIVER_NAME,
  221. },
  222. .probe = microread_i2c_probe,
  223. .remove = microread_i2c_remove,
  224. .id_table = microread_i2c_id,
  225. };
  226. module_i2c_driver(microread_i2c_driver);
  227. MODULE_LICENSE("GPL");
  228. MODULE_DESCRIPTION(DRIVER_DESC);