--- /dev/null
+/*
+ * @copyright Copyright (c) 2017-2020 TOYOTA MOTOR CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "can_hal.h"
+#include "can_hal_core.h"
+#include "can_hal_internal.h"
+#include "can_hal_frameworkunifiedlog.h"
+#include "can_hal_stm.h"
+extern "C" {
+ #include "can_mng_api.h"
+}
+#include <native_service/ns_message_center_if.h>
+#include <native_service/frameworkunified_framework_if.h>
+#include <native_service/frameworkunified_multithreading.h>
+#include <stdio.h>
+#include <pthread.h>
+#include <string>
+
+static CanCtlApiObj g_driver_obj; // can driver handler
+
+typedef struct MessageWrapper {
+ HANDLE h_app;
+ void *message;
+} MessageWrapper;
+
+// define frame
+enum CANHAL_FRAME {
+ CANHAL_FRAME_SF = 0x00,
+ CANHAL_FRAME_FF,
+ CANHAL_FRAME_CF,
+ CANHAL_FRAME_NONE = 0xFF,
+};
+
+// Declaration of the local functions
+static EFrameworkunifiedStatus CanSendData(HANDLE h_app);
+static UINT8 PackageSendData(const CanMessage *send_msg,
+ UINT8 *send_cmd);
+static UINT8 PackageRecvData(const UINT8 *recv_data, CanMessage *message);
+static uint32_t GetCanId(const UINT8 *recv_data);
+
+#define CANHAL_VALID_NUM_INDEX 0x00
+#define CANHAL_CANID_HI_INDEX 0x00
+#define CANHAL_CANID_LO_INDEX 0x01
+#define CANHAL_DLC_INDEX 0x02
+#define CANHAL_DATA_START_INDEX 0x03
+
+#define CANHAL_RECV_DATA_LENGTH_INVALID 0xFF
+
+#define CANHAL_RECV_DATABLOCK_SIZE (0x0B)
+#define CANHAL_RECV_NTA_INDEX (0x03)
+
+// Register table for framework callback
+static const FrameworkunifiedProtocolCallbackHandler kCanHalPcbhs[] = {
+ { TX_INTERNAL, CanSendData },
+};
+
+void *CanHalPackMessage(HANDLE h_app, const void *msg, ssize_t msg_sz,
+ ssize_t *packed_sz) {
+ *packed_sz = msg_sz + sizeof(ssize_t) + sizeof(HANDLE);
+ void *p = malloc(*packed_sz);
+ if (p) {
+ char *_p = (char *)p;
+ // Set HANDLE to new buffer.
+ memcpy(_p, &h_app, sizeof(HANDLE));
+ // Set message size to new buffer
+ _p += sizeof(HANDLE);
+ *(ssize_t *)_p = msg_sz;
+ // Set message body to new buffer
+ _p += (sizeof(ssize_t));
+ memcpy(_p, msg, msg_sz);
+ }
+ return p;
+}
+
+void CanHalUnPackMessage(void *packed, HANDLE *h_app, void **msg,
+ ssize_t *msg_sz) {
+ char *_p = (char *)packed;
+ *h_app = *(HANDLE *)_p;
+ _p += sizeof(HANDLE);
+ *msg_sz = *((ssize_t *)_p);
+ _p += sizeof(ssize_t);
+ *msg = _p;
+}
+
+void CanHalDestroyPackedMessage(void *packed) {
+ free(packed);
+}
+
+// Start function of the receive thread
+void *CanRecvRun(void *arg) {
+ UINT8 data_start_index = 0;
+ UINT8 loop_num = 0;
+ UINT32 ret = 0;
+ CanCtlApiCmd recv_cmd;
+ memset(&recv_cmd, 0x00, sizeof(CanCtlApiCmd));
+ CanMessage recv_data_can;
+ memset(&recv_data_can, 0x00, sizeof(recv_data_can));
+ enum CanHalType *type = (enum CanHalType *)arg;
+
+ while (1) {
+ // call driver API to receive the can data
+ ret = CanCtlApiRcvCmd(&g_driver_obj, &recv_cmd);
+ if (CAN_CTL_RET_SUCCESS != ret) {
+ continue;
+ }
+
+ /**
+ * Receive data in the following structure:
+ * -----------------
+ * BYTE 01 | num of can data |
+ * -----------------
+ * BYTE 02 | CAN ID (Hi) |
+ * -----------------
+ * BYTE 03 | CAN ID (Lo) |
+ * -----------------
+ * BYTE 04 | DLC |
+ * -----------------
+ * BYTE 05 | DATA #1 |
+ * -----------------
+ * | ... |
+ * -----------------
+ * BYTE 12 | DATA #8 |
+ * -----------------
+ * BYTE 13 | CAN ID (Hi) |
+ * -----------------
+ * BYTE 14 | CAN ID (Lo) |
+ * -----------------
+ * BYTE 15 | DLC |
+ * -----------------
+ * BYTE 16 | DATA #1 |
+ * -----------------
+ * | ... |
+ * -----------------
+ * BYTE 23 | DATA #8 |
+ * -----------------
+ * | ... |
+ * -----------------
+ * BYTE 255 | |
+ * -----------------
+ *
+ * BYTE 0 for the invalid number of the can data
+ * CAN ID (Hi) and (Lo) combine for the CAN ID
+ * CAN ID (Hi) byte's low 7 bits is the high 7 bits of the CAN ID
+ * CAN ID (Lo) byte's high 4 bits is the low 4 bits of the CAN ID
+ * DLC for the length of the following data
+ * DATA #1 ~ #8 for the receive data, its actual length changes
+ * according to the previous DLC byte
+ */
+ UINT8 total_data_num = recv_cmd.data[CANHAL_VALID_NUM_INDEX];
+ data_start_index = 1;
+
+ for (loop_num = 0; loop_num < total_data_num; loop_num++) {
+ uint32_t can_id;
+ can_id = GetCanId(&(recv_cmd.data[data_start_index]));
+
+ // normal can
+ // Return value of the PackageRecvData is the total length
+ // of one can data package, so add to the data_start_index
+ // for the next can data package.
+ ret = PackageRecvData(&(recv_cmd.data[data_start_index]),
+ &recv_data_can);
+ if (CANHAL_RECV_DATA_LENGTH_INVALID == ret) {
+ continue;
+ }
+ data_start_index += ret;
+ CanHalReceiveNotify(*type, &(recv_data_can), sizeof(recv_data_can));
+ }
+
+ // reset buffer
+ memset(&recv_cmd, 0x00, sizeof(CanCtlApiCmd));
+ usleep(1000);
+ }
+
+ return NULL;
+}
+
+// get can id from recive buffer
+static uint32_t GetCanId(const UINT8 *recv_data) {
+ uint32_t can_id;
+ can_id = (recv_data[CANHAL_CANID_HI_INDEX] & 0x7F);
+ can_id <<= 4;
+ can_id |= ((recv_data[CANHAL_CANID_LO_INDEX] & 0xF0) >> 4);
+ return can_id;
+}
+
+static CANHAL_RET_API CanOpenCoreCAN(void) {
+ CanCtlRcvId recv_can_id;
+ memset(recv_can_id.id, 0xFF, sizeof(recv_can_id.id));
+ if (CAN_CTL_RET_SUCCESS != CanCtlApiOpen(&g_driver_obj))
+ return CANHAL_RET_ERR_ERR;
+
+ if (CAN_CTL_RET_SUCCESS != CanCtlApiSetRcvId(&g_driver_obj, &recv_can_id)) {
+ return CANHAL_RET_ERR_ERR;
+ }
+
+ return CANHAL_RET_NORMAL;
+}
+
+CANHAL_RET_API CanOpenCore(CanHalType type) {
+ CANHAL_RET_API ret = CANHAL_RET_ERR_ERR;
+ switch (type) {
+ case CAN_HAL_TYPE_CAN:
+ ret = CanOpenCoreCAN();
+ break;
+ default:
+ // Do nothing
+ break;
+ }
+ return ret;
+}
+
+// Initialize the sending thread
+EFrameworkunifiedStatus CanSendThreadStart(HANDLE h_app) {
+ EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK;
+ intptr_t ptr;
+ e_status = FrameworkunifiedAttachCallbacksToDispatcher(h_app,
+ FRAMEWORKUNIFIED_ANY_SOURCE,
+ kCanHalPcbhs,
+ _countof(kCanHalPcbhs));
+ if (e_status != eFrameworkunifiedStatusOK)
+ goto finish;
+
+ e_status = FrameworkunifiedGetMsgDataOfSize(h_app, &ptr, sizeof(ptr));
+ if (e_status != eFrameworkunifiedStatusOK)
+ goto finish;
+
+ *((HANDLE *)ptr) = FrameworkunifiedMcOpenSender(h_app, FrameworkunifiedGetAppName(h_app));
+ if (!(*(HANDLE *)ptr))
+ e_status = eFrameworkunifiedStatusFail;
+
+finish:
+ return e_status;
+}
+
+// Clean the sending thread
+EFrameworkunifiedStatus CanSendThreadStop(HANDLE h_app) {
+ EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK;
+ intptr_t ptr;
+ e_status = FrameworkunifiedGetMsgDataOfSize(h_app, &ptr, sizeof(ptr));
+ if (e_status != eFrameworkunifiedStatusOK)
+ goto finish;
+
+ FrameworkunifiedMcClose(*((HANDLE*)ptr));
+finish:
+ return e_status;
+}
+
+static CANHAL_RET_API CanCloseCoreCAN(void) {
+ CanCtlApiClose(&g_driver_obj);
+ return CANHAL_RET_NORMAL;
+}
+
+// Stop the can hal
+CANHAL_RET_API CanCloseCore(CanHalType type) {
+ CANHAL_RET_API ret = CANHAL_RET_NORMAL;
+ switch (type) {
+ case CAN_HAL_TYPE_CAN:
+ ret = CanCloseCoreCAN();
+ if (ret != CANHAL_RET_NORMAL)
+ goto finish;
+ break;
+ default:
+ goto finish;
+ break;
+ }
+finish:
+ return ret;
+}
+
+// Callback for the sending thread to send the can data
+static EFrameworkunifiedStatus CanSendData(HANDLE h_app) {
+ UINT8 ret = 0;
+ EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK;
+ HANDLE hb = NULL;
+ CanMessage mb;
+ ssize_t sz = 0;
+ void *send_msg = NULL;
+ HANDLE unpacked_h_app;
+ CanMessage *unpacked_msg;
+ ssize_t unpacked_sz;
+
+ send_msg = CanHalPackMessage(hb, (const void *)&mb, sizeof(mb), &sz);
+ if (!send_msg)
+ return eFrameworkunifiedStatusFail;
+
+ e_status = FrameworkunifiedGetMsgDataOfSize(h_app, send_msg, sz, eSMRRelease);
+ if (eFrameworkunifiedStatusOK != e_status) {
+ if (eFrameworkunifiedStatusInvldBufSize == e_status) {
+ FrameworkunifiedClearMsgData(h_app);
+ }
+ return eFrameworkunifiedStatusFail;
+ }
+
+ CanHalUnPackMessage(send_msg, &unpacked_h_app,
+ (void **)&unpacked_msg, &unpacked_sz);
+
+ CanCtlApiCmd send_can_data;
+ memset(&send_can_data, 0, sizeof(CanCtlApiCmd));
+ send_can_data.data[CANHAL_VALID_NUM_INDEX] = 1;
+ ret = PackageSendData(unpacked_msg, &(send_can_data.data[1]));
+ send_can_data.len = ret + 1;
+ CanSendResult send_result;
+ send_result.can_id = unpacked_msg->can_id;
+ send_result.rid = unpacked_msg->rid;
+
+ if (CAN_CTL_RET_SUCCESS == CanCtlApiSndCmd(&g_driver_obj, &send_can_data)) {
+ send_result.result = CAN_SEND_RESULT_SUCCESS;
+ } else {
+ send_result.result = CAN_SEND_RESULT_FAILURE;
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Send status is %d.", send_result.result);
+
+ if (CANHAL_RET_NORMAL != CanHalSendStatus(CAN_HAL_TYPE_CAN,
+ unpacked_h_app, &send_result, sizeof(send_result))) {
+ CanHalDestroyPackedMessage(send_msg);
+ return eFrameworkunifiedStatusFail;
+ }
+
+ CanHalDestroyPackedMessage(send_msg);
+ return eFrameworkunifiedStatusOK;
+}
+
+/**
+ * param [in] send_msg
+ * param [out] send_can_data
+ */
+static UINT8 PackageSendData(const CanMessage *send_msg,
+ UINT8 *send_can_data) {
+ // package according to the rule of the data structure,
+ // refer to the line 108 and 109
+ send_can_data[CANHAL_CANID_HI_INDEX] = (send_msg->can_id & 0x7F0) >> 4;
+ send_can_data[CANHAL_CANID_LO_INDEX] = (send_msg->can_id & 0x0F) << 4;
+ send_can_data[CANHAL_DLC_INDEX] = send_msg->dlc;
+ memcpy(&(send_can_data[CANHAL_DATA_START_INDEX]),
+ send_msg->data,
+ send_msg->dlc);
+ return (send_msg->dlc + CANHAL_DATA_START_INDEX);
+}
+
+/**
+ * param [in] recv_data
+ * param [out] message
+ */
+static UINT8 PackageRecvData(const UINT8 *recv_data, CanMessage *message) {
+ if (CAN_NORMAL_MESSAGE_LEN < recv_data[CANHAL_DLC_INDEX]) {
+ // receive data's length is invalid
+ return CANHAL_RECV_DATA_LENGTH_INVALID;
+ }
+ // package according to the rule of the data structure,
+ // refer to the line 108 and 109
+ message->can_id = recv_data[CANHAL_CANID_HI_INDEX] & 0x7F;
+ message->can_id <<= 4;
+ message->can_id |= (recv_data[CANHAL_CANID_LO_INDEX] & 0xF0) >> 4;
+ message->dlc = recv_data[CANHAL_DLC_INDEX];
+ memcpy(message->data, &(recv_data[CANHAL_DATA_START_INDEX]), CAN_NORMAL_MESSAGE_LEN);
+
+ return CANHAL_RECV_DATABLOCK_SIZE;
+}
+
Code Review / staging / basesystem.git / blobdiff