nfa_hci_api.c revision a24be4f06674b2707b57904deaa0dff5a95823bd
1/******************************************************************************
2 *
3 *  Copyright (C) 2010-2014 Broadcom Corporation
4 *
5 *  Licensed under the Apache License, Version 2.0 (the "License");
6 *  you may not use this file except in compliance with the License.
7 *  You may obtain a copy of the License at:
8 *
9 *  http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *  See the License for the specific language governing permissions and
15 *  limitations under the License.
16 *
17 ******************************************************************************/
18
19
20/******************************************************************************
21 *
22 *  NFA interface to HCI
23 *
24 ******************************************************************************/
25#include <string.h>
26#include "nfc_api.h"
27#include "nfa_sys.h"
28#include "nfa_sys_int.h"
29#include "nfa_hci_api.h"
30#include "nfa_hci_int.h"
31#include "nfa_hci_defs.h"
32
33/*******************************************************************************
34**
35** Function         NFA_HciRegister
36**
37** Description      This function will register an application with hci and
38**                  returns an application handle and provides a mechanism to
39**                  register a callback with HCI to receive NFA HCI event notification.
40**                  When the application is registered (or if an error occurs),
41**                  the app will be notified with NFA_HCI_REGISTER_EVT. Previous
42**                  session information including allocated gates, created pipes
43**                  and pipes states will be returned as part of tNFA_HCI_REGISTER data.
44**
45** Returns          NFA_STATUS_OK if successfully initiated
46**                  NFA_STATUS_FAILED otherwise
47**
48*******************************************************************************/
49tNFA_STATUS NFA_HciRegister (char *p_app_name, tNFA_HCI_CBACK *p_cback, BOOLEAN b_send_conn_evts)
50{
51    tNFA_HCI_API_REGISTER_APP *p_msg;
52    UINT8                     app_name_len;
53
54    if (p_app_name == NULL)
55    {
56        NFA_TRACE_API0 ("NFA_HciRegister (): Invalid Application name");
57        return (NFA_STATUS_FAILED);
58    }
59
60    if (p_cback == NULL)
61    {
62        NFA_TRACE_API0 ("NFA_HciRegister (): Application should provide callback function to register!");
63        return (NFA_STATUS_FAILED);
64    }
65
66    NFA_TRACE_API1 ("NFA_HciRegister (): Application Name: %s", p_app_name);
67
68    app_name_len = (UINT8) strlen (p_app_name);
69
70    /* Register the application with HCI */
71    if (  (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
72        &&(p_app_name != NULL)
73        &&(app_name_len <= NFA_MAX_HCI_APP_NAME_LEN)
74        &&((p_msg = (tNFA_HCI_API_REGISTER_APP *) GKI_getbuf (sizeof (tNFA_HCI_API_REGISTER_APP))) != NULL))
75    {
76        p_msg->hdr.event  = NFA_HCI_API_REGISTER_APP_EVT;
77
78        /* Save application name and callback */
79        memset (p_msg->app_name, 0, sizeof (p_msg->app_name));
80        BCM_STRNCPY_S (p_msg->app_name, sizeof (p_msg->app_name), p_app_name, NFA_MAX_HCI_APP_NAME_LEN);
81        p_msg->p_cback          = p_cback;
82        p_msg->b_send_conn_evts = b_send_conn_evts;
83
84        nfa_sys_sendmsg (p_msg);
85        return (NFA_STATUS_OK);
86    }
87
88    return (NFA_STATUS_FAILED);
89}
90
91/*******************************************************************************
92**
93** Function         NFA_HciGetGateAndPipeList
94**
95** Description      This function will get the list of gates allocated to the
96**                  application and list of dynamic pipes created by the
97**                  application. The app will be notified with
98**                  NFA_HCI_GET_GATE_PIPE_LIST_EVT. List of allocated dynamic
99**                  gates to the application and list of pipes created by the
100**                  application will be returned as part of
101**                  tNFA_HCI_GET_GATE_PIPE_LIST data.
102**
103** Returns          NFA_STATUS_OK if successfully initiated
104**                  NFA_STATUS_FAILED otherwise
105**
106*******************************************************************************/
107tNFA_STATUS NFA_HciGetGateAndPipeList (tNFA_HANDLE hci_handle)
108{
109    tNFA_HCI_API_GET_APP_GATE_PIPE *p_msg;
110
111    if ((NFA_HANDLE_GROUP_MASK & hci_handle) != NFA_HANDLE_GROUP_HCI)
112    {
113        NFA_TRACE_API1 ("NFA_HciGetGateAndPipeList (): Invalid hci_handle:0x%04x", hci_handle);
114        return (NFA_STATUS_FAILED);
115    }
116
117    NFA_TRACE_API1 ("NFA_HciGetGateAndPipeList (): hci_handle:0x%04x", hci_handle);
118
119    /* Register the application with HCI */
120    if (  (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
121        &&((p_msg = (tNFA_HCI_API_GET_APP_GATE_PIPE *) GKI_getbuf (sizeof (tNFA_HCI_API_GET_APP_GATE_PIPE))) != NULL))
122    {
123        p_msg->hdr.event  = NFA_HCI_API_GET_APP_GATE_PIPE_EVT;
124        p_msg->hci_handle = hci_handle;
125
126        nfa_sys_sendmsg (p_msg);
127        return (NFA_STATUS_OK);
128    }
129
130    return (NFA_STATUS_FAILED);
131}
132
133/*******************************************************************************
134**
135** Function         NFA_HciDeregister
136**
137** Description      This function is called to deregister an application
138**                  from HCI. The app will be notified by NFA_HCI_DEREGISTER_EVT
139**                  after deleting all the pipes owned by the app and deallocating
140**                  all the gates allocated to the app or if an error occurs.
141**                  Even if deregistration fails, the app has to register again
142**                  to provide a new cback function.
143**
144** Returns          NFA_STATUS_OK if the application is deregistered successfully
145**                  NFA_STATUS_FAILED otherwise
146
147*******************************************************************************/
148tNFA_STATUS NFA_HciDeregister (char *p_app_name)
149{
150    tNFA_HCI_API_DEREGISTER_APP *p_msg;
151    int                         xx;
152    UINT8                       app_name_len;
153
154    if (p_app_name == NULL)
155    {
156        NFA_TRACE_API0 ("NFA_HciDeregister (): Invalid Application");
157        return (NFA_STATUS_FAILED);
158    }
159
160    NFA_TRACE_API1 ("NFA_HciDeregister (): Application Name: %s", p_app_name);
161    app_name_len = (UINT8) strlen (p_app_name);
162
163    if (app_name_len > NFA_MAX_HCI_APP_NAME_LEN)
164        return (NFA_STATUS_FAILED);
165
166    /* Find the application registration */
167    for (xx = 0; xx < NFA_HCI_MAX_APP_CB; xx++)
168    {
169        if (  (nfa_hci_cb.cfg.reg_app_names[xx][0] != 0)
170            &&(!strncmp (p_app_name, &nfa_hci_cb.cfg.reg_app_names[xx][0], app_name_len)) )
171            break;
172    }
173
174    if (xx == NFA_HCI_MAX_APP_CB)
175    {
176        NFA_TRACE_ERROR1 ("NFA_HciDeregister (): Application Name: %s  NOT FOUND", p_app_name);
177        return (NFA_STATUS_FAILED);
178    }
179
180    /* Deregister the application with HCI */
181    if (  (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
182        &&((p_msg = (tNFA_HCI_API_DEREGISTER_APP *) GKI_getbuf (sizeof (tNFA_HCI_API_DEREGISTER_APP))) != NULL) )
183    {
184        p_msg->hdr.event  = NFA_HCI_API_DEREGISTER_APP_EVT;
185
186        memset (p_msg->app_name, 0, sizeof (p_msg->app_name));
187        BCM_STRNCPY_S (p_msg->app_name, sizeof (p_msg->app_name), p_app_name, NFA_MAX_HCI_APP_NAME_LEN);
188
189        nfa_sys_sendmsg (p_msg);
190        return (NFA_STATUS_OK);
191    }
192
193    return (NFA_STATUS_FAILED);
194}
195
196/*******************************************************************************
197**
198** Function         NFA_HciAllocGate
199**
200** Description      This function will allocate the gate if any specified or an
201**                  available generic gate for the app to provide an entry point
202**                  for a particular service to other host or to establish
203**                  communication with other host. When the gate is
204**                  allocated (or if an error occurs), the app will be notified
205**                  with NFA_HCI_ALLOCATE_GATE_EVT with the gate id. The allocated
206**                  Gate information will be stored in non volatile memory.
207**
208** Returns          NFA_STATUS_OK if this API started
209**                  NFA_STATUS_FAILED if no generic gate is available
210**
211*******************************************************************************/
212tNFA_STATUS NFA_HciAllocGate (tNFA_HANDLE hci_handle, UINT8 gate)
213{
214    tNFA_HCI_API_ALLOC_GATE *p_msg;
215
216    if ((NFA_HANDLE_GROUP_MASK & hci_handle) != NFA_HANDLE_GROUP_HCI)
217    {
218        NFA_TRACE_API1 ("NFA_HciAllocGate (): Invalid hci_handle:0x%04x", hci_handle);
219        return (NFA_STATUS_FAILED);
220    }
221
222    if (  (gate)
223        &&((gate < NFA_HCI_FIRST_HOST_SPECIFIC_GENERIC_GATE) || (gate > NFA_HCI_LAST_PROP_GATE) || (gate == NFA_HCI_CONNECTIVITY_GATE))  )
224    {
225        NFA_TRACE_API1 ("NFA_HciAllocGate (): Cannot allocate gate:0x%02x", gate);
226        return (NFA_STATUS_FAILED);
227    }
228
229    NFA_TRACE_API2 ("NFA_HciAllocGate (): hci_handle:0x%04x, Gate:0x%02x", hci_handle, gate);
230
231    /* Request HCI to allocate gate to the application */
232    if (  (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
233        &&((p_msg = (tNFA_HCI_API_ALLOC_GATE *) GKI_getbuf (sizeof (tNFA_HCI_API_ALLOC_GATE))) != NULL) )
234    {
235        p_msg->hdr.event  = NFA_HCI_API_ALLOC_GATE_EVT;
236        p_msg->hci_handle = hci_handle;
237        p_msg->gate       = gate;
238
239        nfa_sys_sendmsg (p_msg);
240        return (NFA_STATUS_OK);
241    }
242    return (NFA_STATUS_FAILED);
243}
244
245/*******************************************************************************
246**
247** Function         NFA_HciDeallocGate
248**
249** Description      This function will release the specified gate that was
250**                  previously allocated to the application. When the generic
251**                  gate is released (or if an error occurs), the app will be
252**                  notified with NFA_HCI_DEALLOCATE_GATE_EVT with the gate id.
253**
254** Returns          NFA_STATUS_OK if successfully initiated
255**                  NFA_STATUS_FAILED otherwise
256**
257*******************************************************************************/
258tNFA_STATUS NFA_HciDeallocGate (tNFA_HANDLE hci_handle, UINT8 gate)
259{
260    tNFA_HCI_API_DEALLOC_GATE *p_msg;
261
262    if ((NFA_HANDLE_GROUP_MASK & hci_handle) != NFA_HANDLE_GROUP_HCI)
263    {
264        NFA_TRACE_API1 ("NFA_HciDeallocGate (): Invalid hci_handle:0x%04x", hci_handle);
265        return (NFA_STATUS_FAILED);
266    }
267
268    if ((gate < NFA_HCI_FIRST_HOST_SPECIFIC_GENERIC_GATE) || (gate > NFA_HCI_LAST_PROP_GATE) || (gate == NFA_HCI_CONNECTIVITY_GATE))
269    {
270        NFA_TRACE_API1 ("NFA_HciDeallocGate (): Cannot deallocate the gate:0x%02x", gate);
271        return (NFA_STATUS_FAILED);
272    }
273
274    NFA_TRACE_API2 ("NFA_HciDeallocGate (): hci_handle:0x%04x, gate:0x%02X", hci_handle, gate);
275
276    /* Request HCI to deallocate the gate that was previously allocated to the application */
277    if (  (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
278        &&((p_msg = (tNFA_HCI_API_DEALLOC_GATE *) GKI_getbuf (sizeof (tNFA_HCI_API_DEALLOC_GATE))) != NULL) )
279    {
280        p_msg->hdr.event  = NFA_HCI_API_DEALLOC_GATE_EVT;
281        p_msg->hci_handle = hci_handle;
282        p_msg->gate       = gate;
283
284        nfa_sys_sendmsg (p_msg);
285        return (NFA_STATUS_OK);
286    }
287    return (NFA_STATUS_FAILED);
288}
289
290/*******************************************************************************
291**
292** Function         NFA_HciGetHostList
293**
294** Description      This function will request the host controller to return the
295**                  list of hosts that are present in the host network. When
296**                  host controller responds with the host list (or if an error
297**                  occurs), the app will be notified with NFA_HCI_HOST_LIST_EVT
298**
299** Returns          NFA_STATUS_OK if successfully initiated
300**                  NFA_STATUS_FAILED otherwise
301**
302*******************************************************************************/
303tNFA_STATUS NFA_HciGetHostList (tNFA_HANDLE hci_handle)
304{
305    tNFA_HCI_API_GET_HOST_LIST *p_msg;
306
307
308    if ((NFA_HANDLE_GROUP_MASK & hci_handle) != NFA_HANDLE_GROUP_HCI)
309    {
310        NFA_TRACE_API1 ("NFA_HciGetHostList (): Invalid hci_handle:0x%04x", hci_handle);
311        return (NFA_STATUS_FAILED);
312    }
313
314    NFA_TRACE_API1 ("NFA_HciGetHostList (): hci_handle:0x%04x",hci_handle);
315
316    /* Request HCI to get list of host in the hci network */
317    if (  (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
318        &&((p_msg = (tNFA_HCI_API_GET_HOST_LIST *) GKI_getbuf (sizeof (tNFA_HCI_API_GET_HOST_LIST))) != NULL) )
319    {
320        p_msg->hdr.event    = NFA_HCI_API_GET_HOST_LIST_EVT;
321        p_msg->hci_handle   = hci_handle;
322
323        nfa_sys_sendmsg (p_msg);
324        return (NFA_STATUS_OK);
325    }
326
327    return (NFA_STATUS_FAILED);
328}
329
330/*******************************************************************************
331**
332** Function         NFA_HciCreatePipe
333**
334** Description      This function is called to create a dynamic pipe with the
335**                  specified host. When the dynamic pipe is created (or
336**                  if an error occurs), the app will be notified with
337**                  NFA_HCI_CREATE_PIPE_EVT with the pipe id. If a pipe exists
338**                  between the two gates passed as argument and if it was
339**                  created earlier by the calling application then the pipe
340**                  id of the existing pipe will be returned and a new pipe
341**                  will not be created. After successful creation of pipe,
342**                  registry entry will be created for the dynamic pipe and
343**                  all information related to the pipe will be stored in non
344**                  volatile memory.
345**
346** Returns          NFA_STATUS_OK if successfully initiated
347**                  NFA_STATUS_FAILED otherwise
348**
349*******************************************************************************/
350tNFA_STATUS NFA_HciCreatePipe (tNFA_HANDLE  hci_handle,
351                               UINT8        source_gate_id,
352                               UINT8        dest_host,
353                               UINT8        dest_gate)
354{
355    tNFA_HCI_API_CREATE_PIPE_EVT *p_msg;
356    UINT8                        xx;
357
358    NFA_TRACE_API4 ("NFA_HciCreatePipe (): hci_handle:0x%04x, source gate:0x%02X, destination host:0x%02X , destination gate:0x%02X",
359                                         hci_handle, source_gate_id, dest_host, dest_gate);
360
361    if ((NFA_HANDLE_GROUP_MASK & hci_handle) != NFA_HANDLE_GROUP_HCI)
362    {
363        NFA_TRACE_API1 ("NFA_HciCreatePipe (): Invalid hci_handle:0x%04x", hci_handle);
364        return (NFA_STATUS_FAILED);
365    }
366
367    if ((source_gate_id < NFA_HCI_FIRST_HOST_SPECIFIC_GENERIC_GATE) || (source_gate_id > NFA_HCI_LAST_PROP_GATE))
368    {
369        NFA_TRACE_API1 ("NFA_HciCreatePipe (): Invalid local Gate:0x%02x", source_gate_id);
370        return (NFA_STATUS_FAILED);
371    }
372
373    if (  ((dest_gate < NFA_HCI_FIRST_HOST_SPECIFIC_GENERIC_GATE) && (dest_gate != NFA_HCI_LOOP_BACK_GATE) && (dest_gate != NFA_HCI_IDENTITY_MANAGEMENT_GATE))
374        ||(dest_gate > NFA_HCI_LAST_PROP_GATE))
375    {
376        NFA_TRACE_API1 ("NFA_HciCreatePipe (): Invalid Destination Gate:0x%02x", dest_gate);
377        return (NFA_STATUS_FAILED);
378    }
379
380    for (xx = 0; xx < NFA_HCI_MAX_HOST_IN_NETWORK; xx++)
381        if (nfa_hci_cb.inactive_host[xx] == dest_host)
382            break;
383
384    if (xx != NFA_HCI_MAX_HOST_IN_NETWORK)
385    {
386        NFA_TRACE_API1 ("NFA_HciCreatePipe (): Host not active:0x%02x", dest_host);
387        return (NFA_STATUS_FAILED);
388    }
389
390    /* Request HCI to create a pipe between two specified gates */
391    if (  (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
392        &&(!nfa_hci_cb.b_low_power_mode)
393        &&((p_msg = (tNFA_HCI_API_CREATE_PIPE_EVT *) GKI_getbuf (sizeof (tNFA_HCI_API_CREATE_PIPE_EVT))) != NULL) )
394    {
395        p_msg->hdr.event    = NFA_HCI_API_CREATE_PIPE_EVT;
396        p_msg->hci_handle   = hci_handle;
397        p_msg->source_gate  = source_gate_id;
398        p_msg->dest_host    = dest_host;        /* Host id of the destination host */
399        p_msg->dest_gate    = dest_gate;        /* Gate id of the destination gate */
400
401        nfa_sys_sendmsg (p_msg);
402        return (NFA_STATUS_OK);
403    }
404    return (NFA_STATUS_FAILED);
405}
406
407/*******************************************************************************
408**
409** Function         NFA_HciOpenPipe
410**
411** Description      This function is called to open a dynamic pipe.
412**                  When the dynamic pipe is opened (or
413**                  if an error occurs), the app will be notified with
414**                  NFA_HCI_OPEN_PIPE_EVT with the pipe id.
415**
416** Returns          NFA_STATUS_OK if successfully initiated
417**                  NFA_STATUS_FAILED otherwise
418**
419*******************************************************************************/
420tNFA_STATUS NFA_HciOpenPipe (tNFA_HANDLE hci_handle, UINT8 pipe)
421{
422    tNFA_HCI_API_OPEN_PIPE_EVT *p_msg;
423
424    if ((NFA_HANDLE_GROUP_MASK & hci_handle) != NFA_HANDLE_GROUP_HCI)
425    {
426        NFA_TRACE_API1 ("NFA_HciOpenPipe (): Invalid hci_handle:0x%04x", hci_handle);
427        return (NFA_STATUS_FAILED);
428    }
429
430    if ((pipe < NFA_HCI_FIRST_DYNAMIC_PIPE) || (pipe > NFA_HCI_LAST_DYNAMIC_PIPE))
431    {
432        NFA_TRACE_API1 ("NFA_HciOpenPipe (): Invalid Pipe:0x%02x", pipe);
433        return (NFA_STATUS_FAILED);
434    }
435
436
437    NFA_TRACE_API2 ("NFA_HciOpenPipe (): hci_handle:0x%04x, pipe:0x%02X", hci_handle, pipe);
438
439    /* Request HCI to open a pipe if it is in closed state */
440    if (  (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
441        &&(!nfa_hci_cb.b_low_power_mode)
442        &&((p_msg = (tNFA_HCI_API_OPEN_PIPE_EVT *) GKI_getbuf (sizeof (tNFA_HCI_API_OPEN_PIPE_EVT))) != NULL) )
443    {
444        p_msg->hdr.event    = NFA_HCI_API_OPEN_PIPE_EVT;
445        p_msg->hci_handle   = hci_handle;
446        p_msg->pipe         = pipe;                     /* Pipe ID of the pipe to open */
447
448        nfa_sys_sendmsg (p_msg);
449        return (NFA_STATUS_OK);
450    }
451    return (NFA_STATUS_FAILED);
452}
453
454/*******************************************************************************
455**
456** Function         NFA_HciGetRegistry
457**
458** Description      This function requests a peer host to return the desired
459**                  registry field value for the gate that the pipe is on.
460**
461**                  When the peer host responds,the app is notified with
462**                  NFA_HCI_GET_REG_RSP_EVT or
463**                  if an error occurs in sending the command the app will be
464**                  notified by NFA_HCI_CMD_SENT_EVT
465**
466** Returns          NFA_STATUS_OK if successfully initiated
467**                  NFA_STATUS_FAILED otherwise
468**
469*******************************************************************************/
470tNFA_STATUS NFA_HciGetRegistry (tNFA_HANDLE hci_handle, UINT8 pipe, UINT8 reg_inx)
471{
472    tNFA_HCI_API_GET_REGISTRY *p_msg;
473
474    if ((NFA_HANDLE_GROUP_MASK & hci_handle) != NFA_HANDLE_GROUP_HCI)
475    {
476        NFA_TRACE_API1 ("NFA_HciGetRegistry (): Invalid hci_handle:0x%04x", hci_handle);
477        return (NFA_STATUS_FAILED);
478    }
479
480    if (pipe < NFA_HCI_FIRST_DYNAMIC_PIPE)
481    {
482        NFA_TRACE_API1 ("NFA_HciGetRegistry (): Invalid Pipe:0x%02x", pipe);
483        return (NFA_STATUS_FAILED);
484    }
485
486    NFA_TRACE_API2 ("NFA_HciGetRegistry (): hci_handle:0x%04x  Pipe: 0x%02x", hci_handle, pipe);
487
488    /* Request HCI to get list of gates supported by the specified host */
489    if (  (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
490        &&((p_msg = (tNFA_HCI_API_GET_REGISTRY *) GKI_getbuf (sizeof (tNFA_HCI_API_GET_REGISTRY))) != NULL) )
491    {
492        p_msg->hdr.event    = NFA_HCI_API_GET_REGISTRY_EVT;
493        p_msg->hci_handle   = hci_handle;
494        p_msg->pipe         = pipe;
495        p_msg->reg_inx      = reg_inx;
496
497        nfa_sys_sendmsg (p_msg);
498        return (NFA_STATUS_OK);
499    }
500
501    return (NFA_STATUS_FAILED);
502}
503
504/*******************************************************************************
505**
506** Function         NFA_HciSetRegistry
507**
508** Description      This function requests a peer host to set the desired
509**                  registry field value for the gate that the pipe is on.
510**
511**                  When the peer host responds,the app is notified with
512**                  NFA_HCI_SET_REG_RSP_EVT or
513**                  if an error occurs in sending the command the app will be
514**                  notified by NFA_HCI_CMD_SENT_EVT
515**
516** Returns          NFA_STATUS_OK if successfully initiated
517**                  NFA_STATUS_FAILED otherwise
518**
519*******************************************************************************/
520NFC_API extern tNFA_STATUS NFA_HciSetRegistry (tNFA_HANDLE   hci_handle,
521                                               UINT8         pipe,
522                                               UINT8         reg_inx,
523                                               UINT8         data_size,
524                                               UINT8         *p_data)
525{
526    tNFA_HCI_API_SET_REGISTRY *p_msg;
527
528
529    if ((NFA_HANDLE_GROUP_MASK & hci_handle) != NFA_HANDLE_GROUP_HCI)
530    {
531        NFA_TRACE_API1 ("NFA_HciSetRegistry (): Invalid hci_handle:0x%04x", hci_handle);
532        return (NFA_STATUS_FAILED);
533    }
534
535    if (pipe < NFA_HCI_FIRST_DYNAMIC_PIPE)
536    {
537        NFA_TRACE_API1 ("NFA_HciSetRegistry (): Invalid Pipe:0x%02x", pipe);
538        return (NFA_STATUS_FAILED);
539    }
540
541    if ((data_size == 0) || (p_data == NULL) || (data_size > NFA_MAX_HCI_CMD_LEN))
542    {
543        NFA_TRACE_API1 ("NFA_HciSetRegistry (): Invalid data size:0x%02x", data_size);
544        return (NFA_STATUS_FAILED);
545    }
546
547    NFA_TRACE_API2 ("NFA_HciSetRegistry (): hci_handle:0x%04x  Pipe: 0x%02x", hci_handle, pipe);
548
549    /* Request HCI to get list of gates supported by the specified host */
550    if (  (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
551        &&((p_msg = (tNFA_HCI_API_SET_REGISTRY *) GKI_getbuf (sizeof (tNFA_HCI_API_SET_REGISTRY))) != NULL) )
552    {
553        p_msg->hdr.event    = NFA_HCI_API_SET_REGISTRY_EVT;
554        p_msg->hci_handle   = hci_handle;
555        p_msg->pipe         = pipe;
556        p_msg->reg_inx      = reg_inx;
557        p_msg->size         = data_size;
558
559        memcpy (p_msg->data, p_data, data_size);
560        nfa_sys_sendmsg (p_msg);
561        return (NFA_STATUS_OK);
562    }
563
564    return (NFA_STATUS_FAILED);
565}
566
567/*******************************************************************************
568**
569** Function         NFA_HciSendCommand
570**
571** Description      This function is called to send a command on a pipe created
572**                  by the application.
573**                  The app will be notified by NFA_HCI_CMD_SENT_EVT if an error
574**                  occurs.
575**                  When the peer host responds,the app is notified with
576**                  NFA_HCI_RSP_RCVD_EVT
577**
578** Returns          NFA_STATUS_OK if successfully initiated
579**                  NFA_STATUS_FAILED otherwise
580**
581*******************************************************************************/
582tNFA_STATUS NFA_HciSendCommand (tNFA_HANDLE  hci_handle,
583                              UINT8        pipe,
584                              UINT8        cmd_code,
585                              UINT16       cmd_size,
586                              UINT8        *p_data)
587{
588    tNFA_HCI_API_SEND_CMD_EVT *p_msg;
589
590    if ((NFA_HANDLE_GROUP_MASK & hci_handle) != NFA_HANDLE_GROUP_HCI)
591    {
592        NFA_TRACE_API1 ("NFA_HciSendCommand (): Invalid hci_handle:0x%04x", hci_handle);
593        return (NFA_STATUS_FAILED);
594    }
595
596    if (pipe < NFA_HCI_FIRST_DYNAMIC_PIPE)
597    {
598        NFA_TRACE_API1 ("NFA_HciSendCommand (): Invalid Pipe:0x%02x", pipe);
599        return (NFA_STATUS_FAILED);
600    }
601
602    if ((cmd_size && (p_data == NULL)) || (cmd_size > NFA_MAX_HCI_CMD_LEN))
603    {
604        NFA_TRACE_API1 ("NFA_HciSendCommand (): Invalid cmd size:0x%02x", cmd_size);
605        return (NFA_STATUS_FAILED);
606    }
607
608    NFA_TRACE_API3 ("NFA_HciSendCommand (): hci_handle:0x%04x, pipe:0x%02x  Code: 0x%02x", hci_handle, pipe, cmd_code);
609
610    /* Request HCI to post event data on a particular pipe */
611    if (  (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
612        &&((p_msg = (tNFA_HCI_API_SEND_CMD_EVT *) GKI_getbuf (sizeof (tNFA_HCI_API_SEND_CMD_EVT))) != NULL) )
613    {
614        p_msg->hdr.event    = NFA_HCI_API_SEND_CMD_EVT;
615        p_msg->hci_handle   = hci_handle;
616        p_msg->pipe         = pipe;
617        p_msg->cmd_code     = cmd_code;
618        p_msg->cmd_len      = cmd_size;
619
620        if (cmd_size)
621            memcpy (p_msg->data, p_data, cmd_size);
622
623        nfa_sys_sendmsg (p_msg);
624        return (NFA_STATUS_OK);
625    }
626
627    return (NFA_STATUS_FAILED);
628}
629
630/*******************************************************************************
631**
632** Function         NFA_HciSendResponse
633**
634** Description      This function is called to send a response on a pipe created
635**                  by the application.
636**                  The app will be notified by NFA_HCI_RSP_SENT_EVT if an error
637**                  occurs.
638**
639** Returns          NFA_STATUS_OK if successfully initiated
640**                  NFA_STATUS_FAILED otherwise
641**
642*******************************************************************************/
643NFC_API extern tNFA_STATUS NFA_HciSendResponse (tNFA_HANDLE   hci_handle,
644                                                UINT8         pipe,
645                                                UINT8         response,
646                                                UINT8         data_size,
647                                                UINT8         *p_data)
648{
649    tNFA_HCI_API_SEND_RSP_EVT *p_msg;
650
651    if ((NFA_HANDLE_GROUP_MASK & hci_handle) != NFA_HANDLE_GROUP_HCI)
652    {
653        NFA_TRACE_API1 ("NFA_HciSendResponse (): Invalid hci_handle:0x%04x", hci_handle);
654        return (NFA_STATUS_FAILED);
655    }
656
657    if (pipe < NFA_HCI_FIRST_DYNAMIC_PIPE)
658    {
659        NFA_TRACE_API1 ("NFA_HciSendResponse (): Invalid Pipe:0x%02x", pipe);
660        return (NFA_STATUS_FAILED);
661    }
662
663    if ((data_size && (p_data == NULL)) || (data_size > NFA_MAX_HCI_RSP_LEN))
664    {
665        NFA_TRACE_API1 ("NFA_HciSendResponse (): Invalid data size:0x%02x", data_size);
666        return (NFA_STATUS_FAILED);
667    }
668
669    NFA_TRACE_API3 ("NFA_HciSendResponse (): hci_handle:0x%04x  Pipe: 0x%02x  Response: 0x%02x", hci_handle, pipe, response);
670
671    /* Request HCI to get list of gates supported by the specified host */
672    if (  (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
673        &&((p_msg = (tNFA_HCI_API_SEND_RSP_EVT *) GKI_getbuf (sizeof (tNFA_HCI_API_SEND_RSP_EVT))) != NULL) )
674    {
675        p_msg->hdr.event    = NFA_HCI_API_SEND_RSP_EVT;
676        p_msg->hci_handle   = hci_handle;
677        p_msg->response     = response;
678        p_msg->size         = data_size;
679
680        if (data_size)
681            memcpy (p_msg->data, p_data, data_size);
682
683        nfa_sys_sendmsg (p_msg);
684        return (NFA_STATUS_OK);
685    }
686
687    return (NFA_STATUS_FAILED);
688}
689
690/*******************************************************************************
691**
692** Function         NFA_HciSendEvent
693**
694** Description      This function is called to send any event on a pipe created
695**                  by the application.
696**                  The app will be notified by NFA_HCI_EVENT_SENT_EVT
697**                  after successfully sending the event on the specified pipe
698**                  or if an error occurs. The application should wait for this
699**                  event before releasing event buffer passed as argument.
700**                  If the app is expecting a response to the event then it can
701**                  provide response buffer for collecting the response. If it
702**                  provides a response buffer it can also provide response
703**                  timeout indicating maximum timeout for the response.
704**                  Maximum of NFA_MAX_HCI_EVENT_LEN bytes APDU can be received
705**                  using internal buffer if no response buffer is provided by
706**                  the application. The app will be notified by
707**                  NFA_HCI_EVENT_RCVD_EVT after receiving the response event
708**                  or on timeout if app provided response buffer and response
709**                  timeout. If response buffer and response timeout is provided
710**                  by the application, it should wait for this event before
711**                  releasing the response buffer. If the application did not
712**                  provide response timeout then it should not release the
713**                  response buffer until it receives NFA_HCI_EVENT_RCVD_EVT or
714**                  after timeout it sends next event on the same pipe
715**                  and receives NFA_HCI_EVENT_SENT_EVT for that event.
716**
717** Returns          NFA_STATUS_OK if successfully initiated
718**                  NFA_STATUS_FAILED otherwise
719**
720*******************************************************************************/
721tNFA_STATUS NFA_HciSendEvent (tNFA_HANDLE  hci_handle,
722                              UINT8        pipe,
723                              UINT8        evt_code,
724                              UINT16       evt_size,
725                              UINT8        *p_data,
726                              UINT16       rsp_size,
727                              UINT8        *p_rsp_buf,
728                              UINT16       rsp_timeout)
729{
730    tNFA_HCI_API_SEND_EVENT_EVT *p_msg;
731
732    NFA_TRACE_API3 ("NFA_HciSendEvent(): hci_handle:0x%04x, pipe:0x%02x  Code: 0x%02x", hci_handle, pipe, evt_code);
733
734
735    if ((NFA_HANDLE_GROUP_MASK & hci_handle) != NFA_HANDLE_GROUP_HCI)
736    {
737        NFA_TRACE_API1 ("NFA_HciSendEvent (): Invalid hci_handle:0x%04x", hci_handle);
738        return (NFA_STATUS_FAILED);
739    }
740
741    if (pipe < NFA_HCI_FIRST_DYNAMIC_PIPE)
742    {
743        NFA_TRACE_API1 ("NFA_HciSendEvent (): Invalid Pipe:0x%02x", pipe);
744        return (NFA_STATUS_FAILED);
745    }
746
747    if (evt_size && (p_data == NULL))
748    {
749        NFA_TRACE_API1 ("NFA_HciSendEvent (): Invalid Event size:0x%02x", evt_size);
750        return (NFA_STATUS_FAILED);
751    }
752
753    if (rsp_size && (p_rsp_buf == NULL))
754    {
755        NFA_TRACE_API1 ("NFA_HciSendEvent (): No Event buffer, but invalid event buffer size :%u", rsp_size);
756        return (NFA_STATUS_FAILED);
757    }
758
759    /* Request HCI to post event data on a particular pipe */
760    if (  (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
761        &&((p_msg = (tNFA_HCI_API_SEND_EVENT_EVT *) GKI_getbuf (sizeof (tNFA_HCI_API_SEND_EVENT_EVT))) != NULL) )
762    {
763        p_msg->hdr.event    = NFA_HCI_API_SEND_EVENT_EVT;
764        p_msg->hci_handle   = hci_handle;
765        p_msg->pipe         = pipe;
766        p_msg->evt_code     = evt_code;
767        p_msg->evt_len      = evt_size;
768        p_msg->p_evt_buf    = p_data;
769        p_msg->rsp_len      = rsp_size;
770        p_msg->p_rsp_buf    = p_rsp_buf;
771        p_msg->rsp_timeout  = rsp_timeout;
772
773        nfa_sys_sendmsg (p_msg);
774        return (NFA_STATUS_OK);
775    }
776
777    return (NFA_STATUS_FAILED);
778}
779
780/*******************************************************************************
781**
782** Function         NFA_HciClosePipe
783**
784** Description      This function is called to close a dynamic pipe.
785**                  When the dynamic pipe is closed (or
786**                  if an error occurs), the app will be notified with
787**                  NFA_HCI_CLOSE_PIPE_EVT with the pipe id.
788**
789** Returns          NFA_STATUS_OK if successfully initiated
790**                  NFA_STATUS_FAILED otherwise
791**
792*******************************************************************************/
793tNFA_STATUS NFA_HciClosePipe (tNFA_HANDLE hci_handle, UINT8 pipe)
794{
795    tNFA_HCI_API_CLOSE_PIPE_EVT *p_msg;
796
797    NFA_TRACE_API2 ("NFA_HciClosePipe (): hci_handle:0x%04x, pipe:0x%02X", hci_handle, pipe);
798
799    if ((NFA_HANDLE_GROUP_MASK & hci_handle) != NFA_HANDLE_GROUP_HCI)
800    {
801        NFA_TRACE_API1 ("NFA_HciClosePipe (): Invalid hci_handle:0x%04x", hci_handle);
802        return (NFA_STATUS_FAILED);
803    }
804
805    if ((pipe < NFA_HCI_FIRST_DYNAMIC_PIPE) || (pipe > NFA_HCI_LAST_DYNAMIC_PIPE))
806    {
807        NFA_TRACE_API1 ("NFA_HciClosePipe (): Invalid Pipe:0x%02x", pipe);
808        return (NFA_STATUS_FAILED);
809    }
810
811    /* Request HCI to close a pipe if it is in opened state */
812    if (  (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
813        &&(!nfa_hci_cb.b_low_power_mode)
814        &&((p_msg = (tNFA_HCI_API_CLOSE_PIPE_EVT *) GKI_getbuf (sizeof (tNFA_HCI_API_CLOSE_PIPE_EVT))) != NULL) )
815    {
816        p_msg->hdr.event    = NFA_HCI_API_CLOSE_PIPE_EVT;
817        p_msg->hci_handle   = hci_handle;
818        p_msg->pipe         = pipe;
819
820        nfa_sys_sendmsg (p_msg);
821        return (NFA_STATUS_OK);
822    }
823    return (NFA_STATUS_FAILED);
824}
825
826/*******************************************************************************
827**
828** Function         NFA_HciDeletePipe
829**
830** Description      This function is called to delete a particular dynamic pipe.
831**                  When the dynamic pipe is deleted (or if an error occurs),
832**                  the app will be notified with NFA_HCI_DELETE_PIPE_EVT with
833**                  the pipe id. After successful deletion of pipe, registry
834**                  entry will be deleted for the dynamic pipe and all
835**                  information related to the pipe will be deleted from non
836**                  volatile memory.
837**
838** Returns          NFA_STATUS_OK if successfully initiated
839**                  NFA_STATUS_FAILED otherwise
840**
841*******************************************************************************/
842tNFA_STATUS NFA_HciDeletePipe (tNFA_HANDLE  hci_handle, UINT8 pipe)
843{
844    tNFA_HCI_API_DELETE_PIPE_EVT *p_msg;
845
846    if ((NFA_HANDLE_GROUP_MASK & hci_handle) != NFA_HANDLE_GROUP_HCI)
847    {
848        NFA_TRACE_API1 ("NFA_HciDeletePipe (): Invalid hci_handle:0x%04x", hci_handle);
849        return (NFA_STATUS_FAILED);
850    }
851
852    if ((pipe < NFA_HCI_FIRST_DYNAMIC_PIPE) || (pipe > NFA_HCI_LAST_DYNAMIC_PIPE))
853    {
854        NFA_TRACE_API1 ("NFA_HciDeletePipe (): Invalid Pipe:0x%02x", pipe);
855        return (NFA_STATUS_FAILED);
856    }
857
858    NFA_TRACE_API2 ("NFA_HciDeletePipe (): hci_handle:0x%04x, pipe:0x%02X", hci_handle, pipe);
859
860    /* Request HCI to delete a pipe created by the application identified by hci handle */
861    if (  (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
862        &&(!nfa_hci_cb.b_low_power_mode)
863        &&((p_msg = (tNFA_HCI_API_DELETE_PIPE_EVT *) GKI_getbuf (sizeof (tNFA_HCI_API_DELETE_PIPE_EVT))) != NULL) )
864    {
865        p_msg->hdr.event    = NFA_HCI_API_DELETE_PIPE_EVT;
866        p_msg->hci_handle   = hci_handle;
867        p_msg->pipe         = pipe;
868
869        nfa_sys_sendmsg (p_msg);
870        return (NFA_STATUS_OK);
871    }
872    return (NFA_STATUS_FAILED);
873}
874
875
876/*******************************************************************************
877**
878** Function         NFA_HciAddStaticPipe
879**
880** Description      This function is called to add a static pipe for sending
881**                  7816 APDUs. When the static pipe is added (or if an error occurs),
882**                  the app will be notified with NFA_HCI_ADD_STATIC_PIPE_EVT with
883**                  the status.
884** Returns          NFA_STATUS_OK if successfully initiated
885**                  NFA_STATUS_FAILED otherwise
886**
887*******************************************************************************/
888tNFA_STATUS NFA_HciAddStaticPipe (tNFA_HANDLE hci_handle, UINT8 host, UINT8 gate, UINT8 pipe)
889{
890    tNFA_HCI_API_ADD_STATIC_PIPE_EVT *p_msg;
891    UINT8                            xx;
892
893    if ((NFA_HANDLE_GROUP_MASK & hci_handle) != NFA_HANDLE_GROUP_HCI)
894    {
895        NFA_TRACE_API1 ("NFA_HciAddStaticPipe (): Invalid hci_handle:0x%04x", hci_handle);
896        return (NFA_STATUS_FAILED);
897    }
898
899    for (xx = 0; xx < NFA_HCI_MAX_HOST_IN_NETWORK; xx++)
900        if (nfa_hci_cb.inactive_host[xx] == host)
901            break;
902
903    if (xx != NFA_HCI_MAX_HOST_IN_NETWORK)
904    {
905        NFA_TRACE_API1 ("NFA_HciAddStaticPipe (): Host not active:0x%02x", host);
906        return (NFA_STATUS_FAILED);
907    }
908
909    if (gate <= NFA_HCI_LAST_HOST_SPECIFIC_GATE)
910    {
911        NFA_TRACE_API1 ("NFA_HciAddStaticPipe (): Invalid Gate:0x%02x", gate);
912        return (NFA_STATUS_FAILED);
913    }
914
915    if (pipe <= NFA_HCI_LAST_DYNAMIC_PIPE)
916    {
917        NFA_TRACE_API1 ("NFA_HciAddStaticPipe (): Invalid Pipe:0x%02x", pipe);
918        return (NFA_STATUS_FAILED);
919    }
920
921    NFA_TRACE_API2 ("NFA_HciAddStaticPipe (): hci_handle:0x%04x, pipe:0x%02X", hci_handle, pipe);
922
923    /* Request HCI to delete a pipe created by the application identified by hci handle */
924    if (  (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
925        &&((p_msg = (tNFA_HCI_API_ADD_STATIC_PIPE_EVT *) GKI_getbuf (sizeof (tNFA_HCI_API_ADD_STATIC_PIPE_EVT))) != NULL)  )
926    {
927        p_msg->hdr.event    = NFA_HCI_API_ADD_STATIC_PIPE_EVT;
928        p_msg->hci_handle   = hci_handle;
929        p_msg->host         = host;
930        p_msg->gate         = gate;
931        p_msg->pipe         = pipe;
932
933        nfa_sys_sendmsg (p_msg);
934        return (NFA_STATUS_OK);
935    }
936    /* Unable to add static pipe */
937    return (NFA_STATUS_FAILED);
938}
939
940/*******************************************************************************
941**
942** Function         NFA_HciDebug
943**
944** Description      Debug function.
945**
946*******************************************************************************/
947void NFA_HciDebug (UINT8 action, UINT8 size, UINT8 *p_data)
948{
949    int                 xx;
950    tNFA_HCI_DYN_GATE   *pg = nfa_hci_cb.cfg.dyn_gates;
951    tNFA_HCI_DYN_PIPE   *pp = nfa_hci_cb.cfg.dyn_pipes;
952    BT_HDR              *p_msg;
953    UINT8               *p;
954
955    switch (action)
956    {
957    case NFA_HCI_DEBUG_DISPLAY_CB:
958        NFA_TRACE_API0 ("NFA_HciDebug  Host List:");
959        for (xx = 0; xx < NFA_HCI_MAX_APP_CB; xx++)
960        {
961            if (nfa_hci_cb.cfg.reg_app_names[xx][0] != 0)
962            {
963                NFA_TRACE_API2 ("              Host Inx:  %u   Name: %s", xx, &nfa_hci_cb.cfg.reg_app_names[xx][0]);
964            }
965        }
966
967        NFA_TRACE_API0 ("NFA_HciDebug  Gate List:");
968        for (xx = 0; xx < NFA_HCI_MAX_GATE_CB; xx++, pg++)
969        {
970            if (pg->gate_id != 0)
971            {
972                NFA_TRACE_API4 ("              Gate Inx: %x  ID: 0x%02x  Owner: 0x%04x  PipeInxMask: 0x%08x",
973                                xx, pg->gate_id, pg->gate_owner, pg->pipe_inx_mask);
974            }
975        }
976
977        NFA_TRACE_API0 ("NFA_HciDebug  Pipe List:");
978        for (xx = 0; xx < NFA_HCI_MAX_PIPE_CB; xx++, pp++)
979        {
980            if (pp->pipe_id != 0)
981            {
982                NFA_TRACE_API6 ("              Pipe Inx: %x  ID: 0x%02x  State: %u  LocalGate: 0x%02x  Dest Gate: 0x%02x  Host: 0x%02x",
983                    xx, pp->pipe_id, pp->pipe_state, pp->local_gate, pp->dest_gate, pp->dest_host);
984            }
985        }
986        break;
987
988    case NFA_HCI_DEBUG_SIM_HCI_EVENT:
989        if ((p_msg = (BT_HDR *) GKI_getpoolbuf (NFC_RW_POOL_ID)) != NULL)
990        {
991            p = (UINT8 *) (p_msg + 1);
992
993            p_msg->event  = NFA_HCI_CHECK_QUEUE_EVT;
994            p_msg->len    = size;
995            p_msg->offset = 0;
996
997            memcpy (p, p_data, size);
998
999            nfa_sys_sendmsg (p_msg);
1000        }
1001        break;
1002
1003    case NFA_HCI_DEBUG_ENABLE_LOOPBACK:
1004        NFA_TRACE_API0 ("NFA_HciDebug  HCI_LOOPBACK_DEBUG = TRUE");
1005        HCI_LOOPBACK_DEBUG = TRUE;
1006        break;
1007
1008    case NFA_HCI_DEBUG_DISABLE_LOOPBACK:
1009        NFA_TRACE_API0 ("NFA_HciDebug  HCI_LOOPBACK_DEBUG = FALSE");
1010        HCI_LOOPBACK_DEBUG = FALSE;
1011        break;
1012    }
1013}
1014