1 // SPDX-License-Identifier: GPL-2.0
2 #include <stdio.h>
3 #include <errno.h>
4 #include <unistd.h>
5 #include <stdlib.h>
6 #include <termios.h>
7 #include <time.h>
8 #include <sys/time.h>
9 #include <sys/types.h>
10 #include <sys/param.h>
11 #include <sys/ioctl.h>
12 #include <sys/socket.h>
13 #include <sys/uio.h>
14 #include <sys/stat.h>
15 #include <fcntl.h>
16 #include <signal.h>
17 #include <stdint.h>
18 #include <string.h>
19 #include <endian.h>
20 #include <byteswap.h>
21 #include <netinet/in.h>
22 #include <ctype.h>
23 #include <poll.h>
24 #include <sys/timerfd.h>
25 #include <sys/epoll.h>
26 #include "hciattach.h"
27 #include "hciattach_h4.h"
28
29 extern struct rtb_struct rtb_cfg;
30
start_xfer_wait(int fd,uint8_t * cmd,uint16_t len,uint32_t msec,int retry,uint8_t * resp,uint16_t * resp_len)31 static int start_xfer_wait(int fd, uint8_t *cmd, uint16_t len, uint32_t msec,
32 int retry, uint8_t *resp, uint16_t *resp_len)
33 {
34 uint8_t buf[64];
35 int result;
36 int state = 1;
37 int count = 0;
38 int params_len;
39 struct pollfd p[2];
40 uint16_t opcode;
41
42 if (fd == -1 || !cmd || len < 4) {
43 RS_ERR("%s: invalid parameter", __func__);
44 return -1;
45 }
46
47 opcode = ((uint16_t)cmd[2] << 8) + cmd[1];
48
49 start_xfer:
50 result = write(fd, cmd, len);
51 if (result != len) {
52 RS_ERR("%s: Write cmd %04x error, %s", __func__, opcode,
53 strerror(errno));
54 return -1;
55 }
56
57 start_recv:
58 memset(buf, 0, sizeof(buf));
59 memset(p, 0, sizeof(p));
60 state = 1;
61 count = 0;
62 p[0].fd = fd;
63 p[0].events = POLLERR | POLLHUP | POLLIN;
64 for (;;) {
65 p[0].revents = 0;
66 result = poll(p, 1, msec);
67 if (result < 0) {
68 RS_ERR("Poll call error, %s", strerror(errno));
69 result = -1;
70 break;
71 }
72
73 if (result == 0) {
74 RS_WARN("%s: Timeout", __func__);
75 if (retry <= 0) {
76 RS_ERR("%s: Transfer exhausted", __func__);
77 tcflush(fd, TCIOFLUSH);
78 exit(EXIT_FAILURE);
79 }
80 retry--;
81 goto start_xfer;
82 }
83
84 if (p[0].revents & (POLLERR | POLLHUP)) {
85 RS_ERR("POLLERR or POLLUP happens, %s",
86 strerror(errno));
87 result = -1;
88 break;
89 }
90
91 if (state == 1) {
92 result = read(p[0].fd, buf, 1);
93 if (result == -1 || result != 1) {
94 RS_ERR("%s: Read pkt type error, %s", __func__,
95 strerror(errno));
96 result = -1;
97 break;
98 }
99 if (result == 1 && buf[0] == 0x04) {
100 count = 1;
101 state = 2;
102 }
103 } else if (state == 2) {
104 result = read(p[0].fd, buf + count, 2);
105 if (result == -1 || result != 2) {
106 RS_ERR("%s: Read pkt header error, %s",
107 __func__, strerror(errno));
108 break;
109 }
110 count += result;
111 state = 3;
112 params_len = buf[2];
113 if (params_len + 3 > sizeof(buf)) {
114 result = -1;
115 RS_ERR("%s: hci event too long", __func__);
116 break;
117 }
118 } else if (state == 3) {
119 result = read(p[0].fd, buf + count, params_len);
120 if (result == -1) {
121 RS_ERR("%s: Read pkt payload error, %s",
122 __func__, strerror(errno));
123 break;
124 }
125 count += result;
126 params_len -= result;
127 if (!params_len)
128 break;
129 }
130 }
131
132 if (result >= 0) {
133 if (buf[1] == 0x0e) {
134 uint16_t tmp_opcode;
135
136 tmp_opcode = (uint16_t)buf[4] | buf[5] << 8;
137 if (tmp_opcode == opcode) {
138 RS_INFO("Cmd complete event for cmd %04x",
139 opcode);
140 /* Status is not zero indicating command not
141 * succeeded */
142 if (buf[6])
143 return -1;
144 if (!resp)
145 return 0;
146 if (*resp_len > count)
147 *resp_len = count;
148 memcpy(resp, buf, *resp_len);
149 return 0;
150 } else {
151 RS_WARN("Unexpected cmd complete event, %04x",
152 tmp_opcode);
153 return -1;
154 }
155 } else {
156 RS_INFO("%s: Unexpected hci event packet", __func__);
157 util_hexdump(buf, count);
158 /* Continue receiving */
159 }
160 goto start_recv;
161 }
162
163 return result;
164 }
165
h4_download_patch(int fd,int index,uint8_t * data,int len)166 int h4_download_patch(int fd, int index, uint8_t *data, int len)
167 {
168 uint8_t buf[257];
169 uint16_t total_len;
170 int result;
171 uint8_t resp[8];
172 uint16_t rlen = sizeof(resp);
173
174 RS_DBG("fd: %d, index: %d, len: %d", fd, index, len);
175
176 if (data)
177 memcpy(&buf[5], data, len);
178 buf[0] = 0x01;
179 buf[1] = 0x20;
180 buf[2] = 0xfc;
181 buf[3] = len + 1;
182 buf[4] = (uint8_t)index;
183 total_len = len + 5;
184
185 result = start_xfer_wait(fd, buf, total_len, 1000, 0, resp, &rlen);
186 if (result < 0) {
187 RS_ERR("Transfer patch failed, index %d", index);
188 return -1;
189 }
190
191 if (rlen != 8) {
192 RS_ERR("%s: Unexpected length %u", __func__, rlen);
193 return -1;
194 }
195
196 return resp[7];
197 }
198
h4_vendor_change_speed(int fd,uint32_t baudrate)199 int h4_vendor_change_speed(int fd, uint32_t baudrate)
200 {
201 int res;
202 uint8_t cmd[8] = { 0 };
203
204 cmd[0] = 1;
205 cmd[1] = 0x17;
206 cmd[2] = 0xfc;
207 cmd[3] = 4;
208
209 baudrate = cpu_to_le32(baudrate);
210 #ifdef BAUDRATE_4BYTES
211 memcpy((uint16_t *) & cmd[4], &baudrate, 4);
212 #else
213 memcpy((uint16_t *) & cmd[4], &baudrate, 2);
214 cmd[6] = 0;
215 cmd[7] = 0;
216 #endif
217
218 /* TODO: Wait for a while for device to up, just h4 need it */
219 sleep(1);
220
221 RS_DBG("baudrate in change speed command: 0x%02x 0x%02x 0x%02x 0x%02x",
222 cmd[4], cmd[5], cmd[6], cmd[7]);
223
224 res = start_xfer_wait(fd, cmd, 8, 1000, 0, NULL, 0);
225 if (res < 0)
226 RS_ERR("Change Controller baud failed");
227
228 return res;
229 }
230
h4_hci_reset(int fd)231 int h4_hci_reset(int fd)
232 {
233 int result;
234 uint8_t cmd[4] = { 0x01, 0x03, 0x0c, 0x00};
235
236 RS_INFO("%s: Issue hci reset cmd", __func__);
237
238 result = start_xfer_wait(fd, cmd, sizeof(cmd), 1000, 0, NULL, 0);
239 if (result < 0) {
240 RS_ERR("%s: Failed to send reset cmd", __func__);
241 return -1;
242 }
243
244 return 0;
245 }
246
h4_read_local_ver(int fd)247 int h4_read_local_ver(int fd)
248 {
249 uint8_t cmd[4] = { 0x01, 0x01, 0x10, 0x00 };
250 uint8_t resp[16];
251 uint16_t len = sizeof(resp);
252 int result;
253
254 result = start_xfer_wait(fd, cmd, sizeof(cmd), 1000, 0,
255 resp, &len);
256 if (result < 0) {
257 RS_ERR("HCI Read local version info error");
258 return -1;
259 }
260
261 if (len != 15) {
262 RS_ERR("%s: Unexpected length %u", __func__, len);
263 return -1;
264 }
265 rtb_cfg.hci_ver = resp[7];
266 rtb_cfg.hci_rev = (uint32_t)resp[9] << 8 | resp[8];
267 rtb_cfg.lmp_subver = (uint32_t)resp[14] << 8 | resp[13];
268 RS_INFO("hci ver %02x, hci_rev %04x, lmp_subver %04x",
269 rtb_cfg.hci_ver, rtb_cfg.hci_rev, rtb_cfg.lmp_subver);
270 return 0;
271 }
272
h4_vendor_read_rom_ver(int fd)273 int h4_vendor_read_rom_ver(int fd)
274 {
275 uint8_t cmd[4] = { 0x01, 0x6d, 0xfc, 0x00 };
276 uint8_t resp[16];
277 uint16_t len = sizeof(resp);
278 int result;
279
280 result = start_xfer_wait(fd, cmd, sizeof(cmd), 1000, 0,
281 resp, &len);
282 if (result < 0) {
283 RS_ERR("HCI Read local version info error");
284 return -1;
285 }
286
287 if (len != 8) {
288 RS_ERR("%s: Unexpected length %u", __func__, len);
289 return -1;
290 }
291 rtb_cfg.eversion = resp[7];
292 RS_INFO("eversion %02x", rtb_cfg.eversion);
293 return 0;
294 }
295
296