1 /******************************************************************************
2 * Copyright (c) 2022 Telink Semiconductor (Shanghai) Co., Ltd. ("TELINK")
3 * All rights reserved.
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 #include "emi.h"
19 #include "stimer.h"
20 /**********************************************************************************************************************
21 * local macro *
22 *********************************************************************************************************************/
23 #define EMI_STATE0 0x1234
24 #define EMI_STATE1 0x5678
25 #define EMI_TX_FIFO_ADDR 0x14081c
26 #define EMI_TX_PKT_PAYLOAD 37
27
28 /**********************************************************************************************************************
29 * global constants *
30 *********************************************************************************************************************/
31
32 static unsigned char emi_rx_packet[128] __attribute__((aligned(4)));
33 static unsigned char emi_ble_tx_packet[48] __attribute__((aligned(4))) = {3, 0, 0, 0, 0, 10};
34 static unsigned char emi_zigbee_tx_packet[48] __attribute__((aligned(4))) = {19, 0, 0, 0, 20, 0, 0};
35 static unsigned int s_emi_rx_cnt __attribute__((aligned(4))) = 0;
36 static unsigned int s_emi_rssibuf = 0;
37 static signed char s_emi_rssi = 0;
38 static unsigned int s_state0, s_state1;
39
40 /**********************************************************************************************************************
41 * function implementation *
42 *********************************************************************************************************************/
43
44 /**
45 * @brief This function serves to set singletone power
46 * @param[in] level - the power level.
47 * @return none
48 */
rf_set_power_level_index_singletone(rf_power_level_e level)49 void rf_set_power_level_index_singletone(rf_power_level_e level)
50 {
51 unsigned char value = 0;
52
53 if (level & BIT(7)) {
54 write_reg8(0x140e3c, (read_reg8(0x140e3c) & 0xbf) | ((0x01) << 6)); // VANT
55 } else {
56 write_reg8(0x140e3c, (read_reg8(0x140e3c) & 0xbf));
57 }
58 reg_rf_ll_ctrl0 = 0x55; // tx_en
59 delay_us(150);
60
61 value = (unsigned char)level & 0x3f;
62 write_reg8(0x140f78, read_reg8(0x140f78) | BIT(6)); // TX_PA_PWR_OW BIT6 set 1
63 write_reg8(0x140f7c, (read_reg8(0x140f7c) & 0x81) | (value << 1)); // TX_PA_PWR BIT1 t0 BIT6 set value
64 }
65
66 extern unsigned char g_single_tong_freqoffset;
67
68 /**
69 * @brief This function serves to set the TX singletone power and channel
70 * @param[in] power_level - the power level.
71 * @param[in] rf_chn - the channel.
72 * @return none
73 */
rf_emi_tx_single_tone(rf_power_level_e power_level,signed char rf_chn)74 void rf_emi_tx_single_tone(rf_power_level_e power_level, signed char rf_chn)
75 {
76 g_single_tong_freqoffset = 1;
77 rf_mode_init();
78 rf_set_zigbee_250K_mode();
79 rf_set_chn(rf_chn);
80 rf_set_power_level_index_singletone(power_level);
81 rf_set_txmode();
82 g_single_tong_freqoffset = 0;
83 }
84
85 /**
86 * @brief This function serves to stop emi/(close RF)
87 * @return none
88 */
rf_emi_stop(void)89 void rf_emi_stop(void)
90 {
91 write_reg8(0x140f78, 0);
92 write_reg8(0x140f7c, 0); // TX_PA_PWR
93 rf_set_power_level_index(0);
94 rf_set_tx_rx_off();
95 }
96
97 /**
98 * @brief This function serves to set the CD mode correlation register
99 * @return none
100 */
rf_emi_tx_continue_setup(void)101 void rf_emi_tx_continue_setup(void)
102 {
103 write_reg8(0x140800, 0x0a);
104 write_reg8(0x140808, 0x00); // access code
105
106 write_reg8(0x140801, 0x80); // kick tx controller to wait data
107 s_state0 = EMI_STATE0;
108 s_state1 = EMI_STATE1;
109 }
110
111 /**
112 * @brief This function serves to update the CD mode data
113 * @param[in] rf_mode - mode of RF.
114 * @param[in] power_level - power level of RF.
115 * @param[in] rf_chn - channel of RF.
116 * @param[in] pkt_type - The type of data sent.
117 * -#0:random
118 * -#1:0xf0
119 * -#2:0x55
120 * @return none
121 */
rf_emi_tx_continue_update_data(rf_mode_e rf_mode,rf_power_level_e power_level,signed char rf_chn,unsigned char pkt_type)122 void rf_emi_tx_continue_update_data(rf_mode_e rf_mode, rf_power_level_e power_level, signed char rf_chn,
123 unsigned char pkt_type)
124 {
125 rf_mode_init();
126 switch (rf_mode) {
127 case RF_MODE_BLE_1M_NO_PN:
128 rf_set_ble_1M_NO_PN_mode();
129 break;
130 case RF_MODE_BLE_2M:
131 rf_set_ble_2M_NO_PN_mode();
132 break;
133 case RF_MODE_LR_S2_500K:
134 rf_set_ble_500K_mode();
135 break;
136 case RF_MODE_LR_S8_125K:
137 rf_set_ble_125K_mode();
138 break;
139 case RF_MODE_ZIGBEE_250K:
140 rf_set_zigbee_250K_mode();
141 break;
142
143 default:
144 break;
145 }
146 rf_pn_disable();
147 rf_set_chn(rf_chn);
148 reg_rf_ll_ctrl0 = 0x45; // reset tx/rx state machine
149 rf_set_power_level_index_singletone(power_level);
150 rf_emi_tx_continue_setup();
151 write_reg8(0x140808, pkt_type); // 0:pbrs9 1:0xf0 2:0x55
152 }
153
154 /**
155 * @brief This function serves to generate random number.
156 * @param[in] state - the old random number.
157 * @return the new random number
158 */
emi_pn_gen(unsigned int state)159 unsigned int emi_pn_gen(unsigned int state)
160 {
161 unsigned int feed = 0;
162 feed = (state & 0x4000) >> 1;
163 state ^= feed;
164 state <<= 1;
165 state = (state & 0xfffe) + ((state & 0x8000) >> 15);
166 return state;
167 }
168
169 /**
170 * @brief This function serves to continue to run the CD mode
171 * @return none
172 */
rf_continue_mode_run(void)173 void rf_continue_mode_run(void)
174 {
175 if (read_reg8(0x140808) == 1) {
176 write_reg32(EMI_TX_FIFO_ADDR, 0x0f0f0f0f);
177 } else if (read_reg8(0x140808) == 2) {
178 write_reg32(EMI_TX_FIFO_ADDR, 0x55555555);
179 } else if (read_reg8(0x140808) == 3) {
180 write_reg32(EMI_TX_FIFO_ADDR, read_reg32(0x140809));
181 } else if (read_reg8(0x140808) == 4) {
182 write_reg32(EMI_TX_FIFO_ADDR, 0);
183 } else if (read_reg8(0x140808) == 5) {
184 write_reg32(EMI_TX_FIFO_ADDR, 0xffffffff);
185 } else {
186 write_reg32(EMI_TX_FIFO_ADDR, (s_state0 << 16) + s_state1);
187 s_state0 = emi_pn_gen(s_state0);
188 s_state1 = emi_pn_gen(s_state1);
189 }
190
191 while (read_reg8(EMI_TX_FIFO_ADDR) & 0x1) {
192 }
193 }
194
195 /**
196 * @brief This function serves to set rx mode and channel
197 * @param[in] mode - mode of RF.
198 * @param[in] rf_chn - the rx channel.
199 * @return none
200 */
rf_emi_rx_setup(rf_mode_e mode,signed char rf_chn)201 void rf_emi_rx_setup(rf_mode_e mode, signed char rf_chn)
202 {
203 rf_mode_init();
204 switch (mode) {
205 case RF_MODE_BLE_1M_NO_PN:
206 rf_set_ble_1M_NO_PN_mode();
207 break;
208 case RF_MODE_BLE_2M:
209 rf_set_ble_2M_NO_PN_mode();
210 break;
211 case RF_MODE_LR_S2_500K:
212 rf_set_ble_500K_mode();
213 break;
214 case RF_MODE_LR_S8_125K:
215 rf_set_ble_125K_mode();
216 break;
217 case RF_MODE_ZIGBEE_250K:
218 rf_set_zigbee_250K_mode();
219 break;
220
221 default:
222 break;
223 }
224 rf_set_rx_dma(emi_rx_packet, 3, 64);
225 rf_pn_disable();
226 rf_set_chn(rf_chn); // set freq
227 if (mode != RF_MODE_ZIGBEE_250K) {
228 rf_access_code_comm(EMI_ACCESS_CODE);
229 } // accesscode
230 rf_set_tx_rx_off();
231 rf_set_rxmode();
232 delay_us(150);
233 s_emi_rssi = 0;
234 s_emi_rssibuf = 0;
235 s_emi_rx_cnt = 0;
236 }
237
238 /**
239 * @brief This function serves to update the number of receiving packet and the RSSI
240 * @return none
241 */
rf_emi_rx_loop(void)242 void rf_emi_rx_loop(void)
243 {
244 if (rf_get_irq_status(FLD_RF_IRQ_RX)) { // rx irq
245 if ((read_reg8(0x140840) & 0xf0) == 0) { // crc err
246 s_emi_rssibuf += (read_reg8(0x140c5d));
247 if (s_emi_rx_cnt) {
248 if (s_emi_rssibuf != 0) {
249 s_emi_rssibuf >>= 1;
250 }
251 }
252 s_emi_rssi = s_emi_rssibuf - 110;
253 s_emi_rx_cnt++;
254 }
255 rf_clr_irq_status(FLD_RF_IRQ_RX); // clr rx irq
256 write_reg8(0x140a00, 0x80); // stop cmd
257 }
258 }
259
260 /**
261 * @brief This function serves to get the number of packets received
262 * @return the number of packets received
263 */
rf_emi_get_rxpkt_cnt(void)264 unsigned int rf_emi_get_rxpkt_cnt(void)
265 {
266 return s_emi_rx_cnt;
267 }
268
269 /**
270 * @brief This function serves to get the RSSI of packets received
271 * @return the RSSI of packets received
272 */
rf_emi_get_rssi_avg(void)273 char rf_emi_get_rssi_avg(void)
274 {
275 return s_emi_rssi;
276 }
277
278 /**
279 * @brief This function serves to generate random packets that need to be sent in burst mode
280 * @param[in] *p - the address of random packets.
281 * @param[in] n - the number of random packets.
282 * @return none
283 */
rf_phy_test_prbs9(unsigned char * p,int n)284 void rf_phy_test_prbs9(unsigned char *p, int n)
285 {
286 unsigned short x = 0x1ff;
287 int i = 0;
288 int j = 0;
289 for (i = 0; i < n; i++) {
290 unsigned char d = 0;
291 for (j = 0; j < 8; j++) {
292 if (x & 1) {
293 d |= BIT(j);
294 }
295 x = (x >> 1) | (((x << 4) ^ (x << 8)) & 0x100);
296 }
297 *p++ = d;
298 }
299 }
300
301 /**
302 * @brief This function serves to send packets in the burst mode
303 * @param[in] rf_mode - mode of RF.
304 * @param[in] pkt_type - The type of data sent.
305 * -#0:random
306 * -#1:0xf0
307 * -#2:0x55
308 * @return none
309 */
310
rf_emi_tx_burst_loop(rf_mode_e rf_mode,unsigned char pkt_type)311 void rf_emi_tx_burst_loop(rf_mode_e rf_mode, unsigned char pkt_type)
312 {
313 unsigned char rf_data_len = EMI_TX_PKT_PAYLOAD + 1;
314 unsigned int rf_tx_dma_len = rf_tx_packet_dma_len(rf_data_len);
315 write_reg8(0x140a00, 0x80); // stop SM
316 rf_set_txmode();
317 if ((rf_mode == RF_MODE_BLE_1M_NO_PN) || (rf_mode == RF_MODE_BLE_2M)) { // ble
318 rf_data_len = EMI_TX_PKT_PAYLOAD + 2;
319 rf_tx_dma_len = rf_tx_packet_dma_len(rf_data_len);
320 emi_ble_tx_packet[4] = 0;
321 emi_ble_tx_packet[5] = EMI_TX_PKT_PAYLOAD;
322 emi_ble_tx_packet[3] = (rf_tx_dma_len >> 24) & 0xff;
323 emi_ble_tx_packet[2] = (rf_tx_dma_len >> 16) & 0xff;
324 emi_ble_tx_packet[1] = (rf_tx_dma_len >> 8) & 0xff;
325 emi_ble_tx_packet[0] = rf_tx_dma_len & 0xff;
326 rf_start_stx((void *)emi_ble_tx_packet, read_reg32(0x140200) + 10);
327 while (!(rf_get_irq_status(FLD_RF_IRQ_TX))) {
328 }
329
330 rf_clr_irq_status(FLD_RF_IRQ_TX);
331
332 delay_ms(2);
333 if (pkt_type == 0) {
334 rf_phy_test_prbs9(&emi_ble_tx_packet[6], 37);
335 }
336 } else if (rf_mode == RF_MODE_LR_S8_125K) {
337 rf_data_len = EMI_TX_PKT_PAYLOAD + 2;
338 rf_tx_dma_len = rf_tx_packet_dma_len(rf_data_len);
339 emi_ble_tx_packet[4] = 0;
340 emi_ble_tx_packet[5] = EMI_TX_PKT_PAYLOAD;
341 emi_ble_tx_packet[3] = (rf_tx_dma_len >> 24) & 0xff;
342 emi_ble_tx_packet[2] = (rf_tx_dma_len >> 16) & 0xff;
343 emi_ble_tx_packet[1] = (rf_tx_dma_len >> 8) & 0xff;
344 emi_ble_tx_packet[0] = rf_tx_dma_len & 0xff;
345 rf_start_stx((void *)emi_ble_tx_packet, read_reg32(0x140200) + 10);
346 while (!(rf_get_irq_status(FLD_RF_IRQ_TX))) {
347 }
348
349 rf_clr_irq_status(FLD_RF_IRQ_TX);
350
351 delay_ms(2);
352 if (pkt_type == 0) {
353 rf_phy_test_prbs9(&emi_ble_tx_packet[6], 37);
354 }
355 } else if (rf_mode == RF_MODE_LR_S2_500K) {
356 rf_data_len = EMI_TX_PKT_PAYLOAD + 2;
357 rf_tx_dma_len = rf_tx_packet_dma_len(rf_data_len);
358 emi_ble_tx_packet[4] = 0;
359 emi_ble_tx_packet[5] = EMI_TX_PKT_PAYLOAD;
360 emi_ble_tx_packet[3] = (rf_tx_dma_len >> 24) & 0xff;
361 emi_ble_tx_packet[2] = (rf_tx_dma_len >> 16) & 0xff;
362 emi_ble_tx_packet[1] = (rf_tx_dma_len >> 8) & 0xff;
363 emi_ble_tx_packet[0] = rf_tx_dma_len & 0xff;
364 rf_start_stx((void *)emi_ble_tx_packet, read_reg32(0x140200) + 10);
365 while (!(rf_get_irq_status(FLD_RF_IRQ_TX))) {
366 }
367
368 rf_clr_irq_status(FLD_RF_IRQ_TX);
369
370 delay_ms(2);
371 if (pkt_type == 0) {
372 rf_phy_test_prbs9(&emi_ble_tx_packet[6], 37);
373 }
374 } else if (rf_mode == RF_MODE_ZIGBEE_250K) {
375 rf_data_len = EMI_TX_PKT_PAYLOAD + 1;
376 rf_tx_dma_len = rf_tx_packet_dma_len(rf_data_len);
377 emi_zigbee_tx_packet[4] = EMI_TX_PKT_PAYLOAD + 2;
378 emi_zigbee_tx_packet[3] = (rf_tx_dma_len >> 24) & 0xff;
379 emi_zigbee_tx_packet[2] = (rf_tx_dma_len >> 16) & 0xff;
380 emi_zigbee_tx_packet[1] = (rf_tx_dma_len >> 8) & 0xff;
381 emi_zigbee_tx_packet[0] = rf_tx_dma_len & 0xff;
382 rf_start_stx((void *)emi_zigbee_tx_packet, read_reg32(0x140200) + 10);
383 while (!(rf_get_irq_status(FLD_RF_IRQ_TX))) {
384 }
385
386 rf_clr_irq_status(FLD_RF_IRQ_TX);
387
388 delay_us(625 * 2);
389 if (pkt_type == 0) {
390 rf_phy_test_prbs9(&emi_zigbee_tx_packet[5], 37);
391 }
392 }
393 }
394
395 /**
396 * @brief This function serves to set the burst mode
397 * @param[in] rf_mode - mode of RF.
398 * @param[in] power_level - power level of RF.
399 * @param[in] rf_chn - channel of RF.
400 * @param[in] pkt_type - The type of data sent.
401 * -#0:random
402 * -#1:0xf0
403 * -#2:0x55
404 * @return none
405 */
rf_emi_tx_burst_setup(rf_mode_e rf_mode,rf_power_level_e power_level,signed char rf_chn,unsigned char pkt_type)406 void rf_emi_tx_burst_setup(rf_mode_e rf_mode, rf_power_level_e power_level, signed char rf_chn, unsigned char pkt_type)
407 {
408 unsigned char i = 0;
409 unsigned char tx_data = 0;
410 write_reg8(0x10083c, 0x10); // print buffer size set
411 rf_set_tx_dma(2, 128);
412 rf_set_chn(rf_chn);
413 rf_mode_init();
414 switch (rf_mode) {
415 case RF_MODE_BLE_1M_NO_PN:
416 rf_set_ble_1M_NO_PN_mode();
417 break;
418 case RF_MODE_BLE_2M:
419 rf_set_ble_2M_NO_PN_mode();
420 break;
421 case RF_MODE_LR_S2_500K:
422 rf_set_ble_500K_mode();
423 break;
424 case RF_MODE_LR_S8_125K:
425 rf_set_ble_125K_mode();
426 break;
427 case RF_MODE_ZIGBEE_250K:
428 rf_set_zigbee_250K_mode();
429 break;
430
431 default:
432 break;
433 }
434 if (rf_mode != RF_MODE_ZIGBEE_250K) {
435 rf_access_code_comm(EMI_ACCESS_CODE); // accesscode
436 }
437
438 rf_pn_disable();
439 rf_set_power_level(power_level);
440 if (pkt_type == 1) {
441 tx_data = 0x0f;
442 } else if (pkt_type == 2) {
443 tx_data = 0x55;
444 }
445
446 switch (rf_mode) {
447 case RF_MODE_LR_S2_500K:
448 case RF_MODE_LR_S8_125K:
449 case RF_MODE_BLE_1M_NO_PN:
450 case RF_MODE_BLE_2M:
451 emi_ble_tx_packet[4] = pkt_type; // type
452 for (i = 0; i < 37; i++) {
453 emi_ble_tx_packet[6 + i] = tx_data;
454 }
455 break;
456 case RF_MODE_ZIGBEE_250K:
457 emi_zigbee_tx_packet[5] = pkt_type; // type
458 for (i = 0; i < 37; i++) {
459 emi_zigbee_tx_packet[5 + i] = tx_data;
460 }
461 break;
462
463 default:
464 break;
465 }
466 }
467
468 /**
469 * @brief This function serves to reset baseband
470 * @return none
471 */
rf_emi_reset_baseband(void)472 void rf_emi_reset_baseband(void)
473 {
474 reg_rst3 &= (~FLD_RST3_ZB); // reset baseband
475 reg_rst3 |= (FLD_RST3_ZB); // clr baseband
476 }
477