~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/nfc/nci/hci.c

Version: ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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
 73 
 74 #define NCI_HFP_NO_CHAINING        0x80
 75 
 76 #define NCI_NFCEE_ID_HCI                0x80
 77 
 78 #define NCI_EVT_HOT_PLUG           0x03
 79 
 80 #define NCI_HCI_ADMIN_PARAM_SESSION_IDENTITY       0x01
 81 
 82 /* HCP headers */
 83 #define NCI_HCI_HCP_PACKET_HEADER_LEN      1
 84 #define NCI_HCI_HCP_MESSAGE_HEADER_LEN     1
 85 #define NCI_HCI_HCP_HEADER_LEN             2
 86 
 87 /* HCP types */
 88 #define NCI_HCI_HCP_COMMAND        0x00
 89 #define NCI_HCI_HCP_EVENT          0x01
 90 #define NCI_HCI_HCP_RESPONSE       0x02
 91 
 92 #define NCI_HCI_ADM_NOTIFY_PIPE_CREATED     0x12
 93 #define NCI_HCI_ADM_NOTIFY_PIPE_DELETED     0x13
 94 #define NCI_HCI_ADM_NOTIFY_ALL_PIPE_CLEARED 0x15
 95 
 96 #define NCI_HCI_FRAGMENT           0x7f
 97 #define NCI_HCP_HEADER(type, instr) ((((type) & 0x03) << 6) |\
 98                                       ((instr) & 0x3f))
 99 
100 #define NCI_HCP_MSG_GET_TYPE(header) ((header & 0xc0) >> 6)
101 #define NCI_HCP_MSG_GET_CMD(header)  (header & 0x3f)
102 #define NCI_HCP_MSG_GET_PIPE(header) (header & 0x7f)
103 
104 static int nci_hci_result_to_errno(u8 result)
105 {
106         switch (result) {
107         case NCI_HCI_ANY_OK:
108                 return 0;
109         case NCI_HCI_ANY_E_REG_PAR_UNKNOWN:
110                 return -EOPNOTSUPP;
111         case NCI_HCI_ANY_E_TIMEOUT:
112                 return -ETIME;
113         default:
114                 return -1;
115         }
116 }
117 
118 /* HCI core */
119 static void nci_hci_reset_pipes(struct nci_hci_dev *hdev)
120 {
121         int i;
122 
123         for (i = 0; i < NCI_HCI_MAX_PIPES; i++) {
124                 hdev->pipes[i].gate = NCI_HCI_INVALID_GATE;
125                 hdev->pipes[i].host = NCI_HCI_INVALID_HOST;
126         }
127         memset(hdev->gate2pipe, NCI_HCI_INVALID_PIPE, sizeof(hdev->gate2pipe));
128 }
129 
130 static void nci_hci_reset_pipes_per_host(struct nci_dev *ndev, u8 host)
131 {
132         int i;
133 
134         for (i = 0; i < NCI_HCI_MAX_PIPES; i++) {
135                 if (ndev->hci_dev->pipes[i].host == host) {
136                         ndev->hci_dev->pipes[i].gate = NCI_HCI_INVALID_GATE;
137                         ndev->hci_dev->pipes[i].host = NCI_HCI_INVALID_HOST;
138                 }
139         }
140 }
141 
142 /* Fragment HCI data over NCI packet.
143  * NFC Forum NCI 10.2.2 Data Exchange:
144  * The payload of the Data Packets sent on the Logical Connection SHALL be
145  * valid HCP packets, as defined within [ETSI_102622]. Each Data Packet SHALL
146  * contain a single HCP packet. NCI Segmentation and Reassembly SHALL NOT be
147  * applied to Data Messages in either direction. The HCI fragmentation mechanism
148  * is used if required.
149  */
150 static int nci_hci_send_data(struct nci_dev *ndev, u8 pipe,
151                              const u8 data_type, const u8 *data,
152                              size_t data_len)
153 {
154         struct nci_conn_info    *conn_info;
155         struct sk_buff *skb;
156         int len, i, r;
157         u8 cb = pipe;
158 
159         conn_info = ndev->hci_dev->conn_info;
160         if (!conn_info)
161                 return -EPROTO;
162 
163         i = 0;
164         skb = nci_skb_alloc(ndev, conn_info->max_pkt_payload_len +
165                             NCI_DATA_HDR_SIZE, GFP_KERNEL);
166         if (!skb)
167                 return -ENOMEM;
168 
169         skb_reserve(skb, NCI_DATA_HDR_SIZE + 2);
170         *skb_push(skb, 1) = data_type;
171 
172         do {
173                 len = conn_info->max_pkt_payload_len;
174 
175                 /* If last packet add NCI_HFP_NO_CHAINING */
176                 if (i + conn_info->max_pkt_payload_len -
177                     (skb->len + 1) >= data_len) {
178                         cb |= NCI_HFP_NO_CHAINING;
179                         len = data_len - i;
180                 } else {
181                         len = conn_info->max_pkt_payload_len - skb->len - 1;
182                 }
183 
184                 *skb_push(skb, 1) = cb;
185 
186                 if (len > 0)
187                         memcpy(skb_put(skb, len), data + i, len);
188 
189                 r = nci_send_data(ndev, conn_info->conn_id, skb);
190                 if (r < 0)
191                         return r;
192 
193                 i += len;
194 
195                 if (i < data_len) {
196                         skb = nci_skb_alloc(ndev,
197                                             conn_info->max_pkt_payload_len +
198                                             NCI_DATA_HDR_SIZE, GFP_KERNEL);
199                         if (!skb)
200                                 return -ENOMEM;
201 
202                         skb_reserve(skb, NCI_DATA_HDR_SIZE + 1);
203                 }
204         } while (i < data_len);
205 
206         return i;
207 }
208 
209 static void nci_hci_send_data_req(struct nci_dev *ndev, unsigned long opt)
210 {
211         struct nci_data *data = (struct nci_data *)opt;
212 
213         nci_hci_send_data(ndev, data->pipe, data->cmd,
214                           data->data, data->data_len);
215 }
216 
217 int nci_hci_send_event(struct nci_dev *ndev, u8 gate, u8 event,
218                        const u8 *param, size_t param_len)
219 {
220         u8 pipe = ndev->hci_dev->gate2pipe[gate];
221 
222         if (pipe == NCI_HCI_INVALID_PIPE)
223                 return -EADDRNOTAVAIL;
224 
225         return nci_hci_send_data(ndev, pipe,
226                         NCI_HCP_HEADER(NCI_HCI_HCP_EVENT, event),
227                         param, param_len);
228 }
229 EXPORT_SYMBOL(nci_hci_send_event);
230 
231 int nci_hci_send_cmd(struct nci_dev *ndev, u8 gate, u8 cmd,
232                      const u8 *param, size_t param_len,
233                      struct sk_buff **skb)
234 {
235         struct nci_hcp_message *message;
236         struct nci_conn_info   *conn_info;
237         struct nci_data data;
238         int r;
239         u8 pipe = ndev->hci_dev->gate2pipe[gate];
240 
241         if (pipe == NCI_HCI_INVALID_PIPE)
242                 return -EADDRNOTAVAIL;
243 
244         conn_info = ndev->hci_dev->conn_info;
245         if (!conn_info)
246                 return -EPROTO;
247 
248         data.conn_id = conn_info->conn_id;
249         data.pipe = pipe;
250         data.cmd = NCI_HCP_HEADER(NCI_HCI_HCP_COMMAND, cmd);
251         data.data = param;
252         data.data_len = param_len;
253 
254         r = nci_request(ndev, nci_hci_send_data_req, (unsigned long)&data,
255                         msecs_to_jiffies(NCI_DATA_TIMEOUT));
256         if (r == NCI_STATUS_OK) {
257                 message = (struct nci_hcp_message *)conn_info->rx_skb->data;
258                 r = nci_hci_result_to_errno(
259                         NCI_HCP_MSG_GET_CMD(message->header));
260                 skb_pull(conn_info->rx_skb, NCI_HCI_HCP_MESSAGE_HEADER_LEN);
261 
262                 if (!r && skb)
263                         *skb = conn_info->rx_skb;
264         }
265 
266         return r;
267 }
268 EXPORT_SYMBOL(nci_hci_send_cmd);
269 
270 static void nci_hci_event_received(struct nci_dev *ndev, u8 pipe,
271                                    u8 event, struct sk_buff *skb)
272 {
273         if (ndev->ops->hci_event_received)
274                 ndev->ops->hci_event_received(ndev, pipe, event, skb);
275 }
276 
277 static void nci_hci_cmd_received(struct nci_dev *ndev, u8 pipe,
278                                  u8 cmd, struct sk_buff *skb)
279 {
280         u8 gate = ndev->hci_dev->pipes[pipe].gate;
281         u8 status = NCI_HCI_ANY_OK | ~NCI_HCI_FRAGMENT;
282         u8 dest_gate, new_pipe;
283         struct nci_hci_create_pipe_resp *create_info;
284         struct nci_hci_delete_pipe_noti *delete_info;
285         struct nci_hci_all_pipe_cleared_noti *cleared_info;
286 
287         pr_debug("from gate %x pipe %x cmd %x\n", gate, pipe, cmd);
288 
289         switch (cmd) {
290         case NCI_HCI_ADM_NOTIFY_PIPE_CREATED:
291                 if (skb->len != 5) {
292                         status = NCI_HCI_ANY_E_NOK;
293                         goto exit;
294                 }
295                 create_info = (struct nci_hci_create_pipe_resp *)skb->data;
296                 dest_gate = create_info->dest_gate;
297                 new_pipe = create_info->pipe;
298 
299                 /* Save the new created pipe and bind with local gate,
300                  * the description for skb->data[3] is destination gate id
301                  * but since we received this cmd from host controller, we
302                  * are the destination and it is our local gate
303                  */
304                 ndev->hci_dev->gate2pipe[dest_gate] = new_pipe;
305                 ndev->hci_dev->pipes[new_pipe].gate = dest_gate;
306                 ndev->hci_dev->pipes[new_pipe].host =
307                                                 create_info->src_host;
308                 break;
309         case NCI_HCI_ANY_OPEN_PIPE:
310                 /* If the pipe is not created report an error */
311                 if (gate == NCI_HCI_INVALID_GATE) {
312                         status = NCI_HCI_ANY_E_NOK;
313                         goto exit;
314                 }
315                 break;
316         case NCI_HCI_ADM_NOTIFY_PIPE_DELETED:
317                 if (skb->len != 1) {
318                         status = NCI_HCI_ANY_E_NOK;
319                         goto exit;
320                 }
321                 delete_info = (struct nci_hci_delete_pipe_noti *)skb->data;
322 
323                 ndev->hci_dev->pipes[delete_info->pipe].gate =
324                                                 NCI_HCI_INVALID_GATE;
325                 ndev->hci_dev->pipes[delete_info->pipe].host =
326                                                 NCI_HCI_INVALID_HOST;
327                 break;
328         case NCI_HCI_ADM_NOTIFY_ALL_PIPE_CLEARED:
329                 if (skb->len != 1) {
330                         status = NCI_HCI_ANY_E_NOK;
331                         goto exit;
332                 }
333 
334                 cleared_info =
335                         (struct nci_hci_all_pipe_cleared_noti *)skb->data;
336                 nci_hci_reset_pipes_per_host(ndev, cleared_info->host);
337                 break;
338         default:
339                 pr_debug("Discarded unknown cmd %x to gate %x\n", cmd, gate);
340                 break;
341         }
342 
343         if (ndev->ops->hci_cmd_received)
344                 ndev->ops->hci_cmd_received(ndev, pipe, cmd, skb);
345 
346 exit:
347         nci_hci_send_data(ndev, pipe, status, NULL, 0);
348 
349         kfree_skb(skb);
350 }
351 
352 static void nci_hci_resp_received(struct nci_dev *ndev, u8 pipe,
353                                   u8 result, struct sk_buff *skb)
354 {
355         struct nci_conn_info    *conn_info;
356         u8 status = result;
357 
358         conn_info = ndev->hci_dev->conn_info;
359         if (!conn_info) {
360                 status = NCI_STATUS_REJECTED;
361                 goto exit;
362         }
363 
364         conn_info->rx_skb = skb;
365 
366 exit:
367         nci_req_complete(ndev, NCI_STATUS_OK);
368 }
369 
370 /* Receive hcp message for pipe, with type and cmd.
371  * skb contains optional message data only.
372  */
373 static void nci_hci_hcp_message_rx(struct nci_dev *ndev, u8 pipe,
374                                    u8 type, u8 instruction, struct sk_buff *skb)
375 {
376         switch (type) {
377         case NCI_HCI_HCP_RESPONSE:
378                 nci_hci_resp_received(ndev, pipe, instruction, skb);
379                 break;
380         case NCI_HCI_HCP_COMMAND:
381                 nci_hci_cmd_received(ndev, pipe, instruction, skb);
382                 break;
383         case NCI_HCI_HCP_EVENT:
384                 nci_hci_event_received(ndev, pipe, instruction, skb);
385                 break;
386         default:
387                 pr_err("UNKNOWN MSG Type %d, instruction=%d\n",
388                        type, instruction);
389                 kfree_skb(skb);
390                 break;
391         }
392 
393         nci_req_complete(ndev, 0);
394 }
395 
396 static void nci_hci_msg_rx_work(struct work_struct *work)
397 {
398         struct nci_hci_dev *hdev =
399                 container_of(work, struct nci_hci_dev, msg_rx_work);
400         struct sk_buff *skb;
401         struct nci_hcp_message *message;
402         u8 pipe, type, instruction;
403 
404         while ((skb = skb_dequeue(&hdev->msg_rx_queue)) != NULL) {
405                 pipe = NCI_HCP_MSG_GET_PIPE(skb->data[0]);
406                 skb_pull(skb, NCI_HCI_HCP_PACKET_HEADER_LEN);
407                 message = (struct nci_hcp_message *)skb->data;
408                 type = NCI_HCP_MSG_GET_TYPE(message->header);
409                 instruction = NCI_HCP_MSG_GET_CMD(message->header);
410                 skb_pull(skb, NCI_HCI_HCP_MESSAGE_HEADER_LEN);
411 
412                 nci_hci_hcp_message_rx(hdev->ndev, pipe,
413                                        type, instruction, skb);
414         }
415 }
416 
417 void nci_hci_data_received_cb(void *context,
418                               struct sk_buff *skb, int err)
419 {
420         struct nci_dev *ndev = (struct nci_dev *)context;
421         struct nci_hcp_packet *packet;
422         u8 pipe, type;
423         struct sk_buff *hcp_skb;
424         struct sk_buff *frag_skb;
425         int msg_len;
426 
427         pr_debug("\n");
428 
429         if (err) {
430                 nci_req_complete(ndev, err);
431                 return;
432         }
433 
434         packet = (struct nci_hcp_packet *)skb->data;
435         if ((packet->header & ~NCI_HCI_FRAGMENT) == 0) {
436                 skb_queue_tail(&ndev->hci_dev->rx_hcp_frags, skb);
437                 return;
438         }
439 
440         /* it's the last fragment. Does it need re-aggregation? */
441         if (skb_queue_len(&ndev->hci_dev->rx_hcp_frags)) {
442                 pipe = NCI_HCP_MSG_GET_PIPE(packet->header);
443                 skb_queue_tail(&ndev->hci_dev->rx_hcp_frags, skb);
444 
445                 msg_len = 0;
446                 skb_queue_walk(&ndev->hci_dev->rx_hcp_frags, frag_skb) {
447                         msg_len += (frag_skb->len -
448                                     NCI_HCI_HCP_PACKET_HEADER_LEN);
449                 }
450 
451                 hcp_skb = nfc_alloc_recv_skb(NCI_HCI_HCP_PACKET_HEADER_LEN +
452                                              msg_len, GFP_KERNEL);
453                 if (!hcp_skb) {
454                         nci_req_complete(ndev, -ENOMEM);
455                         return;
456                 }
457 
458                 *skb_put(hcp_skb, NCI_HCI_HCP_PACKET_HEADER_LEN) = pipe;
459 
460                 skb_queue_walk(&ndev->hci_dev->rx_hcp_frags, frag_skb) {
461                         msg_len = frag_skb->len - NCI_HCI_HCP_PACKET_HEADER_LEN;
462                         memcpy(skb_put(hcp_skb, msg_len), frag_skb->data +
463                                NCI_HCI_HCP_PACKET_HEADER_LEN, msg_len);
464                 }
465 
466                 skb_queue_purge(&ndev->hci_dev->rx_hcp_frags);
467         } else {
468                 packet->header &= NCI_HCI_FRAGMENT;
469                 hcp_skb = skb;
470         }
471 
472         /* if this is a response, dispatch immediately to
473          * unblock waiting cmd context. Otherwise, enqueue to dispatch
474          * in separate context where handler can also execute command.
475          */
476         packet = (struct nci_hcp_packet *)hcp_skb->data;
477         type = NCI_HCP_MSG_GET_TYPE(packet->message.header);
478         if (type == NCI_HCI_HCP_RESPONSE) {
479                 pipe = NCI_HCP_MSG_GET_PIPE(packet->header);
480                 skb_pull(hcp_skb, NCI_HCI_HCP_PACKET_HEADER_LEN);
481                 nci_hci_hcp_message_rx(ndev, pipe, type,
482                                        NCI_STATUS_OK, hcp_skb);
483         } else {
484                 skb_queue_tail(&ndev->hci_dev->msg_rx_queue, hcp_skb);
485                 schedule_work(&ndev->hci_dev->msg_rx_work);
486         }
487 }
488 
489 int nci_hci_open_pipe(struct nci_dev *ndev, u8 pipe)
490 {
491         struct nci_data data;
492         struct nci_conn_info    *conn_info;
493 
494         conn_info = ndev->hci_dev->conn_info;
495         if (!conn_info)
496                 return -EPROTO;
497 
498         data.conn_id = conn_info->conn_id;
499         data.pipe = pipe;
500         data.cmd = NCI_HCP_HEADER(NCI_HCI_HCP_COMMAND,
501                                        NCI_HCI_ANY_OPEN_PIPE);
502         data.data = NULL;
503         data.data_len = 0;
504 
505         return nci_request(ndev, nci_hci_send_data_req,
506                         (unsigned long)&data,
507                         msecs_to_jiffies(NCI_DATA_TIMEOUT));
508 }
509 EXPORT_SYMBOL(nci_hci_open_pipe);
510 
511 int nci_hci_set_param(struct nci_dev *ndev, u8 gate, u8 idx,
512                       const u8 *param, size_t param_len)
513 {
514         struct nci_hcp_message *message;
515         struct nci_conn_info *conn_info;
516         struct nci_data data;
517         int r;
518         u8 *tmp;
519         u8 pipe = ndev->hci_dev->gate2pipe[gate];
520 
521         pr_debug("idx=%d to gate %d\n", idx, gate);
522 
523         if (pipe == NCI_HCI_INVALID_PIPE)
524                 return -EADDRNOTAVAIL;
525 
526         conn_info = ndev->hci_dev->conn_info;
527         if (!conn_info)
528                 return -EPROTO;
529 
530         tmp = kmalloc(1 + param_len, GFP_KERNEL);
531         if (!tmp)
532                 return -ENOMEM;
533 
534         *tmp = idx;
535         memcpy(tmp + 1, param, param_len);
536 
537         data.conn_id = conn_info->conn_id;
538         data.pipe = pipe;
539         data.cmd = NCI_HCP_HEADER(NCI_HCI_HCP_COMMAND,
540                                        NCI_HCI_ANY_SET_PARAMETER);
541         data.data = tmp;
542         data.data_len = param_len + 1;
543 
544         r = nci_request(ndev, nci_hci_send_data_req,
545                         (unsigned long)&data,
546                         msecs_to_jiffies(NCI_DATA_TIMEOUT));
547         if (r == NCI_STATUS_OK) {
548                 message = (struct nci_hcp_message *)conn_info->rx_skb->data;
549                 r = nci_hci_result_to_errno(
550                         NCI_HCP_MSG_GET_CMD(message->header));
551                 skb_pull(conn_info->rx_skb, NCI_HCI_HCP_MESSAGE_HEADER_LEN);
552         }
553 
554         kfree(tmp);
555         return r;
556 }
557 EXPORT_SYMBOL(nci_hci_set_param);
558 
559 int nci_hci_get_param(struct nci_dev *ndev, u8 gate, u8 idx,
560                       struct sk_buff **skb)
561 {
562         struct nci_hcp_message *message;
563         struct nci_conn_info    *conn_info;
564         struct nci_data data;
565         int r;
566         u8 pipe = ndev->hci_dev->gate2pipe[gate];
567 
568         pr_debug("idx=%d to gate %d\n", idx, gate);
569 
570         if (pipe == NCI_HCI_INVALID_PIPE)
571                 return -EADDRNOTAVAIL;
572 
573         conn_info = ndev->hci_dev->conn_info;
574         if (!conn_info)
575                 return -EPROTO;
576 
577         data.conn_id = conn_info->conn_id;
578         data.pipe = pipe;
579         data.cmd = NCI_HCP_HEADER(NCI_HCI_HCP_COMMAND,
580                                   NCI_HCI_ANY_GET_PARAMETER);
581         data.data = &idx;
582         data.data_len = 1;
583 
584         r = nci_request(ndev, nci_hci_send_data_req, (unsigned long)&data,
585                         msecs_to_jiffies(NCI_DATA_TIMEOUT));
586 
587         if (r == NCI_STATUS_OK) {
588                 message = (struct nci_hcp_message *)conn_info->rx_skb->data;
589                 r = nci_hci_result_to_errno(
590                         NCI_HCP_MSG_GET_CMD(message->header));
591                 skb_pull(conn_info->rx_skb, NCI_HCI_HCP_MESSAGE_HEADER_LEN);
592 
593                 if (!r && skb)
594                         *skb = conn_info->rx_skb;
595         }
596 
597         return r;
598 }
599 EXPORT_SYMBOL(nci_hci_get_param);
600 
601 int nci_hci_connect_gate(struct nci_dev *ndev,
602                          u8 dest_host, u8 dest_gate, u8 pipe)
603 {
604         int r;
605 
606         if (pipe == NCI_HCI_DO_NOT_OPEN_PIPE)
607                 return 0;
608 
609         if (ndev->hci_dev->gate2pipe[dest_gate] != NCI_HCI_INVALID_PIPE)
610                 return -EADDRINUSE;
611 
612         if (pipe != NCI_HCI_INVALID_PIPE)
613                 goto open_pipe;
614 
615         switch (dest_gate) {
616         case NCI_HCI_LINK_MGMT_GATE:
617                 pipe = NCI_HCI_LINK_MGMT_PIPE;
618         break;
619         case NCI_HCI_ADMIN_GATE:
620                 pipe = NCI_HCI_ADMIN_PIPE;
621         break;
622         }
623 
624 open_pipe:
625         r = nci_hci_open_pipe(ndev, pipe);
626         if (r < 0)
627                 return r;
628 
629         ndev->hci_dev->pipes[pipe].gate = dest_gate;
630         ndev->hci_dev->pipes[pipe].host = dest_host;
631         ndev->hci_dev->gate2pipe[dest_gate] = pipe;
632 
633         return 0;
634 }
635 EXPORT_SYMBOL(nci_hci_connect_gate);
636 
637 static int nci_hci_dev_connect_gates(struct nci_dev *ndev,
638                                      u8 gate_count,
639                                      struct nci_hci_gate *gates)
640 {
641         int r;
642 
643         while (gate_count--) {
644                 r = nci_hci_connect_gate(ndev, gates->dest_host,
645                                          gates->gate, gates->pipe);
646                 if (r < 0)
647                         return r;
648                 gates++;
649         }
650 
651         return 0;
652 }
653 
654 int nci_hci_dev_session_init(struct nci_dev *ndev)
655 {
656         struct nci_conn_info    *conn_info;
657         struct sk_buff *skb;
658         int r;
659 
660         ndev->hci_dev->count_pipes = 0;
661         ndev->hci_dev->expected_pipes = 0;
662 
663         conn_info = ndev->hci_dev->conn_info;
664         if (!conn_info)
665                 return -EPROTO;
666 
667         conn_info->data_exchange_cb = nci_hci_data_received_cb;
668         conn_info->data_exchange_cb_context = ndev;
669 
670         nci_hci_reset_pipes(ndev->hci_dev);
671 
672         if (ndev->hci_dev->init_data.gates[0].gate != NCI_HCI_ADMIN_GATE)
673                 return -EPROTO;
674 
675         r = nci_hci_connect_gate(ndev,
676                                  ndev->hci_dev->init_data.gates[0].dest_host,
677                                  ndev->hci_dev->init_data.gates[0].gate,
678                                  ndev->hci_dev->init_data.gates[0].pipe);
679         if (r < 0)
680                 return r;
681 
682         r = nci_hci_get_param(ndev, NCI_HCI_ADMIN_GATE,
683                               NCI_HCI_ADMIN_PARAM_SESSION_IDENTITY, &skb);
684         if (r < 0)
685                 return r;
686 
687         if (skb->len &&
688             skb->len == strlen(ndev->hci_dev->init_data.session_id) &&
689             !memcmp(ndev->hci_dev->init_data.session_id, skb->data, skb->len) &&
690             ndev->ops->hci_load_session) {
691                 /* Restore gate<->pipe table from some proprietary location. */
692                 r = ndev->ops->hci_load_session(ndev);
693         } else {
694                 r = nci_hci_dev_connect_gates(ndev,
695                                               ndev->hci_dev->init_data.gate_count,
696                                               ndev->hci_dev->init_data.gates);
697                 if (r < 0)
698                         goto exit;
699 
700                 r = nci_hci_set_param(ndev, NCI_HCI_ADMIN_GATE,
701                                       NCI_HCI_ADMIN_PARAM_SESSION_IDENTITY,
702                                       ndev->hci_dev->init_data.session_id,
703                                       strlen(ndev->hci_dev->init_data.session_id));
704         }
705 
706 exit:
707         kfree_skb(skb);
708 
709         return r;
710 }
711 EXPORT_SYMBOL(nci_hci_dev_session_init);
712 
713 struct nci_hci_dev *nci_hci_allocate(struct nci_dev *ndev)
714 {
715         struct nci_hci_dev *hdev;
716 
717         hdev = kzalloc(sizeof(*hdev), GFP_KERNEL);
718         if (!hdev)
719                 return NULL;
720 
721         skb_queue_head_init(&hdev->rx_hcp_frags);
722         INIT_WORK(&hdev->msg_rx_work, nci_hci_msg_rx_work);
723         skb_queue_head_init(&hdev->msg_rx_queue);
724         hdev->ndev = ndev;
725 
726         return hdev;
727 }
728 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp