adapter_sd.go

//go:build softdevice

package bluetooth

import (
	"device/nrf"
	"errors"
	"runtime/interrupt"
	"runtime/volatile"
	"unsafe"
)

// #include "ble.h"
// #include "nrf_soc.h"
// #ifndef NRF51
//   #include "nrf_nvic.h"
// #endif
import "C"

var (
	ErrNotDefaultAdapter = errors.New("bluetooth: not the default adapter")
)

var (
	secModeOpen       C.ble_gap_conn_sec_mode_t // No security is needed (aka open link).
	defaultDeviceName = [6]byte{'T', 'i', 'n', 'y', 'G', 'o'}
)

// There can only be one connection at a time in the default configuration.
var currentConnection = volatileHandle{handle: volatile.Register16{C.BLE_CONN_HANDLE_INVALID}}

// Globally allocated buffer for incoming SoftDevice events.
var eventBuf struct {
	C.ble_evt_t
	buf [23]byte
}

func init() {
	secModeOpen.set_bitfield_sm(1)
	secModeOpen.set_bitfield_lv(1)
}

var _ BLEAdapter = (*Adapter)(nil)

// Adapter is a dummy adapter: it represents the connection to the (only)
// SoftDevice on the chip.
type Adapter struct {
	isDefault         bool
	scanning          bool
	charWriteHandlers []charWriteHandler

	connectHandler func(device Device, state ConnectionState)
}

// DefaultAdapter is the default adapter on the current system. On Nordic chips,
// it will return the SoftDevice interface.
//
// Make sure to call Enable() before using it to initialize the adapter.
var DefaultAdapter = &Adapter{isDefault: true,
	connectHandler: func(device Device, state ConnectionState) {
		return
	}}

var eventBufLen C.uint16_t

// flashOpResult is set from the SWI2 interrupt handler when an asynchronous
// sd_flash_write/sd_flash_page_erase command completes. It is a SoC event,
// which is a separate event queue from the BLE events handled by
// handleEvent, but delivered through the same interrupt (SD_EVT_IRQn is
// SWI2_IRQn). 0 means no result yet, 1 success, 2 error. Consumed by bond
// storage and FlashBlockDevice where available, under flashOpMu.
var flashOpResult volatile.Register8

// Static because taking the address of a local variable for a C call would
// heap-allocate, which is not allowed in interrupt context.
var socEvtID C.uint32_t

// Enable configures the BLE stack. It must be called before any
// Bluetooth-related calls (unless otherwise indicated).
func (a *Adapter) Enable() error {
	if !a.isDefault {
		return ErrNotDefaultAdapter
	}

	// Enable the IRQ that handles all events.
	intr := interrupt.New(nrf.IRQ_SWI2, func(interrupt.Interrupt) {
		for {
			eventBufLen = C.uint16_t(unsafe.Sizeof(eventBuf))
			errCode := C.sd_ble_evt_get((*C.uint8_t)(unsafe.Pointer(&eventBuf)), &eventBufLen)
			if errCode != 0 {
				// Possible error conditions:
				//  * NRF_ERROR_NOT_FOUND: no events left, break
				//  * NRF_ERROR_DATA_SIZE: retry with a bigger data buffer
				//    (currently not handled, TODO)
				//  * NRF_ERROR_INVALID_ADDR: pointer is not aligned, should
				//    not happen.
				// In all cases, it's best to simply stop now.
				break
			}
			handleEvent()
		}

		// Drain pending SoC events. Currently only flash operation
		// completion is of interest, but any pending event must still be
		// pulled out of the queue or the SoftDevice will stop delivering new
		// ones.
		for {
			errCode := C.sd_evt_get(&socEvtID)
			if errCode != 0 {
				break
			}
			switch socEvtID {
			case C.NRF_EVT_FLASH_OPERATION_SUCCESS:
				flashOpResult.Set(1)
			case C.NRF_EVT_FLASH_OPERATION_ERROR:
				flashOpResult.Set(2)
			}
		}
	})
	intr.Enable()
	intr.SetPriority(192)

	// Do more specific initialization of this SoftDevice (split out for nrf52*
	// and nrf51 chips because of the different API).
	err := a.enable()
	if err != nil {
		return err
	}

	errCode := C.sd_ble_gap_device_name_set(&secModeOpen, (*C.uint8_t)(unsafe.Pointer(&defaultDeviceName[0])), C.uint16_t(len(defaultDeviceName)))
	if errCode != 0 {
		return Error(errCode)
	}

	var gapConnParams C.ble_gap_conn_params_t
	gapConnParams.min_conn_interval = C.BLE_GAP_CP_MIN_CONN_INTVL_MIN
	gapConnParams.max_conn_interval = C.BLE_GAP_CP_MIN_CONN_INTVL_MAX
	gapConnParams.slave_latency = 0
	gapConnParams.conn_sup_timeout = C.BLE_GAP_CP_CONN_SUP_TIMEOUT_NONE

	errCode = C.sd_ble_gap_ppcp_set(&gapConnParams)
	return makeError(errCode)
}

// Reset is a no-op on SoftDevice. Provided for interface symmetry.
func (a *Adapter) Reset() error {
	return nil
}

// DisableInterrupts must be used instead of disabling interrupts directly, to
// play well with the SoftDevice. Restore interrupts to the previous state with
// RestoreInterrupts.
func DisableInterrupts() uintptr {
	var is_nested_critical_region C.uint8_t
	C.sd_nvic_critical_region_enter(&is_nested_critical_region)
	return uintptr(is_nested_critical_region)
}

// RestoreInterrupts restores interrupts to the state before calling
// DisableInterrupts. The mask parameter must be the value returned by
// DisableInterrupts.
func RestoreInterrupts(mask uintptr) {
	C.sd_nvic_critical_region_exit(C.uint8_t(mask))
}

// Wrapper for volatile.Register16 that uses C.uint16_t instead of uint16, for
// easier interoperability with C.
type volatileHandle struct {
	handle volatile.Register16
}

func (a *volatileHandle) Set(handle C.uint16_t) {
	a.handle.Set(uint16(handle))
}

func (a *volatileHandle) Get() C.uint16_t {
	return C.uint16_t(a.handle.Get())
}

// Convert a SoftDevice MAC address into a Go MAC address.
func makeAddress(mac [6]C.uint8_t) MAC {
	return MAC{
		uint8(mac[0]),
		uint8(mac[1]),
		uint8(mac[2]),
		uint8(mac[3]),
		uint8(mac[4]),
		uint8(mac[5]),
	}
}

// Convert a Go MAC address into a SoftDevice MAC Address.
func makeSDAddress(mac MAC) [6]C.uint8_t {
	return [6]C.uint8_t{
		C.uint8_t(mac[0]),
		C.uint8_t(mac[1]),
		C.uint8_t(mac[2]),
		C.uint8_t(mac[3]),
		C.uint8_t(mac[4]),
		C.uint8_t(mac[5]),
	}
}