1 /*
2 * Copyright (c) 2022 Talkweb Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <stdio.h>
17 #include <hdf_log.h>
18 #include <uart_if.h>
19 #include "cmsis_os2.h"
20 #include "i2c_if.h"
21 #include "los_compiler.h"
22 #include "los_task.h"
23 #include "ohos_run.h"
24 #include "samgr_lite.h"
25
26 #define HDF_I2C_READ 1
27 #define HDF_I2C_WRITE 0
28 #define RJGT102_ADDR 0x68
29
30 #define RJGT_CMD_REGISTER_ADDR 0xB0
31 #define RJGT_MEM_REGISTER_ADDR 0xC0
32 #define RJGT_OBJ_REGISTER_ADDR 0xB2
33 #define RJGT_UUID_MEM_ADDR 0x90
34 #define RJGT_STATUS_REGISTER_ADDR 0xB3
35
36 #define RJGT_CMD_WRITE_UUID 0xAA
37 #define RJGT_CMD_READ_MEM 0x0F
38
39 #define DELAY_TICKS 100
40 #define STACK_SIZE 4096
41 #define TASK_PRIO 2
42
43 static osThreadId_t g_i2cThreadId = NULL;
44 static DevHandle g_i2cHandle = NULL;
45
I2cWriteData(DevHandle handle,unsigned int devAddr,unsigned char * buffer,unsigned int length)46 static int I2cWriteData(DevHandle handle, unsigned int devAddr, unsigned char *buffer, unsigned int length)
47 {
48 struct I2cMsg msg = {0};
49
50 msg.addr = devAddr;
51 msg.buf = buffer;
52 msg.len = length;
53 msg.flags = HDF_I2C_WRITE;
54
55 if (I2cTransfer(handle, &msg, 1) != 1) {
56 HDF_LOGE("[%s]: I2cWriteData fail \r\n", __func__);
57 return HDF_FAILURE;
58 }
59 return HDF_SUCCESS;
60 }
61
I2cReadData(DevHandle handle,unsigned int devAddr,unsigned char * buffer,unsigned int length)62 static int I2cReadData(DevHandle handle, unsigned int devAddr, unsigned char *buffer, unsigned int length)
63 {
64 I2cWriteData(handle, devAddr, buffer, 1);
65
66 struct I2cMsg msg = {0};
67 msg.addr = devAddr;
68 msg.buf = buffer;
69 msg.len = length;
70 msg.flags = HDF_I2C_READ;
71
72 if (I2cTransfer(handle, &msg, 1) != 1) {
73 HDF_LOGE("[%s]: I2cWriteData fail \r\n", __func__);
74 return HDF_FAILURE;
75 }
76 return HDF_SUCCESS;
77 }
78
WriteRJGTCmdReg(unsigned char regVal)79 static void WriteRJGTCmdReg(unsigned char regVal)
80 {
81 unsigned char buffer[2] = {0};
82
83 buffer[0] = RJGT_CMD_REGISTER_ADDR;
84 buffer[1] = regVal;
85 I2cWriteData(g_i2cHandle, RJGT102_ADDR, buffer, sizeof(buffer));
86 }
87
WriteRJGTMemBuf(unsigned char * buf,unsigned int len)88 static void WriteRJGTMemBuf(unsigned char *buf, unsigned int len)
89 {
90 unsigned char buffer[len + 1];
91
92 buffer[0] = RJGT_MEM_REGISTER_ADDR;
93 memcpy(&buffer[1], buf, len);
94 I2cWriteData(g_i2cHandle, RJGT102_ADDR, buffer, sizeof(buffer));
95 }
96
ReadRJGTMemBuf(unsigned char * buf,unsigned int len)97 static void ReadRJGTMemBuf(unsigned char *buf, unsigned int len)
98 {
99 buf[0] = RJGT_MEM_REGISTER_ADDR;
100 I2cReadData(g_i2cHandle, RJGT102_ADDR, buf, len);
101 }
102
GetRJGTWriteStateReg(void)103 static unsigned char GetRJGTWriteStateReg(void)
104 {
105 unsigned char buffer[1] = {RJGT_STATUS_REGISTER_ADDR};
106
107 I2cReadData(g_i2cHandle, RJGT102_ADDR, buffer, sizeof(buffer));
108 return buffer[0];
109 }
110
WriteRJGTObjReg(unsigned char regVal)111 static void WriteRJGTObjReg(unsigned char regVal)
112 {
113 unsigned char buffer[2] = {0};
114
115 buffer[0] = RJGT_OBJ_REGISTER_ADDR;
116 buffer[1] = regVal;
117 I2cWriteData(g_i2cHandle, RJGT102_ADDR, buffer, sizeof(buffer));
118 }
119
Write8ByteUUID(unsigned char * buf,unsigned int len)120 static bool Write8ByteUUID(unsigned char *buf, unsigned int len)
121 {
122 WriteRJGTCmdReg(0x00);
123
124 WriteRJGTMemBuf(buf, len);
125
126 WriteRJGTCmdReg(RJGT_CMD_WRITE_UUID);
127 osDelay(DELAY_TICKS);
128
129 int ret = GetRJGTWriteStateReg();
130 if (ret != 0x01) {
131 HDF_LOGE("Write8ByteUUID fail[%02X]\r\n", ret);
132 return false;
133 }
134 return true;
135 }
136
Read8ByteUUID(unsigned char * buf,unsigned int len)137 static bool Read8ByteUUID(unsigned char *buf, unsigned int len)
138 {
139 WriteRJGTCmdReg(0x00);
140
141 WriteRJGTObjReg(RJGT_UUID_MEM_ADDR);
142
143 WriteRJGTCmdReg(RJGT_CMD_READ_MEM);
144 osDelay(DELAY_TICKS);
145
146 int ret = GetRJGTWriteStateReg();
147 if (ret != 0X01) {
148 HDF_LOGE("Read8ByteUUID fail[%02X]\r\n", ret);
149 return false;
150 }
151
152 ReadRJGTMemBuf(buf, len);
153 return true;
154 }
155
exitThread(void)156 static void exitThread(void)
157 {
158 if (g_i2cHandle != NULL) {
159 I2cClose(g_i2cHandle);
160 }
161
162 osThreadTerminate(g_i2cThreadId);
163 g_i2cThreadId = NULL;
164 }
165
HdfI2cTestEntry(void * arg)166 static void *HdfI2cTestEntry(void *arg)
167 {
168 (void *)arg;
169 unsigned char ret = 0;
170 unsigned char busId = 3;
171
172 g_i2cHandle = I2cOpen(busId);
173 if (g_i2cHandle == NULL) {
174 HDF_LOGE("%s: Open I2c:%u fail!\r\n", __func__, busId);
175 exitThread();
176 return;
177 }
178
179 osDelay(DELAY_TICKS);
180 unsigned char uuidBuf[8] = {0x11, 0x22, 0x33, 0x44, 0xaa, 0xbb, 0xcc, 0xdd};
181 if (Write8ByteUUID(uuidBuf, sizeof(uuidBuf)) != true) {
182 exitThread();
183 return;
184 }
185
186 osDelay(DELAY_TICKS);
187 memset_s(uuidBuf, sizeof(uuidBuf), 0, sizeof(uuidBuf));
188 if (Read8ByteUUID(uuidBuf, sizeof(uuidBuf)) != true) {
189 exitThread();
190 return;
191 }
192
193 while (1) {
194 osDelay(DELAY_TICKS);
195 }
196 }
197
StartHdfI2cTest(void)198 void StartHdfI2cTest(void)
199 {
200 UINT32 uwRet;
201 UINT32 taskID;
202 TSK_INIT_PARAM_S stTask = {0};
203
204 stTask.pfnTaskEntry = (TSK_ENTRY_FUNC)HdfI2cTestEntry;
205 stTask.uwStackSize = STACK_SIZE;
206 stTask.pcName = "HdfI2cTestEntry";
207 stTask.usTaskPrio = TASK_PRIO;
208 uwRet = LOS_TaskCreate(&taskID, &stTask);
209 if (uwRet != LOS_OK) {
210 HDF_LOGE("Task1 create failed\n");
211 }
212 }
213
214 OHOS_APP_RUN(StartHdfI2cTest);
215