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/nfc.h> |
10 | #include <linux/i2c.h> |
11 | #include <linux/delay.h> |
12 | #include <linux/firmware.h> |
13 | #include <net/nfc/nci_core.h> |
14 | |
15 | #include "fdp.h" |
16 | |
17 | #define FDP_OTP_PATCH_NAME "otp.bin" |
18 | #define FDP_RAM_PATCH_NAME "ram.bin" |
19 | #define 576 |
20 | #define FDP_FW_UPDATE_SLEEP 1000 |
21 | |
22 | #define NCI_GET_VERSION_TIMEOUT 8000 |
23 | #define NCI_PATCH_REQUEST_TIMEOUT 8000 |
24 | #define FDP_PATCH_CONN_DEST 0xC2 |
25 | #define FDP_PATCH_CONN_PARAM_TYPE 0xA0 |
26 | |
27 | #define NCI_PATCH_TYPE_RAM 0x00 |
28 | #define NCI_PATCH_TYPE_OTP 0x01 |
29 | #define NCI_PATCH_TYPE_EOT 0xFF |
30 | |
31 | #define NCI_PARAM_ID_FW_RAM_VERSION 0xA0 |
32 | #define NCI_PARAM_ID_FW_OTP_VERSION 0xA1 |
33 | #define NCI_PARAM_ID_OTP_LIMITED_VERSION 0xC5 |
34 | #define NCI_PARAM_ID_KEY_INDEX_ID 0xC6 |
35 | |
36 | #define NCI_GID_PROP 0x0F |
37 | #define NCI_OP_PROP_PATCH_OID 0x08 |
38 | #define NCI_OP_PROP_SET_PDATA_OID 0x23 |
39 | |
40 | struct fdp_nci_info { |
41 | const struct nfc_phy_ops *phy_ops; |
42 | struct fdp_i2c_phy *phy; |
43 | struct nci_dev *ndev; |
44 | |
45 | const struct firmware *otp_patch; |
46 | const struct firmware *ram_patch; |
47 | u32 otp_patch_version; |
48 | u32 ram_patch_version; |
49 | |
50 | u32 otp_version; |
51 | u32 ram_version; |
52 | u32 limited_otp_version; |
53 | u8 key_index; |
54 | |
55 | const u8 *fw_vsc_cfg; |
56 | u8 clock_type; |
57 | u32 clock_freq; |
58 | |
59 | atomic_t data_pkt_counter; |
60 | void (*data_pkt_counter_cb)(struct nci_dev *ndev); |
61 | u8 setup_patch_sent; |
62 | u8 setup_patch_ntf; |
63 | u8 setup_patch_status; |
64 | u8 setup_reset_ntf; |
65 | wait_queue_head_t setup_wq; |
66 | }; |
67 | |
68 | static const u8 nci_core_get_config_otp_ram_version[5] = { |
69 | 0x04, |
70 | NCI_PARAM_ID_FW_RAM_VERSION, |
71 | NCI_PARAM_ID_FW_OTP_VERSION, |
72 | NCI_PARAM_ID_OTP_LIMITED_VERSION, |
73 | NCI_PARAM_ID_KEY_INDEX_ID |
74 | }; |
75 | |
76 | struct nci_core_get_config_rsp { |
77 | u8 status; |
78 | u8 count; |
79 | u8 data[]; |
80 | }; |
81 | |
82 | static int fdp_nci_create_conn(struct nci_dev *ndev) |
83 | { |
84 | struct fdp_nci_info *info = nci_get_drvdata(ndev); |
85 | struct core_conn_create_dest_spec_params param; |
86 | int r; |
87 | |
88 | /* proprietary destination specific paramerer without value */ |
89 | param.type = FDP_PATCH_CONN_PARAM_TYPE; |
90 | param.length = 0x00; |
91 | |
92 | r = nci_core_conn_create(ndev: info->ndev, FDP_PATCH_CONN_DEST, number_destination_params: 1, |
93 | params_len: sizeof(param), params: ¶m); |
94 | if (r) |
95 | return r; |
96 | |
97 | return nci_get_conn_info_by_dest_type_params(ndev, |
98 | FDP_PATCH_CONN_DEST, NULL); |
99 | } |
100 | |
101 | static inline int fdp_nci_get_versions(struct nci_dev *ndev) |
102 | { |
103 | return nci_core_cmd(ndev, NCI_OP_CORE_GET_CONFIG_CMD, |
104 | len: sizeof(nci_core_get_config_otp_ram_version), |
105 | payload: (__u8 *) &nci_core_get_config_otp_ram_version); |
106 | } |
107 | |
108 | static inline int fdp_nci_patch_cmd(struct nci_dev *ndev, u8 type) |
109 | { |
110 | return nci_prop_cmd(ndev, NCI_OP_PROP_PATCH_OID, len: sizeof(type), payload: &type); |
111 | } |
112 | |
113 | static inline int fdp_nci_set_production_data(struct nci_dev *ndev, u8 len, |
114 | const char *data) |
115 | { |
116 | return nci_prop_cmd(ndev, NCI_OP_PROP_SET_PDATA_OID, len, payload: data); |
117 | } |
118 | |
119 | static int fdp_nci_set_clock(struct nci_dev *ndev, u8 clock_type, |
120 | u32 clock_freq) |
121 | { |
122 | u32 fc = 13560; |
123 | u32 nd, num, delta; |
124 | char data[9]; |
125 | |
126 | nd = (24 * fc) / clock_freq; |
127 | delta = 24 * fc - nd * clock_freq; |
128 | num = (32768 * delta) / clock_freq; |
129 | |
130 | data[0] = 0x00; |
131 | data[1] = 0x00; |
132 | data[2] = 0x00; |
133 | |
134 | data[3] = 0x10; |
135 | data[4] = 0x04; |
136 | data[5] = num & 0xFF; |
137 | data[6] = (num >> 8) & 0xff; |
138 | data[7] = nd; |
139 | data[8] = clock_type; |
140 | |
141 | return fdp_nci_set_production_data(ndev, len: 9, data); |
142 | } |
143 | |
144 | static void fdp_nci_send_patch_cb(struct nci_dev *ndev) |
145 | { |
146 | struct fdp_nci_info *info = nci_get_drvdata(ndev); |
147 | |
148 | info->setup_patch_sent = 1; |
149 | wake_up(&info->setup_wq); |
150 | } |
151 | |
152 | /* |
153 | * Register a packet sent counter and a callback |
154 | * |
155 | * We have no other way of knowing when all firmware packets were sent out |
156 | * on the i2c bus. We need to know that in order to close the connection and |
157 | * send the patch end message. |
158 | */ |
159 | static void fdp_nci_set_data_pkt_counter(struct nci_dev *ndev, |
160 | void (*cb)(struct nci_dev *ndev), int count) |
161 | { |
162 | struct fdp_nci_info *info = nci_get_drvdata(ndev); |
163 | struct device *dev = &info->phy->i2c_dev->dev; |
164 | |
165 | dev_dbg(dev, "NCI data pkt counter %d\n" , count); |
166 | atomic_set(v: &info->data_pkt_counter, i: count); |
167 | info->data_pkt_counter_cb = cb; |
168 | } |
169 | |
170 | /* |
171 | * The device is expecting a stream of packets. All packets need to |
172 | * have the PBF flag set to 0x0 (last packet) even if the firmware |
173 | * file is segmented and there are multiple packets. If we give the |
174 | * whole firmware to nci_send_data it will segment it and it will set |
175 | * the PBF flag to 0x01 so we need to do the segmentation here. |
176 | * |
177 | * The firmware will be analyzed and applied when we send NCI_OP_PROP_PATCH_CMD |
178 | * command with NCI_PATCH_TYPE_EOT parameter. The device will send a |
179 | * NFCC_PATCH_NTF packet and a NCI_OP_CORE_RESET_NTF packet. |
180 | */ |
181 | static int fdp_nci_send_patch(struct nci_dev *ndev, u8 conn_id, u8 type) |
182 | { |
183 | struct fdp_nci_info *info = nci_get_drvdata(ndev); |
184 | const struct firmware *fw; |
185 | struct sk_buff *skb; |
186 | unsigned long len; |
187 | int max_size, payload_size; |
188 | int rc = 0; |
189 | |
190 | if ((type == NCI_PATCH_TYPE_OTP && !info->otp_patch) || |
191 | (type == NCI_PATCH_TYPE_RAM && !info->ram_patch)) |
192 | return -EINVAL; |
193 | |
194 | if (type == NCI_PATCH_TYPE_OTP) |
195 | fw = info->otp_patch; |
196 | else |
197 | fw = info->ram_patch; |
198 | |
199 | max_size = nci_conn_max_data_pkt_payload_size(ndev, conn_id); |
200 | if (max_size <= 0) |
201 | return -EINVAL; |
202 | |
203 | len = fw->size; |
204 | |
205 | fdp_nci_set_data_pkt_counter(ndev, cb: fdp_nci_send_patch_cb, |
206 | DIV_ROUND_UP(fw->size, max_size)); |
207 | |
208 | while (len) { |
209 | |
210 | payload_size = min_t(unsigned long, max_size, len); |
211 | |
212 | skb = nci_skb_alloc(ndev, len: (NCI_CTRL_HDR_SIZE + payload_size), |
213 | GFP_KERNEL); |
214 | if (!skb) { |
215 | fdp_nci_set_data_pkt_counter(ndev, NULL, count: 0); |
216 | return -ENOMEM; |
217 | } |
218 | |
219 | |
220 | skb_reserve(skb, NCI_CTRL_HDR_SIZE); |
221 | |
222 | skb_put_data(skb, data: fw->data + (fw->size - len), len: payload_size); |
223 | |
224 | rc = nci_send_data(ndev, conn_id, skb); |
225 | |
226 | if (rc) { |
227 | fdp_nci_set_data_pkt_counter(ndev, NULL, count: 0); |
228 | return rc; |
229 | } |
230 | |
231 | len -= payload_size; |
232 | } |
233 | |
234 | return rc; |
235 | } |
236 | |
237 | static int fdp_nci_open(struct nci_dev *ndev) |
238 | { |
239 | const struct fdp_nci_info *info = nci_get_drvdata(ndev); |
240 | |
241 | return info->phy_ops->enable(info->phy); |
242 | } |
243 | |
244 | static int fdp_nci_close(struct nci_dev *ndev) |
245 | { |
246 | return 0; |
247 | } |
248 | |
249 | static int fdp_nci_send(struct nci_dev *ndev, struct sk_buff *skb) |
250 | { |
251 | struct fdp_nci_info *info = nci_get_drvdata(ndev); |
252 | int ret; |
253 | |
254 | if (atomic_dec_and_test(v: &info->data_pkt_counter)) |
255 | info->data_pkt_counter_cb(ndev); |
256 | |
257 | ret = info->phy_ops->write(info->phy, skb); |
258 | if (ret < 0) { |
259 | kfree_skb(skb); |
260 | return ret; |
261 | } |
262 | |
263 | consume_skb(skb); |
264 | return 0; |
265 | } |
266 | |
267 | static int fdp_nci_request_firmware(struct nci_dev *ndev) |
268 | { |
269 | struct fdp_nci_info *info = nci_get_drvdata(ndev); |
270 | struct device *dev = &info->phy->i2c_dev->dev; |
271 | const u8 *data; |
272 | int r; |
273 | |
274 | r = request_firmware(fw: &info->ram_patch, FDP_RAM_PATCH_NAME, device: dev); |
275 | if (r < 0) { |
276 | nfc_err(dev, "RAM patch request error\n" ); |
277 | return r; |
278 | } |
279 | |
280 | data = info->ram_patch->data; |
281 | info->ram_patch_version = |
282 | data[FDP_FW_HEADER_SIZE] | |
283 | (data[FDP_FW_HEADER_SIZE + 1] << 8) | |
284 | (data[FDP_FW_HEADER_SIZE + 2] << 16) | |
285 | (data[FDP_FW_HEADER_SIZE + 3] << 24); |
286 | |
287 | dev_dbg(dev, "RAM patch version: %d, size: %zu\n" , |
288 | info->ram_patch_version, info->ram_patch->size); |
289 | |
290 | |
291 | r = request_firmware(fw: &info->otp_patch, FDP_OTP_PATCH_NAME, device: dev); |
292 | if (r < 0) { |
293 | nfc_err(dev, "OTP patch request error\n" ); |
294 | return 0; |
295 | } |
296 | |
297 | data = (u8 *) info->otp_patch->data; |
298 | info->otp_patch_version = |
299 | data[FDP_FW_HEADER_SIZE] | |
300 | (data[FDP_FW_HEADER_SIZE + 1] << 8) | |
301 | (data[FDP_FW_HEADER_SIZE+2] << 16) | |
302 | (data[FDP_FW_HEADER_SIZE+3] << 24); |
303 | |
304 | dev_dbg(dev, "OTP patch version: %d, size: %zu\n" , |
305 | info->otp_patch_version, info->otp_patch->size); |
306 | return 0; |
307 | } |
308 | |
309 | static void fdp_nci_release_firmware(struct nci_dev *ndev) |
310 | { |
311 | struct fdp_nci_info *info = nci_get_drvdata(ndev); |
312 | |
313 | if (info->otp_patch) { |
314 | release_firmware(fw: info->otp_patch); |
315 | info->otp_patch = NULL; |
316 | } |
317 | |
318 | if (info->ram_patch) { |
319 | release_firmware(fw: info->ram_patch); |
320 | info->ram_patch = NULL; |
321 | } |
322 | } |
323 | |
324 | static int fdp_nci_patch_otp(struct nci_dev *ndev) |
325 | { |
326 | struct fdp_nci_info *info = nci_get_drvdata(ndev); |
327 | struct device *dev = &info->phy->i2c_dev->dev; |
328 | int conn_id; |
329 | int r = 0; |
330 | |
331 | if (info->otp_version >= info->otp_patch_version) |
332 | return r; |
333 | |
334 | info->setup_patch_sent = 0; |
335 | info->setup_reset_ntf = 0; |
336 | info->setup_patch_ntf = 0; |
337 | |
338 | /* Patch init request */ |
339 | r = fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_OTP); |
340 | if (r) |
341 | return r; |
342 | |
343 | /* Patch data connection creation */ |
344 | conn_id = fdp_nci_create_conn(ndev); |
345 | if (conn_id < 0) |
346 | return conn_id; |
347 | |
348 | /* Send the patch over the data connection */ |
349 | r = fdp_nci_send_patch(ndev, conn_id, NCI_PATCH_TYPE_OTP); |
350 | if (r) |
351 | return r; |
352 | |
353 | /* Wait for all the packets to be send over i2c */ |
354 | wait_event_interruptible(info->setup_wq, |
355 | info->setup_patch_sent == 1); |
356 | |
357 | /* make sure that the NFCC processed the last data packet */ |
358 | msleep(FDP_FW_UPDATE_SLEEP); |
359 | |
360 | /* Close the data connection */ |
361 | r = nci_core_conn_close(ndev: info->ndev, conn_id); |
362 | if (r) |
363 | return r; |
364 | |
365 | /* Patch finish message */ |
366 | if (fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_EOT)) { |
367 | nfc_err(dev, "OTP patch error 0x%x\n" , r); |
368 | return -EINVAL; |
369 | } |
370 | |
371 | /* If the patch notification didn't arrive yet, wait for it */ |
372 | wait_event_interruptible(info->setup_wq, info->setup_patch_ntf); |
373 | |
374 | /* Check if the patching was successful */ |
375 | r = info->setup_patch_status; |
376 | if (r) { |
377 | nfc_err(dev, "OTP patch error 0x%x\n" , r); |
378 | return -EINVAL; |
379 | } |
380 | |
381 | /* |
382 | * We need to wait for the reset notification before we |
383 | * can continue |
384 | */ |
385 | wait_event_interruptible(info->setup_wq, info->setup_reset_ntf); |
386 | |
387 | return r; |
388 | } |
389 | |
390 | static int fdp_nci_patch_ram(struct nci_dev *ndev) |
391 | { |
392 | struct fdp_nci_info *info = nci_get_drvdata(ndev); |
393 | struct device *dev = &info->phy->i2c_dev->dev; |
394 | int conn_id; |
395 | int r = 0; |
396 | |
397 | if (info->ram_version >= info->ram_patch_version) |
398 | return r; |
399 | |
400 | info->setup_patch_sent = 0; |
401 | info->setup_reset_ntf = 0; |
402 | info->setup_patch_ntf = 0; |
403 | |
404 | /* Patch init request */ |
405 | r = fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_RAM); |
406 | if (r) |
407 | return r; |
408 | |
409 | /* Patch data connection creation */ |
410 | conn_id = fdp_nci_create_conn(ndev); |
411 | if (conn_id < 0) |
412 | return conn_id; |
413 | |
414 | /* Send the patch over the data connection */ |
415 | r = fdp_nci_send_patch(ndev, conn_id, NCI_PATCH_TYPE_RAM); |
416 | if (r) |
417 | return r; |
418 | |
419 | /* Wait for all the packets to be send over i2c */ |
420 | wait_event_interruptible(info->setup_wq, |
421 | info->setup_patch_sent == 1); |
422 | |
423 | /* make sure that the NFCC processed the last data packet */ |
424 | msleep(FDP_FW_UPDATE_SLEEP); |
425 | |
426 | /* Close the data connection */ |
427 | r = nci_core_conn_close(ndev: info->ndev, conn_id); |
428 | if (r) |
429 | return r; |
430 | |
431 | /* Patch finish message */ |
432 | if (fdp_nci_patch_cmd(ndev, NCI_PATCH_TYPE_EOT)) { |
433 | nfc_err(dev, "RAM patch error 0x%x\n" , r); |
434 | return -EINVAL; |
435 | } |
436 | |
437 | /* If the patch notification didn't arrive yet, wait for it */ |
438 | wait_event_interruptible(info->setup_wq, info->setup_patch_ntf); |
439 | |
440 | /* Check if the patching was successful */ |
441 | r = info->setup_patch_status; |
442 | if (r) { |
443 | nfc_err(dev, "RAM patch error 0x%x\n" , r); |
444 | return -EINVAL; |
445 | } |
446 | |
447 | /* |
448 | * We need to wait for the reset notification before we |
449 | * can continue |
450 | */ |
451 | wait_event_interruptible(info->setup_wq, info->setup_reset_ntf); |
452 | |
453 | return r; |
454 | } |
455 | |
456 | static int fdp_nci_setup(struct nci_dev *ndev) |
457 | { |
458 | /* Format: total length followed by an NCI packet */ |
459 | struct fdp_nci_info *info = nci_get_drvdata(ndev); |
460 | struct device *dev = &info->phy->i2c_dev->dev; |
461 | int r; |
462 | u8 patched = 0; |
463 | |
464 | r = nci_core_init(ndev); |
465 | if (r) |
466 | goto error; |
467 | |
468 | /* Get RAM and OTP version */ |
469 | r = fdp_nci_get_versions(ndev); |
470 | if (r) |
471 | goto error; |
472 | |
473 | /* Load firmware from disk */ |
474 | r = fdp_nci_request_firmware(ndev); |
475 | if (r) |
476 | goto error; |
477 | |
478 | /* Update OTP */ |
479 | if (info->otp_version < info->otp_patch_version) { |
480 | r = fdp_nci_patch_otp(ndev); |
481 | if (r) |
482 | goto error; |
483 | patched = 1; |
484 | } |
485 | |
486 | /* Update RAM */ |
487 | if (info->ram_version < info->ram_patch_version) { |
488 | r = fdp_nci_patch_ram(ndev); |
489 | if (r) |
490 | goto error; |
491 | patched = 1; |
492 | } |
493 | |
494 | /* Release the firmware buffers */ |
495 | fdp_nci_release_firmware(ndev); |
496 | |
497 | /* If a patch was applied the new version is checked */ |
498 | if (patched) { |
499 | r = nci_core_init(ndev); |
500 | if (r) |
501 | goto error; |
502 | |
503 | r = fdp_nci_get_versions(ndev); |
504 | if (r) |
505 | goto error; |
506 | |
507 | if (info->otp_version != info->otp_patch_version || |
508 | info->ram_version != info->ram_patch_version) { |
509 | nfc_err(dev, "Firmware update failed" ); |
510 | r = -EINVAL; |
511 | goto error; |
512 | } |
513 | } |
514 | |
515 | /* |
516 | * We initialized the devices but the NFC subsystem expects |
517 | * it to not be initialized. |
518 | */ |
519 | return nci_core_reset(ndev); |
520 | |
521 | error: |
522 | fdp_nci_release_firmware(ndev); |
523 | nfc_err(dev, "Setup error %d\n" , r); |
524 | return r; |
525 | } |
526 | |
527 | static int fdp_nci_post_setup(struct nci_dev *ndev) |
528 | { |
529 | struct fdp_nci_info *info = nci_get_drvdata(ndev); |
530 | struct device *dev = &info->phy->i2c_dev->dev; |
531 | int r; |
532 | |
533 | /* Check if the device has VSC */ |
534 | if (info->fw_vsc_cfg && info->fw_vsc_cfg[0]) { |
535 | |
536 | /* Set the vendor specific configuration */ |
537 | r = fdp_nci_set_production_data(ndev, len: info->fw_vsc_cfg[3], |
538 | data: &info->fw_vsc_cfg[4]); |
539 | if (r) { |
540 | nfc_err(dev, "Vendor specific config set error %d\n" , |
541 | r); |
542 | return r; |
543 | } |
544 | } |
545 | |
546 | /* Set clock type and frequency */ |
547 | r = fdp_nci_set_clock(ndev, clock_type: info->clock_type, clock_freq: info->clock_freq); |
548 | if (r) { |
549 | nfc_err(dev, "Clock set error %d\n" , r); |
550 | return r; |
551 | } |
552 | |
553 | /* |
554 | * In order to apply the VSC FDP needs a reset |
555 | */ |
556 | r = nci_core_reset(ndev); |
557 | if (r) |
558 | return r; |
559 | |
560 | /** |
561 | * The nci core was initialized when post setup was called |
562 | * so we leave it like that |
563 | */ |
564 | return nci_core_init(ndev); |
565 | } |
566 | |
567 | static int fdp_nci_core_reset_ntf_packet(struct nci_dev *ndev, |
568 | struct sk_buff *skb) |
569 | { |
570 | struct fdp_nci_info *info = nci_get_drvdata(ndev); |
571 | |
572 | info->setup_reset_ntf = 1; |
573 | wake_up(&info->setup_wq); |
574 | |
575 | return 0; |
576 | } |
577 | |
578 | static int fdp_nci_prop_patch_ntf_packet(struct nci_dev *ndev, |
579 | struct sk_buff *skb) |
580 | { |
581 | struct fdp_nci_info *info = nci_get_drvdata(ndev); |
582 | |
583 | info->setup_patch_ntf = 1; |
584 | info->setup_patch_status = skb->data[0]; |
585 | wake_up(&info->setup_wq); |
586 | |
587 | return 0; |
588 | } |
589 | |
590 | static int fdp_nci_prop_patch_rsp_packet(struct nci_dev *ndev, |
591 | struct sk_buff *skb) |
592 | { |
593 | struct fdp_nci_info *info = nci_get_drvdata(ndev); |
594 | struct device *dev = &info->phy->i2c_dev->dev; |
595 | u8 status = skb->data[0]; |
596 | |
597 | dev_dbg(dev, "%s: status 0x%x\n" , __func__, status); |
598 | nci_req_complete(ndev, result: status); |
599 | |
600 | return 0; |
601 | } |
602 | |
603 | static int fdp_nci_prop_set_production_data_rsp_packet(struct nci_dev *ndev, |
604 | struct sk_buff *skb) |
605 | { |
606 | struct fdp_nci_info *info = nci_get_drvdata(ndev); |
607 | struct device *dev = &info->phy->i2c_dev->dev; |
608 | u8 status = skb->data[0]; |
609 | |
610 | dev_dbg(dev, "%s: status 0x%x\n" , __func__, status); |
611 | nci_req_complete(ndev, result: status); |
612 | |
613 | return 0; |
614 | } |
615 | |
616 | static int fdp_nci_core_get_config_rsp_packet(struct nci_dev *ndev, |
617 | struct sk_buff *skb) |
618 | { |
619 | struct fdp_nci_info *info = nci_get_drvdata(ndev); |
620 | struct device *dev = &info->phy->i2c_dev->dev; |
621 | const struct nci_core_get_config_rsp *rsp = (void *) skb->data; |
622 | unsigned int i; |
623 | const u8 *p; |
624 | |
625 | if (rsp->status == NCI_STATUS_OK) { |
626 | |
627 | p = rsp->data; |
628 | for (i = 0; i < 4; i++) { |
629 | |
630 | switch (*p++) { |
631 | case NCI_PARAM_ID_FW_RAM_VERSION: |
632 | p++; |
633 | info->ram_version = le32_to_cpup(p: (__le32 *) p); |
634 | p += 4; |
635 | break; |
636 | case NCI_PARAM_ID_FW_OTP_VERSION: |
637 | p++; |
638 | info->otp_version = le32_to_cpup(p: (__le32 *) p); |
639 | p += 4; |
640 | break; |
641 | case NCI_PARAM_ID_OTP_LIMITED_VERSION: |
642 | p++; |
643 | info->otp_version = le32_to_cpup(p: (__le32 *) p); |
644 | p += 4; |
645 | break; |
646 | case NCI_PARAM_ID_KEY_INDEX_ID: |
647 | p++; |
648 | info->key_index = *p++; |
649 | } |
650 | } |
651 | } |
652 | |
653 | dev_dbg(dev, "OTP version %d\n" , info->otp_version); |
654 | dev_dbg(dev, "RAM version %d\n" , info->ram_version); |
655 | dev_dbg(dev, "key index %d\n" , info->key_index); |
656 | dev_dbg(dev, "%s: status 0x%x\n" , __func__, rsp->status); |
657 | |
658 | nci_req_complete(ndev, result: rsp->status); |
659 | |
660 | return 0; |
661 | } |
662 | |
663 | static const struct nci_driver_ops fdp_core_ops[] = { |
664 | { |
665 | .opcode = NCI_OP_CORE_GET_CONFIG_RSP, |
666 | .rsp = fdp_nci_core_get_config_rsp_packet, |
667 | }, |
668 | { |
669 | .opcode = NCI_OP_CORE_RESET_NTF, |
670 | .ntf = fdp_nci_core_reset_ntf_packet, |
671 | }, |
672 | }; |
673 | |
674 | static const struct nci_driver_ops fdp_prop_ops[] = { |
675 | { |
676 | .opcode = nci_opcode_pack(NCI_GID_PROP, NCI_OP_PROP_PATCH_OID), |
677 | .rsp = fdp_nci_prop_patch_rsp_packet, |
678 | .ntf = fdp_nci_prop_patch_ntf_packet, |
679 | }, |
680 | { |
681 | .opcode = nci_opcode_pack(NCI_GID_PROP, |
682 | NCI_OP_PROP_SET_PDATA_OID), |
683 | .rsp = fdp_nci_prop_set_production_data_rsp_packet, |
684 | }, |
685 | }; |
686 | |
687 | static const struct nci_ops nci_ops = { |
688 | .open = fdp_nci_open, |
689 | .close = fdp_nci_close, |
690 | .send = fdp_nci_send, |
691 | .setup = fdp_nci_setup, |
692 | .post_setup = fdp_nci_post_setup, |
693 | .prop_ops = fdp_prop_ops, |
694 | .n_prop_ops = ARRAY_SIZE(fdp_prop_ops), |
695 | .core_ops = fdp_core_ops, |
696 | .n_core_ops = ARRAY_SIZE(fdp_core_ops), |
697 | }; |
698 | |
699 | int fdp_nci_probe(struct fdp_i2c_phy *phy, const struct nfc_phy_ops *phy_ops, |
700 | struct nci_dev **ndevp, int tx_headroom, |
701 | int tx_tailroom, u8 clock_type, u32 clock_freq, |
702 | const u8 *fw_vsc_cfg) |
703 | { |
704 | struct device *dev = &phy->i2c_dev->dev; |
705 | struct fdp_nci_info *info; |
706 | struct nci_dev *ndev; |
707 | u32 protocols; |
708 | int r; |
709 | |
710 | info = devm_kzalloc(dev, size: sizeof(struct fdp_nci_info), GFP_KERNEL); |
711 | if (!info) |
712 | return -ENOMEM; |
713 | |
714 | info->phy = phy; |
715 | info->phy_ops = phy_ops; |
716 | info->clock_type = clock_type; |
717 | info->clock_freq = clock_freq; |
718 | info->fw_vsc_cfg = fw_vsc_cfg; |
719 | |
720 | init_waitqueue_head(&info->setup_wq); |
721 | |
722 | protocols = NFC_PROTO_JEWEL_MASK | |
723 | NFC_PROTO_MIFARE_MASK | |
724 | NFC_PROTO_FELICA_MASK | |
725 | NFC_PROTO_ISO14443_MASK | |
726 | NFC_PROTO_ISO14443_B_MASK | |
727 | NFC_PROTO_NFC_DEP_MASK | |
728 | NFC_PROTO_ISO15693_MASK; |
729 | |
730 | BUILD_BUG_ON(ARRAY_SIZE(fdp_prop_ops) > NCI_MAX_PROPRIETARY_CMD); |
731 | ndev = nci_allocate_device(ops: &nci_ops, supported_protocols: protocols, tx_headroom, |
732 | tx_tailroom); |
733 | if (!ndev) { |
734 | nfc_err(dev, "Cannot allocate nfc ndev\n" ); |
735 | return -ENOMEM; |
736 | } |
737 | |
738 | r = nci_register_device(ndev); |
739 | if (r) |
740 | goto err_regdev; |
741 | |
742 | *ndevp = ndev; |
743 | info->ndev = ndev; |
744 | |
745 | nci_set_drvdata(ndev, data: info); |
746 | |
747 | return 0; |
748 | |
749 | err_regdev: |
750 | nci_free_device(ndev); |
751 | return r; |
752 | } |
753 | EXPORT_SYMBOL(fdp_nci_probe); |
754 | |
755 | void fdp_nci_remove(struct nci_dev *ndev) |
756 | { |
757 | nci_unregister_device(ndev); |
758 | nci_free_device(ndev); |
759 | } |
760 | EXPORT_SYMBOL(fdp_nci_remove); |
761 | |
762 | MODULE_LICENSE("GPL" ); |
763 | MODULE_DESCRIPTION("NFC NCI driver for Intel Fields Peak NFC controller" ); |
764 | MODULE_AUTHOR("Robert Dolca <robert.dolca@intel.com>" ); |
765 | |
766 | MODULE_FIRMWARE(FDP_OTP_PATCH_NAME); |
767 | MODULE_FIRMWARE(FDP_RAM_PATCH_NAME); |
768 | |