1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
29
30#include <linux/types.h>
31#include <linux/interrupt.h>
32#include <linux/bitops.h>
33#include <linux/skbuff.h>
34
35#include "../nfc.h"
36#include <net/nfc/nci.h>
37#include <net/nfc/nci_core.h>
38#include <linux/nfc.h>
39
40
41
42static void nci_core_conn_credits_ntf_packet(struct nci_dev *ndev,
43 struct sk_buff *skb)
44{
45 struct nci_core_conn_credit_ntf *ntf = (void *) skb->data;
46 int i;
47
48 pr_debug("num_entries %d\n", ntf->num_entries);
49
50 if (ntf->num_entries > NCI_MAX_NUM_CONN)
51 ntf->num_entries = NCI_MAX_NUM_CONN;
52
53
54 for (i = 0; i < ntf->num_entries; i++) {
55 ntf->conn_entries[i].conn_id =
56 nci_conn_id(&ntf->conn_entries[i].conn_id);
57
58 pr_debug("entry[%d]: conn_id %d, credits %d\n",
59 i, ntf->conn_entries[i].conn_id,
60 ntf->conn_entries[i].credits);
61
62 if (ntf->conn_entries[i].conn_id == NCI_STATIC_RF_CONN_ID) {
63
64 atomic_add(ntf->conn_entries[i].credits,
65 &ndev->credits_cnt);
66 }
67 }
68
69
70 if (!skb_queue_empty(&ndev->tx_q))
71 queue_work(ndev->tx_wq, &ndev->tx_work);
72}
73
74static void nci_core_conn_intf_error_ntf_packet(struct nci_dev *ndev,
75 struct sk_buff *skb)
76{
77 struct nci_core_intf_error_ntf *ntf = (void *) skb->data;
78
79 ntf->conn_id = nci_conn_id(&ntf->conn_id);
80
81 pr_debug("status 0x%x, conn_id %d\n", ntf->status, ntf->conn_id);
82
83
84 if (test_bit(NCI_DATA_EXCHANGE, &ndev->flags))
85 nci_data_exchange_complete(ndev, NULL, -EIO);
86}
87
88static __u8 *nci_extract_rf_params_nfca_passive_poll(struct nci_dev *ndev,
89 struct nci_rf_intf_activated_ntf *ntf, __u8 *data)
90{
91 struct rf_tech_specific_params_nfca_poll *nfca_poll;
92
93 nfca_poll = &ntf->rf_tech_specific_params.nfca_poll;
94
95 nfca_poll->sens_res = __le16_to_cpu(*((__u16 *)data));
96 data += 2;
97
98 nfca_poll->nfcid1_len = *data++;
99
100 pr_debug("sens_res 0x%x, nfcid1_len %d\n",
101 nfca_poll->sens_res, nfca_poll->nfcid1_len);
102
103 memcpy(nfca_poll->nfcid1, data, nfca_poll->nfcid1_len);
104 data += nfca_poll->nfcid1_len;
105
106 nfca_poll->sel_res_len = *data++;
107
108 if (nfca_poll->sel_res_len != 0)
109 nfca_poll->sel_res = *data++;
110
111 pr_debug("sel_res_len %d, sel_res 0x%x\n",
112 nfca_poll->sel_res_len,
113 nfca_poll->sel_res);
114
115 return data;
116}
117
118static int nci_extract_activation_params_iso_dep(struct nci_dev *ndev,
119 struct nci_rf_intf_activated_ntf *ntf, __u8 *data)
120{
121 struct activation_params_nfca_poll_iso_dep *nfca_poll;
122
123 switch (ntf->activation_rf_tech_and_mode) {
124 case NCI_NFC_A_PASSIVE_POLL_MODE:
125 nfca_poll = &ntf->activation_params.nfca_poll_iso_dep;
126 nfca_poll->rats_res_len = *data++;
127 if (nfca_poll->rats_res_len > 0) {
128 memcpy(nfca_poll->rats_res,
129 data,
130 nfca_poll->rats_res_len);
131 }
132 break;
133
134 default:
135 pr_err("unsupported activation_rf_tech_and_mode 0x%x\n",
136 ntf->activation_rf_tech_and_mode);
137 return -EPROTO;
138 }
139
140 return 0;
141}
142
143static void nci_target_found(struct nci_dev *ndev,
144 struct nci_rf_intf_activated_ntf *ntf)
145{
146 struct nfc_target nfc_tgt;
147
148 if (ntf->rf_protocol == NCI_RF_PROTOCOL_T2T)
149 nfc_tgt.supported_protocols = NFC_PROTO_MIFARE_MASK;
150 else if (ntf->rf_protocol == NCI_RF_PROTOCOL_ISO_DEP)
151 nfc_tgt.supported_protocols = NFC_PROTO_ISO14443_MASK;
152 else
153 nfc_tgt.supported_protocols = 0;
154
155 nfc_tgt.sens_res = ntf->rf_tech_specific_params.nfca_poll.sens_res;
156 nfc_tgt.sel_res = ntf->rf_tech_specific_params.nfca_poll.sel_res;
157 nfc_tgt.nfcid1_len = ntf->rf_tech_specific_params.nfca_poll.nfcid1_len;
158 if (nfc_tgt.nfcid1_len > 0) {
159 memcpy(nfc_tgt.nfcid1,
160 ntf->rf_tech_specific_params.nfca_poll.nfcid1,
161 nfc_tgt.nfcid1_len);
162 }
163
164 if (!(nfc_tgt.supported_protocols & ndev->poll_prots)) {
165 pr_debug("the target found does not have the desired protocol\n");
166 return;
167 }
168
169 pr_debug("new target found, supported_protocols 0x%x\n",
170 nfc_tgt.supported_protocols);
171
172 ndev->target_available_prots = nfc_tgt.supported_protocols;
173 ndev->max_data_pkt_payload_size = ntf->max_data_pkt_payload_size;
174 ndev->initial_num_credits = ntf->initial_num_credits;
175
176
177 atomic_set(&ndev->credits_cnt, ndev->initial_num_credits);
178
179 nfc_targets_found(ndev->nfc_dev, &nfc_tgt, 1);
180}
181
182static void nci_rf_intf_activated_ntf_packet(struct nci_dev *ndev,
183 struct sk_buff *skb)
184{
185 struct nci_rf_intf_activated_ntf ntf;
186 __u8 *data = skb->data;
187 int err = 0;
188
189 clear_bit(NCI_DISCOVERY, &ndev->flags);
190 set_bit(NCI_POLL_ACTIVE, &ndev->flags);
191
192 ntf.rf_discovery_id = *data++;
193 ntf.rf_interface = *data++;
194 ntf.rf_protocol = *data++;
195 ntf.activation_rf_tech_and_mode = *data++;
196 ntf.max_data_pkt_payload_size = *data++;
197 ntf.initial_num_credits = *data++;
198 ntf.rf_tech_specific_params_len = *data++;
199
200 pr_debug("rf_discovery_id %d\n", ntf.rf_discovery_id);
201 pr_debug("rf_interface 0x%x\n", ntf.rf_interface);
202 pr_debug("rf_protocol 0x%x\n", ntf.rf_protocol);
203 pr_debug("activation_rf_tech_and_mode 0x%x\n",
204 ntf.activation_rf_tech_and_mode);
205 pr_debug("max_data_pkt_payload_size 0x%x\n",
206 ntf.max_data_pkt_payload_size);
207 pr_debug("initial_num_credits 0x%x\n", ntf.initial_num_credits);
208 pr_debug("rf_tech_specific_params_len %d\n",
209 ntf.rf_tech_specific_params_len);
210
211 if (ntf.rf_tech_specific_params_len > 0) {
212 switch (ntf.activation_rf_tech_and_mode) {
213 case NCI_NFC_A_PASSIVE_POLL_MODE:
214 data = nci_extract_rf_params_nfca_passive_poll(ndev,
215 &ntf, data);
216 break;
217
218 default:
219 pr_err("unsupported activation_rf_tech_and_mode 0x%x\n",
220 ntf.activation_rf_tech_and_mode);
221 return;
222 }
223 }
224
225 ntf.data_exch_rf_tech_and_mode = *data++;
226 ntf.data_exch_tx_bit_rate = *data++;
227 ntf.data_exch_rx_bit_rate = *data++;
228 ntf.activation_params_len = *data++;
229
230 pr_debug("data_exch_rf_tech_and_mode 0x%x\n",
231 ntf.data_exch_rf_tech_and_mode);
232 pr_debug("data_exch_tx_bit_rate 0x%x\n",
233 ntf.data_exch_tx_bit_rate);
234 pr_debug("data_exch_rx_bit_rate 0x%x\n",
235 ntf.data_exch_rx_bit_rate);
236 pr_debug("activation_params_len %d\n",
237 ntf.activation_params_len);
238
239 if (ntf.activation_params_len > 0) {
240 switch (ntf.rf_interface) {
241 case NCI_RF_INTERFACE_ISO_DEP:
242 err = nci_extract_activation_params_iso_dep(ndev,
243 &ntf, data);
244 break;
245
246 case NCI_RF_INTERFACE_FRAME:
247
248 break;
249
250 default:
251 pr_err("unsupported rf_interface 0x%x\n",
252 ntf.rf_interface);
253 return;
254 }
255 }
256
257 if (!err)
258 nci_target_found(ndev, &ntf);
259}
260
261static void nci_rf_deactivate_ntf_packet(struct nci_dev *ndev,
262 struct sk_buff *skb)
263{
264 struct nci_rf_deactivate_ntf *ntf = (void *) skb->data;
265
266 pr_debug("entry, type 0x%x, reason 0x%x\n", ntf->type, ntf->reason);
267
268 clear_bit(NCI_POLL_ACTIVE, &ndev->flags);
269 ndev->target_active_prot = 0;
270
271
272 skb_queue_purge(&ndev->tx_q);
273
274
275 if (ndev->rx_data_reassembly) {
276 kfree_skb(ndev->rx_data_reassembly);
277 ndev->rx_data_reassembly = 0;
278 }
279
280
281 if (test_bit(NCI_DATA_EXCHANGE, &ndev->flags))
282 nci_data_exchange_complete(ndev, NULL, -EIO);
283}
284
285void nci_ntf_packet(struct nci_dev *ndev, struct sk_buff *skb)
286{
287 __u16 ntf_opcode = nci_opcode(skb->data);
288
289 pr_debug("NCI RX: MT=ntf, PBF=%d, GID=0x%x, OID=0x%x, plen=%d\n",
290 nci_pbf(skb->data),
291 nci_opcode_gid(ntf_opcode),
292 nci_opcode_oid(ntf_opcode),
293 nci_plen(skb->data));
294
295
296 skb_pull(skb, NCI_CTRL_HDR_SIZE);
297
298 switch (ntf_opcode) {
299 case NCI_OP_CORE_CONN_CREDITS_NTF:
300 nci_core_conn_credits_ntf_packet(ndev, skb);
301 break;
302
303 case NCI_OP_CORE_INTF_ERROR_NTF:
304 nci_core_conn_intf_error_ntf_packet(ndev, skb);
305 break;
306
307 case NCI_OP_RF_INTF_ACTIVATED_NTF:
308 nci_rf_intf_activated_ntf_packet(ndev, skb);
309 break;
310
311 case NCI_OP_RF_DEACTIVATE_NTF:
312 nci_rf_deactivate_ntf_packet(ndev, skb);
313 break;
314
315 default:
316 pr_err("unknown ntf opcode 0x%x\n", ntf_opcode);
317 break;
318 }
319
320 kfree_skb(skb);
321}
322
