Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
command.c
Go to the documentation of this file.
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
15  * along with this program; if not, write to the
16  * Free Software Foundation, Inc.,
17  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  */
19 
20 #define pr_fmt(fmt) "hci: %s: " fmt, __func__
21 
22 #include <linux/init.h>
23 #include <linux/kernel.h>
24 #include <linux/sched.h>
25 #include <linux/module.h>
26 
27 #include <net/nfc/hci.h>
28 
29 #include "hci.h"
30 
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,
42  param, param_len, cb, cb_context, 3000);
43 }
44 
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)
52 {
53  struct hcp_exec_waiter *hcp_ew = (struct hcp_exec_waiter *)context;
54 
55  pr_debug("HCI Cmd completed with result=%d\n", err);
56 
57  hcp_ew->exec_result = err;
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 {
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 
77  pr_debug("exec cmd sync through pipe=%d, cmd=%d, plen=%zd\n", pipe,
78  cmd, param_len);
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,
85  param, param_len,
86  nfc_hci_execute_cb, &hcp_ew,
87  3000);
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 }
118 
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 }
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 }
155 
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 }
172 
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 
197  tmp, param_len + 1, NULL);
198 
199  kfree(tmp);
200 
201  return r;
202 }
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 }
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;
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,
259  (u8 *) &params, sizeof(params), &skb);
260  if (*result == 0) {
261  resp = (struct hci_create_pipe_resp *)skb->data;
262  pipe = resp->pipe;
263  kfree_skb(skb);
264 
265  pr_debug("pipe created=%d\n", pipe);
266 
267  return pipe;
268  } else
269  return NFC_HCI_INVALID_PIPE;
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 {
282  int r;
283 
284  u8 param[2];
285 
286  /* TODO: Find out what the identity reference data is
287  * and fill param with it. HCI spec 6.1.3.5 */
288 
289  pr_debug("\n");
290 
291  r = nfc_hci_execute_cmd(hdev, NFC_HCI_ADMIN_PIPE,
292  NFC_HCI_ADM_CLEAR_ALL_PIPE, param, 2, NULL);
293 
294  return 0;
295 }
296 
297 int nfc_hci_disconnect_gate(struct nfc_hci_dev *hdev, u8 gate)
298 {
299  int r;
300  u8 pipe = hdev->gate2pipe[gate];
301 
302  pr_debug("\n");
303 
304  if (pipe == NFC_HCI_INVALID_PIPE)
305  return -EADDRNOTAVAIL;
306 
307  r = nfc_hci_close_pipe(hdev, pipe);
308  if (r < 0)
309  return r;
310 
311  if (pipe != NFC_HCI_LINK_MGMT_PIPE && pipe != NFC_HCI_ADMIN_PIPE) {
312  r = nfc_hci_delete_pipe(hdev, pipe);
313  if (r < 0)
314  return r;
315  }
316 
317  hdev->gate2pipe[gate] = NFC_HCI_INVALID_PIPE;
318 
319  return 0;
320 }
322 
324 {
325  int r;
326 
327  pr_debug("\n");
328 
329  r = nfc_hci_clear_all_pipes(hdev);
330  if (r < 0)
331  return r;
332 
333  memset(hdev->gate2pipe, NFC_HCI_INVALID_PIPE, sizeof(hdev->gate2pipe));
334 
335  return 0;
336 }
338 
339 int nfc_hci_connect_gate(struct nfc_hci_dev *hdev, u8 dest_host, u8 dest_gate,
340  u8 pipe)
341 {
342  bool pipe_created = false;
343  int r;
344 
345  pr_debug("\n");
346 
347  if (hdev->gate2pipe[dest_gate] != NFC_HCI_INVALID_PIPE)
348  return -EADDRINUSE;
349 
350  if (pipe != NFC_HCI_INVALID_PIPE)
351  goto pipe_is_open;
352 
353  switch (dest_gate) {
355  pipe = NFC_HCI_LINK_MGMT_PIPE;
356  break;
357  case NFC_HCI_ADMIN_GATE:
358  pipe = NFC_HCI_ADMIN_PIPE;
359  break;
360  default:
361  pipe = nfc_hci_create_pipe(hdev, dest_host, dest_gate, &r);
362  if (pipe == NFC_HCI_INVALID_PIPE)
363  return r;
364  pipe_created = true;
365  break;
366  }
367 
368  r = nfc_hci_open_pipe(hdev, pipe);
369  if (r < 0) {
370  if (pipe_created)
371  if (nfc_hci_delete_pipe(hdev, pipe) < 0) {
372  /* TODO: Cannot clean by deleting pipe...
373  * -> inconsistent state */
374  }
375  return r;
376  }
377 
378 pipe_is_open:
379  hdev->gate2pipe[dest_gate] = pipe;
380 
381  return 0;
382 }