mirror of
https://github.com/switchbrew/libnx.git
synced 2025-06-21 04:22:50 +02:00
1506 lines
49 KiB
C
1506 lines
49 KiB
C
#define NX_SERVICE_ASSUME_NON_DOMAIN
|
|
#include <string.h>
|
|
#include <stdatomic.h>
|
|
#include "service_guard.h"
|
|
#include "arm/counter.h"
|
|
#include "kernel/shmem.h"
|
|
#include "runtime/hosversion.h"
|
|
#include "services/btdrv.h"
|
|
|
|
static Service g_btdrvSrv;
|
|
|
|
static bool g_btdrvSharedmemInitialized;
|
|
static SharedMemory g_btdrvSharedmem;
|
|
static BtdrvCircularBuffer *g_btdrvCircularBuffer;
|
|
|
|
static Result _btdrvCmdNoIO(u32 cmd_id);
|
|
|
|
NX_GENERATE_SERVICE_GUARD(btdrv);
|
|
|
|
Result _btdrvInitialize(void) {
|
|
Result rc=0;
|
|
|
|
rc = smGetService(&g_btdrvSrv, "btdrv");
|
|
if (R_SUCCEEDED(rc)) rc = _btdrvCmdNoIO(0); // InitializeBluetoothDriver
|
|
return rc;
|
|
}
|
|
|
|
void _btdrvCleanup(void) {
|
|
g_btdrvCircularBuffer = NULL;
|
|
shmemClose(&g_btdrvSharedmem);
|
|
serviceClose(&g_btdrvSrv);
|
|
}
|
|
|
|
Service* btdrvGetServiceSession(void) {
|
|
return &g_btdrvSrv;
|
|
}
|
|
|
|
static Result _btdrvCmdNoIO(u32 cmd_id) {
|
|
return serviceDispatch(&g_btdrvSrv, cmd_id);
|
|
}
|
|
|
|
static Result _btdrvCmdGetHandle(Handle* handle_out, u32 cmd_id) {
|
|
return serviceDispatch(&g_btdrvSrv, cmd_id,
|
|
.out_handle_attrs = { SfOutHandleAttr_HipcCopy },
|
|
.out_handles = handle_out,
|
|
);
|
|
}
|
|
|
|
static Result _btdrvCmdInU8NoOut(u8 inval, u64 cmd_id) {
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, inval);
|
|
}
|
|
|
|
static Result _btdrvCmdInBoolNoOut(bool inval, u32 cmd_id) {
|
|
return _btdrvCmdInU8NoOut(inval!=0, cmd_id);
|
|
}
|
|
|
|
static Result _btdrvCmdTwoInBoolsNoOut(bool flag0, bool flag1, u32 cmd_id) {
|
|
const struct {
|
|
u8 flag;
|
|
u8 flag2;
|
|
} in = { flag0!=0, flag1!=0 };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, in);
|
|
}
|
|
|
|
static Result _btdrvCmdInU32NoOut(u32 inval, u32 cmd_id) {
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, inval);
|
|
}
|
|
|
|
static Result _btdrvCmdInAddrNoOut(BtdrvAddress addr, u32 cmd_id) {
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, addr);
|
|
}
|
|
|
|
static Result _btdrvCmdInAddrU8NoOut(BtdrvAddress addr, u8 inval, u32 cmd_id) {
|
|
const struct {
|
|
BtdrvAddress addr;
|
|
u8 inval;
|
|
} in = { addr, inval };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, in);
|
|
}
|
|
|
|
static Result _btdrvCmdInAddrU32NoOut(BtdrvAddress addr, u32 inval, u32 cmd_id) {
|
|
const struct {
|
|
BtdrvAddress addr;
|
|
u8 pad[2];
|
|
u32 inval;
|
|
} in = { addr, {0}, inval };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, in);
|
|
}
|
|
|
|
static Result _btdrvCmdInAddrU32U32NoOut(BtdrvAddress addr, u32 inval0, u32 inval1, u32 cmd_id) {
|
|
const struct {
|
|
BtdrvAddress addr;
|
|
u8 pad[2];
|
|
u32 inval0;
|
|
u32 inval1;
|
|
} in = { addr, {0}, inval0, inval1 };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, in);
|
|
}
|
|
|
|
static Result _btdrvCmdInLeConnectionParameterNoOut(const BtdrvLeConnectionParams *param, u32 cmd_id) {
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, *param);
|
|
}
|
|
|
|
static Result _btdrvCmdInUuidNoOut(const BtdrvGattAttributeUuid *uuid, u32 cmd_id) {
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, *uuid);
|
|
}
|
|
|
|
static Result _btdrvCmdNoInOutU8(u8 *out, u32 cmd_id) {
|
|
return serviceDispatchOut(&g_btdrvSrv, cmd_id, *out);
|
|
}
|
|
|
|
static Result _btdrvCmdNoInOutBool(bool *out, u32 cmd_id) {
|
|
u8 tmp=0;
|
|
Result rc = _btdrvCmdNoInOutU8(&tmp, cmd_id);
|
|
if (R_SUCCEEDED(rc) && out) *out = tmp & 1;
|
|
return rc;
|
|
}
|
|
|
|
static Result _btdrvCmdInU32OutU32(u32 inval, u32 *out, u32 cmd_id) {
|
|
return serviceDispatchInOut(&g_btdrvSrv, cmd_id, inval, *out);
|
|
}
|
|
|
|
static Result _btdrvCmdGetEvent(Event* out_event, bool autoclear, u32 cmd_id) {
|
|
Handle tmp_handle = INVALID_HANDLE;
|
|
Result rc = 0;
|
|
|
|
rc = _btdrvCmdGetHandle(&tmp_handle, cmd_id);
|
|
if (R_SUCCEEDED(rc)) eventLoadRemote(out_event, tmp_handle, autoclear);
|
|
return rc;
|
|
}
|
|
|
|
static Result _btdrvCmdInU32OutEvent(u32 inval, Event* out_event, bool autoclear, u32 cmd_id) {
|
|
Handle tmp_handle = INVALID_HANDLE;
|
|
|
|
Result rc = serviceDispatchIn(&g_btdrvSrv, cmd_id, inval,
|
|
.out_handle_attrs = { SfOutHandleAttr_HipcCopy },
|
|
.out_handles = &tmp_handle,
|
|
);
|
|
|
|
if (R_SUCCEEDED(rc)) eventLoadRemote(out_event, tmp_handle, autoclear);
|
|
return rc;
|
|
}
|
|
|
|
static Result _btdrvCmdInBufPtrFixed(const void* buffer, size_t size, u32 cmd_id) {
|
|
return serviceDispatch(&g_btdrvSrv, cmd_id,
|
|
.buffer_attrs = { SfBufferAttr_HipcPointer | SfBufferAttr_In | SfBufferAttr_FixedSize },
|
|
.buffers = { { buffer, size } },
|
|
);
|
|
}
|
|
|
|
static Result _btdrvCmdOutBufAliasFixed(void* buffer, size_t size, u32 cmd_id) {
|
|
return serviceDispatch(&g_btdrvSrv, cmd_id,
|
|
.buffer_attrs = { SfBufferAttr_HipcMapAlias | SfBufferAttr_Out | SfBufferAttr_FixedSize },
|
|
.buffers = { { buffer, size } },
|
|
);
|
|
}
|
|
|
|
static Result _btdrvCmdOutU32OutBuf(void* buffer, size_t size, u32 *out, u32 cmd_id) {
|
|
return serviceDispatchOut(&g_btdrvSrv, cmd_id, *out,
|
|
.buffer_attrs = { SfBufferAttr_HipcPointer | SfBufferAttr_Out },
|
|
.buffers = { { buffer, size } },
|
|
);
|
|
}
|
|
|
|
static Result _btdrvGattNotification(u32 connection_handle, bool is_primary, const BtdrvGattId *serv_id, const BtdrvGattId *char_id, u32 cmd_id) {
|
|
const struct {
|
|
u8 is_primary;
|
|
u8 pad[3];
|
|
u32 connection_handle;
|
|
BtdrvGattId serv_id;
|
|
BtdrvGattId char_id;
|
|
} in = { is_primary!=0, {0}, connection_handle, *serv_id, *char_id };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, in);
|
|
}
|
|
|
|
Result btdrvInitializeBluetooth(Event* out_event) {
|
|
return _btdrvCmdGetEvent(out_event, true, 1);
|
|
}
|
|
|
|
Result btdrvEnableBluetooth(void) {
|
|
return _btdrvCmdNoIO(2);
|
|
}
|
|
|
|
Result btdrvDisableBluetooth(void) {
|
|
return _btdrvCmdNoIO(3);
|
|
}
|
|
|
|
Result btdrvFinalizeBluetooth(void) {
|
|
return _btdrvCmdNoIO(4);
|
|
}
|
|
|
|
Result btdrvLegacyGetAdapterProperties(BtdrvAdapterPropertyOld *properties) {
|
|
if (hosversionAtLeast(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return serviceDispatch(&g_btdrvSrv, 5,
|
|
.buffer_attrs = { SfBufferAttr_HipcPointer | SfBufferAttr_Out | SfBufferAttr_FixedSize },
|
|
.buffers = { { properties, sizeof(*properties) } },
|
|
);
|
|
}
|
|
|
|
Result btdrvGetAdapterProperties(BtdrvAdapterPropertySet *properties) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return serviceDispatch(&g_btdrvSrv, 5,
|
|
.buffer_attrs = { SfBufferAttr_HipcPointer | SfBufferAttr_Out | SfBufferAttr_FixedSize },
|
|
.buffers = { { properties, sizeof(*properties) } },
|
|
);
|
|
}
|
|
|
|
Result btdrvLegacyGetAdapterProperty(BtdrvBluetoothPropertyType type, void* buffer, size_t size) {
|
|
if (hosversionAtLeast(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
u32 tmp=type;
|
|
return serviceDispatchIn(&g_btdrvSrv, 6, tmp,
|
|
.buffer_attrs = { SfBufferAttr_HipcPointer | SfBufferAttr_Out },
|
|
.buffers = { { buffer, size } },
|
|
);
|
|
}
|
|
|
|
Result btdrvGetAdapterProperty(BtdrvAdapterPropertyType type, BtdrvAdapterProperty *property) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
u32 tmp=type;
|
|
return serviceDispatchIn(&g_btdrvSrv, 6, tmp,
|
|
.buffer_attrs = { SfBufferAttr_HipcPointer | SfBufferAttr_Out | SfBufferAttr_FixedSize },
|
|
.buffers = { { property, sizeof(*property) } },
|
|
);
|
|
}
|
|
|
|
Result btdrvLegacySetAdapterProperty(BtdrvBluetoothPropertyType type, const void* buffer, size_t size) {
|
|
if (hosversionAtLeast(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
u32 tmp=type;
|
|
return serviceDispatchIn(&g_btdrvSrv, 7, tmp,
|
|
.buffer_attrs = { SfBufferAttr_HipcPointer | SfBufferAttr_In },
|
|
.buffers = { { buffer, size } },
|
|
);
|
|
}
|
|
|
|
Result btdrvSetAdapterProperty(BtdrvAdapterPropertyType type, const BtdrvAdapterProperty *property) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
u32 tmp=type;
|
|
return serviceDispatchIn(&g_btdrvSrv, 7, tmp,
|
|
.buffer_attrs = { SfBufferAttr_HipcPointer | SfBufferAttr_In | SfBufferAttr_FixedSize },
|
|
.buffers = { { property, sizeof(*property) } },
|
|
);
|
|
}
|
|
|
|
Result btdrvLegacyStartInquiry(void) {
|
|
if (hosversionAtLeast(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdNoIO(8);
|
|
}
|
|
|
|
Result btdrvStartInquiry(u32 services, s64 duration) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
const struct {
|
|
u32 services;
|
|
s64 duration;
|
|
} in = { services, duration };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, 8, in);
|
|
}
|
|
|
|
Result btdrvStopInquiry(void) {
|
|
return _btdrvCmdNoIO(9);
|
|
}
|
|
|
|
Result btdrvCreateBond(BtdrvAddress addr, u32 type) {
|
|
if (hosversionBefore(9,0,0)) {
|
|
return serviceDispatchIn(&g_btdrvSrv, 10, addr,
|
|
.buffer_attrs = { SfBufferAttr_HipcPointer | SfBufferAttr_In | SfBufferAttr_FixedSize },
|
|
.buffers = { { &type, sizeof(type) } },
|
|
);
|
|
}
|
|
|
|
return _btdrvCmdInAddrU32NoOut(addr, type, 10);
|
|
}
|
|
|
|
Result btdrvRemoveBond(BtdrvAddress addr) {
|
|
return _btdrvCmdInAddrNoOut(addr, 11);
|
|
}
|
|
|
|
Result btdrvCancelBond(BtdrvAddress addr) {
|
|
return _btdrvCmdInAddrNoOut(addr, 12);
|
|
}
|
|
|
|
Result btdrvLegacyRespondToPinRequest(BtdrvAddress addr, bool flag, const BtdrvBluetoothPinCode *pin_code, u8 length) {
|
|
if (hosversionAtLeast(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
const struct {
|
|
BtdrvAddress addr;
|
|
u8 flag;
|
|
u8 length;
|
|
BtdrvBluetoothPinCode pin_code;
|
|
} in = { addr, flag!=0, length, *pin_code };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, 13, in);
|
|
}
|
|
|
|
Result btdrvRespondToPinRequest(BtdrvAddress addr, const BtdrvPinCode *pin_code) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
const struct {
|
|
BtdrvAddress addr;
|
|
BtdrvPinCode pin_code;
|
|
} in = { addr, *pin_code };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, 13, in);
|
|
}
|
|
|
|
Result btdrvRespondToSspRequest(BtdrvAddress addr, u32 variant, bool accept, u32 passkey) {
|
|
if (hosversionBefore(12,0,0)) {
|
|
const struct {
|
|
BtdrvAddress addr;
|
|
u8 variant;
|
|
u8 accept;
|
|
u32 passkey;
|
|
} in = { addr, variant, accept!=0, passkey };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, 14, in);
|
|
}
|
|
else {
|
|
const struct {
|
|
BtdrvAddress addr;
|
|
u8 accept;
|
|
u32 variant;
|
|
u32 passkey;
|
|
} in = { addr, accept!=0, variant, passkey };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, 14, in);
|
|
}
|
|
}
|
|
|
|
Result btdrvGetEventInfo(void* buffer, size_t size, BtdrvEventType *type) {
|
|
return _btdrvCmdOutU32OutBuf(buffer, size, type, 15);
|
|
}
|
|
|
|
Result btdrvInitializeHid(Event* out_event) {
|
|
Handle tmp_handle = INVALID_HANDLE;
|
|
Result rc = 0;
|
|
u16 tmp=0x1;
|
|
|
|
if (R_SUCCEEDED(rc)) {
|
|
rc = serviceDispatchIn(&g_btdrvSrv, 16, tmp,
|
|
.out_handle_attrs = { SfOutHandleAttr_HipcCopy },
|
|
.out_handles = &tmp_handle,
|
|
);
|
|
}
|
|
if (R_SUCCEEDED(rc)) eventLoadRemote(out_event, tmp_handle, true);
|
|
return rc;
|
|
}
|
|
|
|
Result btdrvOpenHidConnection(BtdrvAddress addr) {
|
|
return _btdrvCmdInAddrNoOut(addr, 17);
|
|
}
|
|
|
|
Result btdrvCloseHidConnection(BtdrvAddress addr) {
|
|
return _btdrvCmdInAddrNoOut(addr, 18);
|
|
}
|
|
|
|
Result btdrvWriteHidData(BtdrvAddress addr, const BtdrvHidReport *buffer) {
|
|
size_t size = hosversionBefore(9,0,0) ? sizeof(BtdrvHidData) : sizeof(BtdrvHidReport);
|
|
return serviceDispatchIn(&g_btdrvSrv, 19, addr,
|
|
.buffer_attrs = { SfBufferAttr_HipcPointer | SfBufferAttr_In | SfBufferAttr_FixedSize },
|
|
.buffers = { { buffer, size } },
|
|
);
|
|
}
|
|
|
|
Result btdrvWriteHidData2(BtdrvAddress addr, const void* buffer, size_t size) {
|
|
return serviceDispatchIn(&g_btdrvSrv, 20, addr,
|
|
.buffer_attrs = { SfBufferAttr_HipcPointer | SfBufferAttr_In },
|
|
.buffers = { { buffer, size } },
|
|
);
|
|
}
|
|
|
|
Result btdrvSetHidReport(BtdrvAddress addr, BtdrvBluetoothHhReportType type, const BtdrvHidReport *buffer) {
|
|
size_t size = hosversionBefore(9,0,0) ? sizeof(BtdrvHidData) : sizeof(BtdrvHidReport);
|
|
|
|
const struct {
|
|
BtdrvAddress addr;
|
|
u8 pad[2];
|
|
u32 type;
|
|
} in = { addr, {0}, type };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, 21, in,
|
|
.buffer_attrs = { SfBufferAttr_HipcPointer | SfBufferAttr_In | SfBufferAttr_FixedSize },
|
|
.buffers = { { buffer, size } },
|
|
);
|
|
}
|
|
|
|
Result btdrvGetHidReport(BtdrvAddress addr, u8 report_id, BtdrvBluetoothHhReportType type) {
|
|
const struct {
|
|
BtdrvAddress addr;
|
|
u8 report_id;
|
|
u8 pad;
|
|
u32 type;
|
|
} in = { addr, report_id, 0, type };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, 22, in);
|
|
}
|
|
|
|
Result btdrvTriggerConnection(BtdrvAddress addr, u16 timeout) {
|
|
if (hosversionBefore(9,0,0)) return _btdrvCmdInAddrNoOut(addr, 23);
|
|
|
|
const struct {
|
|
BtdrvAddress addr;
|
|
u16 timeout;
|
|
} in = { addr, timeout };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, 23, in);
|
|
}
|
|
|
|
Result btdrvAddPairedDeviceInfo(const SetSysBluetoothDevicesSettings *settings) {
|
|
return _btdrvCmdInBufPtrFixed(settings, sizeof(*settings), 24);
|
|
}
|
|
|
|
Result btdrvGetPairedDeviceInfo(BtdrvAddress addr, SetSysBluetoothDevicesSettings *settings) {
|
|
return serviceDispatchIn(&g_btdrvSrv, 25, addr,
|
|
.buffer_attrs = { SfBufferAttr_HipcPointer | SfBufferAttr_Out | SfBufferAttr_FixedSize },
|
|
.buffers = { { settings, sizeof(*settings) } },
|
|
);
|
|
}
|
|
|
|
Result btdrvFinalizeHid(void) {
|
|
return _btdrvCmdNoIO(26);
|
|
}
|
|
|
|
Result btdrvGetHidEventInfo(void* buffer, size_t size, BtdrvHidEventType *type) {
|
|
u32 tmp=0;
|
|
Result rc = _btdrvCmdOutU32OutBuf(buffer, size, &tmp, 27);
|
|
if (R_SUCCEEDED(rc) && type) *type = tmp;
|
|
return rc;
|
|
}
|
|
|
|
Result btdrvSetTsi(BtdrvAddress addr, u8 tsi) {
|
|
return _btdrvCmdInAddrU8NoOut(addr, tsi, 28);
|
|
}
|
|
|
|
Result btdrvEnableBurstMode(BtdrvAddress addr, bool flag) {
|
|
return _btdrvCmdInAddrU8NoOut(addr, flag!=0, 29);
|
|
}
|
|
|
|
Result btdrvSetZeroRetransmission(BtdrvAddress addr, u8 *report_ids, u8 count) {
|
|
return serviceDispatchIn(&g_btdrvSrv, 30, addr,
|
|
.buffer_attrs = { SfBufferAttr_HipcPointer | SfBufferAttr_In },
|
|
.buffers = { { report_ids, count } },
|
|
);
|
|
}
|
|
|
|
Result btdrvEnableMcMode(bool flag) {
|
|
return _btdrvCmdInBoolNoOut(flag, 31);
|
|
}
|
|
|
|
Result btdrvEnableLlrScan(void) {
|
|
return _btdrvCmdNoIO(32);
|
|
}
|
|
|
|
Result btdrvDisableLlrScan(void) {
|
|
return _btdrvCmdNoIO(33);
|
|
}
|
|
|
|
Result btdrvEnableRadio(bool flag) {
|
|
return _btdrvCmdInBoolNoOut(flag, 34);
|
|
}
|
|
|
|
Result btdrvSetVisibility(bool inquiry_scan, bool page_scan) {
|
|
return _btdrvCmdTwoInBoolsNoOut(inquiry_scan, page_scan, 35);
|
|
}
|
|
|
|
Result btdrvEnableTbfcScan(bool flag) {
|
|
if (hosversionBefore(4,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInBoolNoOut(flag, 36);
|
|
}
|
|
|
|
Result btdrvRegisterHidReportEvent(Event* out_event) {
|
|
Result rc=0;
|
|
Handle tmphandle=0;
|
|
|
|
if (hosversionAtLeast(7,0,0)) {
|
|
if (!g_btdrvSharedmemInitialized) {
|
|
rc = _btdrvCmdGetHandle(&tmphandle, 38); // GetHidReportEventInfo
|
|
|
|
if (R_SUCCEEDED(rc)) {
|
|
shmemLoadRemote(&g_btdrvSharedmem, tmphandle, 0x3000, Perm_Rw);
|
|
|
|
rc = shmemMap(&g_btdrvSharedmem);
|
|
}
|
|
|
|
if (R_SUCCEEDED(rc)) {
|
|
g_btdrvSharedmemInitialized = true;
|
|
g_btdrvCircularBuffer = shmemGetAddr(&g_btdrvSharedmem);
|
|
}
|
|
else shmemClose(&g_btdrvSharedmem);
|
|
}
|
|
else {
|
|
while (btdrvCircularBufferRead(g_btdrvCircularBuffer)) btdrvCircularBufferFree(g_btdrvCircularBuffer);
|
|
}
|
|
}
|
|
|
|
u32 cmd_id = hosversionBefore(4,0,0) ? 36 : 37;
|
|
if (R_SUCCEEDED(rc)) rc = _btdrvCmdGetEvent(out_event, true, cmd_id); // RegisterHidReportEvent
|
|
return rc;
|
|
}
|
|
|
|
Result btdrvGetHidReportEventInfo(void* buffer, size_t size, BtdrvHidEventType *type) {
|
|
if (hosversionAtLeast(7,0,0)) {
|
|
BtdrvHidReportEventInfo *info = (BtdrvHidReportEventInfo*)buffer;
|
|
BtdrvHidReportEventInfoBufferData *data_ptr = NULL;
|
|
memset(buffer, 0, size);
|
|
if (g_btdrvCircularBuffer==NULL) return MAKERESULT(Module_Libnx, LibnxError_NotInitialized);
|
|
for (; (data_ptr = btdrvCircularBufferRead(g_btdrvCircularBuffer)); btdrvCircularBufferFree(g_btdrvCircularBuffer)) {
|
|
*type = data_ptr->hdr.type;
|
|
if (*type == BtdrvHidEventType_Data) {
|
|
if (armTicksToNs(armGetSystemTick() - data_ptr->hdr.tick) >= 100000001) continue;
|
|
}
|
|
break;
|
|
}
|
|
if (data_ptr == NULL) {
|
|
*type = BtdrvHidEventType_Data;
|
|
return 0;
|
|
}
|
|
bool is_old = hosversionBefore(12,0,0);
|
|
if ((is_old && *type == BtdrvHidEventTypeOld_GetReport) || (!is_old && *type == BtdrvHidEventType_GetReport)) {
|
|
if (hosversionBefore(9,0,0)) memcpy(info->get_report.v1.rawdata, data_ptr->data.get_report.v1.rawdata, sizeof(info->get_report.v1.rawdata));
|
|
else memcpy(info->get_report.v9.rawdata, data_ptr->data.get_report.v9.rawdata, sizeof(info->get_report.v9.rawdata));
|
|
}
|
|
else if ((is_old && *type == BtdrvHidEventTypeOld_SetReport) || (!is_old && *type == BtdrvHidEventType_SetReport)) memcpy(info->set_report.rawdata, data_ptr->data.set_report.rawdata, sizeof(info->set_report.rawdata));
|
|
else if ((is_old && *type == BtdrvHidEventTypeOld_Data) || (!is_old && *type == BtdrvHidEventType_Data)) {
|
|
u16 tmpsize = hosversionBefore(9,0,0) ? data_ptr->data.data_report.v7.report.size : data_ptr->data.data_report.v9.report.size;
|
|
if (size < 0xE) return MAKERESULT(Module_Libnx, LibnxError_BadInput);
|
|
if (tmpsize > size-0xE) tmpsize = size-0xE;
|
|
if (hosversionBefore(9,0,0)) info->data_report.v7.report.size = tmpsize;
|
|
else {
|
|
info->data_report.v9.res = 0;
|
|
info->data_report.v9.report.size = tmpsize;
|
|
}
|
|
if (hosversionBefore(9,0,0)) memcpy(info->data_report.v7.report.data, data_ptr->data.data_report.v7.report.data, tmpsize);
|
|
else memcpy(info->data_report.v9.report.data, data_ptr->data.data_report.v9.report.data, tmpsize);
|
|
|
|
if (hosversionBefore(9,0,0)) memcpy(&info->data_report.v7.addr, &data_ptr->data.data_report.v7.addr, sizeof(BtdrvAddress));
|
|
else memcpy(&info->data_report.v9.addr, &data_ptr->data.data_report.v9.addr, sizeof(BtdrvAddress));
|
|
}
|
|
else return MAKERESULT(Module_Libnx, LibnxError_ShouldNotHappen); // sdknso would Abort here.
|
|
btdrvCircularBufferFree(g_btdrvCircularBuffer);
|
|
return 0;
|
|
}
|
|
|
|
u32 tmp_type=0;
|
|
u32 cmd_id = hosversionBefore(4,0,0) ? 37 : 38;
|
|
Result rc = _btdrvCmdOutU32OutBuf(buffer, size, &tmp_type, cmd_id);
|
|
if (R_SUCCEEDED(rc) && type) *type = tmp_type;
|
|
return rc;
|
|
}
|
|
|
|
void* btdrvGetHidReportEventInfoSharedmemAddr(void) {
|
|
return g_btdrvCircularBuffer;
|
|
}
|
|
|
|
Result btdrvGetLatestPlr(BtdrvPlrList *out) {
|
|
u32 cmd_id = hosversionBefore(4,0,0) ? 38 : 39;
|
|
size_t size = hosversionBefore(9,0,0) ? sizeof(BtdrvPlrStatistics) : sizeof(BtdrvPlrList);
|
|
|
|
return _btdrvCmdOutBufAliasFixed(out, size, cmd_id);
|
|
}
|
|
|
|
Result btdrvGetPendingConnections(void) {
|
|
if (hosversionBefore(3,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(4,0,0) ? 39 : 40;
|
|
|
|
return _btdrvCmdNoIO(cmd_id);
|
|
}
|
|
|
|
Result btdrvGetChannelMap(BtdrvChannelMapList *out) {
|
|
if (hosversionBefore(3,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(4,0,0) ? 40 : 41;
|
|
|
|
return _btdrvCmdOutBufAliasFixed(out, sizeof(*out), cmd_id);
|
|
}
|
|
|
|
Result btdrvEnableTxPowerBoostSetting(bool flag) {
|
|
if (hosversionBefore(3,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(4,0,0) ? 41 : 42;
|
|
|
|
return _btdrvCmdInBoolNoOut(flag, cmd_id);
|
|
}
|
|
|
|
Result btdrvIsTxPowerBoostSettingEnabled(bool *out) {
|
|
if (hosversionBefore(3,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(4,0,0) ? 42 : 43;
|
|
|
|
return _btdrvCmdNoInOutBool(out, cmd_id);
|
|
}
|
|
|
|
Result btdrvEnableAfhSetting(bool flag) {
|
|
if (hosversionBefore(3,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(4,0,0) ? 43 : 44;
|
|
|
|
return _btdrvCmdInBoolNoOut(flag, cmd_id);
|
|
}
|
|
|
|
Result btdrvIsAfhSettingEnabled(bool *out) {
|
|
if (hosversionBefore(3,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(4,0,0) ? 44 : 45;
|
|
|
|
return _btdrvCmdNoInOutBool(out, cmd_id);
|
|
}
|
|
|
|
Result btdrvInitializeBle(Event* out_event) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdGetEvent(out_event, true, 46);
|
|
}
|
|
|
|
Result btdrvEnableBle(void) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdNoIO(47);
|
|
}
|
|
|
|
Result btdrvDisableBle(void) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdNoIO(48);
|
|
}
|
|
|
|
Result btdrvFinalizeBle(void) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdNoIO(49);
|
|
}
|
|
|
|
Result btdrvSetBleVisibility(bool discoverable, bool connectable) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdTwoInBoolsNoOut(discoverable, connectable, 50);
|
|
}
|
|
|
|
Result btdrvSetLeConnectionParameter(const BtdrvLeConnectionParams *param) {
|
|
if (hosversionBefore(5,0,0) || hosversionAtLeast(9,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInLeConnectionParameterNoOut(param, 51);
|
|
}
|
|
|
|
Result btdrvSetBleConnectionParameter(BtdrvAddress addr, const BtdrvBleConnectionParameter *param, bool flag) {
|
|
if (hosversionBefore(9,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
const struct {
|
|
BtdrvAddress addr;
|
|
u8 flag;
|
|
u8 pad;
|
|
BtdrvBleConnectionParameter param;
|
|
} in = { addr, flag!=0, 0, *param };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, 51, in);
|
|
}
|
|
|
|
Result btdrvSetLeDefaultConnectionParameter(const BtdrvLeConnectionParams *param) {
|
|
if (hosversionBefore(5,0,0) || hosversionAtLeast(9,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInLeConnectionParameterNoOut(param, 52);
|
|
}
|
|
|
|
Result btdrvSetBleDefaultConnectionParameter(const BtdrvBleConnectionParameter *param) {
|
|
if (hosversionBefore(9,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, 52, *param);
|
|
}
|
|
|
|
Result btdrvSetBleAdvertiseData(const BtdrvBleAdvertisePacketData *data) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInBufPtrFixed(data, sizeof(*data), 53);
|
|
}
|
|
|
|
Result btdrvSetBleAdvertiseParameter(BtdrvAddress addr, u16 min_interval, u16 max_interval) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
const struct {
|
|
BtdrvAddress addr;
|
|
u16 min_interval;
|
|
u16 max_interval;
|
|
} in = { addr, min_interval, max_interval };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, 54, in);
|
|
}
|
|
|
|
Result btdrvStartBleScan(void) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdNoIO(55);
|
|
}
|
|
|
|
Result btdrvStopBleScan(void) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdNoIO(56);
|
|
}
|
|
|
|
Result btdrvAddBleScanFilterCondition(const BtdrvBleAdvertiseFilter *filter) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInBufPtrFixed(filter, sizeof(*filter), 57);
|
|
}
|
|
|
|
Result btdrvDeleteBleScanFilterCondition(const BtdrvBleAdvertiseFilter *filter) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInBufPtrFixed(filter, sizeof(*filter), 58);
|
|
}
|
|
|
|
Result btdrvDeleteBleScanFilter(u8 index) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInU8NoOut(index, 59);
|
|
}
|
|
|
|
Result btdrvClearBleScanFilters(void) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdNoIO(60);
|
|
}
|
|
|
|
Result btdrvEnableBleScanFilter(bool flag) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInBoolNoOut(flag, 61);
|
|
}
|
|
|
|
Result btdrvRegisterGattClient(const BtdrvGattAttributeUuid *uuid) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInUuidNoOut(uuid, 62);
|
|
}
|
|
|
|
Result btdrvUnregisterGattClient(u8 client_if) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInU8NoOut(client_if, 63);
|
|
}
|
|
|
|
Result btdrvUnregisterAllGattClients(void) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdNoIO(64);
|
|
}
|
|
|
|
Result btdrvConnectGattServer(u8 client_if, BtdrvAddress addr, bool is_direct, u64 AppletResourceUserId) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
const struct {
|
|
u8 client_if;
|
|
BtdrvAddress addr;
|
|
u8 is_direct;
|
|
u64 AppletResourceUserId;
|
|
} in = { client_if, addr, is_direct!=0, AppletResourceUserId };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, 65, in);
|
|
}
|
|
|
|
Result btdrvCancelConnectGattServer(u8 client_if, BtdrvAddress addr, bool is_direct) {
|
|
if (hosversionBefore(5,1,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
const struct {
|
|
u8 client_if;
|
|
BtdrvAddress addr;
|
|
u8 is_direct;
|
|
} in = { client_if, addr, is_direct!=0 };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, 66, in);
|
|
}
|
|
|
|
Result btdrvDisconnectGattServer(u32 conn_id) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 66 : 67;
|
|
|
|
return _btdrvCmdInU32NoOut(conn_id, cmd_id);
|
|
}
|
|
|
|
Result btdrvGetGattAttribute(BtdrvAddress addr, u32 conn_id) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 67 : 68;
|
|
|
|
if (hosversionBefore(9,0,0)) {
|
|
const struct {
|
|
BtdrvAddress addr;
|
|
u32 conn_id;
|
|
} in = { addr, conn_id };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, in);
|
|
}
|
|
return _btdrvCmdInU32NoOut(conn_id, cmd_id);
|
|
}
|
|
|
|
Result btdrvGetGattService(u32 conn_id, const BtdrvGattAttributeUuid *uuid) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 68 : 69;
|
|
|
|
const struct {
|
|
u32 conn_id;
|
|
BtdrvGattAttributeUuid uuid;
|
|
} in = { conn_id, *uuid };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, in);
|
|
}
|
|
|
|
Result btdrvConfigureAttMtu(u32 conn_id, u16 mtu) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 69 : 70;
|
|
|
|
const struct {
|
|
u16 mtu;
|
|
u16 pad;
|
|
u32 conn_id;
|
|
} in = { mtu, 0, conn_id };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, in);
|
|
}
|
|
|
|
Result btdrvRegisterGattServer(const BtdrvGattAttributeUuid *uuid) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 70 : 71;
|
|
|
|
return _btdrvCmdInUuidNoOut(uuid, cmd_id);
|
|
}
|
|
|
|
Result btdrvUnregisterGattServer(u8 server_if) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 71 : 72;
|
|
|
|
return _btdrvCmdInU8NoOut(server_if, cmd_id);
|
|
}
|
|
|
|
Result btdrvConnectGattClient(u8 server_if, BtdrvAddress addr, bool is_direct) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 72 : 73;
|
|
|
|
const struct {
|
|
u8 server_if;
|
|
BtdrvAddress addr;
|
|
u8 is_direct;
|
|
} in = { server_if, addr, is_direct!=0 };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, in);
|
|
}
|
|
|
|
Result btdrvDisconnectGattClient(u8 conn_id, BtdrvAddress addr) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 73 : 74;
|
|
|
|
if (hosversionBefore(9,0,0)) {
|
|
const struct {
|
|
u8 conn_id;
|
|
BtdrvAddress addr;
|
|
} in = { conn_id, addr };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, in);
|
|
}
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, conn_id);
|
|
}
|
|
|
|
Result btdrvAddGattService(u8 server_if, const BtdrvGattAttributeUuid *uuid, u8 num_handle, bool is_primary) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
const struct {
|
|
u8 server_if;
|
|
u8 num_handle;
|
|
u8 is_primary;
|
|
u8 pad;
|
|
BtdrvGattAttributeUuid uuid;
|
|
} in = { server_if, num_handle, is_primary!=0, 0, *uuid };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, 75, in);
|
|
}
|
|
|
|
Result btdrvEnableGattService(u8 server_if, const BtdrvGattAttributeUuid *uuid) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 74 : 76;
|
|
|
|
const struct {
|
|
u8 server_if;
|
|
u8 pad[3];
|
|
BtdrvGattAttributeUuid uuid;
|
|
} in = { server_if, {0}, *uuid };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, in);
|
|
}
|
|
|
|
Result btdrvAddGattCharacteristic(u8 server_if, const BtdrvGattAttributeUuid *serv_uuid, const BtdrvGattAttributeUuid *char_uuid, u16 permissions, u8 property) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
const struct {
|
|
u8 server_if;
|
|
u8 property;
|
|
u16 permissions;
|
|
BtdrvGattAttributeUuid serv_uuid;
|
|
BtdrvGattAttributeUuid char_uuid;
|
|
} in = { server_if, property, permissions, *serv_uuid, *char_uuid };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, 77, in);
|
|
}
|
|
|
|
Result btdrvAddGattDescriptor(u8 server_if, const BtdrvGattAttributeUuid *serv_uuid, const BtdrvGattAttributeUuid *desc_uuid, u16 permissions) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 76 : 78;
|
|
|
|
const struct {
|
|
u8 server_if;
|
|
u8 pad;
|
|
u16 permissions;
|
|
BtdrvGattAttributeUuid serv_uuid;
|
|
BtdrvGattAttributeUuid desc_uuid;
|
|
} in = { server_if, 0, permissions, *serv_uuid, *desc_uuid };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, in);
|
|
}
|
|
|
|
Result btdrvGetBleManagedEventInfo(void* buffer, size_t size, BtdrvBleEventType *type) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 78 : 79;
|
|
|
|
return _btdrvCmdOutU32OutBuf(buffer, size, type, cmd_id);
|
|
}
|
|
|
|
Result btdrvGetGattFirstCharacteristic(u32 conn_id, const BtdrvGattId *serv_id, bool is_primary, const BtdrvGattAttributeUuid *filter_uuid, u8 *out_property, BtdrvGattId *out_char_id) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 79 : 80;
|
|
|
|
const struct {
|
|
u8 is_primary;
|
|
u8 pad[3];
|
|
u32 conn_id;
|
|
BtdrvGattId serv_id;
|
|
BtdrvGattAttributeUuid filter_uuid;
|
|
} in = { is_primary!=0, {0}, conn_id, *serv_id, *filter_uuid };
|
|
|
|
struct {
|
|
u8 property;
|
|
u8 pad[3];
|
|
BtdrvGattId id;
|
|
} out;
|
|
|
|
Result rc = serviceDispatchInOut(&g_btdrvSrv, cmd_id, in, out);
|
|
if (R_SUCCEEDED(rc)) {
|
|
if (out_property) *out_property = out.property;
|
|
if (out_char_id) *out_char_id = out.id;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
Result btdrvGetGattNextCharacteristic(u32 conn_id, const BtdrvGattId *serv_id, bool is_primary, const BtdrvGattId *char_id, const BtdrvGattAttributeUuid *filter_uuid, u8 *out_property, BtdrvGattId *out_char_id) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 80 : 81;
|
|
|
|
const struct {
|
|
u8 is_primary;
|
|
u8 pad[3];
|
|
u32 conn_id;
|
|
BtdrvGattId serv_id;
|
|
BtdrvGattId char_id;
|
|
BtdrvGattAttributeUuid filter_uuid;
|
|
} in = { is_primary!=0, {0}, conn_id, *serv_id, *char_id, *filter_uuid };
|
|
|
|
struct {
|
|
u8 property;
|
|
u8 pad[3];
|
|
BtdrvGattId id;
|
|
} out;
|
|
|
|
Result rc = serviceDispatchInOut(&g_btdrvSrv, cmd_id, in, out);
|
|
if (R_SUCCEEDED(rc)) {
|
|
if (out_property) *out_property = out.property;
|
|
if (out_char_id) *out_char_id = out.id;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
Result btdrvGetGattFirstDescriptor(u32 conn_id, const BtdrvGattId *serv_id, bool is_primary, const BtdrvGattId *char_id, const BtdrvGattAttributeUuid *filter_uuid, BtdrvGattId *out_desc_id) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 81 : 82;
|
|
|
|
const struct {
|
|
u8 is_primary;
|
|
u8 pad[3];
|
|
u32 conn_id;
|
|
BtdrvGattId serv_id;
|
|
BtdrvGattId char_id;
|
|
BtdrvGattAttributeUuid filter_uuid;
|
|
} in = { is_primary!=0, {0}, conn_id, *serv_id, *char_id, *filter_uuid };
|
|
|
|
return serviceDispatchInOut(&g_btdrvSrv, cmd_id, in, *out_desc_id);
|
|
}
|
|
|
|
Result btdrvGetGattNextDescriptor(u32 conn_id, const BtdrvGattId *serv_id, bool is_primary, const BtdrvGattId *char_id, const BtdrvGattId *desc_id, const BtdrvGattAttributeUuid *filter_uuid, BtdrvGattId *out_desc_id) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 82 : 83;
|
|
|
|
const struct {
|
|
u8 is_primary;
|
|
u8 pad[3];
|
|
u32 conn_id;
|
|
BtdrvGattId serv_id;
|
|
BtdrvGattId char_id;
|
|
BtdrvGattId desc_id;
|
|
BtdrvGattAttributeUuid filter_uuid;
|
|
} in = { is_primary!=0, {0}, conn_id, *serv_id, *char_id, *desc_id, *filter_uuid };
|
|
|
|
return serviceDispatchInOut(&g_btdrvSrv, cmd_id, in, *out_desc_id);
|
|
}
|
|
|
|
Result btdrvRegisterGattManagedDataPath(const BtdrvGattAttributeUuid *uuid) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInUuidNoOut(uuid, 84);
|
|
}
|
|
|
|
Result btdrvUnregisterGattManagedDataPath(const BtdrvGattAttributeUuid *uuid) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInUuidNoOut(uuid, 85);
|
|
}
|
|
|
|
Result btdrvRegisterGattHidDataPath(const BtdrvGattAttributeUuid *uuid) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInUuidNoOut(uuid, 86);
|
|
}
|
|
|
|
Result btdrvUnregisterGattHidDataPath(const BtdrvGattAttributeUuid *uuid) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInUuidNoOut(uuid, 87);
|
|
}
|
|
|
|
Result btdrvRegisterGattDataPath(const BtdrvGattAttributeUuid *uuid) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInUuidNoOut(uuid, 88);
|
|
}
|
|
|
|
Result btdrvUnregisterGattDataPath(const BtdrvGattAttributeUuid *uuid) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 83 : 89;
|
|
|
|
return _btdrvCmdInUuidNoOut(uuid, cmd_id);
|
|
}
|
|
|
|
Result btdrvReadGattCharacteristic(u32 connection_handle, bool is_primary, const BtdrvGattId *serv_id, const BtdrvGattId *char_id, u8 auth_req) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 89 : 90;
|
|
|
|
const struct {
|
|
u8 is_primary;
|
|
u8 auth_req;
|
|
u8 pad[2];
|
|
u32 connection_handle;
|
|
BtdrvGattId serv_id;
|
|
BtdrvGattId char_id;
|
|
} in = { is_primary!=0, auth_req, {0}, connection_handle, *serv_id, *char_id};
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, in);
|
|
}
|
|
|
|
Result btdrvReadGattDescriptor(u32 connection_handle, bool is_primary, const BtdrvGattId *serv_id, const BtdrvGattId *char_id, const BtdrvGattId *desc_id, u8 auth_req) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 90 : 91;
|
|
|
|
const struct {
|
|
u8 is_primary;
|
|
u8 auth_req;
|
|
u8 pad[2];
|
|
u32 connection_handle;
|
|
BtdrvGattId serv_id;
|
|
BtdrvGattId char_id;
|
|
BtdrvGattId desc_id;
|
|
} in = { is_primary!=0, auth_req, {0}, connection_handle, *serv_id, *char_id, *desc_id };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, in);
|
|
}
|
|
|
|
Result btdrvWriteGattCharacteristic(u32 connection_handle, bool is_primary, const BtdrvGattId *serv_id, const BtdrvGattId *char_id, const void* buffer, size_t size, u8 auth_req, bool with_response) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 91 : 92;
|
|
|
|
const struct {
|
|
u8 is_primary;
|
|
u8 auth_req;
|
|
u8 with_response;
|
|
u8 pad;
|
|
u32 connection_handle;
|
|
BtdrvGattId serv_id;
|
|
BtdrvGattId char_id;
|
|
} in = { is_primary!=0, auth_req, with_response!=0, 0, connection_handle, *serv_id, *char_id };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, in,
|
|
.buffer_attrs = { SfBufferAttr_HipcPointer | SfBufferAttr_In },
|
|
.buffers = { { buffer, size } },
|
|
);
|
|
}
|
|
|
|
Result btdrvWriteGattDescriptor(u32 connection_handle, bool is_primary, const BtdrvGattId *serv_id, const BtdrvGattId *char_id, const BtdrvGattId *desc_id, const void* buffer, size_t size, u8 auth_req) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 92 : 93;
|
|
|
|
const struct {
|
|
u8 is_primary;
|
|
u8 auth_req;
|
|
u8 pad[2];
|
|
u32 connection_handle;
|
|
BtdrvGattId serv_id;
|
|
BtdrvGattId char_id;
|
|
BtdrvGattId desc_id;
|
|
} in = { is_primary!=0, auth_req, {0}, connection_handle, *serv_id, *char_id, *desc_id };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, cmd_id, in,
|
|
.buffer_attrs = { SfBufferAttr_HipcPointer | SfBufferAttr_In },
|
|
.buffers = { { buffer, size } },
|
|
);
|
|
}
|
|
|
|
Result btdrvRegisterGattNotification(u32 connection_handle, bool is_primary, const BtdrvGattId *serv_id, const BtdrvGattId *char_id) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvGattNotification(connection_handle, is_primary, serv_id, char_id, 94);
|
|
}
|
|
|
|
Result btdrvUnregisterGattNotification(u32 connection_handle, bool is_primary, const BtdrvGattId *serv_id, const BtdrvGattId *char_id) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 93 : 95;
|
|
|
|
return _btdrvGattNotification(connection_handle, is_primary, serv_id, char_id, cmd_id);
|
|
}
|
|
|
|
Result btdrvGetLeHidEventInfo(void* buffer, size_t size, BtdrvBleEventType *type) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 95 : 96;
|
|
|
|
return _btdrvCmdOutU32OutBuf(buffer, size, type, cmd_id);
|
|
}
|
|
|
|
Result btdrvRegisterBleHidEvent(Event* out_event) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
u32 cmd_id = hosversionBefore(5,1,0) ? 96 : 97;
|
|
|
|
return _btdrvCmdGetEvent(out_event, true, cmd_id);
|
|
}
|
|
|
|
Result btdrvSetBleScanParameter(u16 scan_interval, u16 scan_window) {
|
|
if (hosversionBefore(5,1,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
const struct {
|
|
u16 scan_interval;
|
|
u16 scan_window;
|
|
} in = { scan_interval, scan_window };
|
|
|
|
return serviceDispatchIn(&g_btdrvSrv, 98, in);
|
|
}
|
|
|
|
Result btdrvMoveToSecondaryPiconet(BtdrvAddress addr) {
|
|
if (hosversionBefore(10,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInAddrNoOut(addr, 99);
|
|
}
|
|
|
|
Result btdrvIsBluetoothEnabled(bool *out) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdNoInOutBool(out, 100);
|
|
}
|
|
|
|
Result btdrvAcquireAudioEvent(Event* out_event, bool autoclear) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdGetEvent(out_event, autoclear, 128);
|
|
}
|
|
|
|
Result btdrvGetAudioEventInfo(void* buffer, size_t size, BtdrvAudioEventType *type) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
u32 tmp=0;
|
|
Result rc = _btdrvCmdOutU32OutBuf(buffer, size, &tmp, 129);
|
|
if (R_SUCCEEDED(rc) && type) *type = tmp;
|
|
return rc;
|
|
}
|
|
|
|
Result btdrvOpenAudioConnection(BtdrvAddress addr) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInAddrNoOut(addr, 130);
|
|
}
|
|
|
|
Result btdrvCloseAudioConnection(BtdrvAddress addr) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInAddrNoOut(addr, 131);
|
|
}
|
|
|
|
Result btdrvOpenAudioOut(BtdrvAddress addr, u32 *audio_handle) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return serviceDispatchInOut(&g_btdrvSrv, 132, addr, *audio_handle);
|
|
}
|
|
|
|
Result btdrvCloseAudioOut(u32 audio_handle) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInU32NoOut(audio_handle, 133);
|
|
}
|
|
|
|
Result btdrvAcquireAudioOutStateChangedEvent(u32 audio_handle, Event* out_event, bool autoclear) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInU32OutEvent(audio_handle, out_event, autoclear, 134);
|
|
}
|
|
|
|
Result btdrvStartAudioOut(u32 audio_handle, const BtdrvPcmParameter *pcm_param, s64 in_latency, s64 *out_latency, u64 *out1) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
const struct {
|
|
u32 audio_handle;
|
|
BtdrvPcmParameter pcm_param;
|
|
s64 latency;
|
|
} in = { audio_handle, *pcm_param, in_latency };
|
|
|
|
struct {
|
|
s64 latency;
|
|
u64 out1;
|
|
} out;
|
|
|
|
Result rc = serviceDispatchInOut(&g_btdrvSrv, 135, in, out);
|
|
if (R_SUCCEEDED(rc)) {
|
|
if (out_latency) *out_latency = out.latency;
|
|
if (out1) *out1 = out.out1;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
Result btdrvStopAudioOut(u32 audio_handle) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInU32NoOut(audio_handle, 136);
|
|
}
|
|
|
|
Result btdrvGetAudioOutState(u32 audio_handle, BtdrvAudioOutState *out) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
u32 tmp=0;
|
|
Result rc = _btdrvCmdInU32OutU32(audio_handle, &tmp, 137);
|
|
if (R_SUCCEEDED(rc) && out) *out = tmp;
|
|
return rc;
|
|
}
|
|
|
|
Result btdrvGetAudioOutFeedingCodec(u32 audio_handle, BtdrvAudioCodec *out) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
u32 tmp=0;
|
|
Result rc = _btdrvCmdInU32OutU32(audio_handle, &tmp, 138);
|
|
if (R_SUCCEEDED(rc) && out) *out = tmp;
|
|
return rc;
|
|
}
|
|
|
|
Result btdrvGetAudioOutFeedingParameter(u32 audio_handle, BtdrvPcmParameter *out) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return serviceDispatchInOut(&g_btdrvSrv, 139, audio_handle, *out);
|
|
}
|
|
|
|
Result btdrvAcquireAudioOutBufferAvailableEvent(u32 audio_handle, Event* out_event, bool autoclear) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInU32OutEvent(audio_handle, out_event, autoclear, 140);
|
|
}
|
|
|
|
Result btdrvSendAudioData(u32 audio_handle, const void* buffer, size_t size, u64 *transferred_size) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return serviceDispatchInOut(&g_btdrvSrv, 141, audio_handle, *transferred_size,
|
|
.buffer_attrs = { SfBufferAttr_HipcPointer | SfBufferAttr_In },
|
|
.buffers = { { buffer, size } },
|
|
);
|
|
}
|
|
|
|
Result btdrvAcquireAudioControlInputStateChangedEvent(Event* out_event, bool autoclear) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdGetEvent(out_event, autoclear, 142);
|
|
}
|
|
|
|
Result btdrvGetAudioControlInputState(BtdrvAudioControlButtonState *states, s32 count, s32 *total_out) {
|
|
if (hosversionBefore(12,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdOutU32OutBuf(states, count*sizeof(BtdrvAudioControlButtonState), (u32*)total_out, 143);
|
|
}
|
|
|
|
Result btdrvAcquireAudioConnectionStateChangedEvent(Event* out_event, bool autoclear) {
|
|
if (!hosversionBetween(12, 14))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdGetEvent(out_event, autoclear, 144);
|
|
}
|
|
|
|
Result btdrvGetConnectedAudioDevice(BtdrvAddress *addrs, s32 count, s32 *total_out) {
|
|
if (!hosversionBetween(12, 14))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdOutU32OutBuf(addrs, count*sizeof(BtdrvAddress), (u32*)total_out, 145);
|
|
}
|
|
|
|
Result btdrvCloseAudioControlInput(BtdrvAddress addr) {
|
|
if (hosversionBefore(13,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInAddrNoOut(addr, 146);
|
|
}
|
|
|
|
Result btdrvRegisterAudioControlNotification(BtdrvAddress addr, u32 event_type) {
|
|
if (hosversionBefore(13,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInAddrU32NoOut(addr, event_type, 147);
|
|
}
|
|
|
|
Result btdrvSendAudioControlPassthroughCommand(BtdrvAddress addr, u32 op_id, u32 state_type) {
|
|
if (hosversionBefore(13,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInAddrU32U32NoOut(addr, op_id, state_type, 148);
|
|
}
|
|
|
|
Result btdrvSendAudioControlSetAbsoluteVolumeCommand(BtdrvAddress addr, s32 val) {
|
|
if (hosversionBefore(13,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdInAddrU32NoOut(addr, (u32)val, 149);
|
|
}
|
|
|
|
Result btdrvIsManufacturingMode(bool *out) {
|
|
if (hosversionBefore(5,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdNoInOutBool(out, 256);
|
|
}
|
|
|
|
Result btdrvEmulateBluetoothCrash(BtdrvFatalReason reason) {
|
|
if (hosversionBefore(7,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
u32 inval = reason;
|
|
return _btdrvCmdInU32NoOut(inval, 257);
|
|
}
|
|
|
|
Result btdrvGetBleChannelMap(BtdrvChannelMapList *out) {
|
|
if (hosversionBefore(9,0,0))
|
|
return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
|
|
|
|
return _btdrvCmdOutBufAliasFixed(out, sizeof(*out), 258);
|
|
}
|
|
|
|
// CircularBuffer
|
|
|
|
void* btdrvCircularBufferRead(BtdrvCircularBuffer *c) {
|
|
if (c==NULL || !c->initialized) return NULL;
|
|
|
|
do {
|
|
s32 read_offset = atomic_load_explicit(&c->read_offset, memory_order_acquire);
|
|
s32 write_offset = atomic_load_explicit(&c->write_offset, memory_order_acquire);
|
|
if (read_offset == write_offset) return NULL;
|
|
|
|
u8 *data_ptr = &c->data[read_offset];
|
|
if (read_offset >= sizeof(c->data)) return NULL;
|
|
|
|
if (*data_ptr != 0xFF) return data_ptr;
|
|
else {
|
|
if (!c->initialized) return NULL;
|
|
read_offset = atomic_load_explicit(&c->read_offset, memory_order_acquire);
|
|
write_offset = atomic_load_explicit(&c->write_offset, memory_order_acquire);
|
|
if (read_offset == write_offset) continue;
|
|
|
|
data_ptr = &c->data[read_offset];
|
|
u64 tmpsize = read_offset + 0x18;
|
|
if (tmpsize < sizeof(c->data)) tmpsize += *((u64*)&data_ptr[0x10]);
|
|
if (tmpsize >= sizeof(c->data)) tmpsize = 0;
|
|
atomic_store_explicit(&c->read_offset, tmpsize, memory_order_release);
|
|
}
|
|
} while (c->initialized);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool btdrvCircularBufferFree(BtdrvCircularBuffer *c) {
|
|
if (c==NULL || !c->initialized) return false;
|
|
|
|
s32 read_offset = atomic_load_explicit(&c->read_offset, memory_order_acquire);
|
|
s32 write_offset = atomic_load_explicit(&c->write_offset, memory_order_acquire);
|
|
if (read_offset == write_offset) return false;
|
|
|
|
u8 *data_ptr = &c->data[read_offset];
|
|
if (read_offset >= sizeof(c->data)) false;
|
|
|
|
u64 tmpsize = read_offset + 0x18;
|
|
if (tmpsize < sizeof(c->data)) tmpsize += *((u64*)&data_ptr[0x10]);
|
|
if (tmpsize >= sizeof(c->data)) tmpsize = 0;
|
|
atomic_store_explicit(&c->read_offset, tmpsize, memory_order_release);
|
|
|
|
return true;
|
|
}
|
|
|