• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /******************************************************************************
2  *
3  *  Copyright (C) 2012-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  *  Vendor-specific handler for DM events
23  *
24  ******************************************************************************/
25 #include <string.h>
26 #include "nfc_hal_int.h"
27 #include "nfc_hal_post_reset.h"
28 #include "userial.h"
29 #include "upio.h"
30 
31 /*****************************************************************************
32 ** Constants and types
33 *****************************************************************************/
34 
35 #define NFC_HAL_I93_RW_CFG_LEN              (5)
36 #define NFC_HAL_I93_RW_CFG_PARAM_LEN        (3)
37 #define NFC_HAL_I93_AFI                     (0)
38 #define NFC_HAL_I93_ENABLE_SMART_POLL       (1)
39 
40 static UINT8 nfc_hal_dm_i93_rw_cfg[NFC_HAL_I93_RW_CFG_LEN] =
41 {
42     NCI_PARAM_ID_I93_DATARATE,
43     NFC_HAL_I93_RW_CFG_PARAM_LEN,
44     NFC_HAL_I93_FLAG_DATA_RATE,    /* Bit0:Sub carrier, Bit1:Data rate, Bit4:Enable/Disable AFI */
45     NFC_HAL_I93_AFI,               /* AFI if Bit 4 is set in the flag byte */
46     NFC_HAL_I93_ENABLE_SMART_POLL  /* Bit0:Enable/Disable smart poll */
47 };
48 
49 static UINT8 nfc_hal_dm_set_fw_fsm_cmd[NCI_MSG_HDR_SIZE + 1] =
50 {
51     NCI_MTS_CMD|NCI_GID_PROP,
52     NCI_MSG_SET_FWFSM,
53     0x01,
54     0x00,
55 };
56 #define NCI_SET_FWFSM_OFFSET_ENABLE      3
57 
58 #define NCI_PROP_PARAM_SIZE_XTAL_INDEX      3       /* length of parameters in XTAL_INDEX CMD */
59 #ifndef NCI_PROP_PARAM_MAX_SIZE_XTAL_INDEX
60 #define NCI_PROP_PARAM_MAX_SIZE_XTAL_INDEX      20
61 #endif
62 
63 const UINT8 nfc_hal_dm_get_build_info_cmd[NCI_MSG_HDR_SIZE] =
64 {
65     NCI_MTS_CMD|NCI_GID_PROP,
66     NCI_MSG_GET_BUILD_INFO,
67     0x00
68 };
69 #define NCI_BUILD_INFO_OFFSET_HWID  25  /* HW ID offset in build info RSP */
70 
71 const UINT8 nfc_hal_dm_get_patch_version_cmd [NCI_MSG_HDR_SIZE] =
72 {
73     NCI_MTS_CMD|NCI_GID_PROP,
74     NCI_MSG_GET_PATCH_VERSION,
75     0x00
76 };
77 #define NCI_PATCH_INFO_VERSION_LEN  16  /* Length of patch version string in PATCH_INFO */
78 
79 /*****************************************************************************
80 ** Extern function prototypes
81 *****************************************************************************/
82 extern UINT8 *p_nfc_hal_dm_lptd_cfg;
83 extern UINT8 *p_nfc_hal_dm_pll_325_cfg;
84 extern UINT8 *p_nfc_hal_dm_start_up_cfg;
85 extern UINT8 *p_nfc_hal_dm_start_up_vsc_cfg;
86 extern tNFC_HAL_CFG *p_nfc_hal_cfg;
87 extern tNFC_HAL_DM_PRE_SET_MEM *p_nfc_hal_dm_pre_set_mem;
88 
89 /*****************************************************************************
90 ** Local function prototypes
91 *****************************************************************************/
92 
93 /*******************************************************************************
94 **
95 ** Function         nfc_hal_dm_set_config
96 **
97 ** Description      Send NCI config items to NFCC
98 **
99 ** Returns          tHAL_NFC_STATUS
100 **
101 *******************************************************************************/
nfc_hal_dm_set_config(UINT8 tlv_size,UINT8 * p_param_tlvs,tNFC_HAL_NCI_CBACK * p_cback)102 tHAL_NFC_STATUS nfc_hal_dm_set_config (UINT8 tlv_size,
103                                        UINT8 *p_param_tlvs,
104                                        tNFC_HAL_NCI_CBACK *p_cback)
105 {
106     UINT8  *p_buff, *p;
107     UINT8  num_param = 0, param_len, rem_len, *p_tlv;
108     UINT16 cmd_len = NCI_MSG_HDR_SIZE + tlv_size + 1;
109     tHAL_NFC_STATUS status = HAL_NFC_STATUS_FAILED;
110 
111     if ((tlv_size == 0)||(p_param_tlvs == NULL))
112     {
113         return status;
114     }
115 
116     if ((p_buff = (UINT8 *) GKI_getbuf ((UINT16)(NCI_MSG_HDR_SIZE + tlv_size))) != NULL)
117     {
118         p = p_buff;
119 
120         NCI_MSG_BLD_HDR0 (p, NCI_MT_CMD, NCI_GID_CORE);
121         NCI_MSG_BLD_HDR1 (p, NCI_MSG_CORE_SET_CONFIG);
122         UINT8_TO_STREAM  (p, (UINT8) (tlv_size + 1));
123 
124         rem_len = tlv_size;
125         p_tlv   = p_param_tlvs;
126         while (rem_len > 1)
127         {
128             num_param++;                /* number of params */
129 
130             p_tlv ++;                   /* param type   */
131             param_len = *p_tlv++;       /* param length */
132 
133             rem_len -= 2;               /* param type and length */
134             if (rem_len >= param_len)
135             {
136                 rem_len -= param_len;
137                 p_tlv   += param_len;   /* next param_type */
138 
139                 if (rem_len == 0)
140                 {
141                     status = HAL_NFC_STATUS_OK;
142                     break;
143                 }
144             }
145             else
146             {
147                 /* error found */
148                 break;
149             }
150         }
151 
152         if (status == HAL_NFC_STATUS_OK)
153         {
154             UINT8_TO_STREAM (p, num_param);
155             ARRAY_TO_STREAM (p, p_param_tlvs, tlv_size);
156 
157             nfc_hal_dm_send_nci_cmd (p_buff, cmd_len, p_cback);
158         }
159         else
160         {
161             HAL_TRACE_ERROR0 ("nfc_hal_dm_set_config ():Bad TLV");
162         }
163 
164         GKI_freebuf (p_buff);
165     }
166 
167     return status;
168 }
169 
170 /*******************************************************************************
171 **
172 ** Function         nfc_hal_dm_set_fw_fsm
173 **
174 ** Description      Enable or disable FW FSM
175 **
176 ** Returns          void
177 **
178 *******************************************************************************/
nfc_hal_dm_set_fw_fsm(BOOLEAN enable,tNFC_HAL_NCI_CBACK * p_cback)179 void nfc_hal_dm_set_fw_fsm (BOOLEAN enable, tNFC_HAL_NCI_CBACK *p_cback)
180 {
181     if (enable)
182         nfc_hal_dm_set_fw_fsm_cmd[NCI_SET_FWFSM_OFFSET_ENABLE] = 0x01; /* Enable, default is disabled */
183     else
184         nfc_hal_dm_set_fw_fsm_cmd[NCI_SET_FWFSM_OFFSET_ENABLE] = 0x00; /* Disable */
185 
186     nfc_hal_dm_send_nci_cmd (nfc_hal_dm_set_fw_fsm_cmd, NCI_MSG_HDR_SIZE + 1, p_cback);
187 }
188 
189 /*******************************************************************************
190 **
191 ** Function         nfc_hal_dm_config_nfcc_cback
192 **
193 ** Description      Callback for NCI vendor specific command complete
194 **
195 ** Returns          void
196 **
197 *******************************************************************************/
nfc_hal_dm_config_nfcc_cback(tNFC_HAL_NCI_EVT event,UINT16 data_len,UINT8 * p_data)198 void nfc_hal_dm_config_nfcc_cback (tNFC_HAL_NCI_EVT event, UINT16 data_len, UINT8 *p_data)
199 {
200     if (nfc_hal_cb.dev_cb.next_dm_config == NFC_HAL_DM_CONFIG_NONE)
201     {
202         nfc_hal_hci_enable ();
203     }
204     else
205     {
206         nfc_hal_dm_config_nfcc ();
207     }
208 }
209 
210 /*******************************************************************************
211 **
212 ** Function         nfc_hal_dm_send_startup_vsc
213 **
214 ** Description      Send VS command before NFA start-up
215 **
216 ** Returns          None
217 **
218 *******************************************************************************/
nfc_hal_dm_send_startup_vsc(void)219 void nfc_hal_dm_send_startup_vsc (void)
220 {
221     UINT8  *p, *p_end;
222     UINT16 len;
223 
224     HAL_TRACE_DEBUG0 ("nfc_hal_dm_send_startup_vsc ()");
225 
226     /* VSC must have NCI header at least */
227     if (nfc_hal_cb.dev_cb.next_startup_vsc + NCI_MSG_HDR_SIZE - 1 <= *p_nfc_hal_dm_start_up_vsc_cfg)
228     {
229         p     = p_nfc_hal_dm_start_up_vsc_cfg + nfc_hal_cb.dev_cb.next_startup_vsc;
230         len   = *(p + 2);
231         p_end = p + NCI_MSG_HDR_SIZE - 1 + len;
232 
233         if (p_end <= p_nfc_hal_dm_start_up_vsc_cfg + *p_nfc_hal_dm_start_up_vsc_cfg)
234         {
235             /* move to next VSC */
236             nfc_hal_cb.dev_cb.next_startup_vsc += NCI_MSG_HDR_SIZE + len;
237 
238             /* if this is last VSC */
239             if (p_end == p_nfc_hal_dm_start_up_vsc_cfg + *p_nfc_hal_dm_start_up_vsc_cfg)
240                 nfc_hal_cb.dev_cb.next_dm_config = NFC_HAL_DM_CONFIG_NONE;
241 
242             nfc_hal_dm_send_nci_cmd (p, (UINT16)(NCI_MSG_HDR_SIZE + len), nfc_hal_dm_config_nfcc_cback);
243             return;
244         }
245     }
246 
247     HAL_TRACE_ERROR0 ("nfc_hal_dm_send_startup_vsc (): Bad start-up VSC");
248 
249     NFC_HAL_SET_INIT_STATE (NFC_HAL_INIT_STATE_IDLE);
250     nfc_hal_cb.p_stack_cback (HAL_NFC_POST_INIT_CPLT_EVT, HAL_NFC_STATUS_FAILED);
251 }
252 
253 /*******************************************************************************
254 **
255 ** Function         nfc_hal_dm_config_nfcc
256 **
257 ** Description      Send VS config before NFA start-up
258 **
259 ** Returns          void
260 **
261 *******************************************************************************/
nfc_hal_dm_config_nfcc(void)262 void nfc_hal_dm_config_nfcc (void)
263 {
264     HAL_TRACE_DEBUG1 ("nfc_hal_dm_config_nfcc (): next_dm_config = %d", nfc_hal_cb.dev_cb.next_dm_config);
265 
266     if ((p_nfc_hal_dm_lptd_cfg[0]) && (nfc_hal_cb.dev_cb.next_dm_config <= NFC_HAL_DM_CONFIG_LPTD))
267     {
268         nfc_hal_cb.dev_cb.next_dm_config = NFC_HAL_DM_CONFIG_PLL_325;
269 
270         if (nfc_hal_dm_set_config (p_nfc_hal_dm_lptd_cfg[0],
271                                    &p_nfc_hal_dm_lptd_cfg[1],
272                                    nfc_hal_dm_config_nfcc_cback) == HAL_NFC_STATUS_OK)
273         {
274             return;
275         }
276         else
277         {
278             NFC_HAL_SET_INIT_STATE (NFC_HAL_INIT_STATE_IDLE);
279             nfc_hal_cb.p_stack_cback (HAL_NFC_POST_INIT_CPLT_EVT, HAL_NFC_STATUS_FAILED);
280             return;
281         }
282     }
283 
284     if ((p_nfc_hal_dm_pll_325_cfg) && (nfc_hal_cb.dev_cb.next_dm_config <= NFC_HAL_DM_CONFIG_PLL_325))
285     {
286         nfc_hal_cb.dev_cb.next_dm_config = NFC_HAL_DM_CONFIG_START_UP;
287 
288         if (nfc_hal_dm_set_config (NFC_HAL_PLL_325_SETCONFIG_PARAM_LEN,
289                                    p_nfc_hal_dm_pll_325_cfg,
290                                    nfc_hal_dm_config_nfcc_cback) == HAL_NFC_STATUS_OK)
291         {
292             return;
293         }
294         else
295         {
296             NFC_HAL_SET_INIT_STATE (NFC_HAL_INIT_STATE_IDLE);
297             nfc_hal_cb.p_stack_cback (HAL_NFC_POST_INIT_CPLT_EVT, HAL_NFC_STATUS_FAILED);
298             return;
299         }
300     }
301 
302     if ((p_nfc_hal_dm_start_up_cfg[0]) && (nfc_hal_cb.dev_cb.next_dm_config <= NFC_HAL_DM_CONFIG_START_UP))
303     {
304         nfc_hal_cb.dev_cb.next_dm_config = NFC_HAL_DM_CONFIG_I93_DATA_RATE;
305         if (nfc_hal_dm_set_config (p_nfc_hal_dm_start_up_cfg[0],
306                                    &p_nfc_hal_dm_start_up_cfg[1],
307                                    nfc_hal_dm_config_nfcc_cback) == HAL_NFC_STATUS_OK)
308         {
309             return;
310         }
311         else
312         {
313             NFC_HAL_SET_INIT_STATE (NFC_HAL_INIT_STATE_IDLE);
314             nfc_hal_cb.p_stack_cback (HAL_NFC_POST_INIT_CPLT_EVT, HAL_NFC_STATUS_FAILED);
315             return;
316         }
317     }
318 
319 #if (NFC_HAL_I93_FLAG_DATA_RATE == NFC_HAL_I93_FLAG_DATA_RATE_HIGH)
320     if (nfc_hal_cb.dev_cb.next_dm_config  <= NFC_HAL_DM_CONFIG_I93_DATA_RATE)
321     {
322         nfc_hal_cb.dev_cb.next_dm_config = NFC_HAL_DM_CONFIG_FW_FSM;
323         if (nfc_hal_dm_set_config (NFC_HAL_I93_RW_CFG_LEN,
324                                    nfc_hal_dm_i93_rw_cfg,
325                                    nfc_hal_dm_config_nfcc_cback) == HAL_NFC_STATUS_OK)
326         {
327             return;
328         }
329         else
330         {
331             NFC_HAL_SET_INIT_STATE (NFC_HAL_INIT_STATE_IDLE);
332             nfc_hal_cb.p_stack_cback (HAL_NFC_POST_INIT_CPLT_EVT, HAL_NFC_STATUS_FAILED);
333             return;
334         }
335     }
336 #endif
337 
338     /* FW FSM is disabled as default in NFCC */
339     if (nfc_hal_cb.dev_cb.next_dm_config <= NFC_HAL_DM_CONFIG_FW_FSM)
340     {
341         nfc_hal_cb.dev_cb.next_dm_config = NFC_HAL_DM_CONFIG_START_UP_VSC;
342         nfc_hal_dm_set_fw_fsm (NFC_HAL_DM_MULTI_TECH_RESP, nfc_hal_dm_config_nfcc_cback);
343         return;
344     }
345 
346     if (nfc_hal_cb.dev_cb.next_dm_config <= NFC_HAL_DM_CONFIG_START_UP_VSC)
347     {
348         if (p_nfc_hal_dm_start_up_vsc_cfg && *p_nfc_hal_dm_start_up_vsc_cfg)
349         {
350             nfc_hal_dm_send_startup_vsc ();
351             return;
352         }
353     }
354 
355     /* nothing to config */
356     nfc_hal_cb.dev_cb.next_dm_config = NFC_HAL_DM_CONFIG_NONE;
357     nfc_hal_dm_config_nfcc_cback (0, 0, NULL);
358 }
359 
360 /*******************************************************************************
361 **
362 ** Function:    nfc_hal_dm_get_xtal_index
363 **
364 ** Description: Return Xtal index and frequency
365 **
366 ** Returns:     tNFC_HAL_XTAL_INDEX
367 **
368 *******************************************************************************/
nfc_hal_dm_get_xtal_index(UINT32 brcm_hw_id,UINT16 * p_xtal_freq)369 tNFC_HAL_XTAL_INDEX nfc_hal_dm_get_xtal_index (UINT32 brcm_hw_id, UINT16 *p_xtal_freq)
370 {
371     UINT8 xx;
372 
373     HAL_TRACE_DEBUG1("nfc_hal_dm_get_xtal_index() brcm_hw_id:0x%x", brcm_hw_id);
374 
375     for (xx = 0; xx < nfc_post_reset_cb.dev_init_config.num_xtal_cfg; xx++)
376     {
377         if ((brcm_hw_id & BRCM_NFC_GEN_MASK)
378             == nfc_post_reset_cb.dev_init_config.xtal_cfg[xx].brcm_hw_id)
379         {
380             *p_xtal_freq = nfc_post_reset_cb.dev_init_config.xtal_cfg[xx].xtal_freq;
381             return (nfc_post_reset_cb.dev_init_config.xtal_cfg[xx].xtal_index);
382         }
383     }
384 
385     /* if not found */
386     *p_xtal_freq = 0;
387     return (NFC_HAL_XTAL_INDEX_MAX);
388 }
389 
390 /*******************************************************************************
391 **
392 ** Function         nfc_hal_dm_set_xtal_freq_index
393 **
394 ** Description      Set crystal frequency index
395 **
396 ** Returns          void
397 **
398 *******************************************************************************/
nfc_hal_dm_set_xtal_freq_index(void)399 void nfc_hal_dm_set_xtal_freq_index (void)
400 {
401     UINT8 nci_brcm_xtal_index_cmd[NCI_MSG_HDR_SIZE + NCI_PROP_PARAM_MAX_SIZE_XTAL_INDEX];
402     UINT8 *p;
403     tNFC_HAL_XTAL_INDEX xtal_index;
404     UINT16              xtal_freq;
405     UINT8               cmd_len = NCI_PROP_PARAM_SIZE_XTAL_INDEX;
406     extern UINT8 *p_nfc_hal_dm_xtal_params_cfg;
407 
408     HAL_TRACE_DEBUG1 ("nfc_hal_dm_set_xtal_freq_index (): brcm_hw_id = 0x%x", nfc_hal_cb.dev_cb.brcm_hw_id);
409 
410     xtal_index = nfc_hal_dm_get_xtal_index (nfc_hal_cb.dev_cb.brcm_hw_id, &xtal_freq);
411     if ((xtal_index == NFC_HAL_XTAL_INDEX_SPECIAL) && (p_nfc_hal_dm_xtal_params_cfg))
412     {
413         cmd_len += p_nfc_hal_dm_xtal_params_cfg[0]; /* [0] is the length of extra params */
414     }
415 
416     p = nci_brcm_xtal_index_cmd;
417     UINT8_TO_STREAM  (p, (NCI_MTS_CMD|NCI_GID_PROP));
418     UINT8_TO_STREAM  (p, NCI_MSG_GET_XTAL_INDEX_FROM_DH);
419     UINT8_TO_STREAM  (p, cmd_len);
420     UINT8_TO_STREAM  (p, xtal_index);
421     UINT16_TO_STREAM (p, xtal_freq);
422     if (cmd_len > NCI_PROP_PARAM_SIZE_XTAL_INDEX)
423     {
424         memcpy (p, &p_nfc_hal_dm_xtal_params_cfg[1], p_nfc_hal_dm_xtal_params_cfg[0]);
425     }
426 
427     NFC_HAL_SET_INIT_STATE (NFC_HAL_INIT_STATE_W4_XTAL_SET);
428 
429     nfc_hal_dm_send_nci_cmd (nci_brcm_xtal_index_cmd, NCI_MSG_HDR_SIZE + cmd_len, NULL);
430 }
431 
432 /*******************************************************************************
433 **
434 ** Function         nfc_hal_dm_send_get_build_info_cmd
435 **
436 ** Description      Send NCI_MSG_GET_BUILD_INFO CMD
437 **
438 ** Returns          void
439 **
440 *******************************************************************************/
nfc_hal_dm_send_get_build_info_cmd(void)441 void nfc_hal_dm_send_get_build_info_cmd (void)
442 {
443     NFC_HAL_SET_INIT_STATE (NFC_HAL_INIT_STATE_W4_BUILD_INFO);
444 
445     /* get build information to find out HW */
446     nfc_hal_dm_send_nci_cmd (nfc_hal_dm_get_build_info_cmd, NCI_MSG_HDR_SIZE, NULL);
447 }
448 /*******************************************************************************
449 **
450 ** Function:    nfc_hal_dm_adjust_hw_id
451 **
452 ** Description: The hw_id of certain chips are shifted by 8 bits.
453 **              Adjust the hw_id before processing.
454 **
455 ** Returns:     Nothing
456 **
457 *******************************************************************************/
nfc_hal_dm_adjust_hw_id(UINT32 hw_id)458 static UINT32 nfc_hal_dm_adjust_hw_id (UINT32 hw_id)
459 {
460     if ((hw_id & 0xF0000000) == 0)
461         hw_id <<= 4; /* shift hw_id by 4 bits to align w the format of most chips */
462     return hw_id;
463 }
464 
465 
466 /*******************************************************************************
467 **
468 ** Function         nfc_hal_dm_check_xtal
469 **
470 ** Description      check if need to send xtal command.
471 **                  If not, proceed to next step get_patch_version.
472 **
473 ** Returns          void
474 **
475 *******************************************************************************/
nfc_hal_dm_check_xtal(void)476 static void nfc_hal_dm_check_xtal (void)
477 {
478     UINT16  xtal_freq;
479     tNFC_HAL_XTAL_INDEX xtal_index;
480 
481     /* if NFCC needs to set Xtal frequency before getting patch version */
482     xtal_index = nfc_hal_dm_get_xtal_index (nfc_hal_cb.dev_cb.brcm_hw_id, &xtal_freq);
483     if ((xtal_index < NFC_HAL_XTAL_INDEX_MAX) || (xtal_index == NFC_HAL_XTAL_INDEX_SPECIAL))
484     {
485         {
486             /* set Xtal index before getting patch version */
487             nfc_hal_dm_set_xtal_freq_index ();
488             return;
489         }
490     }
491 
492     NFC_HAL_SET_INIT_STATE (NFC_HAL_INIT_STATE_W4_PATCH_INFO);
493 
494     nfc_hal_dm_send_nci_cmd (nfc_hal_dm_get_patch_version_cmd, NCI_MSG_HDR_SIZE, NULL);
495 }
496 
497 /*******************************************************************************
498 **
499 ** Function         nfc_hal_dm_pre_set_mem_cback
500 **
501 ** Description      This is pre-set mem complete callback.
502 **
503 ** Returns          void
504 **
505 *******************************************************************************/
nfc_hal_dm_pre_set_mem_cback(tNFC_HAL_BTVSC_CPLT * pData)506 static void nfc_hal_dm_pre_set_mem_cback (tNFC_HAL_BTVSC_CPLT *pData)
507 {
508     UINT8   status = pData->p_param_buf[0];
509 
510     HAL_TRACE_DEBUG1 ("nfc_hal_dm_pre_set_mem_cback: %d", status);
511     /* if it is completed */
512     if (status == HCI_SUCCESS)
513     {
514         if (!nfc_hal_dm_check_pre_set_mem())
515         {
516             return;
517         }
518     }
519     nfc_hal_dm_check_xtal();
520 }
521 
522 
523 /*******************************************************************************
524 **
525 ** Function         nfc_hal_dm_check_pre_set_mem
526 **
527 ** Description      Check if need to send the command.
528 **
529 ** Returns          TRUE if done.
530 **
531 *******************************************************************************/
nfc_hal_dm_check_pre_set_mem(void)532 BOOLEAN nfc_hal_dm_check_pre_set_mem (void)
533 {
534     UINT8   cmd[NFC_HAL_BT_HCI_CMD_HDR_SIZE + HCI_BRCM_PRE_SET_MEM_LENGTH];
535     UINT8   *p;
536     UINT32  addr = 0;
537 
538     if (p_nfc_hal_dm_pre_set_mem)
539         addr     = p_nfc_hal_dm_pre_set_mem[nfc_hal_cb.pre_set_mem_idx].addr;
540     HAL_TRACE_DEBUG2 ("nfc_hal_dm_check_pre_set_mem: %d/0x%x", nfc_hal_cb.pre_set_mem_idx, addr);
541     if (addr == 0)
542     {
543         return TRUE;
544     }
545     p = cmd;
546 
547     /* Add the command */
548     UINT16_TO_STREAM (p, HCI_BRCM_PRE_SET_MEM);
549     UINT8_TO_STREAM  (p, HCI_BRCM_PRE_SET_MEM_LENGTH);
550 
551     UINT8_TO_STREAM  (p, HCI_BRCM_PRE_SET_MEM_TYPE);
552     UINT32_TO_STREAM  (p, addr);
553     UINT8_TO_STREAM   (p, 0);
554     UINT32_TO_STREAM  (p, p_nfc_hal_dm_pre_set_mem[nfc_hal_cb.pre_set_mem_idx].data);
555     nfc_hal_cb.pre_set_mem_idx++;
556 
557     nfc_hal_dm_send_bt_cmd (cmd,
558                             NFC_HAL_BT_HCI_CMD_HDR_SIZE + HCI_BRCM_PRE_SET_MEM_LENGTH,
559                             nfc_hal_dm_pre_set_mem_cback);
560     return FALSE;
561 }
562 
563 /*******************************************************************************
564 **
565 ** Function         nfc_hal_dm_proc_msg_during_init
566 **
567 ** Description      Process NCI message while initializing NFCC
568 **
569 ** Returns          void
570 **
571 *******************************************************************************/
nfc_hal_dm_proc_msg_during_init(NFC_HDR * p_msg)572 void nfc_hal_dm_proc_msg_during_init (NFC_HDR *p_msg)
573 {
574     UINT8 *p;
575     UINT8 reset_reason, reset_type;
576     UINT8 mt, pbf, gid, op_code;
577     UINT8 *p_old, old_gid, old_oid, old_mt;
578     UINT8 u8;
579     tNFC_HAL_NCI_CBACK *p_cback = NULL;
580     UINT8   chipverlen;
581     UINT8   chipverstr[NCI_SPD_HEADER_CHIPVER_LEN];
582     UINT32  hw_id = 0;
583 
584     HAL_TRACE_DEBUG1 ("nfc_hal_dm_proc_msg_during_init(): init state:%d", nfc_hal_cb.dev_cb.initializing_state);
585 
586     p = (UINT8 *) (p_msg + 1) + p_msg->offset;
587 
588     NCI_MSG_PRS_HDR0 (p, mt, pbf, gid);
589     NCI_MSG_PRS_HDR1 (p, op_code);
590 
591     /* check if waiting for this response */
592     if (  (nfc_hal_cb.ncit_cb.nci_wait_rsp == NFC_HAL_WAIT_RSP_CMD)
593         ||(nfc_hal_cb.ncit_cb.nci_wait_rsp == NFC_HAL_WAIT_RSP_VSC)  )
594     {
595         if (mt == NCI_MT_RSP)
596         {
597             p_old = nfc_hal_cb.ncit_cb.last_hdr;
598             NCI_MSG_PRS_HDR0 (p_old, old_mt, pbf, old_gid);
599             old_oid = ((*p_old) & NCI_OID_MASK);
600             /* make sure this is the RSP we are waiting for before updating the command window */
601             if ((old_gid == gid) && (old_oid == op_code))
602             {
603                 nfc_hal_cb.ncit_cb.nci_wait_rsp = NFC_HAL_WAIT_RSP_NONE;
604                 p_cback = (tNFC_HAL_NCI_CBACK *)nfc_hal_cb.ncit_cb.p_vsc_cback;
605                 nfc_hal_cb.ncit_cb.p_vsc_cback  = NULL;
606                 nfc_hal_main_stop_quick_timer (&nfc_hal_cb.ncit_cb.nci_wait_rsp_timer);
607             }
608         }
609     }
610 
611     if (gid == NCI_GID_CORE)
612     {
613         if (op_code == NCI_MSG_CORE_RESET)
614         {
615             if (mt == NCI_MT_NTF)
616             {
617                 if (  (nfc_hal_cb.dev_cb.initializing_state == NFC_HAL_INIT_STATE_W4_NFCC_ENABLE)
618                     ||(nfc_hal_cb.dev_cb.initializing_state == NFC_HAL_INIT_STATE_POST_XTAL_SET)  )
619                 {
620                     /*
621                     ** Core reset ntf in the following cases;
622                     ** 1) after power up (raising REG_PU)
623                     ** 2) after setting xtal index
624                     ** Start pre-initializing NFCC
625                     */
626                     nfc_hal_main_stop_quick_timer (&nfc_hal_cb.timer);
627                     nfc_hal_dm_pre_init_nfcc ();
628                 }
629                 else
630                 {
631                     /* Core reset ntf after post-patch download, Call reset notification callback */
632                     p++;                                /* Skip over param len */
633                     STREAM_TO_UINT8 (reset_reason, p);
634                     STREAM_TO_UINT8 (reset_type, p);
635                     nfc_hal_prm_spd_reset_ntf (reset_reason, reset_type);
636                 }
637             }
638         }
639         else if (p_cback)
640         {
641             (*p_cback) ((tNFC_HAL_NCI_EVT) (op_code),
642                         p_msg->len,
643                         (UINT8 *) (p_msg + 1) + p_msg->offset);
644         }
645     }
646     else if (gid == NCI_GID_PROP) /* this is for download patch */
647     {
648         if (mt == NCI_MT_NTF)
649             op_code |= NCI_NTF_BIT;
650         else
651             op_code |= NCI_RSP_BIT;
652 
653         if (nfc_hal_cb.dev_cb.initializing_state == NFC_HAL_INIT_STATE_W4_XTAL_SET)
654         {
655             if (op_code == (NCI_RSP_BIT|NCI_MSG_GET_XTAL_INDEX_FROM_DH))
656             {
657                 /* start timer in case that NFCC doesn't send RESET NTF after loading patch from NVM */
658                 NFC_HAL_SET_INIT_STATE (NFC_HAL_INIT_STATE_POST_XTAL_SET);
659 
660                 nfc_hal_main_start_quick_timer (&nfc_hal_cb.timer, NFC_HAL_TTYPE_NFCC_ENABLE,
661                                                 ((p_nfc_hal_cfg->nfc_hal_post_xtal_timeout)*QUICK_TIMER_TICKS_PER_SEC)/1000);
662             }
663         }
664         else if (  (op_code == NFC_VS_GET_BUILD_INFO_EVT)
665                  &&(nfc_hal_cb.dev_cb.initializing_state == NFC_HAL_INIT_STATE_W4_BUILD_INFO)  )
666         {
667             p += NCI_BUILD_INFO_OFFSET_HWID;
668 
669             STREAM_TO_UINT32 (hw_id, p);
670             nfc_hal_cb.dev_cb.brcm_hw_id = nfc_hal_dm_adjust_hw_id (hw_id);
671             HAL_TRACE_DEBUG2 ("brcm_hw_id: 0x%x -> 0x%x", hw_id, nfc_hal_cb.dev_cb.brcm_hw_id);
672 
673             STREAM_TO_UINT8 (chipverlen, p);
674             memset (chipverstr, 0, NCI_SPD_HEADER_CHIPVER_LEN);
675 
676             STREAM_TO_ARRAY (chipverstr, p, chipverlen);
677 
678             nfc_hal_hci_handle_build_info (chipverlen, chipverstr);
679             nfc_hal_cb.pre_set_mem_idx = 0;
680             if (!nfc_hal_dm_check_pre_set_mem())
681             {
682                 /* pre-set mem started */
683                 return;
684             }
685             nfc_hal_dm_check_xtal();
686         }
687         else if (  (op_code == NFC_VS_GET_PATCH_VERSION_EVT)
688                  &&(nfc_hal_cb.dev_cb.initializing_state == NFC_HAL_INIT_STATE_W4_PATCH_INFO)  )
689         {
690             /* Store NVM info to control block */
691 
692             /* Skip over rsp len */
693             p++;
694 
695             /* Get project id */
696             STREAM_TO_UINT16 (nfc_hal_cb.nvm_cb.project_id, p);
697 
698             /* RFU */
699             p++;
700 
701             /* Get chip version string */
702             STREAM_TO_UINT8 (u8, p);
703             if (u8 > NFC_HAL_PRM_MAX_CHIP_VER_LEN)
704                 u8 = NFC_HAL_PRM_MAX_CHIP_VER_LEN;
705             memcpy (nfc_hal_cb.nvm_cb.chip_ver, p, u8);
706             p += NCI_PATCH_INFO_VERSION_LEN;
707 
708             /* Get major/minor version */
709             STREAM_TO_UINT16 (nfc_hal_cb.nvm_cb.ver_major, p);
710             STREAM_TO_UINT16 (nfc_hal_cb.nvm_cb.ver_minor, p);
711 
712             /* Skip over max_size and patch_max_size */
713             p += 4;
714 
715             /* Get current lpm patch size */
716             STREAM_TO_UINT16 (nfc_hal_cb.nvm_cb.lpm_size, p);
717             STREAM_TO_UINT16 (nfc_hal_cb.nvm_cb.fpm_size, p);
718 
719             /* clear all flags which may be set during previous initialization */
720             nfc_hal_cb.nvm_cb.flags = 0;
721 
722             /* Set patch present flag */
723             if ((nfc_hal_cb.nvm_cb.fpm_size) || (nfc_hal_cb.nvm_cb.lpm_size))
724                 nfc_hal_cb.nvm_cb.flags |= NFC_HAL_NVM_FLAGS_PATCH_PRESENT;
725 
726             /* LPMPatchCodeHasBadCRC (if not bad crc, then indicate LPM patch is present in nvm) */
727             STREAM_TO_UINT8 (u8, p);
728             if (u8)
729             {
730                 /* LPM patch in NVM fails CRC check */
731                 nfc_hal_cb.nvm_cb.flags |= NFC_HAL_NVM_FLAGS_LPM_BAD;
732             }
733 
734 
735             /* FPMPatchCodeHasBadCRC (if not bad crc, then indicate LPM patch is present in nvm) */
736             STREAM_TO_UINT8 (u8, p);
737             if (u8)
738             {
739                 /* FPM patch in NVM fails CRC check */
740                 nfc_hal_cb.nvm_cb.flags |= NFC_HAL_NVM_FLAGS_FPM_BAD;
741             }
742 
743             /* Check if downloading patch to RAM only (no NVM) */
744             STREAM_TO_UINT8 (nfc_hal_cb.nvm_cb.nvm_type, p);
745             if (nfc_hal_cb.nvm_cb.nvm_type == NCI_SPD_NVM_TYPE_NONE)
746             {
747                 nfc_hal_cb.nvm_cb.flags |= NFC_HAL_NVM_FLAGS_NO_NVM;
748             }
749 
750             /* let platform update baudrate or download patch */
751             NFC_HAL_SET_INIT_STATE (NFC_HAL_INIT_STATE_W4_APP_COMPLETE);
752             nfc_hal_post_reset_init (nfc_hal_cb.dev_cb.brcm_hw_id, nfc_hal_cb.nvm_cb.nvm_type);
753         }
754         else if (p_cback)
755         {
756             (*p_cback) ((tNFC_HAL_NCI_EVT) (op_code),
757                         p_msg->len,
758                         (UINT8 *) (p_msg + 1) + p_msg->offset);
759         }
760         else if (op_code == NFC_VS_SEC_PATCH_AUTH_EVT)
761         {
762             HAL_TRACE_DEBUG0 ("signature!!");
763             nfc_hal_prm_nci_command_complete_cback ((tNFC_HAL_NCI_EVT) (op_code),
764                                                     p_msg->len,
765                                                     (UINT8 *) (p_msg + 1) + p_msg->offset);
766         }
767     }
768 }
769 
770 /*******************************************************************************
771 **
772 ** Function         nfc_hal_dm_send_nci_cmd
773 **
774 ** Description      Send NCI command to NFCC while initializing BRCM NFCC
775 **
776 ** Returns          void
777 **
778 *******************************************************************************/
nfc_hal_dm_send_nci_cmd(const UINT8 * p_data,UINT16 len,tNFC_HAL_NCI_CBACK * p_cback)779 void nfc_hal_dm_send_nci_cmd (const UINT8 *p_data, UINT16 len, tNFC_HAL_NCI_CBACK *p_cback)
780 {
781     NFC_HDR *p_buf;
782     UINT8  *ps;
783 
784     HAL_TRACE_DEBUG1 ("nfc_hal_dm_send_nci_cmd (): nci_wait_rsp = 0x%x", nfc_hal_cb.ncit_cb.nci_wait_rsp);
785 
786     if (nfc_hal_cb.ncit_cb.nci_wait_rsp != NFC_HAL_WAIT_RSP_NONE)
787     {
788         HAL_TRACE_ERROR0 ("nfc_hal_dm_send_nci_cmd(): no command window");
789         return;
790     }
791 
792     if ((p_buf = (NFC_HDR *)GKI_getpoolbuf (NFC_HAL_NCI_POOL_ID)) != NULL)
793     {
794         nfc_hal_cb.ncit_cb.nci_wait_rsp = NFC_HAL_WAIT_RSP_VSC;
795 
796         p_buf->offset = NFC_HAL_NCI_MSG_OFFSET_SIZE;
797         p_buf->event  = NFC_HAL_EVT_TO_NFC_NCI;
798         p_buf->len    = len;
799 
800         memcpy ((UINT8*) (p_buf + 1) + p_buf->offset, p_data, len);
801 
802         /* Keep a copy of the command and send to NCI transport */
803 
804         /* save the message header to double check the response */
805         ps   = (UINT8 *)(p_buf + 1) + p_buf->offset;
806         memcpy(nfc_hal_cb.ncit_cb.last_hdr, ps, NFC_HAL_SAVED_HDR_SIZE);
807         memcpy(nfc_hal_cb.ncit_cb.last_cmd, ps + NCI_MSG_HDR_SIZE, NFC_HAL_SAVED_CMD_SIZE);
808 
809         /* save the callback for NCI VSCs */
810         nfc_hal_cb.ncit_cb.p_vsc_cback = (void *)p_cback;
811 
812         nfc_hal_nci_send_cmd (p_buf);
813 
814         /* start NFC command-timeout timer */
815         nfc_hal_main_start_quick_timer (&nfc_hal_cb.ncit_cb.nci_wait_rsp_timer, (UINT16)(NFC_HAL_TTYPE_NCI_WAIT_RSP),
816                                         ((UINT32) NFC_HAL_CMD_TOUT) * QUICK_TIMER_TICKS_PER_SEC / 1000);
817     }
818 }
819 
820 /*******************************************************************************
821 **
822 ** Function         nfc_hal_dm_send_pend_cmd
823 **
824 ** Description      Send a command to NFCC
825 **
826 ** Returns          void
827 **
828 *******************************************************************************/
nfc_hal_dm_send_pend_cmd(void)829 void nfc_hal_dm_send_pend_cmd (void)
830 {
831     NFC_HDR *p_buf = nfc_hal_cb.ncit_cb.p_pend_cmd;
832     UINT8  *p;
833 
834     if (p_buf == NULL)
835         return;
836 
837     /* check low power mode state */
838     if (!nfc_hal_dm_power_mode_execute (NFC_HAL_LP_TX_DATA_EVT))
839     {
840         return;
841     }
842 
843     if (nfc_hal_cb.ncit_cb.nci_wait_rsp == NFC_HAL_WAIT_RSP_PROP)
844     {
845 #if (NFC_HAL_TRACE_PROTOCOL == TRUE)
846         DispHciCmd (p_buf);
847 #endif
848 
849         /* save the message header to double check the response */
850         p = (UINT8 *)(p_buf + 1) + p_buf->offset;
851         memcpy(nfc_hal_cb.ncit_cb.last_hdr, p, NFC_HAL_SAVED_HDR_SIZE);
852 
853         /* add packet type for BT message */
854         p_buf->offset--;
855         p_buf->len++;
856 
857         p  = (UINT8 *) (p_buf + 1) + p_buf->offset;
858         *p = HCIT_TYPE_COMMAND;
859 
860         USERIAL_Write (USERIAL_NFC_PORT, p, p_buf->len);
861 
862         GKI_freebuf (p_buf);
863         nfc_hal_cb.ncit_cb.p_pend_cmd = NULL;
864 
865         /* start NFC command-timeout timer */
866         nfc_hal_main_start_quick_timer (&nfc_hal_cb.ncit_cb.nci_wait_rsp_timer, (UINT16)(NFC_HAL_TTYPE_NCI_WAIT_RSP),
867                                         ((UINT32) NFC_HAL_CMD_TOUT) * QUICK_TIMER_TICKS_PER_SEC / 1000);
868 
869     }
870 }
871 
872 /*******************************************************************************
873 **
874 ** Function         nfc_hal_dm_send_bt_cmd
875 **
876 ** Description      Send BT message to NFCC while initializing BRCM NFCC
877 **
878 ** Returns          void
879 **
880 *******************************************************************************/
nfc_hal_dm_send_bt_cmd(const UINT8 * p_data,UINT16 len,tNFC_HAL_BTVSC_CPLT_CBACK * p_cback)881 void nfc_hal_dm_send_bt_cmd (const UINT8 *p_data, UINT16 len, tNFC_HAL_BTVSC_CPLT_CBACK *p_cback)
882 {
883     NFC_HDR *p_buf;
884     char buff[300];
885     char tmp[4];
886     buff[0] = 0;
887     int i;
888 
889     HAL_TRACE_DEBUG1 ("nfc_hal_dm_send_bt_cmd (): nci_wait_rsp = 0x%x", nfc_hal_cb.ncit_cb.nci_wait_rsp);
890 
891     for (i = 0; i < len; i++)
892     {
893         sprintf (tmp, "%02x ", p_data[i]);
894         strcat(buff, tmp);
895     }
896     HAL_TRACE_DEBUG2 ("nfc_hal_dm_send_bt_cmd (): HCI Write (%d bytes): %s", len, buff);
897 
898     if (nfc_hal_cb.ncit_cb.nci_wait_rsp != NFC_HAL_WAIT_RSP_NONE)
899     {
900         HAL_TRACE_ERROR0 ("nfc_hal_dm_send_bt_cmd(): no command window");
901         return;
902     }
903 
904     if ((p_buf = (NFC_HDR *) GKI_getpoolbuf (NFC_HAL_NCI_POOL_ID)) != NULL)
905     {
906         nfc_hal_cb.ncit_cb.nci_wait_rsp = NFC_HAL_WAIT_RSP_PROP;
907 
908         p_buf->offset = NFC_HAL_NCI_MSG_OFFSET_SIZE;
909         p_buf->len    = len;
910 
911         memcpy ((UINT8*) (p_buf + 1) + p_buf->offset, p_data, len);
912 
913         /* save the callback for NCI VSCs)  */
914         nfc_hal_cb.ncit_cb.p_vsc_cback = (void *)p_cback;
915 
916         nfc_hal_cb.ncit_cb.p_pend_cmd = p_buf;
917         if (nfc_hal_cb.dev_cb.initializing_state == NFC_HAL_INIT_STATE_IDLE)
918         {
919             NFC_HAL_SET_INIT_STATE(NFC_HAL_INIT_STATE_W4_CONTROL_DONE);
920             nfc_hal_cb.p_stack_cback (HAL_NFC_REQUEST_CONTROL_EVT, HAL_NFC_STATUS_OK);
921             return;
922         }
923 
924         nfc_hal_dm_send_pend_cmd();
925     }
926 }
927 
928 /*******************************************************************************
929 **
930 ** Function         nfc_hal_dm_set_nfc_wake
931 **
932 ** Description      Set NFC_WAKE line
933 **
934 ** Returns          void
935 **
936 *******************************************************************************/
nfc_hal_dm_set_nfc_wake(UINT8 cmd)937 void nfc_hal_dm_set_nfc_wake (UINT8 cmd)
938 {
939     HAL_TRACE_DEBUG1 ("nfc_hal_dm_set_nfc_wake () %s",
940                       (cmd == NFC_HAL_ASSERT_NFC_WAKE ? "ASSERT" : "DEASSERT"));
941 
942     /*
943     **  nfc_wake_active_mode             cmd              result of voltage on NFC_WAKE
944     **
945     **  NFC_HAL_LP_ACTIVE_LOW (0)    NFC_HAL_ASSERT_NFC_WAKE (0)    pull down NFC_WAKE (GND)
946     **  NFC_HAL_LP_ACTIVE_LOW (0)    NFC_HAL_DEASSERT_NFC_WAKE (1)  pull up NFC_WAKE (VCC)
947     **  NFC_HAL_LP_ACTIVE_HIGH (1)   NFC_HAL_ASSERT_NFC_WAKE (0)    pull up NFC_WAKE (VCC)
948     **  NFC_HAL_LP_ACTIVE_HIGH (1)   NFC_HAL_DEASSERT_NFC_WAKE (1)  pull down NFC_WAKE (GND)
949     */
950 
951     if (cmd == nfc_hal_cb.dev_cb.nfc_wake_active_mode)
952         UPIO_Set (UPIO_GENERAL, NFC_HAL_LP_NFC_WAKE_GPIO, UPIO_OFF); /* pull down NFC_WAKE */
953     else
954         UPIO_Set (UPIO_GENERAL, NFC_HAL_LP_NFC_WAKE_GPIO, UPIO_ON);  /* pull up NFC_WAKE */
955 }
956 
957 /*******************************************************************************
958 **
959 ** Function         nfc_hal_dm_power_mode_execute
960 **
961 ** Description      If snooze mode is enabled in full power mode,
962 **                     Assert NFC_WAKE before sending data
963 **                     Deassert NFC_WAKE when idle timer expires
964 **
965 ** Returns          TRUE if DH can send data to NFCC
966 **
967 *******************************************************************************/
nfc_hal_dm_power_mode_execute(tNFC_HAL_LP_EVT event)968 BOOLEAN nfc_hal_dm_power_mode_execute (tNFC_HAL_LP_EVT event)
969 {
970     BOOLEAN send_to_nfcc = FALSE;
971 
972     HAL_TRACE_DEBUG1 ("nfc_hal_dm_power_mode_execute () event = %d", event);
973 
974     if (nfc_hal_cb.dev_cb.power_mode == NFC_HAL_POWER_MODE_FULL)
975     {
976         if (nfc_hal_cb.dev_cb.snooze_mode != NFC_HAL_LP_SNOOZE_MODE_NONE)
977         {
978             /* if any transport activity */
979             if (  (event == NFC_HAL_LP_TX_DATA_EVT)
980                 ||(event == NFC_HAL_LP_RX_DATA_EVT)  )
981             {
982                 /* if idle timer is not running */
983                 if (nfc_hal_cb.dev_cb.lp_timer.in_use == FALSE)
984                 {
985                     nfc_hal_dm_set_nfc_wake (NFC_HAL_ASSERT_NFC_WAKE);
986                 }
987 
988                 /* start or extend idle timer */
989                 nfc_hal_main_start_quick_timer (&nfc_hal_cb.dev_cb.lp_timer, 0x00,
990                                                 ((UINT32) NFC_HAL_LP_IDLE_TIMEOUT) * QUICK_TIMER_TICKS_PER_SEC / 1000);
991             }
992             else if (event == NFC_HAL_LP_TIMEOUT_EVT)
993             {
994                 /* let NFCC go to snooze mode */
995                 nfc_hal_dm_set_nfc_wake (NFC_HAL_DEASSERT_NFC_WAKE);
996             }
997         }
998 
999         send_to_nfcc = TRUE;
1000     }
1001 
1002     return (send_to_nfcc);
1003 }
1004 
1005 /*******************************************************************************
1006 **
1007 ** Function         nci_brcm_lp_timeout_cback
1008 **
1009 ** Description      callback function for low power timeout
1010 **
1011 ** Returns          void
1012 **
1013 *******************************************************************************/
nci_brcm_lp_timeout_cback(void * p_tle)1014 static void nci_brcm_lp_timeout_cback (void *p_tle)
1015 {
1016     HAL_TRACE_DEBUG0 ("nci_brcm_lp_timeout_cback ()");
1017 
1018     nfc_hal_dm_power_mode_execute (NFC_HAL_LP_TIMEOUT_EVT);
1019 }
1020 
1021 /*******************************************************************************
1022 **
1023 ** Function         nfc_hal_dm_pre_init_nfcc
1024 **
1025 ** Description      This function initializes Broadcom specific control blocks for
1026 **                  NCI transport
1027 **
1028 ** Returns          void
1029 **
1030 *******************************************************************************/
nfc_hal_dm_pre_init_nfcc(void)1031 void nfc_hal_dm_pre_init_nfcc (void)
1032 {
1033     HAL_TRACE_DEBUG0 ("nfc_hal_dm_pre_init_nfcc ()");
1034 
1035     /* if it was waiting for core reset notification after raising REG_PU */
1036     if (nfc_hal_cb.dev_cb.initializing_state == NFC_HAL_INIT_STATE_W4_NFCC_ENABLE)
1037     {
1038         nfc_hal_dm_send_get_build_info_cmd ();
1039     }
1040     /* if it was waiting for core reset notification after setting Xtal */
1041     else if (nfc_hal_cb.dev_cb.initializing_state == NFC_HAL_INIT_STATE_POST_XTAL_SET)
1042     {
1043         {
1044             /* Core reset ntf after xtal setting indicating NFCC loaded patch from NVM */
1045             NFC_HAL_SET_INIT_STATE (NFC_HAL_INIT_STATE_W4_PATCH_INFO);
1046 
1047             nfc_hal_dm_send_nci_cmd (nfc_hal_dm_get_patch_version_cmd, NCI_MSG_HDR_SIZE, NULL);
1048         }
1049     }
1050 }
1051 
1052 /*******************************************************************************
1053 **
1054 ** Function         nfc_hal_dm_shutting_down_nfcc
1055 **
1056 ** Description      This function initializes Broadcom specific control blocks for
1057 **                  NCI transport
1058 **
1059 ** Returns          void
1060 **
1061 *******************************************************************************/
nfc_hal_dm_shutting_down_nfcc(void)1062 void nfc_hal_dm_shutting_down_nfcc (void)
1063 {
1064     HAL_TRACE_DEBUG0 ("nfc_hal_dm_shutting_down_nfcc ()");
1065 
1066     nfc_hal_cb.dev_cb.initializing_state = NFC_HAL_INIT_STATE_CLOSING;
1067 
1068     /* reset low power mode variables */
1069     if (  (nfc_hal_cb.dev_cb.power_mode  == NFC_HAL_POWER_MODE_FULL)
1070         &&(nfc_hal_cb.dev_cb.snooze_mode != NFC_HAL_LP_SNOOZE_MODE_NONE)  )
1071     {
1072         nfc_hal_dm_set_nfc_wake (NFC_HAL_ASSERT_NFC_WAKE);
1073     }
1074 
1075     nfc_hal_cb.ncit_cb.nci_wait_rsp = NFC_HAL_WAIT_RSP_NONE;
1076 
1077     nfc_hal_cb.dev_cb.power_mode  = NFC_HAL_POWER_MODE_FULL;
1078     nfc_hal_cb.dev_cb.snooze_mode = NFC_HAL_LP_SNOOZE_MODE_NONE;
1079 
1080     /* Stop all timers */
1081     nfc_hal_main_stop_quick_timer (&nfc_hal_cb.ncit_cb.nci_wait_rsp_timer);
1082     nfc_hal_main_stop_quick_timer (&nfc_hal_cb.dev_cb.lp_timer);
1083     nfc_hal_main_stop_quick_timer (&nfc_hal_cb.prm.timer);
1084 #if (defined(NFC_HAL_HCI_INCLUDED) && (NFC_HAL_HCI_INCLUDED == TRUE))
1085     nfc_hal_cb.hci_cb.hcp_conn_id = 0;
1086     nfc_hal_main_stop_quick_timer (&nfc_hal_cb.hci_cb.hci_timer);
1087 #endif
1088     nfc_hal_main_stop_quick_timer (&nfc_hal_cb.timer);
1089 }
1090 
1091 /*******************************************************************************
1092 **
1093 ** Function         nfc_hal_dm_init
1094 **
1095 ** Description      This function initializes Broadcom specific control blocks for
1096 **                  NCI transport
1097 **
1098 ** Returns          void
1099 **
1100 *******************************************************************************/
nfc_hal_dm_init(void)1101 void nfc_hal_dm_init (void)
1102 {
1103     HAL_TRACE_DEBUG0 ("nfc_hal_dm_init ()");
1104 
1105     nfc_hal_cb.dev_cb.lp_timer.p_cback = nci_brcm_lp_timeout_cback;
1106 
1107     nfc_hal_cb.ncit_cb.nci_wait_rsp_timer.p_cback = nfc_hal_nci_cmd_timeout_cback;
1108 
1109 #if (defined(NFC_HAL_HCI_INCLUDED) && (NFC_HAL_HCI_INCLUDED == TRUE))
1110     nfc_hal_cb.hci_cb.hci_timer.p_cback = nfc_hal_hci_timeout_cback;
1111 #endif
1112 
1113     nfc_hal_cb.pre_discover_done        = FALSE;
1114 
1115     nfc_post_reset_cb.spd_nvm_detection_cur_count = 0;
1116     nfc_post_reset_cb.spd_skip_on_power_cycle     = FALSE;
1117 
1118 }
1119 
1120 /*******************************************************************************
1121 **
1122 ** Function         HAL_NfcDevInitDone
1123 **
1124 ** Description      Notify that pre-initialization of NFCC is complete
1125 **
1126 ** Returns          void
1127 **
1128 *******************************************************************************/
HAL_NfcPreInitDone(tHAL_NFC_STATUS status)1129 void HAL_NfcPreInitDone (tHAL_NFC_STATUS status)
1130 {
1131     HAL_TRACE_DEBUG1 ("HAL_NfcPreInitDone () status=%d", status);
1132 
1133     if (nfc_hal_cb.dev_cb.initializing_state == NFC_HAL_INIT_STATE_W4_APP_COMPLETE)
1134     {
1135         NFC_HAL_SET_INIT_STATE (NFC_HAL_INIT_STATE_IDLE);
1136 
1137         nfc_hal_main_pre_init_done (status);
1138     }
1139 }
1140 
1141 /*******************************************************************************
1142 **
1143 ** Function         HAL_NfcReInit
1144 **
1145 ** Description      This function is called to restart initialization after REG_PU
1146 **                  toggled because of failure to detect NVM type or download patchram.
1147 **
1148 ** Note             This function should be called only during the HAL init process
1149 **
1150 ** Returns          HAL_NFC_STATUS_OK if successfully initiated
1151 **                  HAL_NFC_STATUS_FAILED otherwise
1152 **
1153 *******************************************************************************/
HAL_NfcReInit(void)1154 tHAL_NFC_STATUS HAL_NfcReInit (void)
1155 {
1156     tHAL_NFC_STATUS status = HAL_NFC_STATUS_FAILED;
1157 
1158     HAL_TRACE_DEBUG1 ("HAL_NfcReInit () init st=0x%x", nfc_hal_cb.dev_cb.initializing_state);
1159     if (nfc_hal_cb.dev_cb.initializing_state == NFC_HAL_INIT_STATE_W4_APP_COMPLETE)
1160     {
1161         {
1162             /* Wait for NFCC to enable - Core reset notification */
1163             NFC_HAL_SET_INIT_STATE (NFC_HAL_INIT_STATE_W4_NFCC_ENABLE);
1164 
1165             /* NFCC Enable timeout */
1166             nfc_hal_main_start_quick_timer (&nfc_hal_cb.timer, NFC_HAL_TTYPE_NFCC_ENABLE,
1167                                             ((p_nfc_hal_cfg->nfc_hal_nfcc_enable_timeout)*QUICK_TIMER_TICKS_PER_SEC)/1000);
1168         }
1169 
1170         status = HAL_NFC_STATUS_OK;
1171     }
1172     return status;
1173 }
1174 
1175 /*******************************************************************************
1176 **
1177 ** Function         nfc_hal_dm_set_snooze_mode_cback
1178 **
1179 ** Description      This is snooze update complete callback.
1180 **
1181 ** Returns          void
1182 **
1183 *******************************************************************************/
nfc_hal_dm_set_snooze_mode_cback(tNFC_HAL_BTVSC_CPLT * pData)1184 static void nfc_hal_dm_set_snooze_mode_cback (tNFC_HAL_BTVSC_CPLT *pData)
1185 {
1186     UINT8             status = pData->p_param_buf[0];
1187     tHAL_NFC_STATUS   hal_status;
1188     tHAL_NFC_STATUS_CBACK *p_cback;
1189 
1190     /* if it is completed */
1191     if (status == HCI_SUCCESS)
1192     {
1193         /* update snooze mode */
1194         nfc_hal_cb.dev_cb.snooze_mode = nfc_hal_cb.dev_cb.new_snooze_mode;
1195 
1196         nfc_hal_dm_set_nfc_wake (NFC_HAL_ASSERT_NFC_WAKE);
1197 
1198         if ( nfc_hal_cb.dev_cb.snooze_mode != NFC_HAL_LP_SNOOZE_MODE_NONE)
1199         {
1200             /* start idle timer */
1201             nfc_hal_main_start_quick_timer (&nfc_hal_cb.dev_cb.lp_timer, 0x00,
1202                                             ((UINT32) NFC_HAL_LP_IDLE_TIMEOUT) * QUICK_TIMER_TICKS_PER_SEC / 1000);
1203         }
1204         else
1205         {
1206             nfc_hal_main_stop_quick_timer (&nfc_hal_cb.dev_cb.lp_timer);
1207         }
1208         hal_status = HAL_NFC_STATUS_OK;
1209     }
1210     else
1211     {
1212         hal_status = HAL_NFC_STATUS_FAILED;
1213     }
1214 
1215     if (nfc_hal_cb.dev_cb.p_prop_cback)
1216     {
1217         p_cback = nfc_hal_cb.dev_cb.p_prop_cback;
1218         nfc_hal_cb.dev_cb.p_prop_cback = NULL;
1219         (*p_cback) (hal_status);
1220     }
1221 }
1222 
1223 /*******************************************************************************
1224 **
1225 ** Function         HAL_NfcSetSnoozeMode
1226 **
1227 ** Description      Set snooze mode
1228 **                  snooze_mode
1229 **                      NFC_HAL_LP_SNOOZE_MODE_NONE - Snooze mode disabled
1230 **                      NFC_HAL_LP_SNOOZE_MODE_UART - Snooze mode for UART
1231 **                      NFC_HAL_LP_SNOOZE_MODE_SPI_I2C - Snooze mode for SPI/I2C
1232 **
1233 **                  idle_threshold_dh/idle_threshold_nfcc
1234 **                      Idle Threshold Host in 100ms unit
1235 **
1236 **                  nfc_wake_active_mode/dh_wake_active_mode
1237 **                      NFC_HAL_LP_ACTIVE_LOW - high to low voltage is asserting
1238 **                      NFC_HAL_LP_ACTIVE_HIGH - low to high voltage is asserting
1239 **
1240 **                  p_snooze_cback
1241 **                      Notify status of operation
1242 **
1243 ** Returns          tHAL_NFC_STATUS
1244 **
1245 *******************************************************************************/
HAL_NfcSetSnoozeMode(UINT8 snooze_mode,UINT8 idle_threshold_dh,UINT8 idle_threshold_nfcc,UINT8 nfc_wake_active_mode,UINT8 dh_wake_active_mode,tHAL_NFC_STATUS_CBACK * p_snooze_cback)1246 tHAL_NFC_STATUS HAL_NfcSetSnoozeMode (UINT8 snooze_mode,
1247                                       UINT8 idle_threshold_dh,
1248                                       UINT8 idle_threshold_nfcc,
1249                                       UINT8 nfc_wake_active_mode,
1250                                       UINT8 dh_wake_active_mode,
1251                                       tHAL_NFC_STATUS_CBACK *p_snooze_cback)
1252 {
1253     UINT8 cmd[NFC_HAL_BT_HCI_CMD_HDR_SIZE + HCI_BRCM_WRITE_SLEEP_MODE_LENGTH];
1254     UINT8 *p;
1255 
1256     HAL_TRACE_API1 ("HAL_NfcSetSnoozeMode (): snooze_mode = %d", snooze_mode);
1257 
1258     nfc_hal_cb.dev_cb.new_snooze_mode      = snooze_mode;
1259     nfc_hal_cb.dev_cb.nfc_wake_active_mode = nfc_wake_active_mode;
1260     nfc_hal_cb.dev_cb.p_prop_cback         = p_snooze_cback;
1261 
1262     p = cmd;
1263 
1264     /* Add the HCI command */
1265     UINT16_TO_STREAM (p, HCI_BRCM_WRITE_SLEEP_MODE);
1266     UINT8_TO_STREAM  (p, HCI_BRCM_WRITE_SLEEP_MODE_LENGTH);
1267 
1268     memset (p, 0x00, HCI_BRCM_WRITE_SLEEP_MODE_LENGTH);
1269 
1270     UINT8_TO_STREAM  (p, snooze_mode);          /* Sleep Mode               */
1271 
1272     UINT8_TO_STREAM  (p, idle_threshold_dh);    /* Idle Threshold Host      */
1273     UINT8_TO_STREAM  (p, idle_threshold_nfcc);  /* Idle Threshold HC        */
1274     UINT8_TO_STREAM  (p, nfc_wake_active_mode); /* BT Wake Active Mode      */
1275     UINT8_TO_STREAM  (p, dh_wake_active_mode);  /* Host Wake Active Mode    */
1276 
1277     nfc_hal_dm_send_bt_cmd (cmd,
1278                             NFC_HAL_BT_HCI_CMD_HDR_SIZE + HCI_BRCM_WRITE_SLEEP_MODE_LENGTH,
1279                             nfc_hal_dm_set_snooze_mode_cback);
1280     return (NCI_STATUS_OK);
1281 }
1282 
1283 
1284 
1285 
1286 
1287 
1288 
1289 
1290