projects/linux·blob master · refs

296 lines · 6.0 KiB

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