xref: /btstack/port/raspi/main.c (revision 2c4f9bbb6d93b3f1a90ed62ac67e4cd019f0736a)
1 /*
2  * Copyright (C) 2014 BlueKitchen GmbH
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the copyright holders nor the names of
14  *    contributors may be used to endorse or promote products derived
15  *    from this software without specific prior written permission.
16  * 4. Any redistribution, use, or modification is done solely for
17  *    personal benefit and not for any commercial purpose or for
18  *    monetary gain.
19  *
20  * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS
24  * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
26  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
27  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
30  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  * Please inquire about commercial licensing options at
34  * [email protected]
35  *
36  */
37 
38 #define __BTSTACK_FILE__ "main.c"
39 
40 // *****************************************************************************
41 //
42 //   Port for Rasperry Pi with built-in BCM chipset via H4 or H5
43 //
44 // *****************************************************************************
45 
46 #include <errno.h>
47 #include <fcntl.h>
48 #include <inttypes.h>
49 #include <signal.h>
50 #include <stdint.h>
51 #include <stdio.h>
52 #include <stdlib.h>
53 #include <string.h>
54 #include <sys/stat.h>
55 #include <termios.h>
56 #include <unistd.h>
57 
58 #include "btstack_config.h"
59 
60 #include "btstack_debug.h"
61 #include "btstack_event.h"
62 #include "ble/le_device_db_tlv.h"
63 #include "classic/btstack_link_key_db_tlv.h"
64 #include "btstack_memory.h"
65 #include "btstack_run_loop.h"
66 #include "btstack_run_loop_posix.h"
67 #include "bluetooth_company_id.h"
68 #include "hci.h"
69 #include "hci_dump.h"
70 #include "hci_dump_posix_fs.h"
71 #include "hci_transport.h"
72 #include "hci_transport_h4.h"
73 #include "hci_transport_h5.h"
74 #include "btstack_stdin.h"
75 #include "btstack_tlv_posix.h"
76 #include "btstack_uart.h"
77 #include "btstack_uart_block.h"
78 #include "btstack_uart_slip_wrapper.h"
79 
80 #include "btstack_chipset_bcm.h"
81 #include "btstack_chipset_bcm_download_firmware.h"
82 #include "btstack_control_raspi.h"
83 
84 
85 #include "raspi_get_model.h"
86 
87 int btstack_main(int argc, const char * argv[]);
88 
89 typedef enum  {
90     UART_INVALID,
91     UART_SOFTWARE_NO_FLOW,
92     UART_HARDWARE_NO_FLOW,
93     UART_HARDWARE_FLOW
94 } uart_type_t;
95 
96 // default config, updated depending on RasperryPi UART configuration
97 static hci_transport_config_uart_t transport_config = {
98     HCI_TRANSPORT_CONFIG_UART,
99     115200,
100     0,       // main baudrate
101     0,       // flow control
102     NULL,
103 };
104 
105 static btstack_uart_config_t uart_config;
106 
107 static int main_argc;
108 static const char ** main_argv;
109 
110 static btstack_packet_callback_registration_t hci_event_callback_registration;
111 
112 #define TLV_DB_PATH_PREFIX "/tmp/btstack_"
113 #define TLV_DB_PATH_POSTFIX ".tlv"
114 static char tlv_db_path[100];
115 static const btstack_tlv_t * tlv_impl;
116 static btstack_tlv_posix_t   tlv_context;
117 
118 
119 static int raspi_speed_to_baud(speed_t baud)
120 {
121     switch (baud) {
122         case B9600:
123             return 9600;
124         case B19200:
125             return 19200;
126         case B38400:
127             return 38400;
128         case B57600:
129             return 57600;
130         case B115200:
131             return 115200;
132         case B230400:
133             return 230400;
134         case B460800:
135             return 460800;
136         case B500000:
137             return 500000;
138         case B576000:
139             return 576000;
140         case B921600:
141             return 921600;
142         case B1000000:
143             return 1000000;
144         case B1152000:
145             return 1152000;
146         case B1500000:
147             return 1500000;
148         case B2000000:
149             return 2000000;
150         case B2500000:
151             return 2500000;
152         case B3000000:
153             return 3000000;
154         case B3500000:
155             return 3500000;
156         case B4000000:
157             return 4000000;
158         default:
159             return -1;
160     }
161 }
162 
163 static void raspi_get_terminal_params( hci_transport_config_uart_t *tc )
164 {
165     // open serial terminal and get parameters
166     int fd = open( tc->device_name, O_RDONLY );
167     if( fd < 0 )
168     {
169         perror( "can't open serial port" );
170         return;
171     }
172     struct termios tios;
173     tcgetattr( fd, &tios );
174     close( fd );
175 
176     speed_t ospeed = cfgetospeed( &tios );
177     int baud = raspi_speed_to_baud( ospeed );
178     printf( "current serial terminal parameter baudrate: %d, flow control: %s\n", baud, (tios.c_cflag&CRTSCTS)?"Hardware":"None" );
179 
180     // overwrites the initial baudrate only in case it was likely to be altered before
181     if( baud > 9600 )
182     {
183         tc->baudrate_init = baud;
184         tc->flowcontrol = (tios.c_cflag & CRTSCTS)?1:0;
185     }
186 }
187 
188 static void sigint_handler(int param){
189     UNUSED(param);
190 
191     printf("CTRL-C - SIGINT received, shutting down..\n");
192     log_info("sigint_handler: shutting down");
193 
194     // reset anyway
195     btstack_stdin_reset();
196 
197     // power down
198     hci_power_control(HCI_POWER_OFF);
199     hci_close();
200     log_info("Good bye, see you.\n");
201     exit(0);
202 }
203 
204 static int led_state = 0;
205 void hal_led_toggle(void){
206     led_state = 1 - led_state;
207     printf("LED State %u\n", led_state);
208 }
209 
210 static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
211     bd_addr_t addr;
212     if (packet_type != HCI_EVENT_PACKET) return;
213     switch (hci_event_packet_get_type(packet)){
214         case BTSTACK_EVENT_STATE:
215             if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) break;
216             gap_local_bd_addr(addr);
217             printf("BTstack up and running at %s\n",  bd_addr_to_str(addr));
218             // setup TLV
219             strcpy(tlv_db_path, TLV_DB_PATH_PREFIX);
220             strcat(tlv_db_path, bd_addr_to_str(addr));
221             strcat(tlv_db_path, TLV_DB_PATH_POSTFIX);
222             tlv_impl = btstack_tlv_posix_init_instance(&tlv_context, tlv_db_path);
223             btstack_tlv_set_instance(tlv_impl, &tlv_context);
224 #ifdef ENABLE_CLASSIC
225             hci_set_link_key_db(btstack_link_key_db_tlv_get_instance(tlv_impl, &tlv_context));
226 #endif
227 #ifdef ENABLE_BLE
228             le_device_db_tlv_configure(tlv_impl, &tlv_context);
229 #endif
230             break;
231         case HCI_EVENT_COMMAND_COMPLETE:
232             if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_read_local_name)){
233                 if (hci_event_command_complete_get_return_parameters(packet)[0]) break;
234                 // terminate, name 248 chars
235                 packet[6+248] = 0;
236                 printf("Local name: %s\n", &packet[6]);
237 
238                 btstack_chipset_bcm_set_device_name((const char *)&packet[6]);
239             }
240             break;
241         default:
242             break;
243     }
244 }
245 
246 // see https://github.com/RPi-Distro/pi-bluetooth/blob/master/usr/bin/btuart
247 static int raspi_get_bd_addr(bd_addr_t addr){
248 
249     FILE *fd = fopen( "/proc/device-tree/serial-number", "r" );
250     if( fd == NULL ){
251         fprintf(stderr, "can't read serial number, %s\n", strerror( errno ) );
252         return -1;
253     }
254     fscanf( fd, "%*08x" "%*02x" "%02" SCNx8 "%02" SCNx8 "%02" SCNx8, &addr[3], &addr[4], &addr[5] );
255     fclose( fd );
256 
257     addr[0] =  0xb8; addr[1]  = 0x27; addr[2] =  0xeb;
258     addr[3] ^= 0xaa; addr[4] ^= 0xaa; addr[5] ^= 0xaa;
259 
260     return 0;
261 }
262 
263 // see https://github.com/RPi-Distro/pi-bluetooth/blob/master/usr/bin/btuart
264 // on UART_INVALID errno is set
265 static uart_type_t raspi_get_bluetooth_uart_type(void){
266 
267     uint8_t deviceUart0[21] = { 0 };
268     FILE *fd = fopen( "/proc/device-tree/aliases/uart0", "r" );
269     if( fd == NULL ) return UART_INVALID;
270     fscanf( fd, "%20s", deviceUart0 );
271     fclose( fd );
272 
273     uint8_t deviceSerial1[21] = { 0 };
274     fd = fopen( "/proc/device-tree/aliases/serial1", "r" );
275     if( fd == NULL ) return UART_INVALID;
276     fscanf( fd, "%20s", deviceSerial1 );
277     fclose( fd );
278 
279     // test if uart0 is an alias for serial1
280     if( strncmp( (const char *) deviceUart0, (const char *) deviceSerial1, 21 ) == 0 ){
281         // HW uart
282         size_t count = 0;
283         uint8_t buf[16];
284         fd = fopen( "/proc/device-tree/soc/gpio@7e200000/uart0_pins/brcm,pins", "r" );
285         if( fd == NULL ) return UART_INVALID;
286         count = fread( buf, 1, 16, fd );
287         fclose( fd );
288 
289         // contains assigned pins
290         int pins = count / 4;
291         if( pins == 4 ){
292             return UART_HARDWARE_FLOW;
293         } else {
294             return UART_HARDWARE_NO_FLOW;
295         }
296     } else {
297         return UART_SOFTWARE_NO_FLOW;
298     }
299 }
300 
301 static void phase2(int status);
302 int main(int argc, const char * argv[]){
303 
304     /// GET STARTED with BTstack ///
305     btstack_memory_init();
306 
307     // log into file using HCI_DUMP_PACKETLOGGER format
308     const char * pklg_path = "/tmp/hci_dump.pklg";
309     hci_dump_posix_fs_open(pklg_path, HCI_DUMP_PACKETLOGGER);
310     const hci_dump_t * hci_dump_impl = hci_dump_posix_fs_get_instance();
311     hci_dump_init(hci_dump_impl);
312     printf("Packet Log: %s\n", pklg_path);
313 
314     // setup run loop
315     btstack_run_loop_init(btstack_run_loop_posix_get_instance());
316 
317     // pick serial port and configure uart block driver
318     transport_config.device_name = "/dev/serial1";
319 
320     // derive bd_addr from serial number
321     bd_addr_t addr = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
322     raspi_get_bd_addr(addr);
323 
324     // set UART config based on raspi Bluetooth UART type
325     int bt_reg_en_pin = -1;
326     bool power_cycle = true;
327     switch (raspi_get_bluetooth_uart_type()){
328         case UART_INVALID:
329             fprintf(stderr, "can't verify HW uart, %s\n", strerror( errno ) );
330             return -1;
331         case UART_SOFTWARE_NO_FLOW:
332             // ??
333             bt_reg_en_pin = 128;
334             transport_config.baudrate_main = 460800;
335             transport_config.flowcontrol   = 0;
336             break;
337         case UART_HARDWARE_NO_FLOW:
338             // Raspberry Pi 3 A
339             // Raspberry Pi 3 B
340             // power up with H5 and without power cycle untested/unsupported
341             bt_reg_en_pin = 128;
342             transport_config.baudrate_main = 921600;
343             transport_config.flowcontrol   = 0;
344             break;
345         case UART_HARDWARE_FLOW:
346             // Raspberry Pi Zero W gpio 45, 3 mbps does not work (investigation pending)
347             // Raspberry Pi 3A+ vgpio 129 but WLAN + BL
348             // Raspberry Pi 3B+ vgpio 129 but WLAN + BL
349             transport_config.flowcontrol = 1;
350             int model = raspi_get_model();
351             if (model == MODEL_ZERO_W){
352                 bt_reg_en_pin =  45;
353                 transport_config.baudrate_main =  921600;
354             } else {
355                 bt_reg_en_pin = 129;
356                 transport_config.baudrate_main = 3000000;
357             }
358 
359 #ifdef ENABLE_CONTROLLER_WARM_BOOT
360             power_cycle = false;
361 #else
362             // warn about power cycle on devices with shared reg_en pins
363             if (model == MODEL_3APLUS || model == MODEL_3BPLUS){
364                 printf("Wifi and Bluetooth share a single RESET line and BTstack needs to reset Bluetooth -> SSH over Wifi will fail\n");
365                 printf("Please add ENABLE_CONTROLLER_WARM_BOOT to btstack_config.h to enable startup without RESET\n");
366             }
367 #endif
368             break;
369     }
370     printf("%s, %u, BT_REG_EN at GPIO %u, %s\n", transport_config.flowcontrol ? "H4":"H5", transport_config.baudrate_main, bt_reg_en_pin, power_cycle ? "Reset Controller" : "Warm Boot");
371 
372     // get BCM chipset driver
373     const btstack_chipset_t * chipset = btstack_chipset_bcm_instance();
374     chipset->init(&transport_config);
375 
376     // set path to firmware files
377     btstack_chipset_bcm_set_hcd_folder_path("/lib/firmware/brcm");
378 
379     // setup UART driver
380     const btstack_uart_t * uart_driver = btstack_uart_posix_instance();
381 
382     // extract UART config from transport config
383     uart_config.baudrate    = transport_config.baudrate_init;
384     uart_config.flowcontrol = transport_config.flowcontrol;
385     uart_config.device_name = transport_config.device_name;
386     uart_driver->init(&uart_config);
387 
388     // HW with FlowControl -> we can use regular h4 mode
389     const hci_transport_t * transport;
390     if (transport_config.flowcontrol){
391         transport = hci_transport_h4_instance(uart_driver);
392     } else {
393         transport = hci_transport_h5_instance(uart_driver);
394     }
395 
396     // setup HCI (to be able to use bcm chipset driver)
397     hci_init(transport, (void*) &transport_config);
398     hci_set_bd_addr( addr );
399     hci_set_chipset(btstack_chipset_bcm_instance());
400 
401     // inform about BTstack state
402     hci_event_callback_registration.callback = &packet_handler;
403     hci_add_event_handler(&hci_event_callback_registration);
404 
405     // handle CTRL-c
406     signal(SIGINT, sigint_handler);
407 
408     main_argc = argc;
409     main_argv = argv;
410 
411     // power cycle Bluetooth controller on older models without flowcontrol
412     if (power_cycle){
413         btstack_control_raspi_set_bt_reg_en_pin(bt_reg_en_pin);
414         btstack_control_t *control = btstack_control_raspi_get_instance();
415         control->init(NULL);
416         control->off();
417         usleep( 100000 );
418         control->on();
419     }
420 
421     if (transport_config.flowcontrol){
422 
423         // re-use current terminal speed (if there was no power cycle)
424         if (!power_cycle){
425             raspi_get_terminal_params( &transport_config );
426         }
427 
428         // with flowcontrol, we use h4 and are done
429         btstack_main(main_argc, main_argv);
430 
431     } else {
432 
433         // assume BCM4343W used in Pi 3 A/B. Pi 3 A/B+ have a newer controller but support H4 with Flowcontrol
434         btstack_chipset_bcm_set_device_name("BCM43430A1");
435 
436         // phase #1 download firmware
437         printf("Phase 1: Download firmware\n");
438 
439         // phase #2 start main app
440         btstack_chipset_bcm_download_firmware(uart_driver, transport_config.baudrate_main, &phase2);
441     }
442 
443     // go
444     btstack_run_loop_execute();
445     return 0;
446 }
447 
448 static void phase2(int status){
449 
450     if (status){
451         printf("Download firmware failed\n");
452         return;
453     }
454 
455     printf("Phase 2: Main app\n");
456 
457     // setup app
458     btstack_main(main_argc, main_argv);
459 }
460 
461