1/******************************************************************************
2 *
3 *  Copyright (C) 1999-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#define LOG_TAG "USERIAL_LINUX"
20
21#include <string.h>
22#include "_OverrideLog.h"
23#include "gki.h"
24#include "nfc_hal_api.h"
25#include "nfc_hal_int.h"
26#include "nfc_target.h"
27#include "userial.h"
28
29#include <errno.h>
30#include <fcntl.h>
31#include <gki_int.h>
32#include <poll.h>
33#include <pthread.h>
34#include <stdio.h>
35#include <termios.h>
36#include <unistd.h>
37#include "bcm2079x.h"
38#include "config.h"
39#include "upio.h"
40
41#define HCISU_EVT EVENT_MASK(APPL_EVT_0)
42#define MAX_ERROR 10
43#define default_transport "/dev/bcm2079x"
44
45#define NUM_RESET_ATTEMPTS 5
46#define NFC_WAKE_ASSERTED_ON_POR UPIO_OFF
47
48#ifndef BTE_APPL_MAX_USERIAL_DEV_NAME
49#define BTE_APPL_MAX_USERIAL_DEV_NAME (256)
50#endif
51extern uint8_t appl_trace_level;
52
53/* Mapping of USERIAL_PORT_x to linux */
54extern uint32_t ScrProtocolTraceFlag;
55static tUPIO_STATE current_nfc_wake_state = UPIO_OFF;
56int uart_port = 0;
57int isLowSpeedTransport = 0;
58int nfc_wake_delay = 0;
59int nfc_write_delay = 0;
60int gPowerOnDelay = 300;
61static int gPrePowerOffDelay = 0;   // default value
62static int gPostPowerOffDelay = 0;  // default value
63static pthread_mutex_t close_thread_mutex = PTHREAD_MUTEX_INITIALIZER;
64
65char userial_dev[BTE_APPL_MAX_USERIAL_DEV_NAME + 1];
66char power_control_dev[BTE_APPL_MAX_USERIAL_DEV_NAME + 1];
67tSNOOZE_MODE_CONFIG gSnoozeModeCfg = {
68    NFC_HAL_LP_SNOOZE_MODE_SPI_I2C, /* Sleep Mode (0=Disabled 1=UART
69                                       8=SPI/I2C) */
70    NFC_HAL_LP_IDLE_THRESHOLD_HOST, /* Idle Threshold Host */
71    NFC_HAL_LP_IDLE_THRESHOLD_HC,   /* Idle Threshold HC */
72    NFC_HAL_LP_ACTIVE_LOW,          /* NFC Wake active mode (0=ActiveLow
73                                       1=ActiveHigh) */
74    NFC_HAL_LP_ACTIVE_HIGH          /* Host Wake active mode (0=ActiveLow
75                                       1=ActiveHigh) */
76};
77
78uint8_t bcmi2cnfc_client_addr = 0;
79uint8_t bcmi2cnfc_read_multi_packets = 0;
80
81#define USERIAL_Debug_verbose \
82  ((ScrProtocolTraceFlag & 0x80000000) == 0x80000000)
83
84#include <sys/socket.h>
85
86static uint8_t spi_negotiation[10] = {
87    0xF0, /* CMD */
88    0x00, /* SPI PARM Negotiation */
89    0x01, /* SPI Version */
90    0x00, /* SPI Mode:0, SPI_INT active low */
91    0x00, /* 8Bit, MSB first, Little Endian byte order */
92    0x00, /* Reserved */
93    0xFF, /* Sleep timeout Lower Byte */
94    0xFF, /* Sleep timeout Upper Byte */
95    0x00, /* Reserved */
96    0x00  /* Reserved */
97};
98static uint8_t spi_nego_res[20];
99
100/* Modes used when powering off (independent
101   of what the stack/jni has configured */
102#define POM_NORMAL (0)  /* Normal */
103#define POM_CE3SO (1)   /* Go to CE3-SO */
104#define POM_NFC_OFF (2) /* Set NFC Off bit */
105
106static int gPowerOffMode = POM_NORMAL;
107
108static uint8_t ce3_so_cmd[10] = {
109    0x10, 0x2F, /* CMD */
110    0x08, 0x06, /* size of cmd */
111    0x02,       /* CE3 power-level */
112    0xF3,       /* LpmUicc */
113    0x01,       /* LpmListenTech */
114    0x01,       /* Param */
115    0x00,       /* Forced */
116    0x00        /* Debug */
117};
118
119static uint8_t set_nfc_off_cmd[5] = {
120    0x10, 0x2F, /* CMD */
121    0x38, 0x01, /* size of cmd */
122    0x01        /* setNfcOff */
123};
124
125#include <ctype.h>
126
127#define USING_BRCM_USB TRUE
128
129/* use tc interface to change baudrate instead of close/open sequence which can
130 * fail on some platforms
131 * due to tx line movement when opeing/closing the UART. the 43xx do not like
132 * this. */
133#ifndef USERIAL_USE_TCIO_BAUD_CHANGE
134#define USERIAL_USE_TCIO_BAUD_CHANGE FALSE
135#endif
136
137#ifndef USERIAL_USE_IO_BT_WAKE
138#define USERIAL_USE_IO_BT_WAKE FALSE
139#endif
140
141/* this are the ioctl values used for bt_wake ioctl via UART driver. you may
142 * need to redefine at for
143 * you platform! Logically they need to be unique and not colide with existing
144 * uart ioctl's.
145 */
146#ifndef USERIAL_IO_BT_WAKE_ASSERT
147#define USERIAL_IO_BT_WAKE_ASSERT 0x8003
148#endif
149#ifndef USERIAL_IO_BT_WAKE_DEASSERT
150#define USERIAL_IO_BT_WAKE_DEASSERT 0x8004
151#endif
152#ifndef USERIAL_IO_BT_WAKE_GET_ST
153#define USERIAL_IO_BT_WAKE_GET_ST 0x8005
154#endif
155
156/* the read limit in this current implementation depends on the GKI_BUF3_SIZE
157 * It would be better to use some ring buffer from the USERIAL_Read() is reading
158 * instead of putting it into GKI buffers.
159 */
160#define READ_LIMIT (USERIAL_POOL_BUF_SIZE - NFC_HDR_SIZE)
161/*
162 * minimum buffer size requirement to read a full sized packet from NFCC = 255 +
163 * 4 byte header
164 */
165#define MIN_BUFSIZE 259
166#define POLL_TIMEOUT 1000
167/* priority of the reader thread */
168#define USERIAL_READ_TRHEAD_PRIO 90
169/* time (ms) to wait before trying to allocate again a GKI buffer */
170#define NO_GKI_BUFFER_RECOVER_TIME 100
171#define MAX_SERIAL_PORT (USERIAL_PORT_15 + 1)
172
173extern void dumpbin(const char* data, int size);
174extern uint8_t* scru_dump_hex(uint8_t* p, char* p_title, uint32_t len,
175                              uint32_t trace_layer, uint32_t trace_type);
176
177static pthread_t worker_thread1 = 0;
178
179typedef struct {
180  volatile unsigned long bt_wake_state;
181  int sock;
182  tUSERIAL_CBACK* ser_cb;
183  uint16_t baud;
184  uint8_t data_bits;
185  uint16_t parity;
186  uint8_t stop_bits;
187  uint8_t port;
188  tUSERIAL_OPEN_CFG open_cfg;
189  int sock_power_control;
190  int client_device_address;
191  struct timespec write_time;
192} tLINUX_CB;
193
194static tLINUX_CB
195    linux_cb; /* case of multipel port support use array : [MAX_SERIAL_PORT] */
196
197void userial_close_thread(uint32_t params);
198
199static uint8_t device_name[BTE_APPL_MAX_USERIAL_DEV_NAME + 1];
200static int bSerialPortDevice = false;
201static int _timeout = POLL_TIMEOUT;
202static bool is_close_thread_is_waiting = false;
203
204static int change_client_addr(int addr);
205
206int perf_log_every_count = 0;
207typedef struct {
208  const char* label;
209  long lapse;
210  long bytes;
211  long count;
212  long overhead;
213} tPERF_DATA;
214
215/*******************************************************************************
216**
217** Function         perf_reset
218**
219** Description      reset performance measurement data
220**
221** Returns          none
222**
223*******************************************************************************/
224void perf_reset(tPERF_DATA* t) { t->count = t->bytes = t->lapse = 0; }
225
226/*******************************************************************************
227**
228** Function         perf_log
229**
230** Description      produce a log entry of cvurrent performance data
231**
232** Returns          none
233**
234*******************************************************************************/
235void perf_log(tPERF_DATA* t) {
236  // round to nearest ms
237  // t->lapse += 500;
238  // t->lapse /= 1000;
239  if (t->lapse) {
240    if (t->bytes)
241      ALOGD(
242          "%s:%s, bytes=%ld, lapse=%ld (%d.%02d kbps) (bus data rate %d.%02d "
243          "kbps) overhead %d(%d percent)\n",
244          __func__, t->label, t->bytes, t->lapse,
245          (int)(8 * t->bytes / t->lapse),
246          (int)(800 * t->bytes / (t->lapse)) % 100,
247          (int)(9 * (t->bytes + t->count * t->overhead) / t->lapse),
248          (int)(900 * (t->bytes + t->count * t->overhead) / (t->lapse)) % 100,
249          (int)(t->count * t->overhead),
250          (int)(t->count * t->overhead * 100 / t->bytes));
251    else
252      ALOGD("%s:%s, lapse=%ld (average %ld)\n", __func__, t->label, t->lapse,
253            (int)t->lapse / t->count);
254  }
255  perf_reset(t);
256}
257
258/*******************************************************************************
259**
260** Function         perf_update
261**
262** Description      update perforamnce measurement data
263**
264** Returns          none
265**
266*******************************************************************************/
267void perf_update(tPERF_DATA* t, long lapse, long bytes) {
268  if (!perf_log_every_count) return;
269  // round to nearest ms
270  lapse += 500;
271  lapse /= 1000;
272  t->count++;
273  t->bytes += bytes;
274  t->lapse += lapse;
275  if (t->count == perf_log_every_count) perf_log(t);
276}
277
278static tPERF_DATA perf_poll = {"USERIAL_Poll", 0, 0, 0, 0};
279static tPERF_DATA perf_read = {"USERIAL_Read", 0, 0, 0, 9};
280static tPERF_DATA perf_write = {"USERIAL_Write", 0, 0, 0, 3};
281static tPERF_DATA perf_poll_2_poll = {"USERIAL_Poll_to_Poll", 0, 0, 0, 0};
282static clock_t _poll_t0 = 0;
283
284static uint32_t userial_baud_tbl[] = {
285    300,     /* USERIAL_BAUD_300          0 */
286    600,     /* USERIAL_BAUD_600          1 */
287    1200,    /* USERIAL_BAUD_1200         2 */
288    2400,    /* USERIAL_BAUD_2400         3 */
289    9600,    /* USERIAL_BAUD_9600         4 */
290    19200,   /* USERIAL_BAUD_19200        5 */
291    57600,   /* USERIAL_BAUD_57600        6 */
292    115200,  /* USERIAL_BAUD_115200       7 */
293    230400,  /* USERIAL_BAUD_230400       8 */
294    460800,  /* USERIAL_BAUD_460800       9 */
295    921600,  /* USERIAL_BAUD_921600       10 */
296    1000000, /* USERIAL_BAUD_1M           11 */
297    1500000, /* USERIAL_BAUD_1_5M         12 */
298    2000000, /* USERIAL_BAUD_2M           13 */
299    3000000, /* USERIAL_BAUD_3M           14 */
300    4000000  /* USERIAL_BAUD_4M           15 */
301};
302
303/*******************************************************************************
304**
305** Function         wake_state
306**
307** Description      return current state of NFC_WAKE gpio
308**
309** Returns          GPIO value to wake NFCC
310**
311*******************************************************************************/
312static inline int wake_state() {
313  return ((gSnoozeModeCfg.nfc_wake_active_mode == NFC_HAL_LP_ACTIVE_HIGH)
314              ? UPIO_ON
315              : UPIO_OFF);
316}
317
318/*******************************************************************************
319**
320** Function         sleep_state
321**
322** Description      return current state of NFC_WAKE gpio
323**
324** Returns          GPIO value to allow NFCC to goto sleep
325**
326*******************************************************************************/
327static inline int sleep_state() {
328  return ((gSnoozeModeCfg.nfc_wake_active_mode == NFC_HAL_LP_ACTIVE_HIGH)
329              ? UPIO_OFF
330              : UPIO_ON);
331}
332
333/*******************************************************************************
334**
335** Function         isWake
336**
337** Description      return current state of NFC_WAKE gpio based on the active
338*mode setting
339**
340** Returns          asserted_state if it's awake, deasserted_state if it's
341*allowed to sleep
342**
343*******************************************************************************/
344static inline int isWake(int state) {
345  int asserted_state =
346      ((gSnoozeModeCfg.nfc_wake_active_mode == NFC_HAL_LP_ACTIVE_HIGH)
347           ? UPIO_ON
348           : UPIO_OFF);
349  return (state != -1) ? state == asserted_state
350                       : current_nfc_wake_state == asserted_state;
351}
352
353/*******************************************************************************
354**
355** Function           setWriteDelay
356**
357** Description        Record a delay for the next write operation
358**
359** Input Parameter    delay in milliseconds
360**
361** Comments           use this function to register a delay before next write,
362**                    This is used in three instances: power up delay, wake
363*delay
364**                    and write delay
365**
366*******************************************************************************/
367static void setWriteDelay(int delay) {
368  if (delay <= 0) {
369    // Set a minimum delay of 5ms between back-to-back writes
370    delay = 5;
371  }
372
373  clock_gettime(CLOCK_MONOTONIC, &linux_cb.write_time);
374  if (delay > 1000) {
375    linux_cb.write_time.tv_sec += delay / 1000;
376    delay %= 1000;
377  }
378  unsigned long write_delay = delay * 1000 * 1000;
379  linux_cb.write_time.tv_nsec += write_delay;
380  if (linux_cb.write_time.tv_nsec > 1000 * 1000 * 1000) {
381    linux_cb.write_time.tv_nsec -= 1000 * 1000 * 1000;
382    linux_cb.write_time.tv_sec++;
383  }
384}
385
386/*******************************************************************************
387**
388** Function           doWriteDelay
389**
390** Description        Execute a delay as registered in setWriteDelay()
391**
392** Output Parameter   none
393**
394** Returns            none
395**
396** Comments           This function calls GKI_Delay to execute a delay to
397*fulfill
398**                    the delay registered earlier.
399**
400*******************************************************************************/
401static void doWriteDelay() {
402  struct timespec now;
403  clock_gettime(CLOCK_MONOTONIC, &now);
404  long delay = 0;
405
406  if (now.tv_sec > linux_cb.write_time.tv_sec)
407    return;
408  else if (now.tv_sec == linux_cb.write_time.tv_sec) {
409    if (now.tv_nsec > linux_cb.write_time.tv_nsec) return;
410    delay = (linux_cb.write_time.tv_nsec - now.tv_nsec) / 1000000;
411  } else
412    delay = (linux_cb.write_time.tv_sec - now.tv_sec) * 1000 +
413            linux_cb.write_time.tv_nsec / 1000000 - now.tv_nsec / 1000000;
414
415  if (delay > 0 && delay < 1000) {
416    ALOGD_IF((appl_trace_level >= BT_TRACE_LEVEL_DEBUG),
417             "doWriteDelay() delay %ld ms", delay);
418    GKI_delay(delay);
419  }
420}
421
422/*******************************************************************************
423**
424** Function         create_signal_fds
425**
426** Description      create a socketpair for read thread to use
427**
428** Returns          file descriptor
429**
430*******************************************************************************/
431
432static int signal_fds[2];
433static inline int create_signal_fds(struct pollfd* set) {
434  if (signal_fds[0] == 0 &&
435      socketpair(AF_UNIX, SOCK_STREAM, 0, signal_fds) < 0) {
436    ALOGE("%s create_signal_sockets:socketpair failed, errno: %d", __func__,
437          errno);
438    return -1;
439  }
440  set->fd = signal_fds[0];
441  return signal_fds[0];
442}
443
444/*******************************************************************************
445**
446** Function         close_signal_fds
447**
448** Description      close the socketpair
449**
450** Returns          none
451**
452*******************************************************************************/
453static inline void close_signal_fds() {
454  int stat = 0;
455
456  stat = close(signal_fds[0]);
457  if (stat == -1) ALOGE("%s, fail close index 0; errno=%d", __func__, errno);
458  signal_fds[0] = 0;
459
460  stat = close(signal_fds[1]);
461  if (stat == -1) ALOGE("%s, fail close index 1; errno=%d", __func__, errno);
462  signal_fds[1] = 0;
463}
464
465/*******************************************************************************
466**
467** Function         send_wakeup_signal
468**
469** Description      send a one byte data to the socket as signal to the read
470*thread
471**                  for it to stop
472**
473** Returns          number of bytes sent, or error no
474**
475*******************************************************************************/
476static inline int send_wakeup_signal() {
477  char sig_on = 1;
478  ALOGD("%s: Sending signal to %d", __func__, signal_fds[1]);
479  return send(signal_fds[1], &sig_on, sizeof(sig_on), 0);
480}
481
482/*******************************************************************************
483**
484** Function         reset_signal
485**
486** Description      read the one byte data from the socket
487**
488** Returns          received data
489**
490*******************************************************************************/
491static inline int reset_signal() {
492  char sig_recv = 0;
493  ALOGD("%s: Receiving signal from %d", __func__, signal_fds[0]);
494  recv(signal_fds[0], &sig_recv, sizeof(sig_recv), MSG_WAITALL);
495  return (int)sig_recv;
496}
497
498/*******************************************************************************
499**
500** Function         is_signaled
501**
502** Description      test if there's data waiting on the socket
503**
504** Returns          TRUE is data is available
505**
506*******************************************************************************/
507static inline int is_signaled(struct pollfd* set) {
508  return ((set->revents & POLLIN) == POLLIN) ||
509         ((set->revents & POLLRDNORM) == POLLRDNORM);
510}
511
512/******************************************************************************/
513
514typedef unsigned char uchar;
515
516BUFFER_Q Userial_in_q;
517
518/*******************************************************************************
519 **
520 ** Function           USERIAL_GetLineSpeed
521 **
522 ** Description        This function convert USERIAL baud to line speed.
523 **
524 ** Output Parameter   None
525 **
526 ** Returns            line speed
527 **
528 *******************************************************************************/
529extern uint32_t USERIAL_GetLineSpeed(uint8_t baud) {
530  return (baud <= USERIAL_BAUD_4M) ? userial_baud_tbl[baud - USERIAL_BAUD_300]
531                                   : 0;
532}
533
534/*******************************************************************************
535 **
536 ** Function           USERIAL_GetBaud
537 **
538 ** Description        This function convert line speed to USERIAL baud.
539 **
540 ** Output Parameter   None
541 **
542 ** Returns            line speed
543 **
544 *******************************************************************************/
545extern uint8_t USERIAL_GetBaud(uint32_t line_speed) {
546  uint8_t i;
547  for (i = USERIAL_BAUD_300; i <= USERIAL_BAUD_921600; i++) {
548    if (userial_baud_tbl[i - USERIAL_BAUD_300] == line_speed) return i;
549  }
550
551  return USERIAL_BAUD_AUTO;
552}
553
554/*******************************************************************************
555**
556** Function           USERIAL_Init
557**
558** Description        This function initializes the  serial driver.
559**
560** Output Parameter   None
561**
562** Returns            Nothing
563**
564*******************************************************************************/
565
566void USERIAL_Init(void* p_cfg) {
567  ALOGI(__func__);
568
569  // if userial_close_thread() is waiting to run; let it go first;
570  // let it finish; then continue this function
571  while (true) {
572    pthread_mutex_lock(&close_thread_mutex);
573    if (is_close_thread_is_waiting) {
574      pthread_mutex_unlock(&close_thread_mutex);
575      ALOGI("USERIAL_Init(): wait for close-thread");
576      sleep(1);
577    } else
578      break;
579  }
580
581  memset(&linux_cb, 0, sizeof(linux_cb));
582  linux_cb.sock = -1;
583  linux_cb.ser_cb = NULL;
584  linux_cb.sock_power_control = -1;
585  linux_cb.client_device_address = 0;
586  GKI_init_q(&Userial_in_q);
587  pthread_mutex_unlock(&close_thread_mutex);
588}
589
590/*******************************************************************************
591 **
592 ** Function           my_read
593 **
594 ** Description        This function read a packet from driver.
595 **
596 ** Output Parameter   None
597 **
598 ** Returns            number of bytes in the packet or error code
599 **
600 *******************************************************************************/
601int my_read(int fd, uchar* pbuf, int len) {
602  struct pollfd fds[2];
603
604  int n = 0;
605  int ret = 0;
606  int count = 0;
607  int offset = 0;
608  clock_t t1, t2;
609
610  if (!isLowSpeedTransport && _timeout != POLL_TIMEOUT)
611    ALOGD_IF((appl_trace_level >= BT_TRACE_LEVEL_DEBUG),
612             "%s: enter, pbuf=%lx, len = %d\n", __func__, (unsigned long)pbuf,
613             len);
614  memset(pbuf, 0, len);
615  /* need to use select in order to avoid collistion between read and close on
616   * same fd */
617  /* Initialize the input set */
618  fds[0].fd = fd;
619  fds[0].events = POLLIN | POLLERR | POLLRDNORM;
620  fds[0].revents = 0;
621
622  create_signal_fds(&fds[1]);
623  fds[1].events = POLLIN | POLLERR | POLLRDNORM;
624  fds[1].revents = 0;
625  t1 = clock();
626  n = TEMP_FAILURE_RETRY(poll(fds, 2, _timeout));
627  t2 = clock();
628  perf_update(&perf_poll, t2 - t1, 0);
629  if (_poll_t0) perf_update(&perf_poll_2_poll, t2 - _poll_t0, 0);
630
631  _poll_t0 = t2;
632  /* See if there was an error */
633  if (n < 0) {
634    ALOGD("select failed; errno = %d\n", errno);
635    return -errno;
636  } else if (n == 0)
637    return -EAGAIN;
638
639  if (is_signaled(&fds[1])) {
640    ALOGD("%s: exit signal received\n", __func__);
641    reset_signal();
642    return -1;
643  }
644  if (!bSerialPortDevice || len < MIN_BUFSIZE)
645    count = len;
646  else
647    count = 1;
648  do {
649    t2 = clock();
650    ret = TEMP_FAILURE_RETRY(read(fd, pbuf + offset, (size_t)count));
651    if (ret > 0) perf_update(&perf_read, clock() - t2, ret);
652
653    if (ret <= 0 || !bSerialPortDevice || len < MIN_BUFSIZE) break;
654
655    if (isLowSpeedTransport) goto done;
656
657    if (offset == 0) {
658      if (pbuf[offset] == HCIT_TYPE_NFC)
659        count = 3;
660      else if (pbuf[offset] == HCIT_TYPE_EVENT)
661        count = 2;
662      else {
663        ALOGD("%s: unknown HCIT type header pbuf[%d] = %x\n", __func__, offset,
664              pbuf[offset]);
665        break;
666      }
667      offset = 1;
668    } else if (offset == 1) {
669      offset += count;
670      count = pbuf[offset - 1];
671      if (count > (len - offset))  // if (count > (remaining buffer size))
672        count =
673            len - offset;  // only read what the remaining buffer size can hold
674    } else {
675      offset += ret;
676      count -= ret;
677    }
678    if (count == 0) {
679      ret = offset;
680      break;
681    }
682  } while (count > 0);
683
684#if VALIDATE_PACKET
685  /*
686   * vallidate the packet structure
687   */
688  if (ret > 0 && len >= MIN_BUFSIZE) {
689    count = 0;
690    while (count < ret) {
691      if (pbuf[count] == HCIT_TYPE_NFC) {
692        if (USERIAL_Debug_verbose)
693          scru_dump_hex(pbuf + count, NULL, pbuf[count + 3] + 4, 0, 0);
694        count += pbuf[count + 3] + 4;
695      } else if (pbuf[count] == HCIT_TYPE_EVENT) {
696        if (USERIAL_Debug_verbose)
697          scru_dump_hex(pbuf + count, NULL, pbuf[count + 2] + 3, 0, 0);
698        count += pbuf[count + 2] + 3;
699      } else {
700        ALOGD("%s: unknown HCIT type header pbuf[%d] = %x, remain %d bytes\n",
701              __func__, count, pbuf[count], ret - count);
702        scru_dump_hex(pbuf + count, NULL, ret - count, 0, 0);
703        break;
704      }
705    } /* while*/
706  }
707#endif
708done:
709  if (!isLowSpeedTransport)
710    ALOGD_IF((appl_trace_level >= BT_TRACE_LEVEL_DEBUG),
711             "%s: return %d(0x%x) bytes, errno=%d count=%d, n=%d, timeout=%d\n",
712             __func__, ret, ret, errno, count, n, _timeout);
713  if (_timeout == POLL_TIMEOUT) _timeout = -1;
714  return ret;
715}
716extern bool gki_chk_buf_damage(void* p_buf);
717static int sRxLength = 0;
718
719/*******************************************************************************
720 **
721 ** Function           userial_read_thread
722 **
723 ** Description        entry point of read thread.
724 **
725 ** Output Parameter   None
726 **
727 ** Returns            0
728 **
729 *******************************************************************************/
730uint32_t userial_read_thread(uint32_t arg) {
731  int rx_length;
732  int error_count = 0;
733  int bErrorReported = 0;
734  int iMaxError = MAX_ERROR;
735  NFC_HDR* p_buf = NULL;
736
737  worker_thread1 = pthread_self();
738
739  ALOGD("start userial_read_thread, id=%lx", worker_thread1);
740  _timeout = POLL_TIMEOUT;
741
742  for (; linux_cb.sock > 0;) {
743    NFC_HDR* p_buf;
744    uint8_t* current_packet;
745
746    p_buf = (NFC_HDR*)GKI_getpoolbuf(USERIAL_POOL_ID);
747    if (p_buf != NULL) {
748      p_buf->offset = 0;
749      p_buf->layer_specific = 0;
750
751      current_packet = (uint8_t*)(p_buf + 1);
752      rx_length = my_read(linux_cb.sock, current_packet, READ_LIMIT);
753
754    } else {
755      ALOGE(
756          "userial_read_thread(): unable to get buffer from GKI p_buf = %p "
757          "poolid = %d\n",
758          p_buf, USERIAL_POOL_ID);
759      rx_length = 0; /* paranoia setting */
760      GKI_delay(NO_GKI_BUFFER_RECOVER_TIME);
761      continue;
762    }
763    if (rx_length > 0) {
764      bErrorReported = 0;
765      error_count = 0;
766      iMaxError = 3;
767      if (rx_length > sRxLength) sRxLength = rx_length;
768      p_buf->len = (uint16_t)rx_length;
769      GKI_enqueue(&Userial_in_q, p_buf);
770      if (!isLowSpeedTransport)
771        ALOGD_IF(
772            (appl_trace_level >= BT_TRACE_LEVEL_DEBUG),
773            "userial_read_thread(): enqueued p_buf=%p, count=%d, length=%d\n",
774            p_buf, Userial_in_q.count, rx_length);
775
776      if (linux_cb.ser_cb != NULL)
777        (*linux_cb.ser_cb)(linux_cb.port, USERIAL_RX_READY_EVT,
778                           (tUSERIAL_EVT_DATA*)p_buf);
779
780      GKI_send_event(USERIAL_HAL_TASK, HCISU_EVT);
781    } else {
782      GKI_freebuf(p_buf);
783      if (rx_length == -EAGAIN)
784        continue;
785      else if (rx_length == -1) {
786        ALOGD("userial_read_thread(): exiting\n");
787        break;
788      } else if (rx_length == 0 && !isWake(-1))
789        continue;
790      ++error_count;
791      if (rx_length <= 0 &&
792          ((error_count > 0) && ((error_count % iMaxError) == 0))) {
793        if (bErrorReported == 0) {
794          ALOGE(
795              "userial_read_thread(): my_read returned (%d) error count = %d, "
796              "errno=%d return USERIAL_ERR_EVT\n",
797              rx_length, error_count, errno);
798          if (linux_cb.ser_cb != NULL)
799            (*linux_cb.ser_cb)(linux_cb.port, USERIAL_ERR_EVT,
800                               (tUSERIAL_EVT_DATA*)p_buf);
801
802          GKI_send_event(USERIAL_HAL_TASK, HCISU_EVT);
803          ++bErrorReported;
804        }
805        if (sRxLength == 0) {
806          ALOGE(
807              "userial_read_thread(): my_read returned (%d) error count = %d, "
808              "errno=%d exit read thread\n",
809              rx_length, error_count, errno);
810          break;
811        }
812      }
813    }
814  } /* for */
815
816  ALOGD("userial_read_thread(): freeing GKI_buffers\n");
817  while ((p_buf = (NFC_HDR*)GKI_dequeue(&Userial_in_q)) != NULL) {
818    GKI_freebuf(p_buf);
819    ALOGD("userial_read_thread: dequeued buffer from Userial_in_q\n");
820  }
821
822  GKI_exit_task(GKI_get_taskid());
823  ALOGD("USERIAL READ: EXITING TASK\n");
824
825  return 0;
826}
827
828/*******************************************************************************
829 **
830 ** Function           userial_to_tcio_baud
831 **
832 ** Description        helper function converts USERIAL baud rates into TCIO
833 *conforming baud rates
834 **
835 ** Output Parameter   None
836 **
837 ** Returns            TRUE - success
838 **                    FALSE - unsupported baud rate, default of 115200 is used
839 **
840 *******************************************************************************/
841bool userial_to_tcio_baud(uint8_t cfg_baud, uint32_t* baud) {
842  if (cfg_baud == USERIAL_BAUD_600)
843    *baud = B600;
844  else if (cfg_baud == USERIAL_BAUD_1200)
845    *baud = B1200;
846  else if (cfg_baud == USERIAL_BAUD_9600)
847    *baud = B9600;
848  else if (cfg_baud == USERIAL_BAUD_19200)
849    *baud = B19200;
850  else if (cfg_baud == USERIAL_BAUD_57600)
851    *baud = B57600;
852  else if (cfg_baud == USERIAL_BAUD_115200)
853    *baud = B115200 | CBAUDEX;
854  else if (cfg_baud == USERIAL_BAUD_230400)
855    *baud = B230400;
856  else if (cfg_baud == USERIAL_BAUD_460800)
857    *baud = B460800;
858  else if (cfg_baud == USERIAL_BAUD_921600)
859    *baud = B921600;
860  else if (cfg_baud == USERIAL_BAUD_1M)
861    *baud = B1000000;
862  else if (cfg_baud == USERIAL_BAUD_2M)
863    *baud = B2000000;
864  else if (cfg_baud == USERIAL_BAUD_3M)
865    *baud = B3000000;
866  else if (cfg_baud == USERIAL_BAUD_4M)
867    *baud = B4000000;
868  else {
869    ALOGE("userial_to_tcio_baud: unsupported baud idx %i", cfg_baud);
870    *baud = B115200;
871    return false;
872  }
873  return true;
874}
875
876#if (USERIAL_USE_IO_BT_WAKE == TRUE)
877/*******************************************************************************
878 **
879 ** Function           userial_io_init_bt_wake
880 **
881 ** Description        helper function to set the open state of the bt_wake if
882 *ioctl
883 **                    is used. it should not hurt in the rfkill case but it
884 *might
885 **                    be better to compile it out.
886 **
887 ** Returns            none
888 **
889 *******************************************************************************/
890void userial_io_init_bt_wake(int fd, unsigned long* p_wake_state) {
891  /* assert BT_WAKE for ioctl. should NOT hurt on rfkill version */
892  ioctl(fd, USERIAL_IO_BT_WAKE_ASSERT, NULL);
893  ioctl(fd, USERIAL_IO_BT_WAKE_GET_ST, p_wake_state);
894  if (*p_wake_state == 0)
895    ALOGI(
896        "\n***userial_io_init_bt_wake(): Ooops, asserted BT_WAKE signal, but "
897        "still got BT_WAKE state == to %d\n",
898        *p_wake_state);
899
900  *p_wake_state = 1;
901}
902#endif
903
904/*******************************************************************************
905**
906** Function           USERIAL_Open
907**
908** Description        Open the indicated serial port with the given
909*configuration
910**
911** Output Parameter   None
912**
913** Returns            Nothing
914**
915*******************************************************************************/
916void USERIAL_Open(tUSERIAL_PORT port, tUSERIAL_OPEN_CFG* p_cfg,
917                  tUSERIAL_CBACK* p_cback) {
918  uint32_t baud = 0;
919  uint8_t data_bits = 0;
920  uint16_t parity = 0;
921  uint8_t stop_bits = 0;
922  struct termios termios;
923  const char ttyusb[] = "/dev/ttyUSB";
924  const char devtty[] = "/dev/tty";
925  unsigned long num = 0;
926  int ret = 0;
927
928  ALOGI("USERIAL_Open(): enter");
929
930  // if userial_close_thread() is waiting to run; let it go first;
931  // let it finish; then continue this function
932  while (true) {
933    pthread_mutex_lock(&close_thread_mutex);
934    if (is_close_thread_is_waiting) {
935      pthread_mutex_unlock(&close_thread_mutex);
936      ALOGI("USERIAL_Open(): wait for close-thread");
937      sleep(1);
938    } else
939      break;
940  }
941
942  // restore default power off delay settings incase they were changed in
943  // userial_set_poweroff_delays()
944  gPrePowerOffDelay = 0;
945  gPostPowerOffDelay = 0;
946
947  if (!GetStrValue(NAME_TRANSPORT_DRIVER, userial_dev, sizeof(userial_dev)))
948    strcpy(userial_dev, default_transport);
949  if (GetNumValue(NAME_UART_PORT, &num, sizeof(num))) uart_port = num;
950  if (GetNumValue(NAME_LOW_SPEED_TRANSPORT, &num, sizeof(num)))
951    isLowSpeedTransport = num;
952  if (GetNumValue(NAME_NFC_WAKE_DELAY, &num, sizeof(num))) nfc_wake_delay = num;
953  if (GetNumValue(NAME_NFC_WRITE_DELAY, &num, sizeof(num)))
954    nfc_write_delay = num;
955  if (GetNumValue(NAME_PERF_MEASURE_FREQ, &num, sizeof(num)))
956    perf_log_every_count = num;
957  if (GetNumValue(NAME_POWER_ON_DELAY, &num, sizeof(num))) gPowerOnDelay = num;
958  if (GetNumValue(NAME_PRE_POWER_OFF_DELAY, &num, sizeof(num)))
959    gPrePowerOffDelay = num;
960  if (GetNumValue(NAME_POST_POWER_OFF_DELAY, &num, sizeof(num)))
961    gPostPowerOffDelay = num;
962  if (GetNumValue(NAME_POWER_OFF_MODE, &num, sizeof(num))) gPowerOffMode = num;
963  ALOGI(
964      "USERIAL_Open() device: %s port=%d, uart_port=%d WAKE_DELAY(%d) "
965      "WRITE_DELAY(%d) POWER_ON_DELAY(%d) PRE_POWER_OFF_DELAY(%d) "
966      "POST_POWER_OFF_DELAY(%d)",
967      (char*)userial_dev, port, uart_port, nfc_wake_delay, nfc_write_delay,
968      gPowerOnDelay, gPrePowerOffDelay, gPostPowerOffDelay);
969
970  strcpy((char*)device_name, (char*)userial_dev);
971  sRxLength = 0;
972  _poll_t0 = 0;
973
974  if ((strncmp(userial_dev, ttyusb, sizeof(ttyusb) - 1) == 0) ||
975      (strncmp(userial_dev, devtty, sizeof(devtty) - 1) == 0)) {
976    if (uart_port >= MAX_SERIAL_PORT) {
977      ALOGD("Port > MAX_SERIAL_PORT\n");
978      goto done_open;
979    }
980    bSerialPortDevice = true;
981    sprintf((char*)device_name, "%s%d", (char*)userial_dev, uart_port);
982    ALOGI("USERIAL_Open() using device_name: %s ", (char*)device_name);
983    if (!userial_to_tcio_baud(p_cfg->baud, &baud)) goto done_open;
984
985    if (p_cfg->fmt & USERIAL_DATABITS_8)
986      data_bits = CS8;
987    else if (p_cfg->fmt & USERIAL_DATABITS_7)
988      data_bits = CS7;
989    else if (p_cfg->fmt & USERIAL_DATABITS_6)
990      data_bits = CS6;
991    else if (p_cfg->fmt & USERIAL_DATABITS_5)
992      data_bits = CS5;
993    else
994      goto done_open;
995
996    if (p_cfg->fmt & USERIAL_PARITY_NONE)
997      parity = 0;
998    else if (p_cfg->fmt & USERIAL_PARITY_EVEN)
999      parity = PARENB;
1000    else if (p_cfg->fmt & USERIAL_PARITY_ODD)
1001      parity = (PARENB | PARODD);
1002    else
1003      goto done_open;
1004
1005    if (p_cfg->fmt & USERIAL_STOPBITS_1)
1006      stop_bits = 0;
1007    else if (p_cfg->fmt & USERIAL_STOPBITS_2)
1008      stop_bits = CSTOPB;
1009    else
1010      goto done_open;
1011  } else
1012    strcpy((char*)device_name, (char*)userial_dev);
1013
1014  {
1015    ALOGD("%s Opening %s\n", __func__, device_name);
1016    linux_cb.sock = open((char*)device_name, O_RDWR | O_NOCTTY);
1017    if (linux_cb.sock == -1) {
1018      ALOGI("%s unable to open %s", __func__, device_name);
1019      GKI_send_event(NFC_HAL_TASK, NFC_HAL_TASK_EVT_TERMINATE);
1020      goto done_open;
1021    }
1022    ALOGD("%s sock = %d\n", __func__, linux_cb.sock);
1023    if (GetStrValue(NAME_POWER_CONTROL_DRIVER, power_control_dev,
1024                    sizeof(power_control_dev)) &&
1025        power_control_dev[0] != '\0') {
1026      if (strcmp(power_control_dev, userial_dev) == 0)
1027        linux_cb.sock_power_control = linux_cb.sock;
1028      else {
1029        linux_cb.sock_power_control =
1030            open((char*)power_control_dev, O_RDWR | O_NOCTTY);
1031        if (linux_cb.sock_power_control == -1) {
1032          ALOGI("%s unable to open %s", __func__, power_control_dev);
1033        }
1034      }
1035    }
1036    if (bSerialPortDevice) {
1037      tcflush(linux_cb.sock, TCIOFLUSH);
1038      tcgetattr(linux_cb.sock, &termios);
1039
1040      termios.c_cflag &= ~(CSIZE | PARENB);
1041      termios.c_cflag = CLOCAL | CREAD | data_bits | stop_bits | parity;
1042      if (!parity) termios.c_cflag |= IGNPAR;
1043      // termios.c_cflag &= ~CRTSCTS;
1044      termios.c_oflag = 0;
1045      termios.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN | ISIG);
1046      termios.c_iflag &=
1047          ~(BRKINT | ICRNL | INLCR | ISTRIP | IXON | IGNBRK | PARMRK | INPCK);
1048      termios.c_lflag = 0;
1049      termios.c_iflag = 0;
1050      cfsetospeed(&termios, baud);
1051      cfsetispeed(&termios, baud);
1052
1053      termios.c_cc[VTIME] = 0;
1054      termios.c_cc[VMIN] = 1;
1055      tcsetattr(linux_cb.sock, TCSANOW, &termios);
1056
1057      tcflush(linux_cb.sock, TCIOFLUSH);
1058
1059#if (USERIAL_USE_IO_BT_WAKE == TRUE)
1060      userial_io_init_bt_wake(linux_cb.sock, &linux_cb.bt_wake_state);
1061#endif
1062      GKI_delay(gPowerOnDelay);
1063    } else {
1064      USERIAL_PowerupDevice(port);
1065    }
1066  }
1067
1068  linux_cb.ser_cb = p_cback;
1069  linux_cb.port = port;
1070  memcpy(&linux_cb.open_cfg, p_cfg, sizeof(tUSERIAL_OPEN_CFG));
1071  GKI_create_task((TASKPTR)userial_read_thread, USERIAL_HAL_TASK,
1072                  (int8_t*)"USERIAL_HAL_TASK", 0, 0, (pthread_cond_t*)NULL,
1073                  NULL);
1074
1075#if (USERIAL_DEBUG == TRUE)
1076  ALOGD("Leaving USERIAL_Open\n");
1077#endif
1078
1079#if (SERIAL_AMBA == TRUE)
1080  /* give 20ms time for reader thread */
1081  GKI_delay(20);
1082#endif
1083
1084done_open:
1085  pthread_mutex_unlock(&close_thread_mutex);
1086  ALOGI("USERIAL_Open(): exit");
1087  return;
1088}
1089
1090/*******************************************************************************
1091**
1092** Function           USERIAL_Read
1093**
1094** Description        Read data from a serial port using byte buffers.
1095**
1096** Output Parameter   None
1097**
1098** Returns            Number of bytes actually read from the serial port and
1099**                    copied into p_data.  This may be less than len.
1100**
1101*******************************************************************************/
1102
1103static NFC_HDR* pbuf_USERIAL_Read = NULL;
1104
1105uint16_t USERIAL_Read(tUSERIAL_PORT port, uint8_t* p_data, uint16_t len) {
1106  uint16_t total_len = 0;
1107  uint16_t copy_len = 0;
1108  uint8_t* current_packet = NULL;
1109
1110#if (USERIAL_DEBUG == TRUE)
1111  ALOGD("%s ++ len=%d pbuf_USERIAL_Read=%p, p_data=%p\n", __func__, len,
1112        pbuf_USERIAL_Read, p_data);
1113#endif
1114  do {
1115    if (pbuf_USERIAL_Read != NULL) {
1116      current_packet =
1117          ((uint8_t*)(pbuf_USERIAL_Read + 1)) + (pbuf_USERIAL_Read->offset);
1118
1119      if ((pbuf_USERIAL_Read->len) <= (len - total_len))
1120        copy_len = pbuf_USERIAL_Read->len;
1121      else
1122        copy_len = (len - total_len);
1123
1124      memcpy((p_data + total_len), current_packet, copy_len);
1125
1126      total_len += copy_len;
1127
1128      pbuf_USERIAL_Read->offset += copy_len;
1129      pbuf_USERIAL_Read->len -= copy_len;
1130
1131      if (pbuf_USERIAL_Read->len == 0) {
1132        GKI_freebuf(pbuf_USERIAL_Read);
1133        pbuf_USERIAL_Read = NULL;
1134      }
1135    }
1136
1137    if (pbuf_USERIAL_Read == NULL && (total_len < len))
1138      pbuf_USERIAL_Read = (NFC_HDR*)GKI_dequeue(&Userial_in_q);
1139
1140  } while ((pbuf_USERIAL_Read != NULL) && (total_len < len));
1141
1142#if (USERIAL_DEBUG == TRUE)
1143  ALOGD("%s: returned %d bytes", __func__, total_len);
1144#endif
1145  return total_len;
1146}
1147
1148/*******************************************************************************
1149**
1150** Function           USERIAL_Readbuf
1151**
1152** Description        Read data from a serial port using GKI buffers.
1153**
1154** Output Parameter   Pointer to a GKI buffer which contains the data.
1155**
1156** Returns            Nothing
1157**
1158** Comments           The caller of this function is responsible for freeing the
1159**                    GKI buffer when it is finished with the data.  If there is
1160**                    no data to be read, the value of the returned pointer is
1161**                    NULL.
1162**
1163*******************************************************************************/
1164
1165void USERIAL_ReadBuf(tUSERIAL_PORT port, NFC_HDR** p_buf) {}
1166
1167/*******************************************************************************
1168**
1169** Function           USERIAL_WriteBuf
1170**
1171** Description        Write data to a serial port using a GKI buffer.
1172**
1173** Output Parameter   None
1174**
1175** Returns            TRUE  if buffer accepted for write.
1176**                    FALSE if there is already a buffer being processed.
1177**
1178** Comments           The buffer will be freed by the serial driver.  Therefore,
1179**                    the application calling this function must not free the
1180**                    buffer.
1181**
1182*******************************************************************************/
1183
1184bool USERIAL_WriteBuf(tUSERIAL_PORT port, NFC_HDR* p_buf) { return false; }
1185
1186/*******************************************************************************
1187**
1188** Function           USERIAL_Write
1189**
1190** Description        Write data to a serial port using a byte buffer.
1191**
1192** Output Parameter   None
1193**
1194** Returns            Number of bytes actually written to the transport.  This
1195**                    may be less than len.
1196**
1197*******************************************************************************/
1198uint16_t USERIAL_Write(tUSERIAL_PORT port, uint8_t* p_data, uint16_t len) {
1199  int ret = 0, total = 0;
1200  int i = 0;
1201  clock_t t;
1202
1203  ALOGD_IF((appl_trace_level >= BT_TRACE_LEVEL_DEBUG),
1204           "USERIAL_Write: (%d bytes)", len);
1205  pthread_mutex_lock(&close_thread_mutex);
1206
1207  doWriteDelay();
1208  t = clock();
1209  while (len != 0 && linux_cb.sock != -1) {
1210    ret = TEMP_FAILURE_RETRY(write(linux_cb.sock, p_data + total, len));
1211    if (ret < 0) {
1212      ALOGE("USERIAL_Write len = %d, ret = %d, errno = %d", len, ret, errno);
1213      break;
1214    } else {
1215      ALOGD_IF((appl_trace_level >= BT_TRACE_LEVEL_DEBUG),
1216               "USERIAL_Write len = %d, ret = %d", len, ret);
1217    }
1218
1219    total += ret;
1220    len -= ret;
1221  }
1222  perf_update(&perf_write, clock() - t, total);
1223
1224  /* register a delay for next write */
1225  setWriteDelay(total * nfc_write_delay / 1000);
1226
1227  pthread_mutex_unlock(&close_thread_mutex);
1228
1229  return ((uint16_t)total);
1230}
1231
1232/*******************************************************************************
1233**
1234** Function           userial_change_rate
1235**
1236** Description        change naud rate
1237**
1238** Output Parameter   None
1239**
1240** Returns            None
1241**
1242*******************************************************************************/
1243void userial_change_rate(uint8_t baud) {
1244#if (USING_BRCM_USB == FALSE)
1245  struct termios termios;
1246#endif
1247#if (USERIAL_USE_TCIO_BAUD_CHANGE == TRUE)
1248  uint32_t tcio_baud;
1249#endif
1250
1251#if (USING_BRCM_USB == FALSE)
1252  tcflush(linux_cb.sock, TCIOFLUSH);
1253
1254  tcgetattr(linux_cb.sock, &termios);
1255
1256  cfmakeraw(&termios);
1257  cfsetospeed(&termios, baud);
1258  cfsetispeed(&termios, baud);
1259
1260  termios.c_cflag |= (CLOCAL | CREAD | CRTSCTS | stop_bits);
1261
1262  tcsetattr(linux_cb.sock, TCSANOW, &termios);
1263  tcflush(linux_cb.sock, TCIOFLUSH);
1264
1265#else
1266#if (USERIAL_USE_TCIO_BAUD_CHANGE == FALSE)
1267  fprintf(stderr, "userial_change_rate: Closing UART Port\n");
1268  ALOGI("userial_change_rate: Closing UART Port\n");
1269  USERIAL_Close(linux_cb.port);
1270
1271  GKI_delay(50);
1272
1273  /* change baud rate in settings - leave everything else the same  */
1274  linux_cb.open_cfg.baud = baud;
1275
1276  ALOGD("userial_change_rate: Attempting to reopen the UART Port at 0x%08x\n",
1277        (unsigned int)USERIAL_GetLineSpeed(baud));
1278  ALOGI("userial_change_rate: Attempting to reopen the UART Port at %i\n",
1279        (unsigned int)USERIAL_GetLineSpeed(baud));
1280
1281  USERIAL_Open(linux_cb.port, &linux_cb.open_cfg, linux_cb.ser_cb);
1282#else /* amba uart */
1283  fprintf(stderr, "userial_change_rate(): changeing baud rate via TCIO \n");
1284  ALOGI("userial_change_rate: (): changeing baud rate via TCIO \n");
1285  /* change baud rate in settings - leave everything else the same  */
1286  linux_cb.open_cfg.baud = baud;
1287  if (!userial_to_tcio_baud(linux_cb.open_cfg.baud, &tcio_baud)) return;
1288
1289  tcflush(linux_cb.sock, TCIOFLUSH);
1290
1291  /* get current settings. they should be fine besides baud rate we want to
1292   * change */
1293  tcgetattr(linux_cb.sock, &termios);
1294
1295  /* set input/output baudrate */
1296  cfsetospeed(&termios, tcio_baud);
1297  cfsetispeed(&termios, tcio_baud);
1298  tcsetattr(linux_cb.sock, TCSANOW, &termios);
1299
1300  tcflush(linux_cb.sock, TCIOFLUSH);
1301#endif
1302#endif /* USING_BRCM_USB  */
1303}
1304
1305/*******************************************************************************
1306**
1307** Function           userial_close_port
1308**
1309** Description        close the transport driver
1310**
1311** Returns            Nothing
1312**
1313*******************************************************************************/
1314void userial_close_port(void) { USERIAL_Close(linux_cb.port); }
1315
1316/*******************************************************************************
1317**
1318** Function           USERIAL_Ioctl
1319**
1320** Description        Perform an operation on a serial port.
1321**
1322** Output Parameter   The p_data parameter is either an input or output
1323*depending
1324**                    on the operation.
1325**
1326** Returns            Nothing
1327**
1328*******************************************************************************/
1329
1330void USERIAL_Ioctl(tUSERIAL_PORT port, tUSERIAL_OP op,
1331                   tUSERIAL_IOCTL_DATA* p_data) {
1332#if (defined(LINUX_OS) && LINUX_OS == TRUE)
1333  USB_SCO_CONTROL ioctl_data;
1334
1335/* just ignore port parameter as we are using USB in this case  */
1336#endif
1337
1338  switch (op) {
1339    case USERIAL_OP_FLUSH:
1340      break;
1341    case USERIAL_OP_FLUSH_RX:
1342      break;
1343    case USERIAL_OP_FLUSH_TX:
1344      break;
1345    case USERIAL_OP_BAUD_WR:
1346      ALOGI(
1347          "USERIAL_Ioctl: Received USERIAL_OP_BAUD_WR on port: %d, ioctl "
1348          "baud%i\n",
1349          port, p_data->baud);
1350      linux_cb.port = port;
1351      userial_change_rate(p_data->baud);
1352      break;
1353
1354    default:
1355      break;
1356  }
1357
1358  return;
1359}
1360
1361/*******************************************************************************
1362**
1363** Function         USERIAL_SetPowerOffDelays
1364**
1365** Description      Set power off delays used during USERIAL_Close().  The
1366**                  values in the conf. file setting override these if set.
1367**
1368** Returns          None.
1369**
1370*******************************************************************************/
1371void USERIAL_SetPowerOffDelays(int pre_poweroff_delay,
1372                               int post_poweroff_delay) {
1373  gPrePowerOffDelay = pre_poweroff_delay;
1374  gPostPowerOffDelay = post_poweroff_delay;
1375}
1376
1377/*******************************************************************************
1378**
1379** Function           USERIAL_Close
1380**
1381** Description        Close a serial port
1382**
1383** Output Parameter   None
1384**
1385** Returns            Nothing
1386**
1387*******************************************************************************/
1388void USERIAL_Close(tUSERIAL_PORT port) {
1389  pthread_attr_t attr;
1390  pthread_t close_thread;
1391  uint8_t res[10];
1392  uint32_t delay = 100;
1393
1394  ALOGD("%s: enter; gPowerOffMode=%d", __func__, gPowerOffMode);
1395
1396  /* Do we need to put NFCC into certain mode before switching off?... */
1397  if (gPowerOffMode != POM_NORMAL) {
1398    switch (gPowerOffMode) {
1399      case POM_CE3SO:
1400        ALOGD("%s: Sending Set_PwrLevel cmd to go to CE3-SO mode", __func__);
1401        USERIAL_Write(port, ce3_so_cmd, sizeof(ce3_so_cmd));
1402        delay = 1000;
1403        break;
1404
1405      case POM_NFC_OFF:
1406        ALOGD("%s: Sending Set_NfcOff cmd", __func__);
1407        USERIAL_Write(port, set_nfc_off_cmd, sizeof(set_nfc_off_cmd));
1408        break;
1409    }
1410
1411    USERIAL_Read(port, res, sizeof(res));
1412    GKI_delay(delay);
1413  }
1414
1415  // check to see if thread is already running
1416  if (pthread_mutex_trylock(&close_thread_mutex) == 0) {
1417    // mutex aquired so thread is not running
1418    is_close_thread_is_waiting = TRUE;
1419    pthread_mutex_unlock(&close_thread_mutex);
1420
1421    // close transport in a new thread so we don't block the caller
1422    // make thread detached, no other thread will join
1423    pthread_attr_init(&attr);
1424    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
1425    pthread_create(&close_thread, &attr, (void*)userial_close_thread, NULL);
1426    pthread_attr_destroy(&attr);
1427  } else {
1428    // mutex not aquired to thread is already running
1429    ALOGD("USERIAL_Close(): already closing \n");
1430  }
1431  ALOGD("%s: exit", __func__);
1432}
1433
1434/*******************************************************************************
1435**
1436** Function         userial_close_thread
1437**
1438** Description      Thread to close USERIAL
1439**
1440** Returns          None.
1441**
1442*******************************************************************************/
1443void userial_close_thread(uint32_t params) {
1444  NFC_HDR* p_buf = NULL;
1445  int result;
1446
1447  ALOGD("%s: closing transport (%d)\n", __func__, linux_cb.sock);
1448  pthread_mutex_lock(&close_thread_mutex);
1449  is_close_thread_is_waiting = false;
1450
1451  if (linux_cb.sock <= 0) {
1452    ALOGD("%s: already closed (%d)\n", __func__, linux_cb.sock);
1453    pthread_mutex_unlock(&close_thread_mutex);
1454    return;
1455  }
1456
1457  send_wakeup_signal();
1458  result = pthread_join(worker_thread1, NULL);
1459  if (result < 0)
1460    ALOGE("%s: pthread_join() FAILED: result: %d", __func__, result);
1461  else
1462    ALOGD("%s: pthread_join() joined: result: %d", __func__, result);
1463
1464  if (linux_cb.sock_power_control > 0) {
1465    result = ioctl(linux_cb.sock_power_control, BCMNFC_WAKE_CTL, sleep_state());
1466    ALOGD("%s: Delay %dms before turning off the chip", __func__,
1467          gPrePowerOffDelay);
1468    GKI_delay(gPrePowerOffDelay);
1469    result = ioctl(linux_cb.sock_power_control, BCMNFC_POWER_CTL, 0);
1470    ALOGD("%s: Delay %dms after turning off the chip", __func__,
1471          gPostPowerOffDelay);
1472    GKI_delay(gPostPowerOffDelay);
1473  }
1474  result = close(linux_cb.sock);
1475  if (result == -1)
1476    ALOGE("%s: fail close linux_cb.sock; errno=%d", __func__, errno);
1477
1478  if (linux_cb.sock_power_control > 0 &&
1479      linux_cb.sock_power_control != linux_cb.sock)
1480    result = close(linux_cb.sock_power_control);
1481  if (result == -1)
1482    ALOGE("%s: fail close linux_cb.sock_power_control; errno=%d", __func__,
1483          errno);
1484
1485  linux_cb.sock_power_control = -1;
1486  linux_cb.sock = -1;
1487
1488  close_signal_fds();
1489  pthread_mutex_unlock(&close_thread_mutex);
1490  ALOGD("%s: exiting", __func__);
1491}
1492
1493/*******************************************************************************
1494**
1495** Function           USERIAL_Feature
1496**
1497** Description        Check whether a feature of the serial API is supported.
1498**
1499** Output Parameter   None
1500**
1501** Returns            TRUE  if the feature is supported
1502**                    FALSE if the feature is not supported
1503**
1504*******************************************************************************/
1505
1506bool USERIAL_Feature(tUSERIAL_FEATURE feature) {
1507  switch (feature) {
1508    case USERIAL_FEAT_PORT_1:
1509    case USERIAL_FEAT_PORT_2:
1510    case USERIAL_FEAT_PORT_3:
1511    case USERIAL_FEAT_PORT_4:
1512
1513    case USERIAL_FEAT_BAUD_600:
1514    case USERIAL_FEAT_BAUD_1200:
1515    case USERIAL_FEAT_BAUD_9600:
1516    case USERIAL_FEAT_BAUD_19200:
1517    case USERIAL_FEAT_BAUD_57600:
1518    case USERIAL_FEAT_BAUD_115200:
1519
1520    case USERIAL_FEAT_STOPBITS_1:
1521    case USERIAL_FEAT_STOPBITS_2:
1522
1523    case USERIAL_FEAT_PARITY_NONE:
1524    case USERIAL_FEAT_PARITY_EVEN:
1525    case USERIAL_FEAT_PARITY_ODD:
1526
1527    case USERIAL_FEAT_DATABITS_5:
1528    case USERIAL_FEAT_DATABITS_6:
1529    case USERIAL_FEAT_DATABITS_7:
1530    case USERIAL_FEAT_DATABITS_8:
1531
1532    case USERIAL_FEAT_FC_HW:
1533    case USERIAL_FEAT_BUF_BYTE:
1534
1535    case USERIAL_FEAT_OP_FLUSH_RX:
1536    case USERIAL_FEAT_OP_FLUSH_TX:
1537      return true;
1538    default:
1539      return false;
1540  }
1541
1542  return false;
1543}
1544
1545/*****************************************************************************
1546**
1547** Function         UPIO_Set
1548**
1549** Description
1550**      This function sets one or more GPIO devices to the given state.
1551**      Multiple GPIOs of the same type can be masked together to set more
1552**      than one GPIO. This function can only be used on types UPIO_LED and
1553**      UPIO_GENERAL.
1554**
1555** Input Parameters:
1556**      type    The type of device.
1557**      pio     Indicates the particular GPIOs.
1558**      state   The desired state.
1559**
1560** Output Parameter:
1561**      None.
1562**
1563** Returns:
1564**      None.
1565**
1566*****************************************************************************/
1567void UPIO_Set(tUPIO_TYPE type, tUPIO pio, tUPIO_STATE new_state) {
1568  int ret;
1569  if (type == UPIO_GENERAL) {
1570    if (pio == NFC_HAL_LP_NFC_WAKE_GPIO) {
1571      if (new_state == UPIO_ON || new_state == UPIO_OFF) {
1572        if (linux_cb.sock_power_control > 0) {
1573          ALOGD("%s: ioctl, state=%d", __func__, new_state);
1574          ret = ioctl(linux_cb.sock_power_control, BCMNFC_WAKE_CTL, new_state);
1575          if (isWake(new_state) && nfc_wake_delay > 0 &&
1576              new_state != current_nfc_wake_state) {
1577            ALOGD("%s: ioctl, old state=%d, insert delay for %d ms", __func__,
1578                  current_nfc_wake_state, nfc_wake_delay);
1579            setWriteDelay(nfc_wake_delay);
1580          }
1581          current_nfc_wake_state = new_state;
1582        }
1583      }
1584    }
1585  }
1586}
1587
1588/*****************************************************************************
1589**
1590** Function         setReadPacketSize
1591**
1592** Description
1593**      This function sets the packetSize to the driver.
1594**      this enables faster read operation of NCI/HCI responses
1595**
1596** Input Parameters:
1597**      len     number of bytes to read per operation.
1598**
1599** Output Parameter:
1600**      None.
1601**
1602** Returns:
1603**      None.
1604**
1605*****************************************************************************/
1606void setReadPacketSize(int len) {
1607  int ret;
1608  ALOGD("%s: ioctl, len=%d", __func__, len);
1609  ret = ioctl(linux_cb.sock, BCMNFC_READ_FULL_PACKET, len);
1610}
1611
1612bool USERIAL_IsClosed() { return (linux_cb.sock == -1) ? true : false; }
1613
1614void USERIAL_PowerupDevice(tUSERIAL_PORT port) {
1615  int ret = -1;
1616  unsigned long num = 0;
1617  unsigned int resetSuccess = 0;
1618  unsigned int numTries = 0;
1619  unsigned char spi_negotiation[64];
1620  int delay = gPowerOnDelay;
1621  ALOGD("%s: enter", __func__);
1622
1623  if (GetNumValue(NAME_READ_MULTI_PACKETS, &num, sizeof(num)))
1624    bcmi2cnfc_read_multi_packets = num;
1625
1626  if (bcmi2cnfc_read_multi_packets > 0)
1627    ioctl(linux_cb.sock, BCMNFC_READ_MULTI_PACKETS,
1628          bcmi2cnfc_read_multi_packets);
1629
1630  while (!resetSuccess && numTries < NUM_RESET_ATTEMPTS) {
1631    if (numTries++ > 0) {
1632      ALOGW("BCM2079x: retrying reset, attempt %d/%d", numTries,
1633            NUM_RESET_ATTEMPTS);
1634    }
1635    if (linux_cb.sock_power_control > 0) {
1636      current_nfc_wake_state = NFC_WAKE_ASSERTED_ON_POR;
1637      ioctl(linux_cb.sock_power_control, BCMNFC_WAKE_CTL,
1638            NFC_WAKE_ASSERTED_ON_POR);
1639      ioctl(linux_cb.sock_power_control, BCMNFC_POWER_CTL, 0);
1640      GKI_delay(10);
1641      ret = ioctl(linux_cb.sock_power_control, BCMNFC_POWER_CTL, 1);
1642    }
1643
1644    ret = GetStrValue(NAME_SPI_NEGOTIATION, (char*)spi_negotiation,
1645                      sizeof(spi_negotiation));
1646    if (ret > 0 && spi_negotiation[0] > 0 &&
1647        spi_negotiation[0] < sizeof(spi_negotiation) - 1) {
1648      int len = spi_negotiation[0];
1649      /* Wake control is not available: Start SPI negotiation*/
1650      USERIAL_Write(port, &spi_negotiation[1], len);
1651      USERIAL_Read(port, spi_nego_res, sizeof(spi_nego_res));
1652    }
1653
1654    if (GetNumValue(NAME_CLIENT_ADDRESS, &num, sizeof(num)))
1655      bcmi2cnfc_client_addr = num & 0xFF;
1656    if (bcmi2cnfc_client_addr != 0 && 0x07 < bcmi2cnfc_client_addr &&
1657        bcmi2cnfc_client_addr < 0x78) {
1658      /* Delay needed after turning on chip */
1659      GKI_delay(delay);
1660      ALOGD("Change client address to %x\n", bcmi2cnfc_client_addr);
1661      ret = change_client_addr(bcmi2cnfc_client_addr);
1662      if (!ret) {
1663        resetSuccess = 1;
1664        linux_cb.client_device_address = bcmi2cnfc_client_addr;
1665        /* Delay long enough for address change */
1666        /* MACO xxx this needs to be at least 200 ms for BCM2079x B3 */
1667        delay = 200;
1668      }
1669    } else {
1670      resetSuccess = 1;
1671    }
1672  }
1673
1674  if (!resetSuccess) {
1675    ALOGE("BCM2079x: failed to initialize NFC controller");
1676  }
1677
1678  GKI_delay(delay);
1679  ALOGD("%s: exit", __func__);
1680}
1681
1682#define DEFAULT_CLIENT_ADDRESS 0x77
1683#define ALIAS_CLIENT_ADDRESS 0x79
1684static int change_client_addr(int addr) {
1685  int ret;
1686  int i;
1687  char addr_data[] = {0xFA, 0xF2, 0x00, 0x00, 0x00,
1688                      0x38, 0x00, 0x00, 0x00, 0x2A};
1689  int size = sizeof(addr_data) - 1;
1690
1691  addr_data[5] = addr & 0xFF;
1692
1693  /* set the checksum */
1694  ret = 0;
1695  for (i = 1; i < size; ++i) ret += addr_data[i];
1696  addr_data[size] = (ret & 0xFF);
1697  ALOGD("change_client_addr() change addr from 0x%x to 0x%x\n",
1698        DEFAULT_CLIENT_ADDRESS, addr);
1699  /* ignore the return code from IOCTL */
1700  /* always revert back to the default client address */
1701  ioctl(linux_cb.sock, BCMNFC_SET_CLIENT_ADDR, DEFAULT_CLIENT_ADDRESS);
1702  /* Send address change command (skipping first byte) */
1703  ret = TEMP_FAILURE_RETRY(write(linux_cb.sock, &addr_data[1], size));
1704
1705  /* If it fails, it is likely a B3 we are talking to */
1706  if (ret != size) {
1707    ALOGD(
1708        "change_client_addr() change addr to 0x%x by setting BSP address to "
1709        "0x%x\n",
1710        addr, ALIAS_CLIENT_ADDRESS);
1711    /* legacy kernel */
1712    /* MACO xxx commented out code below only works with new kernel driver,
1713     * but Mako/Manta ship with old one */
1714    ret = ioctl(linux_cb.sock, BCMNFC_CHANGE_ADDR, addr);
1715    return ret;
1716    /*
1717    ret = ioctl(linux_cb.sock, BCMNFC_SET_CLIENT_ADDR, ALIAS_CLIENT_ADDRESS);
1718    size++;
1719    ret = write(linux_cb.sock, addr_data, size);
1720    */
1721  }
1722
1723  if (ret == size) {
1724    ALOGD("change_client_addr() set client address 0x%x to client driver\n",
1725          addr);
1726    ret = ioctl(linux_cb.sock, BCMNFC_SET_CLIENT_ADDR, addr);
1727  } else {
1728    ret = -EIO;
1729  }
1730  return ret;
1731}
1732