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
51 extern uint8_t appl_trace_level;
52
53 /* Mapping of USERIAL_PORT_x to linux */
54 extern uint32_t ScrProtocolTraceFlag;
55 static tUPIO_STATE current_nfc_wake_state = UPIO_OFF;
56 int uart_port = 0;
57 int isLowSpeedTransport = 0;
58 int nfc_wake_delay = 0;
59 int nfc_write_delay = 0;
60 int gPowerOnDelay = 300;
61 static int gPrePowerOffDelay = 0; // default value
62 static int gPostPowerOffDelay = 0; // default value
63 static pthread_mutex_t close_thread_mutex = PTHREAD_MUTEX_INITIALIZER;
64
65 char userial_dev[BTE_APPL_MAX_USERIAL_DEV_NAME + 1];
66 char power_control_dev[BTE_APPL_MAX_USERIAL_DEV_NAME + 1];
67 tSNOOZE_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
78 uint8_t bcmi2cnfc_client_addr = 0;
79 uint8_t bcmi2cnfc_read_multi_packets = 0;
80
81 #define USERIAL_Debug_verbose \
82 ((ScrProtocolTraceFlag & 0x80000000) == 0x80000000)
83
84 #include <sys/socket.h>
85
86 static 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 };
98 static 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
106 static int gPowerOffMode = POM_NORMAL;
107
108 static 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
119 static 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
173 extern void dumpbin(const char* data, int size);
174 extern uint8_t* scru_dump_hex(uint8_t* p, char* p_title, uint32_t len,
175 uint32_t trace_layer, uint32_t trace_type);
176
177 static pthread_t worker_thread1 = 0;
178
179 typedef 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
194 static tLINUX_CB
195 linux_cb; /* case of multipel port support use array : [MAX_SERIAL_PORT] */
196
197 void userial_close_thread(uint32_t params);
198
199 static uint8_t device_name[BTE_APPL_MAX_USERIAL_DEV_NAME + 1];
200 static int bSerialPortDevice = false;
201 static int _timeout = POLL_TIMEOUT;
202 static bool is_close_thread_is_waiting = false;
203
204 static int change_client_addr(int addr);
205
206 int perf_log_every_count = 0;
207 typedef 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 *******************************************************************************/
perf_reset(tPERF_DATA * t)224 void 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 *******************************************************************************/
perf_log(tPERF_DATA * t)235 void 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 *******************************************************************************/
perf_update(tPERF_DATA * t,long lapse,long bytes)267 void 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
278 static tPERF_DATA perf_poll = {"USERIAL_Poll", 0, 0, 0, 0};
279 static tPERF_DATA perf_read = {"USERIAL_Read", 0, 0, 0, 9};
280 static tPERF_DATA perf_write = {"USERIAL_Write", 0, 0, 0, 3};
281 static tPERF_DATA perf_poll_2_poll = {"USERIAL_Poll_to_Poll", 0, 0, 0, 0};
282 static clock_t _poll_t0 = 0;
283
284 static 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 *******************************************************************************/
wake_state()312 static 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 *******************************************************************************/
sleep_state()327 static 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 *******************************************************************************/
isWake(int state)344 static 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 *******************************************************************************/
setWriteDelay(int delay)367 static 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 *******************************************************************************/
doWriteDelay()401 static 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
432 static int signal_fds[2];
create_signal_fds(struct pollfd * set)433 static 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 *******************************************************************************/
close_signal_fds()453 static 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 *******************************************************************************/
send_wakeup_signal()476 static 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 *******************************************************************************/
reset_signal()491 static 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 *******************************************************************************/
is_signaled(struct pollfd * set)507 static inline int is_signaled(struct pollfd* set) {
508 return ((set->revents & POLLIN) == POLLIN) ||
509 ((set->revents & POLLRDNORM) == POLLRDNORM);
510 }
511
512 /******************************************************************************/
513
514 typedef unsigned char uchar;
515
516 BUFFER_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 *******************************************************************************/
USERIAL_GetLineSpeed(uint8_t baud)529 extern 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 *******************************************************************************/
USERIAL_GetBaud(uint32_t line_speed)545 extern 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
USERIAL_Init(void * p_cfg)566 void 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 *******************************************************************************/
my_read(int fd,uchar * pbuf,int len)601 int 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
708 done:
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 }
716 extern bool gki_chk_buf_damage(void* p_buf);
717 static 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 *******************************************************************************/
userial_read_thread(uint32_t arg)730 uint32_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 *******************************************************************************/
userial_to_tcio_baud(uint8_t cfg_baud,uint32_t * baud)841 bool 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 *******************************************************************************/
userial_io_init_bt_wake(int fd,unsigned long * p_wake_state)890 void 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 *******************************************************************************/
USERIAL_Open(tUSERIAL_PORT port,tUSERIAL_OPEN_CFG * p_cfg,tUSERIAL_CBACK * p_cback)916 void 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
1084 done_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
1103 static NFC_HDR* pbuf_USERIAL_Read = NULL;
1104
USERIAL_Read(tUSERIAL_PORT port,uint8_t * p_data,uint16_t len)1105 uint16_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
USERIAL_ReadBuf(tUSERIAL_PORT port,NFC_HDR ** p_buf)1165 void 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
USERIAL_WriteBuf(tUSERIAL_PORT port,NFC_HDR * p_buf)1184 bool 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 *******************************************************************************/
USERIAL_Write(tUSERIAL_PORT port,uint8_t * p_data,uint16_t len)1198 uint16_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 *******************************************************************************/
userial_change_rate(uint8_t baud)1243 void 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 *******************************************************************************/
userial_close_port(void)1314 void 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
USERIAL_Ioctl(tUSERIAL_PORT port,tUSERIAL_OP op,tUSERIAL_IOCTL_DATA * p_data)1330 void 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 *******************************************************************************/
USERIAL_SetPowerOffDelays(int pre_poweroff_delay,int post_poweroff_delay)1371 void 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 *******************************************************************************/
USERIAL_Close(tUSERIAL_PORT port)1388 void 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 *******************************************************************************/
userial_close_thread(uint32_t params)1443 void 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
USERIAL_Feature(tUSERIAL_FEATURE feature)1506 bool 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 *****************************************************************************/
UPIO_Set(tUPIO_TYPE type,tUPIO pio,tUPIO_STATE new_state)1567 void 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 *****************************************************************************/
setReadPacketSize(int len)1606 void 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
USERIAL_IsClosed()1612 bool USERIAL_IsClosed() { return (linux_cb.sock == -1) ? true : false; }
1613
USERIAL_PowerupDevice(tUSERIAL_PORT port)1614 void 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
change_client_addr(int addr)1684 static 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