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