Commit | Line | Data |
---|---|---|
11f54f22 CR |
1 | /* |
2 | * The NFC Controller Interface is the communication protocol between an | |
3 | * NFC Controller (NFCC) and a Device Host (DH). | |
4 | * This is the HCI over NCI implementation, as specified in the 10.2 | |
5 | * section of the NCI 1.1 specification. | |
6 | * | |
7 | * Copyright (C) 2014 STMicroelectronics SAS. All rights reserved. | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License version 2 | |
11 | * as published by the Free Software Foundation | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, see <http://www.gnu.org/licenses/>. | |
20 | * | |
21 | */ | |
22 | ||
23 | #include <linux/skbuff.h> | |
24 | ||
25 | #include "../nfc.h" | |
26 | #include <net/nfc/nci.h> | |
27 | #include <net/nfc/nci_core.h> | |
28 | #include <linux/nfc.h> | |
29 | ||
30 | struct nci_data { | |
31 | u8 conn_id; | |
32 | u8 pipe; | |
33 | u8 cmd; | |
34 | const u8 *data; | |
35 | u32 data_len; | |
36 | } __packed; | |
37 | ||
38 | struct nci_hci_create_pipe_params { | |
39 | u8 src_gate; | |
40 | u8 dest_host; | |
41 | u8 dest_gate; | |
42 | } __packed; | |
43 | ||
44 | struct nci_hci_create_pipe_resp { | |
45 | u8 src_host; | |
46 | u8 src_gate; | |
47 | u8 dest_host; | |
48 | u8 dest_gate; | |
49 | u8 pipe; | |
50 | } __packed; | |
51 | ||
52 | struct nci_hci_delete_pipe_noti { | |
53 | u8 pipe; | |
54 | } __packed; | |
55 | ||
56 | struct nci_hci_all_pipe_cleared_noti { | |
57 | u8 host; | |
58 | } __packed; | |
59 | ||
60 | struct nci_hcp_message { | |
61 | u8 header; /* type -cmd,evt,rsp- + instruction */ | |
62 | u8 data[]; | |
63 | } __packed; | |
64 | ||
65 | struct nci_hcp_packet { | |
66 | u8 header; /* cbit+pipe */ | |
67 | struct nci_hcp_message message; | |
68 | } __packed; | |
69 | ||
70 | #define NCI_HCI_ANY_SET_PARAMETER 0x01 | |
71 | #define NCI_HCI_ANY_GET_PARAMETER 0x02 | |
72 | #define NCI_HCI_ANY_CLOSE_PIPE 0x04 | |
fa6fbade | 73 | #define NCI_HCI_ADM_CLEAR_ALL_PIPE 0x14 |
11f54f22 CR |
74 | |
75 | #define NCI_HFP_NO_CHAINING 0x80 | |
76 | ||
77 | #define NCI_NFCEE_ID_HCI 0x80 | |
78 | ||
79 | #define NCI_EVT_HOT_PLUG 0x03 | |
80 | ||
81 | #define NCI_HCI_ADMIN_PARAM_SESSION_IDENTITY 0x01 | |
a1b0b941 CR |
82 | #define NCI_HCI_ADM_CREATE_PIPE 0x10 |
83 | #define NCI_HCI_ADM_DELETE_PIPE 0x11 | |
11f54f22 CR |
84 | |
85 | /* HCP headers */ | |
86 | #define NCI_HCI_HCP_PACKET_HEADER_LEN 1 | |
87 | #define NCI_HCI_HCP_MESSAGE_HEADER_LEN 1 | |
88 | #define NCI_HCI_HCP_HEADER_LEN 2 | |
89 | ||
90 | /* HCP types */ | |
91 | #define NCI_HCI_HCP_COMMAND 0x00 | |
92 | #define NCI_HCI_HCP_EVENT 0x01 | |
93 | #define NCI_HCI_HCP_RESPONSE 0x02 | |
94 | ||
95 | #define NCI_HCI_ADM_NOTIFY_PIPE_CREATED 0x12 | |
96 | #define NCI_HCI_ADM_NOTIFY_PIPE_DELETED 0x13 | |
97 | #define NCI_HCI_ADM_NOTIFY_ALL_PIPE_CLEARED 0x15 | |
98 | ||
99 | #define NCI_HCI_FRAGMENT 0x7f | |
100 | #define NCI_HCP_HEADER(type, instr) ((((type) & 0x03) << 6) |\ | |
101 | ((instr) & 0x3f)) | |
102 | ||
103 | #define NCI_HCP_MSG_GET_TYPE(header) ((header & 0xc0) >> 6) | |
104 | #define NCI_HCP_MSG_GET_CMD(header) (header & 0x3f) | |
105 | #define NCI_HCP_MSG_GET_PIPE(header) (header & 0x7f) | |
106 | ||
d8cd37ed CR |
107 | static int nci_hci_result_to_errno(u8 result) |
108 | { | |
109 | switch (result) { | |
110 | case NCI_HCI_ANY_OK: | |
111 | return 0; | |
112 | case NCI_HCI_ANY_E_REG_PAR_UNKNOWN: | |
113 | return -EOPNOTSUPP; | |
114 | case NCI_HCI_ANY_E_TIMEOUT: | |
115 | return -ETIME; | |
116 | default: | |
117 | return -1; | |
118 | } | |
119 | } | |
120 | ||
11f54f22 CR |
121 | /* HCI core */ |
122 | static void nci_hci_reset_pipes(struct nci_hci_dev *hdev) | |
123 | { | |
124 | int i; | |
125 | ||
126 | for (i = 0; i < NCI_HCI_MAX_PIPES; i++) { | |
127 | hdev->pipes[i].gate = NCI_HCI_INVALID_GATE; | |
128 | hdev->pipes[i].host = NCI_HCI_INVALID_HOST; | |
129 | } | |
130 | memset(hdev->gate2pipe, NCI_HCI_INVALID_PIPE, sizeof(hdev->gate2pipe)); | |
131 | } | |
132 | ||
133 | static void nci_hci_reset_pipes_per_host(struct nci_dev *ndev, u8 host) | |
134 | { | |
135 | int i; | |
136 | ||
137 | for (i = 0; i < NCI_HCI_MAX_PIPES; i++) { | |
138 | if (ndev->hci_dev->pipes[i].host == host) { | |
139 | ndev->hci_dev->pipes[i].gate = NCI_HCI_INVALID_GATE; | |
140 | ndev->hci_dev->pipes[i].host = NCI_HCI_INVALID_HOST; | |
141 | } | |
142 | } | |
143 | } | |
144 | ||
145 | /* Fragment HCI data over NCI packet. | |
146 | * NFC Forum NCI 10.2.2 Data Exchange: | |
147 | * The payload of the Data Packets sent on the Logical Connection SHALL be | |
148 | * valid HCP packets, as defined within [ETSI_102622]. Each Data Packet SHALL | |
149 | * contain a single HCP packet. NCI Segmentation and Reassembly SHALL NOT be | |
150 | * applied to Data Messages in either direction. The HCI fragmentation mechanism | |
151 | * is used if required. | |
152 | */ | |
153 | static int nci_hci_send_data(struct nci_dev *ndev, u8 pipe, | |
154 | const u8 data_type, const u8 *data, | |
155 | size_t data_len) | |
156 | { | |
157 | struct nci_conn_info *conn_info; | |
158 | struct sk_buff *skb; | |
159 | int len, i, r; | |
160 | u8 cb = pipe; | |
161 | ||
162 | conn_info = ndev->hci_dev->conn_info; | |
163 | if (!conn_info) | |
164 | return -EPROTO; | |
165 | ||
500c4ef0 CR |
166 | i = 0; |
167 | skb = nci_skb_alloc(ndev, conn_info->max_pkt_payload_len + | |
11f54f22 CR |
168 | NCI_DATA_HDR_SIZE, GFP_KERNEL); |
169 | if (!skb) | |
170 | return -ENOMEM; | |
171 | ||
500c4ef0 | 172 | skb_reserve(skb, NCI_DATA_HDR_SIZE + 2); |
11f54f22 CR |
173 | *skb_push(skb, 1) = data_type; |
174 | ||
11f54f22 | 175 | do { |
500c4ef0 CR |
176 | len = conn_info->max_pkt_payload_len; |
177 | ||
11f54f22 CR |
178 | /* If last packet add NCI_HFP_NO_CHAINING */ |
179 | if (i + conn_info->max_pkt_payload_len - | |
180 | (skb->len + 1) >= data_len) { | |
181 | cb |= NCI_HFP_NO_CHAINING; | |
182 | len = data_len - i; | |
183 | } else { | |
184 | len = conn_info->max_pkt_payload_len - skb->len - 1; | |
185 | } | |
186 | ||
187 | *skb_push(skb, 1) = cb; | |
188 | ||
189 | if (len > 0) | |
190 | memcpy(skb_put(skb, len), data + i, len); | |
191 | ||
192 | r = nci_send_data(ndev, conn_info->conn_id, skb); | |
193 | if (r < 0) | |
194 | return r; | |
195 | ||
196 | i += len; | |
500c4ef0 | 197 | |
11f54f22 | 198 | if (i < data_len) { |
500c4ef0 CR |
199 | skb = nci_skb_alloc(ndev, |
200 | conn_info->max_pkt_payload_len + | |
201 | NCI_DATA_HDR_SIZE, GFP_KERNEL); | |
202 | if (!skb) | |
203 | return -ENOMEM; | |
204 | ||
205 | skb_reserve(skb, NCI_DATA_HDR_SIZE + 1); | |
11f54f22 CR |
206 | } |
207 | } while (i < data_len); | |
208 | ||
209 | return i; | |
210 | } | |
211 | ||
212 | static void nci_hci_send_data_req(struct nci_dev *ndev, unsigned long opt) | |
213 | { | |
214 | struct nci_data *data = (struct nci_data *)opt; | |
215 | ||
216 | nci_hci_send_data(ndev, data->pipe, data->cmd, | |
217 | data->data, data->data_len); | |
218 | } | |
219 | ||
220 | int nci_hci_send_event(struct nci_dev *ndev, u8 gate, u8 event, | |
221 | const u8 *param, size_t param_len) | |
222 | { | |
223 | u8 pipe = ndev->hci_dev->gate2pipe[gate]; | |
224 | ||
225 | if (pipe == NCI_HCI_INVALID_PIPE) | |
226 | return -EADDRNOTAVAIL; | |
227 | ||
228 | return nci_hci_send_data(ndev, pipe, | |
229 | NCI_HCP_HEADER(NCI_HCI_HCP_EVENT, event), | |
230 | param, param_len); | |
231 | } | |
232 | EXPORT_SYMBOL(nci_hci_send_event); | |
233 | ||
234 | int nci_hci_send_cmd(struct nci_dev *ndev, u8 gate, u8 cmd, | |
235 | const u8 *param, size_t param_len, | |
236 | struct sk_buff **skb) | |
237 | { | |
d8cd37ed CR |
238 | struct nci_hcp_message *message; |
239 | struct nci_conn_info *conn_info; | |
11f54f22 CR |
240 | struct nci_data data; |
241 | int r; | |
242 | u8 pipe = ndev->hci_dev->gate2pipe[gate]; | |
243 | ||
244 | if (pipe == NCI_HCI_INVALID_PIPE) | |
245 | return -EADDRNOTAVAIL; | |
246 | ||
247 | conn_info = ndev->hci_dev->conn_info; | |
248 | if (!conn_info) | |
249 | return -EPROTO; | |
250 | ||
251 | data.conn_id = conn_info->conn_id; | |
252 | data.pipe = pipe; | |
253 | data.cmd = NCI_HCP_HEADER(NCI_HCI_HCP_COMMAND, cmd); | |
254 | data.data = param; | |
255 | data.data_len = param_len; | |
256 | ||
257 | r = nci_request(ndev, nci_hci_send_data_req, (unsigned long)&data, | |
258 | msecs_to_jiffies(NCI_DATA_TIMEOUT)); | |
d8cd37ed CR |
259 | if (r == NCI_STATUS_OK) { |
260 | message = (struct nci_hcp_message *)conn_info->rx_skb->data; | |
261 | r = nci_hci_result_to_errno( | |
262 | NCI_HCP_MSG_GET_CMD(message->header)); | |
263 | skb_pull(conn_info->rx_skb, NCI_HCI_HCP_MESSAGE_HEADER_LEN); | |
264 | ||
265 | if (!r && skb) | |
266 | *skb = conn_info->rx_skb; | |
267 | } | |
11f54f22 CR |
268 | |
269 | return r; | |
270 | } | |
271 | EXPORT_SYMBOL(nci_hci_send_cmd); | |
272 | ||
fa6fbade CR |
273 | int nci_hci_clear_all_pipes(struct nci_dev *ndev) |
274 | { | |
275 | int r; | |
276 | ||
277 | r = nci_hci_send_cmd(ndev, NCI_HCI_ADMIN_GATE, | |
278 | NCI_HCI_ADM_CLEAR_ALL_PIPE, NULL, 0, NULL); | |
279 | if (r < 0) | |
280 | return r; | |
281 | ||
282 | nci_hci_reset_pipes(ndev->hci_dev); | |
283 | return r; | |
284 | } | |
285 | EXPORT_SYMBOL(nci_hci_clear_all_pipes); | |
286 | ||
11f54f22 CR |
287 | static void nci_hci_event_received(struct nci_dev *ndev, u8 pipe, |
288 | u8 event, struct sk_buff *skb) | |
289 | { | |
290 | if (ndev->ops->hci_event_received) | |
291 | ndev->ops->hci_event_received(ndev, pipe, event, skb); | |
292 | } | |
293 | ||
294 | static void nci_hci_cmd_received(struct nci_dev *ndev, u8 pipe, | |
295 | u8 cmd, struct sk_buff *skb) | |
296 | { | |
297 | u8 gate = ndev->hci_dev->pipes[pipe].gate; | |
298 | u8 status = NCI_HCI_ANY_OK | ~NCI_HCI_FRAGMENT; | |
299 | u8 dest_gate, new_pipe; | |
300 | struct nci_hci_create_pipe_resp *create_info; | |
301 | struct nci_hci_delete_pipe_noti *delete_info; | |
302 | struct nci_hci_all_pipe_cleared_noti *cleared_info; | |
303 | ||
304 | pr_debug("from gate %x pipe %x cmd %x\n", gate, pipe, cmd); | |
305 | ||
306 | switch (cmd) { | |
307 | case NCI_HCI_ADM_NOTIFY_PIPE_CREATED: | |
308 | if (skb->len != 5) { | |
309 | status = NCI_HCI_ANY_E_NOK; | |
310 | goto exit; | |
311 | } | |
312 | create_info = (struct nci_hci_create_pipe_resp *)skb->data; | |
313 | dest_gate = create_info->dest_gate; | |
314 | new_pipe = create_info->pipe; | |
315 | ||
316 | /* Save the new created pipe and bind with local gate, | |
317 | * the description for skb->data[3] is destination gate id | |
318 | * but since we received this cmd from host controller, we | |
319 | * are the destination and it is our local gate | |
320 | */ | |
321 | ndev->hci_dev->gate2pipe[dest_gate] = new_pipe; | |
322 | ndev->hci_dev->pipes[new_pipe].gate = dest_gate; | |
323 | ndev->hci_dev->pipes[new_pipe].host = | |
324 | create_info->src_host; | |
325 | break; | |
326 | case NCI_HCI_ANY_OPEN_PIPE: | |
327 | /* If the pipe is not created report an error */ | |
328 | if (gate == NCI_HCI_INVALID_GATE) { | |
329 | status = NCI_HCI_ANY_E_NOK; | |
330 | goto exit; | |
331 | } | |
332 | break; | |
333 | case NCI_HCI_ADM_NOTIFY_PIPE_DELETED: | |
334 | if (skb->len != 1) { | |
335 | status = NCI_HCI_ANY_E_NOK; | |
336 | goto exit; | |
337 | } | |
338 | delete_info = (struct nci_hci_delete_pipe_noti *)skb->data; | |
339 | ||
340 | ndev->hci_dev->pipes[delete_info->pipe].gate = | |
341 | NCI_HCI_INVALID_GATE; | |
342 | ndev->hci_dev->pipes[delete_info->pipe].host = | |
343 | NCI_HCI_INVALID_HOST; | |
344 | break; | |
345 | case NCI_HCI_ADM_NOTIFY_ALL_PIPE_CLEARED: | |
346 | if (skb->len != 1) { | |
347 | status = NCI_HCI_ANY_E_NOK; | |
348 | goto exit; | |
349 | } | |
350 | ||
351 | cleared_info = | |
352 | (struct nci_hci_all_pipe_cleared_noti *)skb->data; | |
353 | nci_hci_reset_pipes_per_host(ndev, cleared_info->host); | |
354 | break; | |
355 | default: | |
356 | pr_debug("Discarded unknown cmd %x to gate %x\n", cmd, gate); | |
357 | break; | |
358 | } | |
359 | ||
360 | if (ndev->ops->hci_cmd_received) | |
361 | ndev->ops->hci_cmd_received(ndev, pipe, cmd, skb); | |
362 | ||
363 | exit: | |
364 | nci_hci_send_data(ndev, pipe, status, NULL, 0); | |
365 | ||
366 | kfree_skb(skb); | |
367 | } | |
368 | ||
369 | static void nci_hci_resp_received(struct nci_dev *ndev, u8 pipe, | |
370 | u8 result, struct sk_buff *skb) | |
371 | { | |
372 | struct nci_conn_info *conn_info; | |
373 | u8 status = result; | |
374 | ||
11f54f22 CR |
375 | conn_info = ndev->hci_dev->conn_info; |
376 | if (!conn_info) { | |
377 | status = NCI_STATUS_REJECTED; | |
378 | goto exit; | |
379 | } | |
380 | ||
381 | conn_info->rx_skb = skb; | |
382 | ||
383 | exit: | |
d8cd37ed | 384 | nci_req_complete(ndev, NCI_STATUS_OK); |
11f54f22 CR |
385 | } |
386 | ||
387 | /* Receive hcp message for pipe, with type and cmd. | |
388 | * skb contains optional message data only. | |
389 | */ | |
390 | static void nci_hci_hcp_message_rx(struct nci_dev *ndev, u8 pipe, | |
391 | u8 type, u8 instruction, struct sk_buff *skb) | |
392 | { | |
393 | switch (type) { | |
394 | case NCI_HCI_HCP_RESPONSE: | |
395 | nci_hci_resp_received(ndev, pipe, instruction, skb); | |
396 | break; | |
397 | case NCI_HCI_HCP_COMMAND: | |
398 | nci_hci_cmd_received(ndev, pipe, instruction, skb); | |
399 | break; | |
400 | case NCI_HCI_HCP_EVENT: | |
401 | nci_hci_event_received(ndev, pipe, instruction, skb); | |
402 | break; | |
403 | default: | |
404 | pr_err("UNKNOWN MSG Type %d, instruction=%d\n", | |
405 | type, instruction); | |
406 | kfree_skb(skb); | |
407 | break; | |
408 | } | |
409 | ||
064d0047 | 410 | nci_req_complete(ndev, NCI_STATUS_OK); |
11f54f22 CR |
411 | } |
412 | ||
413 | static void nci_hci_msg_rx_work(struct work_struct *work) | |
414 | { | |
415 | struct nci_hci_dev *hdev = | |
416 | container_of(work, struct nci_hci_dev, msg_rx_work); | |
417 | struct sk_buff *skb; | |
418 | struct nci_hcp_message *message; | |
419 | u8 pipe, type, instruction; | |
420 | ||
421 | while ((skb = skb_dequeue(&hdev->msg_rx_queue)) != NULL) { | |
e65917b6 | 422 | pipe = NCI_HCP_MSG_GET_PIPE(skb->data[0]); |
11f54f22 CR |
423 | skb_pull(skb, NCI_HCI_HCP_PACKET_HEADER_LEN); |
424 | message = (struct nci_hcp_message *)skb->data; | |
425 | type = NCI_HCP_MSG_GET_TYPE(message->header); | |
426 | instruction = NCI_HCP_MSG_GET_CMD(message->header); | |
427 | skb_pull(skb, NCI_HCI_HCP_MESSAGE_HEADER_LEN); | |
428 | ||
429 | nci_hci_hcp_message_rx(hdev->ndev, pipe, | |
430 | type, instruction, skb); | |
431 | } | |
432 | } | |
433 | ||
434 | void nci_hci_data_received_cb(void *context, | |
435 | struct sk_buff *skb, int err) | |
436 | { | |
437 | struct nci_dev *ndev = (struct nci_dev *)context; | |
438 | struct nci_hcp_packet *packet; | |
d8cd37ed | 439 | u8 pipe, type; |
11f54f22 CR |
440 | struct sk_buff *hcp_skb; |
441 | struct sk_buff *frag_skb; | |
442 | int msg_len; | |
443 | ||
444 | pr_debug("\n"); | |
445 | ||
446 | if (err) { | |
447 | nci_req_complete(ndev, err); | |
448 | return; | |
449 | } | |
450 | ||
451 | packet = (struct nci_hcp_packet *)skb->data; | |
452 | if ((packet->header & ~NCI_HCI_FRAGMENT) == 0) { | |
453 | skb_queue_tail(&ndev->hci_dev->rx_hcp_frags, skb); | |
454 | return; | |
455 | } | |
456 | ||
457 | /* it's the last fragment. Does it need re-aggregation? */ | |
458 | if (skb_queue_len(&ndev->hci_dev->rx_hcp_frags)) { | |
e65917b6 | 459 | pipe = NCI_HCP_MSG_GET_PIPE(packet->header); |
11f54f22 CR |
460 | skb_queue_tail(&ndev->hci_dev->rx_hcp_frags, skb); |
461 | ||
462 | msg_len = 0; | |
463 | skb_queue_walk(&ndev->hci_dev->rx_hcp_frags, frag_skb) { | |
464 | msg_len += (frag_skb->len - | |
465 | NCI_HCI_HCP_PACKET_HEADER_LEN); | |
466 | } | |
467 | ||
468 | hcp_skb = nfc_alloc_recv_skb(NCI_HCI_HCP_PACKET_HEADER_LEN + | |
469 | msg_len, GFP_KERNEL); | |
470 | if (!hcp_skb) { | |
471 | nci_req_complete(ndev, -ENOMEM); | |
472 | return; | |
473 | } | |
474 | ||
475 | *skb_put(hcp_skb, NCI_HCI_HCP_PACKET_HEADER_LEN) = pipe; | |
476 | ||
477 | skb_queue_walk(&ndev->hci_dev->rx_hcp_frags, frag_skb) { | |
d8cd37ed | 478 | msg_len = frag_skb->len - NCI_HCI_HCP_PACKET_HEADER_LEN; |
11f54f22 CR |
479 | memcpy(skb_put(hcp_skb, msg_len), frag_skb->data + |
480 | NCI_HCI_HCP_PACKET_HEADER_LEN, msg_len); | |
481 | } | |
482 | ||
483 | skb_queue_purge(&ndev->hci_dev->rx_hcp_frags); | |
484 | } else { | |
485 | packet->header &= NCI_HCI_FRAGMENT; | |
486 | hcp_skb = skb; | |
487 | } | |
488 | ||
489 | /* if this is a response, dispatch immediately to | |
490 | * unblock waiting cmd context. Otherwise, enqueue to dispatch | |
491 | * in separate context where handler can also execute command. | |
492 | */ | |
493 | packet = (struct nci_hcp_packet *)hcp_skb->data; | |
494 | type = NCI_HCP_MSG_GET_TYPE(packet->message.header); | |
495 | if (type == NCI_HCI_HCP_RESPONSE) { | |
d8cd37ed CR |
496 | pipe = NCI_HCP_MSG_GET_PIPE(packet->header); |
497 | skb_pull(hcp_skb, NCI_HCI_HCP_PACKET_HEADER_LEN); | |
498 | nci_hci_hcp_message_rx(ndev, pipe, type, | |
499 | NCI_STATUS_OK, hcp_skb); | |
11f54f22 CR |
500 | } else { |
501 | skb_queue_tail(&ndev->hci_dev->msg_rx_queue, hcp_skb); | |
502 | schedule_work(&ndev->hci_dev->msg_rx_work); | |
503 | } | |
504 | } | |
505 | ||
506 | int nci_hci_open_pipe(struct nci_dev *ndev, u8 pipe) | |
507 | { | |
508 | struct nci_data data; | |
509 | struct nci_conn_info *conn_info; | |
510 | ||
511 | conn_info = ndev->hci_dev->conn_info; | |
512 | if (!conn_info) | |
513 | return -EPROTO; | |
514 | ||
515 | data.conn_id = conn_info->conn_id; | |
516 | data.pipe = pipe; | |
517 | data.cmd = NCI_HCP_HEADER(NCI_HCI_HCP_COMMAND, | |
518 | NCI_HCI_ANY_OPEN_PIPE); | |
519 | data.data = NULL; | |
520 | data.data_len = 0; | |
521 | ||
522 | return nci_request(ndev, nci_hci_send_data_req, | |
523 | (unsigned long)&data, | |
524 | msecs_to_jiffies(NCI_DATA_TIMEOUT)); | |
525 | } | |
526 | EXPORT_SYMBOL(nci_hci_open_pipe); | |
527 | ||
a1b0b941 CR |
528 | static u8 nci_hci_create_pipe(struct nci_dev *ndev, u8 dest_host, |
529 | u8 dest_gate, int *result) | |
530 | { | |
531 | u8 pipe; | |
532 | struct sk_buff *skb; | |
533 | struct nci_hci_create_pipe_params params; | |
534 | struct nci_hci_create_pipe_resp *resp; | |
535 | ||
536 | pr_debug("gate=%d\n", dest_gate); | |
537 | ||
538 | params.src_gate = NCI_HCI_ADMIN_GATE; | |
539 | params.dest_host = dest_host; | |
540 | params.dest_gate = dest_gate; | |
541 | ||
542 | *result = nci_hci_send_cmd(ndev, NCI_HCI_ADMIN_GATE, | |
543 | NCI_HCI_ADM_CREATE_PIPE, | |
544 | (u8 *)¶ms, sizeof(params), &skb); | |
545 | if (*result < 0) | |
546 | return NCI_HCI_INVALID_PIPE; | |
547 | ||
548 | resp = (struct nci_hci_create_pipe_resp *)skb->data; | |
549 | pipe = resp->pipe; | |
550 | kfree_skb(skb); | |
551 | ||
552 | pr_debug("pipe created=%d\n", pipe); | |
553 | ||
554 | return pipe; | |
555 | } | |
556 | ||
557 | static int nci_hci_delete_pipe(struct nci_dev *ndev, u8 pipe) | |
558 | { | |
559 | pr_debug("\n"); | |
560 | ||
561 | return nci_hci_send_cmd(ndev, NCI_HCI_ADMIN_GATE, | |
562 | NCI_HCI_ADM_DELETE_PIPE, &pipe, 1, NULL); | |
563 | } | |
564 | ||
11f54f22 CR |
565 | int nci_hci_set_param(struct nci_dev *ndev, u8 gate, u8 idx, |
566 | const u8 *param, size_t param_len) | |
567 | { | |
d8cd37ed | 568 | struct nci_hcp_message *message; |
11f54f22 CR |
569 | struct nci_conn_info *conn_info; |
570 | struct nci_data data; | |
571 | int r; | |
572 | u8 *tmp; | |
573 | u8 pipe = ndev->hci_dev->gate2pipe[gate]; | |
574 | ||
575 | pr_debug("idx=%d to gate %d\n", idx, gate); | |
576 | ||
577 | if (pipe == NCI_HCI_INVALID_PIPE) | |
578 | return -EADDRNOTAVAIL; | |
579 | ||
580 | conn_info = ndev->hci_dev->conn_info; | |
581 | if (!conn_info) | |
582 | return -EPROTO; | |
583 | ||
584 | tmp = kmalloc(1 + param_len, GFP_KERNEL); | |
585 | if (!tmp) | |
586 | return -ENOMEM; | |
587 | ||
588 | *tmp = idx; | |
589 | memcpy(tmp + 1, param, param_len); | |
590 | ||
591 | data.conn_id = conn_info->conn_id; | |
592 | data.pipe = pipe; | |
593 | data.cmd = NCI_HCP_HEADER(NCI_HCI_HCP_COMMAND, | |
594 | NCI_HCI_ANY_SET_PARAMETER); | |
595 | data.data = tmp; | |
596 | data.data_len = param_len + 1; | |
597 | ||
598 | r = nci_request(ndev, nci_hci_send_data_req, | |
599 | (unsigned long)&data, | |
600 | msecs_to_jiffies(NCI_DATA_TIMEOUT)); | |
d8cd37ed CR |
601 | if (r == NCI_STATUS_OK) { |
602 | message = (struct nci_hcp_message *)conn_info->rx_skb->data; | |
603 | r = nci_hci_result_to_errno( | |
604 | NCI_HCP_MSG_GET_CMD(message->header)); | |
605 | skb_pull(conn_info->rx_skb, NCI_HCI_HCP_MESSAGE_HEADER_LEN); | |
606 | } | |
11f54f22 CR |
607 | |
608 | kfree(tmp); | |
609 | return r; | |
610 | } | |
611 | EXPORT_SYMBOL(nci_hci_set_param); | |
612 | ||
613 | int nci_hci_get_param(struct nci_dev *ndev, u8 gate, u8 idx, | |
614 | struct sk_buff **skb) | |
615 | { | |
d8cd37ed | 616 | struct nci_hcp_message *message; |
11f54f22 CR |
617 | struct nci_conn_info *conn_info; |
618 | struct nci_data data; | |
619 | int r; | |
620 | u8 pipe = ndev->hci_dev->gate2pipe[gate]; | |
621 | ||
622 | pr_debug("idx=%d to gate %d\n", idx, gate); | |
623 | ||
624 | if (pipe == NCI_HCI_INVALID_PIPE) | |
625 | return -EADDRNOTAVAIL; | |
626 | ||
627 | conn_info = ndev->hci_dev->conn_info; | |
628 | if (!conn_info) | |
629 | return -EPROTO; | |
630 | ||
631 | data.conn_id = conn_info->conn_id; | |
632 | data.pipe = pipe; | |
633 | data.cmd = NCI_HCP_HEADER(NCI_HCI_HCP_COMMAND, | |
634 | NCI_HCI_ANY_GET_PARAMETER); | |
635 | data.data = &idx; | |
636 | data.data_len = 1; | |
637 | ||
638 | r = nci_request(ndev, nci_hci_send_data_req, (unsigned long)&data, | |
639 | msecs_to_jiffies(NCI_DATA_TIMEOUT)); | |
640 | ||
d8cd37ed CR |
641 | if (r == NCI_STATUS_OK) { |
642 | message = (struct nci_hcp_message *)conn_info->rx_skb->data; | |
643 | r = nci_hci_result_to_errno( | |
644 | NCI_HCP_MSG_GET_CMD(message->header)); | |
645 | skb_pull(conn_info->rx_skb, NCI_HCI_HCP_MESSAGE_HEADER_LEN); | |
646 | ||
647 | if (!r && skb) | |
648 | *skb = conn_info->rx_skb; | |
649 | } | |
11f54f22 CR |
650 | |
651 | return r; | |
652 | } | |
653 | EXPORT_SYMBOL(nci_hci_get_param); | |
654 | ||
655 | int nci_hci_connect_gate(struct nci_dev *ndev, | |
656 | u8 dest_host, u8 dest_gate, u8 pipe) | |
657 | { | |
a1b0b941 | 658 | bool pipe_created = false; |
11f54f22 CR |
659 | int r; |
660 | ||
661 | if (pipe == NCI_HCI_DO_NOT_OPEN_PIPE) | |
662 | return 0; | |
663 | ||
664 | if (ndev->hci_dev->gate2pipe[dest_gate] != NCI_HCI_INVALID_PIPE) | |
665 | return -EADDRINUSE; | |
666 | ||
667 | if (pipe != NCI_HCI_INVALID_PIPE) | |
668 | goto open_pipe; | |
669 | ||
670 | switch (dest_gate) { | |
671 | case NCI_HCI_LINK_MGMT_GATE: | |
672 | pipe = NCI_HCI_LINK_MGMT_PIPE; | |
673 | break; | |
674 | case NCI_HCI_ADMIN_GATE: | |
675 | pipe = NCI_HCI_ADMIN_PIPE; | |
676 | break; | |
a1b0b941 CR |
677 | default: |
678 | pipe = nci_hci_create_pipe(ndev, dest_host, dest_gate, &r); | |
2a84193f | 679 | if (pipe == NCI_HCI_INVALID_PIPE) |
a1b0b941 CR |
680 | return r; |
681 | pipe_created = true; | |
682 | break; | |
11f54f22 CR |
683 | } |
684 | ||
685 | open_pipe: | |
686 | r = nci_hci_open_pipe(ndev, pipe); | |
a1b0b941 CR |
687 | if (r < 0) { |
688 | if (pipe_created) { | |
689 | if (nci_hci_delete_pipe(ndev, pipe) < 0) { | |
690 | /* TODO: Cannot clean by deleting pipe... | |
691 | * -> inconsistent state | |
692 | */ | |
693 | } | |
694 | } | |
11f54f22 | 695 | return r; |
a1b0b941 | 696 | } |
11f54f22 CR |
697 | |
698 | ndev->hci_dev->pipes[pipe].gate = dest_gate; | |
699 | ndev->hci_dev->pipes[pipe].host = dest_host; | |
700 | ndev->hci_dev->gate2pipe[dest_gate] = pipe; | |
701 | ||
702 | return 0; | |
703 | } | |
704 | EXPORT_SYMBOL(nci_hci_connect_gate); | |
705 | ||
706 | static int nci_hci_dev_connect_gates(struct nci_dev *ndev, | |
707 | u8 gate_count, | |
708 | struct nci_hci_gate *gates) | |
709 | { | |
710 | int r; | |
711 | ||
712 | while (gate_count--) { | |
713 | r = nci_hci_connect_gate(ndev, gates->dest_host, | |
714 | gates->gate, gates->pipe); | |
715 | if (r < 0) | |
716 | return r; | |
717 | gates++; | |
718 | } | |
719 | ||
720 | return 0; | |
721 | } | |
722 | ||
723 | int nci_hci_dev_session_init(struct nci_dev *ndev) | |
724 | { | |
15d4a8da | 725 | struct nci_conn_info *conn_info; |
11f54f22 CR |
726 | struct sk_buff *skb; |
727 | int r; | |
728 | ||
729 | ndev->hci_dev->count_pipes = 0; | |
730 | ndev->hci_dev->expected_pipes = 0; | |
731 | ||
15d4a8da CR |
732 | conn_info = ndev->hci_dev->conn_info; |
733 | if (!conn_info) | |
734 | return -EPROTO; | |
735 | ||
736 | conn_info->data_exchange_cb = nci_hci_data_received_cb; | |
737 | conn_info->data_exchange_cb_context = ndev; | |
738 | ||
11f54f22 CR |
739 | nci_hci_reset_pipes(ndev->hci_dev); |
740 | ||
741 | if (ndev->hci_dev->init_data.gates[0].gate != NCI_HCI_ADMIN_GATE) | |
742 | return -EPROTO; | |
743 | ||
744 | r = nci_hci_connect_gate(ndev, | |
745 | ndev->hci_dev->init_data.gates[0].dest_host, | |
746 | ndev->hci_dev->init_data.gates[0].gate, | |
747 | ndev->hci_dev->init_data.gates[0].pipe); | |
748 | if (r < 0) | |
2622e2a0 | 749 | return r; |
11f54f22 CR |
750 | |
751 | r = nci_hci_get_param(ndev, NCI_HCI_ADMIN_GATE, | |
752 | NCI_HCI_ADMIN_PARAM_SESSION_IDENTITY, &skb); | |
753 | if (r < 0) | |
2622e2a0 | 754 | return r; |
11f54f22 CR |
755 | |
756 | if (skb->len && | |
757 | skb->len == strlen(ndev->hci_dev->init_data.session_id) && | |
2622e2a0 | 758 | !memcmp(ndev->hci_dev->init_data.session_id, skb->data, skb->len) && |
11f54f22 CR |
759 | ndev->ops->hci_load_session) { |
760 | /* Restore gate<->pipe table from some proprietary location. */ | |
761 | r = ndev->ops->hci_load_session(ndev); | |
11f54f22 | 762 | } else { |
8a49943f CR |
763 | r = nci_hci_clear_all_pipes(ndev); |
764 | if (r < 0) | |
765 | goto exit; | |
766 | ||
11f54f22 CR |
767 | r = nci_hci_dev_connect_gates(ndev, |
768 | ndev->hci_dev->init_data.gate_count, | |
769 | ndev->hci_dev->init_data.gates); | |
770 | if (r < 0) | |
771 | goto exit; | |
772 | ||
773 | r = nci_hci_set_param(ndev, NCI_HCI_ADMIN_GATE, | |
774 | NCI_HCI_ADMIN_PARAM_SESSION_IDENTITY, | |
775 | ndev->hci_dev->init_data.session_id, | |
776 | strlen(ndev->hci_dev->init_data.session_id)); | |
777 | } | |
11f54f22 CR |
778 | |
779 | exit: | |
780 | kfree_skb(skb); | |
781 | ||
782 | return r; | |
783 | } | |
784 | EXPORT_SYMBOL(nci_hci_dev_session_init); | |
785 | ||
786 | struct nci_hci_dev *nci_hci_allocate(struct nci_dev *ndev) | |
787 | { | |
788 | struct nci_hci_dev *hdev; | |
789 | ||
790 | hdev = kzalloc(sizeof(*hdev), GFP_KERNEL); | |
791 | if (!hdev) | |
792 | return NULL; | |
793 | ||
794 | skb_queue_head_init(&hdev->rx_hcp_frags); | |
795 | INIT_WORK(&hdev->msg_rx_work, nci_hci_msg_rx_work); | |
796 | skb_queue_head_init(&hdev->msg_rx_queue); | |
797 | hdev->ndev = ndev; | |
798 | ||
799 | return hdev; | |
800 | } |