Commit | Line | Data |
---|---|---|
8b8d2e08 EL |
1 | /* |
2 | * Copyright (C) 2012 Intel Corporation. All rights reserved. | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License as published by | |
6 | * the Free Software Foundation; either version 2 of the License, or | |
7 | * (at your option) any later version. | |
8 | * | |
9 | * This program is distributed in the hope that it will be useful, | |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | * GNU General Public License for more details. | |
13 | * | |
14 | * You should have received a copy of the GNU General Public License | |
98b32dec | 15 | * along with this program; if not, see <http://www.gnu.org/licenses/>. |
8b8d2e08 EL |
16 | */ |
17 | ||
18 | #define pr_fmt(fmt) "hci: %s: " fmt, __func__ | |
19 | ||
20 | #include <linux/init.h> | |
21 | #include <linux/kernel.h> | |
22 | #include <linux/sched.h> | |
23 | #include <linux/module.h> | |
24 | ||
25 | #include <net/nfc/hci.h> | |
26 | ||
27 | #include "hci.h" | |
28 | ||
d330905d CR |
29 | #define MAX_FWI 4949 |
30 | ||
e4c4789e EL |
31 | static int nfc_hci_execute_cmd_async(struct nfc_hci_dev *hdev, u8 pipe, u8 cmd, |
32 | const u8 *param, size_t param_len, | |
33 | data_exchange_cb_t cb, void *cb_context) | |
34 | { | |
35 | pr_debug("exec cmd async through pipe=%d, cmd=%d, plen=%zd\n", pipe, | |
36 | cmd, param_len); | |
37 | ||
38 | /* TODO: Define hci cmd execution delay. Should it be the same | |
39 | * for all commands? | |
40 | */ | |
41 | return nfc_hci_hcp_message_tx(hdev, pipe, NFC_HCI_HCP_COMMAND, cmd, | |
d330905d | 42 | param, param_len, cb, cb_context, MAX_FWI); |
e4c4789e EL |
43 | } |
44 | ||
b5faa648 EL |
45 | /* |
46 | * HCI command execution completion callback. | |
47 | * err will be a standard linux error (may be converted from HCI response) | |
48 | * skb contains the response data and must be disposed, or may be NULL if | |
49 | * an error occured | |
50 | */ | |
51 | static void nfc_hci_execute_cb(void *context, struct sk_buff *skb, int err) | |
8b8d2e08 | 52 | { |
b5faa648 | 53 | struct hcp_exec_waiter *hcp_ew = (struct hcp_exec_waiter *)context; |
8b8d2e08 | 54 | |
6c1c5b9e | 55 | pr_debug("HCI Cmd completed with result=%d\n", err); |
8b8d2e08 | 56 | |
6c1c5b9e | 57 | hcp_ew->exec_result = err; |
8b8d2e08 EL |
58 | if (hcp_ew->exec_result == 0) |
59 | hcp_ew->result_skb = skb; | |
60 | else | |
61 | kfree_skb(skb); | |
62 | hcp_ew->exec_complete = true; | |
63 | ||
64 | wake_up(hcp_ew->wq); | |
65 | } | |
66 | ||
67 | static int nfc_hci_execute_cmd(struct nfc_hci_dev *hdev, u8 pipe, u8 cmd, | |
68 | const u8 *param, size_t param_len, | |
69 | struct sk_buff **skb) | |
70 | { | |
71 | DECLARE_WAIT_QUEUE_HEAD_ONSTACK(ew_wq); | |
72 | struct hcp_exec_waiter hcp_ew; | |
73 | hcp_ew.wq = &ew_wq; | |
74 | hcp_ew.exec_complete = false; | |
75 | hcp_ew.result_skb = NULL; | |
76 | ||
e4c4789e EL |
77 | pr_debug("exec cmd sync through pipe=%d, cmd=%d, plen=%zd\n", pipe, |
78 | cmd, param_len); | |
8b8d2e08 EL |
79 | |
80 | /* TODO: Define hci cmd execution delay. Should it be the same | |
81 | * for all commands? | |
82 | */ | |
83 | hcp_ew.exec_result = nfc_hci_hcp_message_tx(hdev, pipe, | |
84 | NFC_HCI_HCP_COMMAND, cmd, | |
85 | param, param_len, | |
86 | nfc_hci_execute_cb, &hcp_ew, | |
d330905d | 87 | MAX_FWI); |
8b8d2e08 EL |
88 | if (hcp_ew.exec_result < 0) |
89 | return hcp_ew.exec_result; | |
90 | ||
91 | wait_event(ew_wq, hcp_ew.exec_complete == true); | |
92 | ||
93 | if (hcp_ew.exec_result == 0) { | |
94 | if (skb) | |
95 | *skb = hcp_ew.result_skb; | |
96 | else | |
97 | kfree_skb(hcp_ew.result_skb); | |
98 | } | |
99 | ||
100 | return hcp_ew.exec_result; | |
101 | } | |
102 | ||
103 | int nfc_hci_send_event(struct nfc_hci_dev *hdev, u8 gate, u8 event, | |
104 | const u8 *param, size_t param_len) | |
105 | { | |
106 | u8 pipe; | |
107 | ||
108 | pr_debug("%d to gate %d\n", event, gate); | |
109 | ||
110 | pipe = hdev->gate2pipe[gate]; | |
111 | if (pipe == NFC_HCI_INVALID_PIPE) | |
112 | return -EADDRNOTAVAIL; | |
113 | ||
114 | return nfc_hci_hcp_message_tx(hdev, pipe, NFC_HCI_HCP_EVENT, event, | |
115 | param, param_len, NULL, NULL, 0); | |
116 | } | |
117 | EXPORT_SYMBOL(nfc_hci_send_event); | |
118 | ||
119 | int nfc_hci_send_response(struct nfc_hci_dev *hdev, u8 gate, u8 response, | |
120 | const u8 *param, size_t param_len) | |
121 | { | |
122 | u8 pipe; | |
123 | ||
124 | pr_debug("\n"); | |
125 | ||
126 | pipe = hdev->gate2pipe[gate]; | |
127 | if (pipe == NFC_HCI_INVALID_PIPE) | |
128 | return -EADDRNOTAVAIL; | |
129 | ||
130 | return nfc_hci_hcp_message_tx(hdev, pipe, NFC_HCI_HCP_RESPONSE, | |
131 | response, param, param_len, NULL, NULL, | |
132 | 0); | |
133 | } | |
134 | EXPORT_SYMBOL(nfc_hci_send_response); | |
135 | ||
136 | /* | |
137 | * Execute an hci command sent to gate. | |
138 | * skb will contain response data if success. skb can be NULL if you are not | |
139 | * interested by the response. | |
140 | */ | |
141 | int nfc_hci_send_cmd(struct nfc_hci_dev *hdev, u8 gate, u8 cmd, | |
142 | const u8 *param, size_t param_len, struct sk_buff **skb) | |
143 | { | |
144 | u8 pipe; | |
145 | ||
146 | pr_debug("\n"); | |
147 | ||
148 | pipe = hdev->gate2pipe[gate]; | |
149 | if (pipe == NFC_HCI_INVALID_PIPE) | |
150 | return -EADDRNOTAVAIL; | |
151 | ||
152 | return nfc_hci_execute_cmd(hdev, pipe, cmd, param, param_len, skb); | |
153 | } | |
154 | EXPORT_SYMBOL(nfc_hci_send_cmd); | |
155 | ||
e4c4789e EL |
156 | int nfc_hci_send_cmd_async(struct nfc_hci_dev *hdev, u8 gate, u8 cmd, |
157 | const u8 *param, size_t param_len, | |
158 | data_exchange_cb_t cb, void *cb_context) | |
159 | { | |
160 | u8 pipe; | |
161 | ||
162 | pr_debug("\n"); | |
163 | ||
164 | pipe = hdev->gate2pipe[gate]; | |
165 | if (pipe == NFC_HCI_INVALID_PIPE) | |
166 | return -EADDRNOTAVAIL; | |
167 | ||
168 | return nfc_hci_execute_cmd_async(hdev, pipe, cmd, param, param_len, | |
169 | cb, cb_context); | |
170 | } | |
171 | EXPORT_SYMBOL(nfc_hci_send_cmd_async); | |
172 | ||
8b8d2e08 EL |
173 | int nfc_hci_set_param(struct nfc_hci_dev *hdev, u8 gate, u8 idx, |
174 | const u8 *param, size_t param_len) | |
175 | { | |
176 | int r; | |
177 | u8 *tmp; | |
178 | ||
179 | /* TODO ELa: reg idx must be inserted before param, but we don't want | |
180 | * to ask the caller to do it to keep a simpler API. | |
181 | * For now, just create a new temporary param buffer. This is far from | |
182 | * optimal though, and the plan is to modify APIs to pass idx down to | |
183 | * nfc_hci_hcp_message_tx where the frame is actually built, thereby | |
184 | * eliminating the need for the temp allocation-copy here. | |
185 | */ | |
186 | ||
187 | pr_debug("idx=%d to gate %d\n", idx, gate); | |
188 | ||
189 | tmp = kmalloc(1 + param_len, GFP_KERNEL); | |
190 | if (tmp == NULL) | |
191 | return -ENOMEM; | |
192 | ||
193 | *tmp = idx; | |
194 | memcpy(tmp + 1, param, param_len); | |
195 | ||
196 | r = nfc_hci_send_cmd(hdev, gate, NFC_HCI_ANY_SET_PARAMETER, | |
197 | tmp, param_len + 1, NULL); | |
198 | ||
199 | kfree(tmp); | |
200 | ||
201 | return r; | |
202 | } | |
203 | EXPORT_SYMBOL(nfc_hci_set_param); | |
204 | ||
205 | int nfc_hci_get_param(struct nfc_hci_dev *hdev, u8 gate, u8 idx, | |
206 | struct sk_buff **skb) | |
207 | { | |
208 | pr_debug("gate=%d regidx=%d\n", gate, idx); | |
209 | ||
210 | return nfc_hci_send_cmd(hdev, gate, NFC_HCI_ANY_GET_PARAMETER, | |
211 | &idx, 1, skb); | |
212 | } | |
213 | EXPORT_SYMBOL(nfc_hci_get_param); | |
214 | ||
215 | static int nfc_hci_open_pipe(struct nfc_hci_dev *hdev, u8 pipe) | |
216 | { | |
217 | struct sk_buff *skb; | |
218 | int r; | |
219 | ||
220 | pr_debug("pipe=%d\n", pipe); | |
221 | ||
222 | r = nfc_hci_execute_cmd(hdev, pipe, NFC_HCI_ANY_OPEN_PIPE, | |
223 | NULL, 0, &skb); | |
224 | if (r == 0) { | |
225 | /* dest host other than host controller will send | |
226 | * number of pipes already open on this gate before | |
227 | * execution. The number can be found in skb->data[0] | |
228 | */ | |
229 | kfree_skb(skb); | |
230 | } | |
231 | ||
232 | return r; | |
233 | } | |
234 | ||
235 | static int nfc_hci_close_pipe(struct nfc_hci_dev *hdev, u8 pipe) | |
236 | { | |
237 | pr_debug("\n"); | |
238 | ||
239 | return nfc_hci_execute_cmd(hdev, pipe, NFC_HCI_ANY_CLOSE_PIPE, | |
240 | NULL, 0, NULL); | |
241 | } | |
242 | ||
243 | static u8 nfc_hci_create_pipe(struct nfc_hci_dev *hdev, u8 dest_host, | |
244 | u8 dest_gate, int *result) | |
245 | { | |
246 | struct sk_buff *skb; | |
247 | struct hci_create_pipe_params params; | |
248 | struct hci_create_pipe_resp *resp; | |
249 | u8 pipe; | |
250 | ||
251 | pr_debug("gate=%d\n", dest_gate); | |
252 | ||
253 | params.src_gate = NFC_HCI_ADMIN_GATE; | |
254 | params.dest_host = dest_host; | |
255 | params.dest_gate = dest_gate; | |
256 | ||
257 | *result = nfc_hci_execute_cmd(hdev, NFC_HCI_ADMIN_PIPE, | |
258 | NFC_HCI_ADM_CREATE_PIPE, | |
259 | (u8 *) ¶ms, sizeof(params), &skb); | |
80e4232e SJ |
260 | if (*result < 0) |
261 | return NFC_HCI_INVALID_PIPE; | |
8b8d2e08 | 262 | |
80e4232e SJ |
263 | resp = (struct hci_create_pipe_resp *)skb->data; |
264 | pipe = resp->pipe; | |
265 | kfree_skb(skb); | |
8b8d2e08 | 266 | |
80e4232e SJ |
267 | pr_debug("pipe created=%d\n", pipe); |
268 | ||
269 | return pipe; | |
8b8d2e08 EL |
270 | } |
271 | ||
272 | static int nfc_hci_delete_pipe(struct nfc_hci_dev *hdev, u8 pipe) | |
273 | { | |
274 | pr_debug("\n"); | |
275 | ||
276 | return nfc_hci_execute_cmd(hdev, NFC_HCI_ADMIN_PIPE, | |
277 | NFC_HCI_ADM_DELETE_PIPE, &pipe, 1, NULL); | |
278 | } | |
279 | ||
280 | static int nfc_hci_clear_all_pipes(struct nfc_hci_dev *hdev) | |
281 | { | |
8b8d2e08 | 282 | u8 param[2]; |
bf71ab8b | 283 | size_t param_len = 2; |
8b8d2e08 EL |
284 | |
285 | /* TODO: Find out what the identity reference data is | |
286 | * and fill param with it. HCI spec 6.1.3.5 */ | |
287 | ||
288 | pr_debug("\n"); | |
289 | ||
bf71ab8b EL |
290 | if (test_bit(NFC_HCI_QUIRK_SHORT_CLEAR, &hdev->quirks)) |
291 | param_len = 0; | |
292 | ||
0250ffc5 | 293 | return nfc_hci_execute_cmd(hdev, NFC_HCI_ADMIN_PIPE, |
bf71ab8b EL |
294 | NFC_HCI_ADM_CLEAR_ALL_PIPE, param, param_len, |
295 | NULL); | |
8b8d2e08 EL |
296 | } |
297 | ||
298 | int nfc_hci_disconnect_gate(struct nfc_hci_dev *hdev, u8 gate) | |
299 | { | |
300 | int r; | |
301 | u8 pipe = hdev->gate2pipe[gate]; | |
302 | ||
303 | pr_debug("\n"); | |
304 | ||
305 | if (pipe == NFC_HCI_INVALID_PIPE) | |
306 | return -EADDRNOTAVAIL; | |
307 | ||
308 | r = nfc_hci_close_pipe(hdev, pipe); | |
309 | if (r < 0) | |
310 | return r; | |
311 | ||
312 | if (pipe != NFC_HCI_LINK_MGMT_PIPE && pipe != NFC_HCI_ADMIN_PIPE) { | |
313 | r = nfc_hci_delete_pipe(hdev, pipe); | |
314 | if (r < 0) | |
315 | return r; | |
316 | } | |
317 | ||
318 | hdev->gate2pipe[gate] = NFC_HCI_INVALID_PIPE; | |
319 | ||
320 | return 0; | |
321 | } | |
322 | EXPORT_SYMBOL(nfc_hci_disconnect_gate); | |
323 | ||
324 | int nfc_hci_disconnect_all_gates(struct nfc_hci_dev *hdev) | |
325 | { | |
326 | int r; | |
327 | ||
328 | pr_debug("\n"); | |
329 | ||
330 | r = nfc_hci_clear_all_pipes(hdev); | |
331 | if (r < 0) | |
332 | return r; | |
333 | ||
334 | memset(hdev->gate2pipe, NFC_HCI_INVALID_PIPE, sizeof(hdev->gate2pipe)); | |
335 | ||
336 | return 0; | |
337 | } | |
338 | EXPORT_SYMBOL(nfc_hci_disconnect_all_gates); | |
339 | ||
a10d595b EL |
340 | int nfc_hci_connect_gate(struct nfc_hci_dev *hdev, u8 dest_host, u8 dest_gate, |
341 | u8 pipe) | |
8b8d2e08 | 342 | { |
8b8d2e08 EL |
343 | bool pipe_created = false; |
344 | int r; | |
345 | ||
346 | pr_debug("\n"); | |
347 | ||
b3a55b9c CR |
348 | if (hdev->gate2pipe[dest_gate] == NFC_HCI_DO_NOT_CREATE_PIPE) |
349 | return 0; | |
350 | ||
8b8d2e08 EL |
351 | if (hdev->gate2pipe[dest_gate] != NFC_HCI_INVALID_PIPE) |
352 | return -EADDRINUSE; | |
353 | ||
a10d595b | 354 | if (pipe != NFC_HCI_INVALID_PIPE) |
07887e92 | 355 | goto open_pipe; |
a10d595b | 356 | |
8b8d2e08 EL |
357 | switch (dest_gate) { |
358 | case NFC_HCI_LINK_MGMT_GATE: | |
359 | pipe = NFC_HCI_LINK_MGMT_PIPE; | |
360 | break; | |
361 | case NFC_HCI_ADMIN_GATE: | |
362 | pipe = NFC_HCI_ADMIN_PIPE; | |
363 | break; | |
364 | default: | |
365 | pipe = nfc_hci_create_pipe(hdev, dest_host, dest_gate, &r); | |
366 | if (pipe == NFC_HCI_INVALID_PIPE) | |
367 | return r; | |
368 | pipe_created = true; | |
369 | break; | |
370 | } | |
371 | ||
07887e92 | 372 | open_pipe: |
8b8d2e08 EL |
373 | r = nfc_hci_open_pipe(hdev, pipe); |
374 | if (r < 0) { | |
375 | if (pipe_created) | |
376 | if (nfc_hci_delete_pipe(hdev, pipe) < 0) { | |
377 | /* TODO: Cannot clean by deleting pipe... | |
378 | * -> inconsistent state */ | |
379 | } | |
380 | return r; | |
381 | } | |
382 | ||
383 | hdev->gate2pipe[dest_gate] = pipe; | |
384 | ||
385 | return 0; | |
386 | } | |
387 | EXPORT_SYMBOL(nfc_hci_connect_gate); |