Add toolchain and mbtk source
Change-Id: Ie12546301367ea59240bf23d5e184ad7e36e40b3
diff --git a/mbtk/mbtk_adbd/src/main.c b/mbtk/mbtk_adbd/src/main.c
new file mode 100755
index 0000000..996839a
--- /dev/null
+++ b/mbtk/mbtk_adbd/src/main.c
@@ -0,0 +1,495 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <cutils/properties.h>
+#include <time.h>
+#include <sys/time.h>
+#include <termios.h> //UART
+
+#include "mbtk_log.h"
+#include "mbtk_adb_info.h"
+#include "mbtk_file.h"
+#include "mbtk_utils.h"
+
+// 同步收发数据
+#define MBTK_ADB_MSG_SYNC 1
+#define ADB_BUFF_SIZE 2048
+
+#define DATABITS CS8
+#define STOPBITS 0
+#define PARITYON 0
+#define PARITY 0
+
+static uint8 adb_buff[ADB_BUFF_SIZE];
+static int adb_buff_size = 0;
+static uint8 *adb_buff_ptr = NULL;
+static int file_fd = -1;
+static int adb_fd = -1;
+static char shell_cmd[ADB_BUFF_SIZE];
+
+static int adb_port_open(const char *dev, unsigned int baud)
+{
+#if 0
+ //unsigned int baud = B921600;
+ //unsigned int baud = B3000000;
+ struct termios options;
+#if MBTK_ADB_MSG_SYNC
+ int fd = open(dev, O_RDWR | O_NOCTTY, 0644);
+#else
+ int fd = open(dev, O_RDWR | O_NOCTTY | O_NONBLOCK, 0644);
+#endif
+ if (fd < 0)
+ {
+ LOGE("Can't open device = (%s)", dev);
+ return -1;
+ }
+
+ tcgetattr(fd, &options);
+ cfmakeraw(&options);
+ cfsetospeed(&options, baud);
+ if (tcsetattr(fd, TCSAFLUSH, &options) != 0)
+ {
+ LOGE("setting fd tc");
+ close(fd);
+ return -1;
+ }
+
+ tcflush(fd, TCIFLUSH);
+ return fd;
+#else
+
+ int fd = open(dev, O_RDWR);
+ /* set newtio */
+ struct termios newtio;
+ memset(&newtio, 0, sizeof(newtio));
+ (void)fcntl(fd, F_SETFL, 0);
+#if 1 //UART2_AT
+ /* no flow control for uart by default */
+ newtio.c_cflag = baud | DATABITS | STOPBITS | PARITYON | PARITY | CLOCAL | CREAD;
+#else
+ newtio.c_cflag = baud | CRTSCTS | DATABITS | STOPBITS | PARITYON | PARITY | CLOCAL | CREAD;
+#endif
+ newtio.c_iflag = IGNPAR;
+ //newtio.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
+ newtio.c_oflag = 0;
+ newtio.c_lflag = 0; /* disable ECHO, ICANON, etc... */
+
+ newtio.c_cc[VERASE] = 0x8; /* del */
+ newtio.c_cc[VEOF] = 4; /* Ctrl-d */
+ newtio.c_cc[VMIN] = 1; /* blocking read until 1 character arrives */
+ newtio.c_cc[VEOL] = 0xD; /* '\0' */
+
+ tcflush(fd, TCIFLUSH);
+ tcsetattr(fd, TCSANOW, &newtio);
+
+ return fd;
+#endif
+}
+
+static int adb_msg_send(int fd, int msg, const void *data, int data_len)
+{
+ uint8 buff[ADB_BUFF_SIZE] = {0};
+ uint8 *ptr = buff;
+
+ uint32_2_byte(MBTK_ADB_PACK_FLAG, ptr, true);
+ ptr += sizeof(uint32);
+
+ *ptr = (uint8)msg;
+ ptr++;
+
+ uint16_2_byte((uint16)data_len, ptr, false);
+ ptr += sizeof(uint16);
+
+ if(data && data_len > 0) {
+ memcpy(ptr, data, data_len);
+ ptr += data_len;
+ }
+ int result = file_write(fd, buff, ptr - buff);
+
+ LOGD("SEND : %d / %d", result, ptr - buff);
+ log_hex("SEND", buff, ptr - buff);
+ return result;
+}
+
+static void shell_cmd_cb_func(char *buf,int buf_size)
+{
+ LOGD("data_len : %d", buf_size);
+ if(buf == NULL || buf_size == 0) { // shell complete
+ if(adb_msg_send(adb_fd, MBTK_ADB_MSG_CMD_RSP_COMPLETE, NULL, 0) <= 0) {
+ LOGE("Send MBTK_ADB_MSG_CMD_RSP_COMPLETE fail.");
+ }
+
+ memset(shell_cmd, 0, ADB_BUFF_SIZE);
+ } else {
+ if(adb_msg_send(adb_fd, MBTK_ADB_MSG_CMD_RSP, buf, buf_size) <= 0) {
+ LOGE("Send MBTK_ADB_MSG_CMD_RSP fail.");
+ }
+
+ usleep(10);
+ }
+}
+
+static void* shell_or_at_func(void* argv)
+{
+ UNUSED(argv);
+
+ // Process in thread.
+ LOGD("CMD : %s", shell_cmd);
+ if(!strncasecmp(shell_cmd, "at ", 3)) { // AT command.
+ LOGE("Process AT:%s", shell_cmd + 3);
+
+ // "at ati"
+ if(!mbtk_cmd_line_ex(shell_cmd, shell_cmd_cb_func)) {
+ LOGE("Shell or AT command error.");
+ }
+ } else if(!strncasecmp(shell_cmd, "shell ", 6)) { // Shell command.
+ if(!strcmp(shell_cmd + 6, "cd") || !strncmp(shell_cmd + 6, "cd ", 3)) {
+ char *cmd = NULL;
+ if(!strncmp(shell_cmd + 6, "cd ", 3)) {
+ cmd = shell_cmd + 9;
+ } else {
+ cmd = "/";
+ }
+
+ if(chdir(cmd)) {
+ char buff[ADB_BUFF_SIZE] = {0};
+ sprintf(buff, "Can't cd to %s", cmd);
+ if(adb_msg_send(adb_fd, MBTK_ADB_MSG_CMD_RSP_COMPLETE, buff, strlen(buff)) <= 0) {
+ LOGE("Send MBTK_ADB_MSG_CMD_RSP_COMPLETE fail.");
+ }
+ } else {
+ if(adb_msg_send(adb_fd, MBTK_ADB_MSG_CMD_RSP_COMPLETE, NULL, 0) <= 0) {
+ LOGE("Send MBTK_ADB_MSG_CMD_RSP_COMPLETE fail.");
+ }
+ }
+ } else {
+ if(!mbtk_cmd_line_ex(shell_cmd + 6, shell_cmd_cb_func)) {
+ LOGE("Shell or AT command error.");
+ }
+ }
+ } else {
+ LOGE("Command error.");
+ if(adb_msg_send(adb_fd, MBTK_ADB_MSG_ERR_COMMAND, NULL, 0) <= 0) {
+ LOGE("Send MBTK_ADB_MSG_ERR_COMMAND fail.");
+ }
+ }
+
+ return NULL;
+}
+
+static mbtk_adb_msg_err_enum adb_pack_process(int fd, mbtk_adb_pack_t *pack)
+{
+ static int data_recv_len = 0;
+ static int data_recv_count_len = 0;
+// mbtk_adb_msg_err_enum err = MBTK_ADB_MSG_ERR_SUCCESS;
+ switch(pack->msg_id) {
+ case MBTK_ADB_MSG_CONN_START:
+ {
+ if(adb_msg_send(fd, MBTK_ADB_MSG_CONN_SUCCESS, NULL, 0) <= 0) {
+ return MBTK_ADB_MSG_ERR_IO;
+ }
+
+ LOGD("CONN_SUCCESS");
+
+ chdir("/");
+ break;
+ }
+ case MBTK_ADB_MSG_PUSH:
+ {
+ // data_len[4] path_len[2] path[path_len]
+ uint8 *ptr = pack->data;
+
+ data_recv_count_len = byte_2_uint32(ptr, false);
+ if(data_recv_count_len <= 0) {
+ LOGE("File size error:%d", data_recv_count_len);
+ return MBTK_ADB_MSG_ERR_FILE_SIZE;
+ }
+ ptr += sizeof(uint32);
+
+ char path[1024] = {0};
+ int path_len = byte_2_uint16(ptr, false);
+ if(path_len <= 0) {
+ LOGE("path length error:%d", path_len);
+ return MBTK_ADB_MSG_ERR_FILE_PATH;
+ }
+ ptr += sizeof(uint16);
+
+ memcpy(path, ptr, path_len);
+
+ file_fd = open(path, O_CREAT | O_WRONLY | O_TRUNC, 0777);
+ if(file_fd < 0) {
+ LOGE("Open file(%s) error:%d", path, errno);
+ return MBTK_ADB_MSG_ERR_FILE_PATH;
+ }
+
+ data_recv_len = 0;
+ if(adb_msg_send(fd, MBTK_ADB_MSG_PUSH_READY, NULL, 0) <= 0) {
+ return MBTK_ADB_MSG_ERR_IO;
+ }
+
+ LOGD("Start recv file data.");
+ break;
+ }
+ case MBTK_ADB_MSG_PUSH_COMPLETE:
+ {
+ close(file_fd);
+ file_fd = -1;
+
+ if(adb_msg_send(fd, MBTK_ADB_MSG_PUSH_SIZE, &data_recv_len, sizeof(uint32)) <= 0) {
+ return MBTK_ADB_MSG_ERR_IO;
+ }
+
+ LOGD("PUSH_COMPLETE : %d / %d", data_recv_len, data_recv_count_len);
+ break;
+ }
+ case MBTK_ADB_MSG_CMD_REQ:
+ {
+ // Shell command or AT command.
+ memset(shell_cmd, 0, ADB_BUFF_SIZE);
+ memcpy(shell_cmd, pack->data, pack->data_len);
+
+ pthread_t pid;
+ if (pthread_create(&pid, NULL, shell_or_at_func, NULL) != 0) {
+ LOGE("Create shell/at thread fail.");
+ return MBTK_ADB_MSG_ERR_COMMAND;
+ }
+ break;
+ }
+ case MBTK_ADB_MSG_CMD_KILL:
+ {
+ if(!strncasecmp(shell_cmd, "at ", 3)) { // AT command.
+ LOGE("Kill AT:%s", shell_cmd + 3);
+
+ } else if(!strncasecmp(shell_cmd, "shell ", 6)) { // Shell command.
+ LOGD("Kill cmd:%s", shell_cmd + 6);
+ char cmd[1024] = {0};
+ snprintf(cmd,1024,"kill `pidof %s | awk '{print $1}'`", shell_cmd + 6);
+ system(cmd);
+ } else {
+ LOGE("Kill Command/AT error.");
+ }
+ break;
+ }
+ case MBTK_ADB_MSG_CLOSE_START:
+ {
+ if(adb_msg_send(fd, MBTK_ADB_MSG_CLOSE_SUCCESS, NULL, 0) <= 0) {
+ return MBTK_ADB_MSG_ERR_IO;
+ }
+ break;
+ }
+ case MBTK_ADB_MSG_DATA:
+ {
+ if(file_fd < 0) {
+ LOGE("Data transfer not started.");
+ return MBTK_ADB_MSG_ERR_TRANS_NO_START;
+ }
+
+ if(pack->data_len > 0) {
+ int size = write(file_fd, pack->data, pack->data_len);
+ if(size == pack->data_len) {
+ data_recv_len += size;
+ } else {
+ LOGE("Write error:%d", errno);
+ return MBTK_ADB_MSG_ERR_IO;
+ }
+ }
+ break;
+ }
+ default:
+ {
+ LOGE("MSG id error:%d", pack->msg_id);
+ return MBTK_ADB_MSG_ERR_UNKNOWN_MSG;
+ }
+ }
+
+ return MBTK_ADB_MSG_ERR_SUCCESS;
+}
+
+/*
+* 1 2 data_len
+* F6 F7 F8 F9 [msg_id] [data_len] [data...]
+*/
+static mbtk_adb_msg_err_enum adb_read_a_pack(int fd, mbtk_adb_pack_t *pack)
+{
+ memset(pack, 0x0, sizeof(mbtk_adb_pack_t));
+ if(adb_buff_size < MBTK_ADB_PACK_HEAD_SIZE) {
+read_once:
+ // LOGD("Will read:adb_buff_size = %d", adb_buff_size);
+ if(adb_buff_size > 0) {
+ memmove(adb_buff, adb_buff_ptr, adb_buff_size);
+ adb_buff_ptr = adb_buff;
+ } else if(adb_buff_size == 0) {
+ adb_buff_ptr = adb_buff;
+ } else {
+ LOGE("Data error:%d", adb_buff_size);
+ goto error;
+ }
+ int size = read(fd, adb_buff_ptr + adb_buff_size, ADB_BUFF_SIZE - (adb_buff_ptr - adb_buff) - adb_buff_size);
+ if(size <= 0) {
+ LOGE("read() error:%d.", errno);
+ goto error;
+ }
+
+#if 0
+ log_hex("RECV", adb_buff_ptr + adb_buff_size, size);
+#endif
+ adb_buff_size += size;
+ }
+
+ if(adb_buff_size < MBTK_ADB_PACK_HEAD_SIZE) {
+ goto read_once;
+ }
+
+ if(MBTK_ADB_PACK_FLAG != byte_2_uint32(adb_buff_ptr, true))
+ {
+ LOGE("Packet FLAG error.");
+ goto error;
+ }
+
+ pack->msg_id = (mbtk_adb_msg_enum)*(adb_buff_ptr + sizeof(uint32));
+ pack->data_len = byte_2_uint16(adb_buff_ptr + sizeof(uint32) + sizeof(uint8), false);
+
+ if(pack->data_len > 0 && adb_buff_size < MBTK_ADB_PACK_HEAD_SIZE + pack->data_len) {
+ goto read_once;
+ }
+
+ if(pack->msg_id == MBTK_ADB_MSG_DATA)
+ LOGD("DATA : %d", pack->data_len);
+ else
+ log_hex("PACK", adb_buff_ptr, MBTK_ADB_PACK_HEAD_SIZE + pack->data_len);
+
+ // Jump 'flag'
+ adb_buff_ptr += MBTK_ADB_PACK_HEAD_SIZE;
+ adb_buff_size -= MBTK_ADB_PACK_HEAD_SIZE;
+
+ if(pack->data_len > 0) {
+ pack->data = adb_buff_ptr;
+
+ // Jump 'data'
+ adb_buff_ptr += pack->data_len;
+ adb_buff_size -= pack->data_len;
+ }
+
+ return MBTK_ADB_MSG_ERR_SUCCESS;
+error:
+ return MBTK_ADB_MSG_ERR_PACK;
+}
+
+
+int main(int argc, char *argv[])
+{
+ char port_config[32] = {0};
+ mbtk_log_init("radio", "MBTK_ADBD");
+ memset(port_config, 0, 32);
+ property_get("persist.mbtk.dev_ttyGS0", port_config, "at");
+ if(strcmp(port_config, "adb")) {
+ memset(port_config, 0, 32);
+ property_get("persist.mbtk.dev_ttymodem0", port_config, "at");
+ if(strcmp(port_config, "adb")) {
+ memset(port_config, 0, 32);
+ property_get("persist.mbtk.dev_ttyS1", port_config, "at");
+ if(strcmp(port_config, "adb")) {
+ LOGE("No config mbtk adb port.");
+ return 0;
+ } else {
+ memset(port_config, 0, 32);
+ strcpy(port_config, "/dev/ttyS1");
+ }
+ } else {
+ memset(port_config, 0, 32);
+ strcpy(port_config, "/dev/ttymodem0");
+ }
+ } else {
+ memset(port_config, 0, 32);
+ strcpy(port_config, "/dev/ttyGS0");
+ }
+
+ LOGD("Port : %s", port_config);
+
+ if(access(port_config, R_OK | W_OK)) {
+ LOGE("Dev %s error:%d", port_config, errno);
+ return 0;
+ }
+
+ if((adb_fd = adb_port_open(port_config, B921600)) < 0) {
+ LOGE("Open dev %s fail:%d", port_config, errno);
+ return 0;
+ }
+
+#if MBTK_ADB_MSG_SYNC
+
+ mbtk_adb_pack_t pack;
+ mbtk_adb_msg_err_enum err;
+ while(1) {
+ memset(adb_buff, 0x0, ADB_BUFF_SIZE);
+ memset(&pack, 0x0, sizeof(mbtk_adb_pack_t));
+ adb_buff_size = 0;
+ adb_buff_ptr = adb_buff;
+
+ LOGD("Start/Restart connectting.");
+ while(1) {
+ err = adb_read_a_pack(adb_fd, &pack);
+ if(MBTK_ADB_MSG_ERR_SUCCESS != err) {
+ adb_msg_send(adb_fd, err, NULL, 0);
+ break;
+ }
+
+ err = adb_pack_process(adb_fd, &pack);
+ if(MBTK_ADB_MSG_ERR_SUCCESS != err) {
+ adb_msg_send(adb_fd, err, NULL, 0);
+ break;
+ }
+ }
+ }
+#else
+ int select_timeout = 30; // 30s
+ do
+ {
+ struct timeval timeval;
+ fd_set fdr, fdw;
+ int ret = 0;
+
+ FD_ZERO(&fdw);
+ FD_ZERO(&fdr);
+ FD_SET(adb_fd, &fdr);
+
+ timeval.tv_sec = select_timeout;
+ timeval.tv_usec = 0;
+
+ ret = select(adb_fd + 1, &fdr, &fdw, 0, &timeval);
+ if (ret < 0)
+ {
+ if (errno == EINTR)
+ {
+ continue;
+ }
+ LOGE("select error, errno = %d (%s)", errno, strerror(errno));
+ break;
+ }
+ else if (ret == 0)
+ {
+ LOGE("select timeout");
+ continue;
+ }
+
+ // New AT command recv.
+ if (FD_ISSET(adb_fd, &fdr))
+ {
+
+ }
+ else
+ {
+ LOGW("Unknown select event.");
+ continue;
+ }
+ } while(1);
+#endif
+
+ LOGD("EXIT!");
+
+ return 0;
+}
+