1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* ------------------------------------------------------------------------- |
3 | * Copyright (C) 2014-2016, Intel Corporation |
4 | * |
5 | * ------------------------------------------------------------------------- |
6 | */ |
7 | |
8 | #include <linux/module.h> |
9 | #include <linux/acpi.h> |
10 | #include <linux/i2c.h> |
11 | #include <linux/interrupt.h> |
12 | #include <linux/nfc.h> |
13 | #include <linux/delay.h> |
14 | #include <linux/gpio/consumer.h> |
15 | #include <net/nfc/nfc.h> |
16 | #include <net/nfc/nci_core.h> |
17 | |
18 | #include "fdp.h" |
19 | |
20 | #define FDP_I2C_DRIVER_NAME "fdp_nci_i2c" |
21 | |
22 | #define FDP_DP_CLOCK_TYPE_NAME "clock-type" |
23 | #define FDP_DP_CLOCK_FREQ_NAME "clock-freq" |
24 | #define FDP_DP_FW_VSC_CFG_NAME "fw-vsc-cfg" |
25 | |
26 | #define FDP_FRAME_HEADROOM 2 |
27 | #define FDP_FRAME_TAILROOM 1 |
28 | |
29 | #define FDP_NCI_I2C_MIN_PAYLOAD 5 |
30 | #define FDP_NCI_I2C_MAX_PAYLOAD 261 |
31 | |
32 | #define FDP_POWER_OFF 0 |
33 | #define FDP_POWER_ON 1 |
34 | |
35 | #define fdp_nci_i2c_dump_skb(dev, prefix, skb) \ |
36 | print_hex_dump(KERN_DEBUG, prefix": ", DUMP_PREFIX_OFFSET, \ |
37 | 16, 1, (skb)->data, (skb)->len, 0) |
38 | |
39 | static void fdp_nci_i2c_reset(const struct fdp_i2c_phy *phy) |
40 | { |
41 | /* Reset RST/WakeUP for at least 100 micro-second */ |
42 | gpiod_set_value_cansleep(desc: phy->power_gpio, FDP_POWER_OFF); |
43 | usleep_range(min: 1000, max: 4000); |
44 | gpiod_set_value_cansleep(desc: phy->power_gpio, FDP_POWER_ON); |
45 | usleep_range(min: 10000, max: 14000); |
46 | } |
47 | |
48 | static int fdp_nci_i2c_enable(void *phy_id) |
49 | { |
50 | const struct fdp_i2c_phy *phy = phy_id; |
51 | |
52 | fdp_nci_i2c_reset(phy); |
53 | |
54 | return 0; |
55 | } |
56 | |
57 | static void fdp_nci_i2c_disable(void *phy_id) |
58 | { |
59 | const struct fdp_i2c_phy *phy = phy_id; |
60 | |
61 | fdp_nci_i2c_reset(phy); |
62 | } |
63 | |
64 | static void fdp_nci_i2c_add_len_lrc(struct sk_buff *skb) |
65 | { |
66 | u8 lrc = 0; |
67 | u16 len, i; |
68 | |
69 | /* Add length header */ |
70 | len = skb->len; |
71 | *(u8 *)skb_push(skb, len: 1) = len & 0xff; |
72 | *(u8 *)skb_push(skb, len: 1) = len >> 8; |
73 | |
74 | /* Compute and add lrc */ |
75 | for (i = 0; i < len + 2; i++) |
76 | lrc ^= skb->data[i]; |
77 | |
78 | skb_put_u8(skb, val: lrc); |
79 | } |
80 | |
81 | static void fdp_nci_i2c_remove_len_lrc(struct sk_buff *skb) |
82 | { |
83 | skb_pull(skb, FDP_FRAME_HEADROOM); |
84 | skb_trim(skb, len: skb->len - FDP_FRAME_TAILROOM); |
85 | } |
86 | |
87 | static int fdp_nci_i2c_write(void *phy_id, struct sk_buff *skb) |
88 | { |
89 | struct fdp_i2c_phy *phy = phy_id; |
90 | struct i2c_client *client = phy->i2c_dev; |
91 | int r; |
92 | |
93 | if (phy->hard_fault != 0) |
94 | return phy->hard_fault; |
95 | |
96 | fdp_nci_i2c_add_len_lrc(skb); |
97 | fdp_nci_i2c_dump_skb(&client->dev, "fdp_wr" , skb); |
98 | |
99 | r = i2c_master_send(client, buf: skb->data, count: skb->len); |
100 | if (r == -EREMOTEIO) { /* Retry, chip was in standby */ |
101 | usleep_range(min: 1000, max: 4000); |
102 | r = i2c_master_send(client, buf: skb->data, count: skb->len); |
103 | } |
104 | |
105 | if (r < 0 || r != skb->len) |
106 | dev_dbg(&client->dev, "%s: error err=%d len=%d\n" , |
107 | __func__, r, skb->len); |
108 | |
109 | if (r >= 0) { |
110 | if (r != skb->len) { |
111 | phy->hard_fault = r; |
112 | r = -EREMOTEIO; |
113 | } else { |
114 | r = 0; |
115 | } |
116 | } |
117 | |
118 | fdp_nci_i2c_remove_len_lrc(skb); |
119 | |
120 | return r; |
121 | } |
122 | |
123 | static const struct nfc_phy_ops i2c_phy_ops = { |
124 | .write = fdp_nci_i2c_write, |
125 | .enable = fdp_nci_i2c_enable, |
126 | .disable = fdp_nci_i2c_disable, |
127 | }; |
128 | |
129 | static int fdp_nci_i2c_read(struct fdp_i2c_phy *phy, struct sk_buff **skb) |
130 | { |
131 | int r, len; |
132 | u8 tmp[FDP_NCI_I2C_MAX_PAYLOAD], lrc, k; |
133 | u16 i; |
134 | struct i2c_client *client = phy->i2c_dev; |
135 | |
136 | *skb = NULL; |
137 | |
138 | /* Read the length packet and the data packet */ |
139 | for (k = 0; k < 2; k++) { |
140 | |
141 | len = phy->next_read_size; |
142 | |
143 | r = i2c_master_recv(client, buf: tmp, count: len); |
144 | if (r != len) { |
145 | dev_dbg(&client->dev, "%s: i2c recv err: %d\n" , |
146 | __func__, r); |
147 | goto flush; |
148 | } |
149 | |
150 | /* Check packet integruty */ |
151 | for (lrc = i = 0; i < r; i++) |
152 | lrc ^= tmp[i]; |
153 | |
154 | /* |
155 | * LRC check failed. This may due to transmission error or |
156 | * desynchronization between driver and FDP. Drop the packet |
157 | * and force resynchronization |
158 | */ |
159 | if (lrc) { |
160 | dev_dbg(&client->dev, "%s: corrupted packet\n" , |
161 | __func__); |
162 | phy->next_read_size = 5; |
163 | goto flush; |
164 | } |
165 | |
166 | /* Packet that contains a length */ |
167 | if (tmp[0] == 0 && tmp[1] == 0) { |
168 | phy->next_read_size = (tmp[2] << 8) + tmp[3] + 3; |
169 | } else { |
170 | phy->next_read_size = FDP_NCI_I2C_MIN_PAYLOAD; |
171 | |
172 | *skb = alloc_skb(size: len, GFP_KERNEL); |
173 | if (*skb == NULL) { |
174 | r = -ENOMEM; |
175 | goto flush; |
176 | } |
177 | |
178 | skb_put_data(skb: *skb, data: tmp, len); |
179 | fdp_nci_i2c_dump_skb(&client->dev, "fdp_rd" , *skb); |
180 | |
181 | fdp_nci_i2c_remove_len_lrc(skb: *skb); |
182 | } |
183 | } |
184 | |
185 | return 0; |
186 | |
187 | flush: |
188 | /* Flush the remaining data */ |
189 | if (i2c_master_recv(client, buf: tmp, count: sizeof(tmp)) < 0) |
190 | r = -EREMOTEIO; |
191 | |
192 | return r; |
193 | } |
194 | |
195 | static irqreturn_t fdp_nci_i2c_irq_thread_fn(int irq, void *phy_id) |
196 | { |
197 | struct fdp_i2c_phy *phy = phy_id; |
198 | struct sk_buff *skb; |
199 | int r; |
200 | |
201 | if (!phy || irq != phy->i2c_dev->irq) { |
202 | WARN_ON_ONCE(1); |
203 | return IRQ_NONE; |
204 | } |
205 | |
206 | r = fdp_nci_i2c_read(phy, skb: &skb); |
207 | |
208 | if (r == -EREMOTEIO || r == -ENOMEM || r == -EBADMSG) |
209 | return IRQ_HANDLED; |
210 | |
211 | if (skb != NULL) |
212 | nci_recv_frame(ndev: phy->ndev, skb); |
213 | |
214 | return IRQ_HANDLED; |
215 | } |
216 | |
217 | static void fdp_nci_i2c_read_device_properties(struct device *dev, |
218 | u8 *clock_type, u32 *clock_freq, |
219 | u8 **fw_vsc_cfg) |
220 | { |
221 | int r; |
222 | u8 len; |
223 | |
224 | r = device_property_read_u8(dev, FDP_DP_CLOCK_TYPE_NAME, val: clock_type); |
225 | if (r) { |
226 | dev_dbg(dev, "Using default clock type" ); |
227 | *clock_type = 0; |
228 | } |
229 | |
230 | r = device_property_read_u32(dev, FDP_DP_CLOCK_FREQ_NAME, val: clock_freq); |
231 | if (r) { |
232 | dev_dbg(dev, "Using default clock frequency\n" ); |
233 | *clock_freq = 26000; |
234 | } |
235 | |
236 | if (device_property_present(dev, FDP_DP_FW_VSC_CFG_NAME)) { |
237 | r = device_property_read_u8(dev, FDP_DP_FW_VSC_CFG_NAME, |
238 | val: &len); |
239 | |
240 | if (r || len <= 0) |
241 | goto vsc_read_err; |
242 | |
243 | /* Add 1 to the length to inclue the length byte itself */ |
244 | len++; |
245 | |
246 | *fw_vsc_cfg = devm_kmalloc_array(dev, |
247 | n: len, size: sizeof(**fw_vsc_cfg), |
248 | GFP_KERNEL); |
249 | |
250 | if (!*fw_vsc_cfg) |
251 | goto alloc_err; |
252 | |
253 | r = device_property_read_u8_array(dev, FDP_DP_FW_VSC_CFG_NAME, |
254 | val: *fw_vsc_cfg, nval: len); |
255 | |
256 | if (r) { |
257 | devm_kfree(dev, p: *fw_vsc_cfg); |
258 | goto vsc_read_err; |
259 | } |
260 | } else { |
261 | vsc_read_err: |
262 | dev_dbg(dev, "FW vendor specific commands not present\n" ); |
263 | *fw_vsc_cfg = NULL; |
264 | } |
265 | |
266 | alloc_err: |
267 | dev_dbg(dev, "Clock type: %d, clock frequency: %d, VSC: %s" , |
268 | *clock_type, *clock_freq, *fw_vsc_cfg != NULL ? "yes" : "no" ); |
269 | } |
270 | |
271 | static const struct acpi_gpio_params power_gpios = { 0, 0, false }; |
272 | |
273 | static const struct acpi_gpio_mapping acpi_fdp_gpios[] = { |
274 | { "power-gpios" , &power_gpios, 1 }, |
275 | {}, |
276 | }; |
277 | |
278 | static int fdp_nci_i2c_probe(struct i2c_client *client) |
279 | { |
280 | struct fdp_i2c_phy *phy; |
281 | struct device *dev = &client->dev; |
282 | u8 *fw_vsc_cfg; |
283 | u8 clock_type; |
284 | u32 clock_freq; |
285 | int r = 0; |
286 | |
287 | if (!i2c_check_functionality(adap: client->adapter, I2C_FUNC_I2C)) { |
288 | nfc_err(dev, "No I2C_FUNC_I2C support\n" ); |
289 | return -ENODEV; |
290 | } |
291 | |
292 | /* Checking if we have an irq */ |
293 | if (client->irq <= 0) { |
294 | nfc_err(dev, "IRQ not present\n" ); |
295 | return -ENODEV; |
296 | } |
297 | |
298 | phy = devm_kzalloc(dev, size: sizeof(struct fdp_i2c_phy), GFP_KERNEL); |
299 | if (!phy) |
300 | return -ENOMEM; |
301 | |
302 | phy->i2c_dev = client; |
303 | phy->next_read_size = FDP_NCI_I2C_MIN_PAYLOAD; |
304 | i2c_set_clientdata(client, data: phy); |
305 | |
306 | r = devm_request_threaded_irq(dev, irq: client->irq, |
307 | NULL, thread_fn: fdp_nci_i2c_irq_thread_fn, |
308 | IRQF_TRIGGER_RISING | IRQF_ONESHOT, |
309 | FDP_I2C_DRIVER_NAME, dev_id: phy); |
310 | |
311 | if (r < 0) { |
312 | nfc_err(&client->dev, "Unable to register IRQ handler\n" ); |
313 | return r; |
314 | } |
315 | |
316 | r = devm_acpi_dev_add_driver_gpios(dev, gpios: acpi_fdp_gpios); |
317 | if (r) |
318 | dev_dbg(dev, "Unable to add GPIO mapping table\n" ); |
319 | |
320 | /* Requesting the power gpio */ |
321 | phy->power_gpio = devm_gpiod_get(dev, con_id: "power" , flags: GPIOD_OUT_LOW); |
322 | if (IS_ERR(ptr: phy->power_gpio)) { |
323 | nfc_err(dev, "Power GPIO request failed\n" ); |
324 | return PTR_ERR(ptr: phy->power_gpio); |
325 | } |
326 | |
327 | /* read device properties to get the clock and production settings */ |
328 | fdp_nci_i2c_read_device_properties(dev, clock_type: &clock_type, clock_freq: &clock_freq, |
329 | fw_vsc_cfg: &fw_vsc_cfg); |
330 | |
331 | /* Call the NFC specific probe function */ |
332 | r = fdp_nci_probe(phy, phy_ops: &i2c_phy_ops, ndev: &phy->ndev, |
333 | FDP_FRAME_HEADROOM, FDP_FRAME_TAILROOM, |
334 | clock_type, clock_freq, fw_vsc_cfg); |
335 | if (r < 0) { |
336 | nfc_err(dev, "NCI probing error\n" ); |
337 | return r; |
338 | } |
339 | |
340 | return 0; |
341 | } |
342 | |
343 | static void fdp_nci_i2c_remove(struct i2c_client *client) |
344 | { |
345 | struct fdp_i2c_phy *phy = i2c_get_clientdata(client); |
346 | |
347 | fdp_nci_remove(ndev: phy->ndev); |
348 | fdp_nci_i2c_disable(phy_id: phy); |
349 | } |
350 | |
351 | static const struct acpi_device_id fdp_nci_i2c_acpi_match[] = { |
352 | {"INT339A" , 0}, |
353 | {} |
354 | }; |
355 | MODULE_DEVICE_TABLE(acpi, fdp_nci_i2c_acpi_match); |
356 | |
357 | static struct i2c_driver fdp_nci_i2c_driver = { |
358 | .driver = { |
359 | .name = FDP_I2C_DRIVER_NAME, |
360 | .acpi_match_table = fdp_nci_i2c_acpi_match, |
361 | }, |
362 | .probe = fdp_nci_i2c_probe, |
363 | .remove = fdp_nci_i2c_remove, |
364 | }; |
365 | module_i2c_driver(fdp_nci_i2c_driver); |
366 | |
367 | MODULE_LICENSE("GPL" ); |
368 | MODULE_DESCRIPTION("I2C driver for Intel Fields Peak NFC controller" ); |
369 | MODULE_AUTHOR("Robert Dolca <robert.dolca@intel.com>" ); |
370 | |