1 /*
2 ******************************************************************************/
3 /* DriverLib Includes */
4 #include "driverlib.h"
5
6 /* Standard Includes */
7 #include <stdint.h>
8
9 #include <stdbool.h>
10 #include <string.h>
11 #include <stdio.h>
12
13 #include "btstack_config.h"
14
15 #include "bluetooth_company_id.h"
16 #include "btstack_chipset_cc256x.h"
17 #include "btstack_defines.h"
18 #include "btstack_event.h"
19 #include "btstack_debug.h"
20 #include "btstack_memory.h"
21 #include "btstack_tlv.h"
22 #include "btstack_run_loop.h"
23 #include "btstack_run_loop_embedded.h"
24 #include "hci_dump.h"
25 #include "hci_transport.h"
26 #include "hci_transport_h4.h"
27 #include "btstack_tlv_flash_bank.h"
28 #include "hal_flash_bank_msp432.h"
29 #include "classic/btstack_link_key_db_tlv.h"
30 #include "ble/le_device_db_tlv.h"
31
32 #ifdef ENABLE_SEGGER_RTT
33 #include "hci_dump_segger_rtt_stdout.h"
34 #else
35 #include "hci_dump_embedded_stdout.h"
36 #endif
37
38 static void delay_ms(uint32_t ms);
39
40 static hci_transport_config_uart_t config = {
41 HCI_TRANSPORT_CONFIG_UART,
42 115200,
43 3000000, // main baudrate
44 1, // flow control
45 NULL,
46 };
47
48 static hal_flash_bank_msp432_t hal_flash_bank_context;
49 static btstack_tlv_flash_bank_t btstack_tlv_flash_bank_context;
50
51 #ifndef ENABLE_SEGGER_RTT
52
53 /**
54 * Use USART_CONSOLE as a console.
55 * This is a syscall for newlib
56 * @param file
57 * @param ptr
58 * @param len
59 * @return
60 */
61 #include <stdio.h>
62 #include <unistd.h>
63 #include <errno.h>
64 int _write(int file, char *ptr, int len);
_write(int file,char * ptr,int len)65 int _write(int file, char *ptr, int len){
66 uint8_t cr = '\r';
67 int i;
68
69 if (file == STDOUT_FILENO || file == STDERR_FILENO) {
70 for (i = 0; i < len; i++) {
71 if (ptr[i] == '\n') {
72 HAL_UART_Transmit( &huart2, &cr, 1, HAL_MAX_DELAY );
73 }
74 HAL_UART_Transmit( &huart2, (uint8_t *) &ptr[i], 1, HAL_MAX_DELAY );
75 }
76 return i;
77 }
78 errno = EIO;
79 return -1;
80 }
81
82 #endif
83
_read(int file,char * ptr,int len)84 int _read(int file, char * ptr, int len){
85 UNUSED(file);
86 UNUSED(ptr);
87 UNUSED(len);
88 return -1;
89 }
90
91
_close(int file)92 int _close(int file){
93 UNUSED(file);
94 return -1;
95 }
96
_isatty(int file)97 int _isatty(int file){
98 UNUSED(file);
99 return -1;
100 }
101
_lseek(int file)102 int _lseek(int file){
103 UNUSED(file);
104 return -1;
105 }
106
_fstat(int file)107 int _fstat(int file){
108 UNUSED(file);
109 return -1;
110 }
111
112 // end of bss, start of heap
113 extern int _end;
_sbrk(int incr)114 void * _sbrk(int incr){
115 static unsigned char *heap = NULL;
116 unsigned char *prev_heap;
117
118 if (heap == NULL) {
119 heap = (unsigned char *)&_end;
120 }
121 prev_heap = heap;
122 heap += incr;
123 return prev_heap;
124 }
125
abort(void)126 void abort(void){
127 btstack_assert(false);
128 while (1);
129 }
130
131 #ifdef ENABLE_SEGGER_RTT
132
133 #include "SEGGER_RTT.h"
134
135 int SEGGER_RTT_vprintf(unsigned BufferIndex, const char * sFormat, va_list * pParamList);
136
137 // gcc/clang map printf to puts or putchar for printf("...\n"), or printf("%c", c) respectively
138
puts(const char * s)139 int puts(const char * s){
140 SEGGER_RTT_WriteString(0, s);
141 SEGGER_RTT_PutChar(0, '\n');
142 }
143
putchar(int c)144 int putchar(int c){
145 SEGGER_RTT_PutChar(0, c);
146 }
147
printf(const char * format,...)148 int printf(const char * format, ...){
149 va_list argptr;
150 va_start(argptr, format);
151 SEGGER_RTT_vprintf(0, format, &argptr);
152 va_end(argptr);
153 }
154
vprintf(const char * format,va_list argptr)155 int vprintf(const char * format, va_list argptr){
156 SEGGER_RTT_vprintf(0, format, &argptr);
157 }
158 #endif
159
160
161 // HAL CPU
162 #include "hal_cpu.h"
163
hal_cpu_disable_irqs(void)164 void hal_cpu_disable_irqs(void){
165 __disable_irq();
166 }
167
hal_cpu_enable_irqs(void)168 void hal_cpu_enable_irqs(void){
169 __enable_irq();
170 }
171
hal_cpu_enable_irqs_and_sleep(void)172 void hal_cpu_enable_irqs_and_sleep(void){
173 __enable_irq();
174 __asm__("wfe"); // go to sleep if event flag isn't set. if set, just clear it. IRQs set event flag
175 }
176
177 // HAL LED
178 #include "hal_led.h"
hal_led_toggle(void)179 void hal_led_toggle(void){
180 static bool on = false;
181 if (on){
182 on = false;
183 GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);
184 } else {
185 on = true;
186 GPIO_setOutputHighOnPin(GPIO_PORT_P1, GPIO_PIN0);
187 }
188 }
189
190 // HAL UART DMA
191 #include "hal_uart_dma.h"
192
193 // DMA Control Table
194 // 8 channels are implemented => 16 channel control data structures (a 16 bytes) are needed
195 // GCC
196 __attribute__ ((aligned (256)))
197 static DMA_ControlTable MSP_EXP432P401RLP_DMAControlTable[16];
198
199 // RX Ping Pong Buffer - similar to circular buffer on other MCUs
200 #define HAL_DMA_RX_BUFFER_SIZE 64
201 static uint8_t hal_dma_rx_ping_pong_buffer[2 * HAL_DMA_RX_BUFFER_SIZE];
202
203 // active buffer and position to read from
204 static uint8_t hal_dma_rx_active_buffer = 0;
205 static uint16_t hal_dma_rx_offset;
206
207 // rx state
208 static uint16_t bytes_to_read = 0;
209 static uint8_t * rx_buffer_ptr = 0;
210
211 // tx state
212 static uint16_t bytes_to_write = 0;
213 static uint8_t * tx_buffer_ptr = 0;
214
215 // handlers
216 static void (*rx_done_handler)(void);
217 static void (*tx_done_handler)(void);
218
219 // #define BLUETOOTH_DEBUG_PORT GPIO_PORT_P5
220 // #define BLUETOOTH_DEBUG_PIN GPIO_PIN0
221
222 #define BLUETOOTH_TX_PORT GPIO_PORT_P3
223 #define BLUETOOTH_TX_PIN GPIO_PIN2
224 #define BLUETOOTH_RX_PORT GPIO_PORT_P3
225 #define BLUETOOTH_RX_PIN GPIO_PIN3
226
227 #if 0
228 // BOOST-CC2564MODA (CC2564B BoosterPack)
229 #define BLUETOOTH_RTS_PORT GPIO_PORT_P6
230 #define BLUETOOTH_RTS_PIN GPIO_PIN6
231 #define BLUETOOTH_CTS_PORT GPIO_PORT_P5
232 #define BLUETOOTH_CTS_PIN GPIO_PIN6
233 #define BLUETOOTH_nSHUTDOWN_PORT GPIO_PORT_P2
234 #define BLUETOOTH_nSHUTDOWN_PIN GPIO_PIN5
235 #else
236 // EM Wireless BoosterPack with CC256x module
237 #define BLUETOOTH_RTS_PORT GPIO_PORT_P3
238 #define BLUETOOTH_RTS_PIN GPIO_PIN6
239 #define BLUETOOTH_CTS_PORT GPIO_PORT_P5
240 #define BLUETOOTH_CTS_PIN GPIO_PIN2
241 #define BLUETOOTH_nSHUTDOWN_PORT GPIO_PORT_P6
242 #define BLUETOOTH_nSHUTDOWN_PIN GPIO_PIN4
243 #endif
244
245 /* UART Configuration Parameter. These are the configuration parameters to
246 * make the eUSCI A UART module to operate with a 115200 baud rate. These
247 * values were calculated using the online calculator that TI provides
248 * at:
249 * http://software-dl.ti.com/msp430/msp430_public_sw/mcu/msp430/MSP430BaudRateConverter/index.html
250 */
251 static eUSCI_UART_ConfigV1 uartConfig =
252 {
253 EUSCI_A_UART_CLOCKSOURCE_SMCLK, // SMCLK Clock Source
254 0 , // BRDIV (template)
255 0, // UCxBRF (template)
256 0 , // UCxBRS (template)
257 EUSCI_A_UART_NO_PARITY, // No Parity
258 EUSCI_A_UART_LSB_FIRST, // MSB First
259 EUSCI_A_UART_ONE_STOP_BIT, // One stop bit
260 EUSCI_A_UART_MODE, // UART mode: normal
261 0, // Oversampling (template)
262 EUSCI_A_UART_8_BIT_LEN, // 8 bit
263 };
264
265 // table
266 static struct baudrate_config {
267 uint32_t baudrate;
268 uint8_t clock_prescalar;
269 uint8_t first_mod_reg;
270 uint8_t second_mod_reg;
271 uint8_t oversampling;
272 } baudrate_configs[] = {
273 // Config for 48 Mhz
274 { 57600, 52, 1, 37, 1},
275 { 115200, 26, 1, 111, 1},
276 { 230400, 13, 0, 37, 1},
277 { 460800, 6, 8, 32, 1},
278 { 921600, 3, 4, 2, 1},
279 { 1000000, 3, 0, 0, 1},
280 { 2000000, 1, 8, 0, 1},
281 { 3000000, 1, 0, 0, 1},
282 { 4000000, 12, 0, 0, 0},
283 };
284
285 #ifdef TEST_LOOPBACK
286 static uint8_t test_tx[16];
287 static uint8_t test_rx[16];
288 static uint8_t test_rx_flag;
test_tx_complete(void)289 static void test_tx_complete(void){
290 }
test_rx_complete(void)291 static void test_rx_complete(void){
292 test_rx_flag = 1;
293 }
294 #endif
295
296 // return true if ok
hal_uart_dma_config(uint32_t baud)297 static bool hal_uart_dma_config(uint32_t baud){
298 int index = -1;
299 int i;
300 for (i=0;i<sizeof(baudrate_configs)/sizeof(struct baudrate_config);i++){
301 if (baudrate_configs[i].baudrate == baud){
302 index = i;
303 break;
304 }
305 }
306 if (index < 0) return false;
307
308 uartConfig.clockPrescalar = baudrate_configs[index].clock_prescalar;
309 uartConfig.firstModReg = baudrate_configs[index].first_mod_reg;
310 uartConfig.secondModReg = baudrate_configs[index].second_mod_reg;
311 uartConfig.overSampling = baudrate_configs[index].oversampling ? EUSCI_A_UART_OVERSAMPLING_BAUDRATE_GENERATION : EUSCI_A_UART_LOW_FREQUENCY_BAUDRATE_GENERATION;
312 return true;
313 }
314
hal_dma_rx_start_transfer(uint8_t buffer)315 static void hal_dma_rx_start_transfer(uint8_t buffer){
316 uint32_t channel = DMA_CH5_EUSCIA2RX | (buffer == 0 ? UDMA_PRI_SELECT : UDMA_ALT_SELECT);
317 MAP_DMA_setChannelTransfer(channel, UDMA_MODE_PINGPONG, (void *) UART_getReceiveBufferAddressForDMA(EUSCI_A2_BASE),
318 (uint8_t *) &hal_dma_rx_ping_pong_buffer[buffer * HAL_DMA_RX_BUFFER_SIZE], HAL_DMA_RX_BUFFER_SIZE);
319 }
320
hal_dma_rx_bytes_avail(uint8_t buffer,uint16_t offset)321 static uint16_t hal_dma_rx_bytes_avail(uint8_t buffer, uint16_t offset){
322 uint32_t channel = DMA_CH5_EUSCIA2RX | (buffer == 0 ? UDMA_PRI_SELECT : UDMA_ALT_SELECT);
323 return HAL_DMA_RX_BUFFER_SIZE - MAP_DMA_getChannelSize(channel) - offset;
324 }
325
hal_uart_dma_update_rts(void)326 static void hal_uart_dma_update_rts(void){
327 // get active transfer
328 uint32_t attribute = MAP_DMA_getChannelAttribute(DMA_CH5_EUSCIA2RX & 0x0F);
329 uint8_t active_transfer_buffer = (attribute & UDMA_ATTR_ALTSELECT) ? 1 : 0;
330 if (hal_dma_rx_active_buffer == active_transfer_buffer){
331 GPIO_setOutputLowOnPin(BLUETOOTH_CTS_PORT, BLUETOOTH_CTS_PIN);
332 } else {
333 GPIO_setOutputHighOnPin(BLUETOOTH_CTS_PORT, BLUETOOTH_CTS_PIN);
334 }
335 }
336
337 // directly called from timer or similar interrupt. to call from non-isr context, interrupts must be disabled
hal_uart_dma_harvest(void)338 static void hal_uart_dma_harvest(void){
339 if (bytes_to_read == 0) {
340 return;
341 }
342
343 uint16_t bytes_avail = hal_dma_rx_bytes_avail(hal_dma_rx_active_buffer, hal_dma_rx_offset);
344 if (bytes_avail == 0) {
345 return;
346 }
347
348 // fetch bytes from current buffer
349 uint16_t bytes_to_copy = btstack_min(bytes_avail, bytes_to_read);
350 memcpy(rx_buffer_ptr, &hal_dma_rx_ping_pong_buffer[hal_dma_rx_active_buffer * HAL_DMA_RX_BUFFER_SIZE + hal_dma_rx_offset], bytes_to_copy);
351 rx_buffer_ptr += bytes_to_copy;
352 hal_dma_rx_offset += bytes_to_copy;
353 bytes_to_read -= bytes_to_copy;
354
355 // if current buffer fully processed, restart DMA transfer and switch to next buffer
356 if (hal_dma_rx_offset == HAL_DMA_RX_BUFFER_SIZE){
357 hal_dma_rx_offset = 0;
358 hal_dma_rx_start_transfer(hal_dma_rx_active_buffer);
359 hal_dma_rx_active_buffer = 1 - hal_dma_rx_active_buffer;
360 hal_uart_dma_update_rts();
361 }
362
363 if (bytes_to_read == 0){
364 (*rx_done_handler)();
365 }
366 }
367
DMA_INT1_IRQHandler(void)368 void DMA_INT1_IRQHandler(void){
369 MAP_DMA_clearInterruptFlag(DMA_CH4_EUSCIA2TX & 0x0F);
370 MAP_DMA_disableChannel(DMA_CH4_EUSCIA2TX & 0x0F);
371 (*tx_done_handler)();
372 }
373
DMA_INT2_IRQHandler(void)374 void DMA_INT2_IRQHandler(void){
375 MAP_DMA_clearInterruptFlag(DMA_CH5_EUSCIA2RX & 0x0F);
376 // update RTS
377 hal_uart_dma_update_rts();
378 // process data
379 #ifdef BLUETOOTH_DEBUG_PORT
380 MAP_GPIO_setOutputHighOnPin(BLUETOOTH_DEBUG_PIN, BLUETOOTH_DEBUG_PORT);
381 #endif
382 hal_uart_dma_harvest();
383 #ifdef BLUETOOTH_DEBUG_PORT
384 MAP_GPIO_setOutputLowOnPin(BLUETOOTH_DEBUG_PIN, BLUETOOTH_DEBUG_PORT);
385 #endif
386 }
387
388
hal_uart_dma_init(void)389 void hal_uart_dma_init(void){
390 // nShutdown
391 MAP_GPIO_setAsOutputPin(BLUETOOTH_nSHUTDOWN_PORT, BLUETOOTH_nSHUTDOWN_PIN);
392 // BT-CTS
393 MAP_GPIO_setAsOutputPin(BLUETOOTH_CTS_PORT, BLUETOOTH_CTS_PIN);
394 GPIO_setOutputHighOnPin(BLUETOOTH_CTS_PORT, BLUETOOTH_CTS_PIN);
395 // BT-RTS
396 MAP_GPIO_setAsInputPinWithPullDownResistor(BLUETOOTH_RTS_PORT, BLUETOOTH_RTS_PIN);
397 // UART pins
398 MAP_GPIO_setAsPeripheralModuleFunctionInputPin(BLUETOOTH_TX_PORT, BLUETOOTH_TX_PIN, GPIO_PRIMARY_MODULE_FUNCTION);
399 MAP_GPIO_setAsPeripheralModuleFunctionInputPin(BLUETOOTH_RX_PORT, BLUETOOTH_RX_PIN, GPIO_PRIMARY_MODULE_FUNCTION);
400
401 #ifdef BLUETOOTH_DEBUG_PORT
402 // debug pin
403 MAP_GPIO_setAsOutputPin(BLUETOOTH_DEBUG_PIN, BLUETOOTH_DEBUG_PORT);
404 MAP_GPIO_setOutputLowOnPin(BLUETOOTH_DEBUG_PIN, BLUETOOTH_DEBUG_PORT);
405 #endif
406
407 // UART
408
409 /* Configuring and enable UART Module */
410 hal_uart_dma_config(115200);
411 MAP_UART_initModule(EUSCI_A2_BASE, &uartConfig);
412 MAP_UART_enableModule(EUSCI_A2_BASE);
413
414 // DMA
415
416 /* Configuring DMA module */
417 MAP_DMA_enableModule();
418 MAP_DMA_setControlBase(MSP_EXP432P401RLP_DMAControlTable);
419
420 /* Assign DMA channel 4 to EUSCI_A2_TX, channel 5 to EUSCI_A2_RX */
421 MAP_DMA_assignChannel(DMA_CH4_EUSCIA2TX);
422 MAP_DMA_assignChannel(DMA_CH5_EUSCIA2RX);
423
424 /* Setup the RX and TX transfer characteristics */
425 MAP_DMA_setChannelControl(DMA_CH4_EUSCIA2TX | UDMA_PRI_SELECT, UDMA_SIZE_8 | UDMA_SRC_INC_8 | UDMA_DST_INC_NONE | UDMA_ARB_1);
426 MAP_DMA_setChannelControl(DMA_CH5_EUSCIA2RX | UDMA_PRI_SELECT, UDMA_SIZE_8 | UDMA_SRC_INC_NONE | UDMA_DST_INC_8 | UDMA_ARB_1);
427 MAP_DMA_setChannelControl(DMA_CH5_EUSCIA2RX | UDMA_ALT_SELECT, UDMA_SIZE_8 | UDMA_SRC_INC_NONE | UDMA_DST_INC_8 | UDMA_ARB_1);
428
429 /* Enable DMA interrupt for both channels */
430 MAP_DMA_assignInterrupt(INT_DMA_INT1, DMA_CH4_EUSCIA2TX & 0x0f);
431 MAP_DMA_assignInterrupt(INT_DMA_INT2, DMA_CH5_EUSCIA2RX & 0x0f);
432
433 /* Clear interrupt flags */
434 MAP_DMA_clearInterruptFlag(DMA_CH4_EUSCIA2TX & 0x0F);
435 MAP_DMA_clearInterruptFlag(DMA_CH5_EUSCIA2RX & 0x0F);
436
437 /* Enable Interrupts */
438 MAP_Interrupt_enableInterrupt(INT_DMA_INT1);
439 MAP_Interrupt_enableInterrupt(INT_DMA_INT2);
440 MAP_DMA_enableInterrupt(INT_DMA_INT1);
441 MAP_DMA_enableInterrupt(INT_DMA_INT2);
442
443 // power cycle
444 MAP_GPIO_setOutputLowOnPin(BLUETOOTH_nSHUTDOWN_PORT, BLUETOOTH_nSHUTDOWN_PIN);
445 delay_ms(10);
446 MAP_GPIO_setOutputHighOnPin(BLUETOOTH_nSHUTDOWN_PORT, BLUETOOTH_nSHUTDOWN_PIN);
447 delay_ms(200);
448
449 // setup ping pong rx
450 hal_dma_rx_start_transfer(0);
451 hal_dma_rx_start_transfer(1);
452
453 hal_dma_rx_active_buffer = 0;
454 hal_dma_rx_offset = 0;
455
456 MAP_DMA_enableChannel(DMA_CH5_EUSCIA2RX & 0x0F);
457
458 // ready
459 GPIO_setOutputLowOnPin(BLUETOOTH_CTS_PORT, BLUETOOTH_CTS_PIN);
460
461 #ifdef TEST_LOOPBACK
462 // test code
463 rx_done_handler = &test_rx_complete;
464 tx_done_handler = &test_tx_complete;
465 uint8_t value = 0;
466 uint8_t block_size = 6;
467 while(true){
468 // prepare data
469 uint8_t pos;
470 for (pos=0;pos<block_size;pos++){
471 test_tx[pos] = value++;
472 }
473 // trigger receive
474 hal_uart_dma_receive_block(test_rx, block_size);
475 // trigger send
476 printf_hexdump(test_tx, block_size);
477 hal_uart_dma_send_block(test_tx, block_size);
478 while (test_rx_flag == 0){
479 hal_cpu_disable_irqs();
480 hal_uart_dma_harvest();
481 hal_cpu_enable_irqs();
482 };
483 test_rx_flag = 0;
484 printf_hexdump(test_rx, block_size);
485 printf("\n");
486 if (memcmp(test_rx, test_tx, block_size) != 0) break;
487 }
488 while (1);
489 #endif
490 }
491
hal_uart_dma_set_baud(uint32_t baud)492 int hal_uart_dma_set_baud(uint32_t baud){
493 hal_uart_dma_config(baud);
494 MAP_UART_disableModule(EUSCI_A2_BASE);
495 /* BaudRate Control Register */
496 uint32_t moduleInstance = EUSCI_A2_BASE;
497 const eUSCI_UART_ConfigV1 *config = &uartConfig;
498 EUSCI_A_CMSIS(moduleInstance)->BRW = config->clockPrescalar;
499 EUSCI_A_CMSIS(moduleInstance)->MCTLW = ((config->secondModReg << 8) + (config->firstModReg << 4) + config->overSampling);
500 MAP_UART_enableModule(EUSCI_A2_BASE);
501 return 0;
502 }
503
hal_uart_dma_set_sleep(uint8_t sleep)504 void hal_uart_dma_set_sleep(uint8_t sleep){
505 UNUSED(sleep);
506 }
507
hal_uart_dma_set_csr_irq_handler(void (* the_irq_handler)(void))508 void hal_uart_dma_set_csr_irq_handler( void (*the_irq_handler)(void)){
509 UNUSED(the_irq_handler);
510 }
511
hal_uart_dma_set_block_received(void (* the_block_handler)(void))512 void hal_uart_dma_set_block_received( void (*the_block_handler)(void)){
513 rx_done_handler = the_block_handler;
514 }
515
hal_uart_dma_set_block_sent(void (* the_block_handler)(void))516 void hal_uart_dma_set_block_sent( void (*the_block_handler)(void)){
517 tx_done_handler = the_block_handler;
518 }
519
hal_uart_dma_send_block(const uint8_t * data,uint16_t len)520 void hal_uart_dma_send_block(const uint8_t * data, uint16_t len){
521 MAP_DMA_setChannelTransfer(DMA_CH4_EUSCIA2TX | UDMA_PRI_SELECT, UDMA_MODE_BASIC, (uint8_t *) data,
522 (void *) MAP_UART_getTransmitBufferAddressForDMA(EUSCI_A2_BASE),
523 len);
524 MAP_DMA_enableChannel(DMA_CH4_EUSCIA2TX & 0x0F);
525 }
526
527 // int used to indicate a request for more new data
hal_uart_dma_receive_block(uint8_t * buffer,uint16_t len)528 void hal_uart_dma_receive_block(uint8_t *buffer, uint16_t len){
529 rx_buffer_ptr = buffer;
530 bytes_to_read = len;
531 hal_cpu_disable_irqs();
532 hal_uart_dma_harvest();
533 hal_cpu_enable_irqs();
534 }
535
536 // HAL TIME MS Implementation
537 #include "hal_time_ms.h"
538 static volatile uint32_t systick;
539
SysTick_Handler(void)540 void SysTick_Handler(void){
541 systick++;
542 // process received data
543 #ifdef BLUETOOTH_DEBUG_PORT
544 MAP_GPIO_setOutputHighOnPin(BLUETOOTH_DEBUG_PIN, BLUETOOTH_DEBUG_PORT);
545 #endif
546 hal_uart_dma_harvest();
547 #ifdef BLUETOOTH_DEBUG_PORT
548 MAP_GPIO_setOutputLowOnPin(BLUETOOTH_DEBUG_PIN, BLUETOOTH_DEBUG_PORT);
549 #endif
550 }
551
552
init_systick(void)553 static void init_systick(void){
554 // Configuring SysTick to trigger every ms (48 Mhz / 48000 = 1 ms)
555 MAP_SysTick_enableModule();
556 MAP_SysTick_setPeriod(48000);
557 // MAP_Interrupt_enableSleepOnIsrExit();
558 MAP_SysTick_enableInterrupt();
559 }
560
delay_ms(uint32_t ms)561 static void delay_ms(uint32_t ms){
562 uint32_t delay_until = systick + ms;
563 // assumes mcu runs fast enough to check once every ms
564 while (systick != delay_until);
565 }
566
hal_time_ms(void)567 uint32_t hal_time_ms(void){
568 return systick;
569 }
570
571 // btstack assert
btstack_assert_failed(const char * file,uint16_t line_nr)572 void btstack_assert_failed(const char * file, uint16_t line_nr){
573 printf("ASSERT failed in %s, line %u\n", file, line_nr);
574 while (1);
575 }
576
577 // main.c
578 #include "SEGGER_RTT.h"
579
580 // HAL FLASH MSP432 Configuration - use two last 4kB sectors
581 #define HAL_FLASH_BANK_SIZE 4096
582 #define HAL_FLASH_BANK_0_SECTOR FLASH_SECTOR30
583 #define HAL_FLASH_BANK_1_SECTOR FLASH_SECTOR31
584 #define HAL_FLASH_BANK_0_ADDR 0x3E000
585 #define HAL_FLASH_BANK_1_ADDR 0x3F000
586
587 int btstack_main(const int argc, const char * argvp[]);
588
589 static btstack_packet_callback_registration_t hci_event_callback_registration;
590
packet_handler(uint8_t packet_type,uint16_t channel,uint8_t * packet,uint16_t size)591 static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
592 UNUSED(size);
593 UNUSED(channel);
594 bd_addr_t local_addr;
595 if (packet_type != HCI_EVENT_PACKET) return;
596 switch(hci_event_packet_get_type(packet)){
597 case BTSTACK_EVENT_STATE:
598 if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) return;
599 gap_local_bd_addr(local_addr);
600 printf("BTstack up and running on %s.\n", bd_addr_to_str(local_addr));
601 break;
602 case HCI_EVENT_COMMAND_COMPLETE:
603 if (hci_event_command_complete_get_command_opcode(packet) == HCI_OPCODE_HCI_READ_LOCAL_VERSION_INFORMATION){
604 uint16_t manufacturer = little_endian_read_16(packet, 10);
605 uint16_t lmp_subversion = little_endian_read_16(packet, 12);
606 // assert manufacturer is TI
607 if (manufacturer != BLUETOOTH_COMPANY_ID_TEXAS_INSTRUMENTS_INC){
608 printf("ERROR: Expected Bluetooth Chipset from TI but got manufacturer 0x%04x\n", manufacturer);
609 break;
610 }
611 // assert correct init script is used based on expected lmp_subversion
612 if (lmp_subversion != btstack_chipset_cc256x_lmp_subversion()){
613 printf("Error: LMP Subversion does not match initscript!\n");
614 printf("Your initscripts is for %s chipset\n", btstack_chipset_cc256x_lmp_subversion() < lmp_subversion ? "an older" : "a newer");
615 printf("Please update Makefile to include the appropriate bluetooth_init_cc256???.c file\n");
616 btstack_assert(false);
617 break;
618 }
619 }
620 break;
621 default:
622 break;
623 }
624 }
625
main(void)626 int main(void)
627 {
628 /* Halting the Watchdog */
629 MAP_WDT_A_holdTimer();
630
631 init_systick();
632
633 // init led
634 MAP_GPIO_setAsOutputPin(GPIO_PORT_P1, GPIO_PIN0);
635 hal_led_toggle();
636
637 // start with BTstack init - especially configure HCI Transport
638 btstack_memory_init();
639 btstack_run_loop_init(btstack_run_loop_embedded_get_instance());
640
641 // uncomment to enable packet logger
642 #ifdef ENABLE_SEGGER_RTT
643 // hci_dump_init(hci_dump_segger_rtt_stdout_get_instance());
644 #else
645 // hci_dump_init(hci_dump_embedded_stdout_get_instance());
646 #endif
647
648 // init HCI
649 hci_init(hci_transport_h4_instance(btstack_uart_block_embedded_instance()), (void*) &config);
650 hci_set_chipset(btstack_chipset_cc256x_instance());
651
652 // setup TLV Flash Sector implementation
653 const hal_flash_bank_t * hal_flash_bank_impl = hal_flash_bank_msp432_init_instance(
654 &hal_flash_bank_context,
655 HAL_FLASH_BANK_SIZE,
656 HAL_FLASH_BANK_0_SECTOR,
657 HAL_FLASH_BANK_1_SECTOR,
658 HAL_FLASH_BANK_0_ADDR,
659 HAL_FLASH_BANK_1_ADDR);
660
661 const btstack_tlv_t * btstack_tlv_impl = btstack_tlv_flash_bank_init_instance(
662 &btstack_tlv_flash_bank_context,
663 hal_flash_bank_impl,
664 &hal_flash_bank_context);
665
666 // setup global tlv
667 btstack_tlv_set_instance(btstack_tlv_impl, &btstack_tlv_flash_bank_context);
668
669 // setup Link Key DB using TLV
670 const btstack_link_key_db_t * btstack_link_key_db = btstack_link_key_db_tlv_get_instance(btstack_tlv_impl, &btstack_tlv_flash_bank_context);
671 hci_set_link_key_db(btstack_link_key_db);
672
673 // setup LE Device DB using TLV
674 le_device_db_tlv_configure(btstack_tlv_impl, &btstack_tlv_flash_bank_context);
675
676 // inform about BTstack state
677 hci_event_callback_registration.callback = &packet_handler;
678 hci_add_event_handler(&hci_event_callback_registration);
679
680 // hand over to btstack embedded code
681 btstack_main(0, NULL);
682
683 // go
684 btstack_run_loop_execute();
685 }
686
687
688