type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
defines | #define QSPI_STD_CMD_READ_ID 0x9F /**< Read ID command*/
|
defines |
#define BD_PAGE_PROGRAM_SIZE 256 /**< Page program size (minimum block size)*/
|
defines |
#define BD_ERASE_UNIT_INVALID_ID 0xFFFFFFFF /**< Invalid erase unit number*/
|
defines | #define BD_ERASE_UNIT_ERASE_VAL 0xFFFFFFFF /**< Erased memory value*/
|
defines | #define BD_BLOCK_TO_ERASEUNIT(blk_id, blk_size) \
|
defines | #define BD_BLOCKS_PER_ERASEUNIT(blk_size) \
|
functions | void block_dev_qspi_read_from_eunit(nrf_block_dev_qspi_t const * p_qspi_dev)
{
nrf_block_dev_qspi_work_t const * p_work = p_qspi_dev->p_work;
/*In write-back mode data that we read might not be the same as in erase unit buffer*/
uint32_t eunit_start = BD_BLOCK_TO_ERASEUNIT(p_work->req.blk_id,
... |
functions | void qspi_handler(nrf_drv_qspi_evt_t event, void * p_context)
{
if (m_active_qspi_dev != p_context)
{
return;
} |
functions | void wait_for_idle(nrf_block_dev_qspi_t const * p_qspi_dev)
{
nrf_block_dev_qspi_work_t * p_work = p_qspi_dev->p_work;
while (p_work->state != NRF_BLOCK_DEV_QSPI_STATE_IDLE)
{
__WFI();
} |
functions | ret_code_t block_dev_qspi_init(nrf_block_dev_t const * p_blk_dev,
nrf_block_dev_ev_handler ev_handler,
void const * p_context)
{
ASSERT(p_blk_dev);
nrf_block_dev_qspi_t const * p_qspi_dev =
CONTA... |
functions | ret_code_t block_dev_qspi_uninit(nrf_block_dev_t const * p_blk_dev)
{
ASSERT(p_blk_dev);
nrf_block_dev_qspi_t const * p_qspi_dev =
CONTAINER_OF(p_blk_dev, nrf_block_dev_qspi_t, block_dev);
nrf_block_dev_qspi_work_t * p_work = p_qspi_dev->p_work;
if (m_active_qspi... |
functions | ret_code_t block_dev_qspi_read_req(nrf_block_dev_t const * p_blk_dev,
nrf_block_req_t const * p_blk)
{
ASSERT(p_blk_dev);
ASSERT(p_blk);
nrf_block_dev_qspi_t const * p_qspi_dev =
CONTAINER_OF(p_blk_dev, nrf_block_dev_qspi_t, bl... |
functions | bool block_dev_qspi_update_eunit(nrf_block_dev_qspi_t const * p_qspi_dev,
size_t off,
const void * p_src,
size_t len)
{
ASSERT((len % sizeof(uint32_t)) == 0)
nrf_block_dev_qspi_work_t * ... |
functions | ret_code_t block_dev_qspi_write_start(nrf_block_dev_qspi_t const * p_qspi_dev)
{
nrf_block_dev_qspi_work_t * p_work = p_qspi_dev->p_work;
if (!p_work->erase_required)
{
/*Get first block to program from program mask*/
uint32_t block_to_program = __CLZ(__RBIT(p_work->erase_unit_dirty... |
functions | ret_code_t block_dev_qspi_eunit_write(nrf_block_dev_qspi_t const * p_qspi_dev,
nrf_block_req_t * p_blk_left)
{
nrf_block_dev_qspi_work_t * p_work = p_qspi_dev->p_work;
size_t blk = p_blk_left->blk_id %
BD_BLOCKS_PER_ERASEUNIT(p_work->geometry... |
functions | ret_code_t block_dev_qspi_write_req(nrf_block_dev_t const * p_blk_dev,
nrf_block_req_t const * p_blk)
{
ASSERT(p_blk_dev);
ASSERT(p_blk);
nrf_block_dev_qspi_t const * p_qspi_dev =
CONTAINER_OF(p_blk_dev, nrf_block_dev_qspi_t, ... |
functions | ret_code_t block_dev_qspi_ioctl(nrf_block_dev_t const * p_blk_dev,
nrf_block_dev_ioctl_req_t req,
void * p_data)
{
ASSERT(p_blk_dev);
nrf_block_dev_qspi_t const * p_qspi_dev =
CONTAINER_OF(p_blk_... |
includes |
#include <stdio.h> |
includes | #include <string.h> |
includes | #include <stdbool.h> |
includes | #include <errno.h> |
defines |
#define MODESP_ESPCONN (1) |
defines |
#define MODESP_INCLUDE_CONSTANTS (1) |
functions | mp_obj_t esp_socket_make_new_base() {
esp_socket_obj_t *s = m_new_obj_with_finaliser(esp_socket_obj_t);
s->recvbuf = NULL;
s->base.type = (mp_obj_t)&esp_socket_type;
s->cb_connect = mp_const_none;
s->cb_recv = mp_const_none;
s->cb_disconnect = mp_const_none;
s->cb_sent = mp_const_none;
s... |
functions | mp_obj_t esp_socket_make_new(const mp_obj_type_t *type_in, mp_uint_t n_args,
mp_uint_t n_kw, const mp_obj_t *args) {
mp_arg_check_num(n_args, n_kw, 0, 4, false);
esp_socket_obj_t *s = esp_socket_make_new_base();
s->espconn = m_new_obj(struct espconn);
s->espconn->reverse = s;
// TODO: UDP Supp... |
functions | mp_obj_t esp_socket_close(mp_obj_t self_in) {
esp_socket_obj_t *s = self_in;
if (esp_socket_listening == s) {
esp_socket_listening = NULL;
} |
functions | mp_obj_t esp_socket___del__(mp_obj_t self_in) {
esp_socket_obj_t *s = self_in;
esp_socket_close(self_in);
if (s->fromserver) {
espconn_delete(s->espconn);
} |
functions | mp_obj_t esp_socket_bind(mp_obj_t self_in, mp_obj_t addr_in) {
esp_socket_obj_t *s = self_in;
mp_uint_t port = netutils_parse_inet_addr(addr_in,
s->espconn->proto.tcp->remote_ip, NETUTILS_BIG);
s->espconn->proto.tcp->local_port = port;
return mp_const_none;
} |
functions | void esp_socket_recv_callback(void *arg, char *pdata, unsigned short len) {
struct espconn *conn = arg;
esp_socket_obj_t *s = conn->reverse;
if (s->cb_recv != mp_const_none) {
call_function_2_protected(s->cb_recv, s, mp_obj_new_bytes((byte *)pdata, len));
} |
functions | void esp_socket_sent_callback(void *arg) {
struct espconn *conn = arg;
esp_socket_obj_t *s = conn->reverse;
if (s->cb_sent != mp_const_none) {
call_function_1_protected(s->cb_sent, s);
} |
functions | void esp_socket_disconnect_callback(void *arg) {
struct espconn *conn = arg;
esp_socket_obj_t *s = conn->reverse;
if (s->cb_disconnect != mp_const_none) {
call_function_1_protected(s->cb_disconnect, s);
} |
functions | void esp_socket_connect_callback_server(void *arg) {
struct espconn *conn = arg;
esp_socket_obj_t *s = esp_socket_make_new_base();
s->espconn = conn;
s->fromserver = true;
conn->reverse = s;
espconn_regist_recvcb(conn, esp_socket_recv_callback);
espconn_regist_sentcb(conn, esp_socket_sent_... |
functions | void esp_socket_connect_callback_client(void *arg) {
struct espconn *conn = arg;
esp_socket_obj_t *s = conn->reverse;
if (s->cb_connect != mp_const_none) {
call_function_1_protected(s->cb_connect, s);
} |
functions | mp_obj_t esp_socket_listen(mp_obj_t self_in, mp_obj_t backlog) {
esp_socket_obj_t *s = self_in;
if (esp_socket_listening != NULL) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"only one espconn can listen at a time"));
} |
functions | mp_obj_t esp_socket_accept(mp_obj_t self_in) {
esp_socket_obj_t *s = self_in;
if (s->connlist == NULL) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"not listening"));
} |
functions | mp_obj_t esp_socket_connect(mp_obj_t self_in, mp_obj_t addr_in) {
esp_socket_obj_t *s = self_in;
if (s->espconn == NULL || s->espconn->state != ESPCONN_NONE) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"transport endpoint is already connected or closed"));
} |
functions | mp_obj_t esp_socket_send(mp_obj_t self_in, mp_obj_t buf_in) {
esp_socket_obj_t *s = self_in;
if (s->espconn->state == ESPCONN_NONE || s->espconn->state == ESPCONN_CLOSE) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"not connected"));
} |
functions | mp_obj_t esp_socket_recv(mp_obj_t self_in, mp_obj_t len_in) {
esp_socket_obj_t *s = self_in;
if (s->recvbuf == NULL) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"no data available"));
} |
functions | mp_obj_t esp_socket_sendto(mp_obj_t self_in, mp_obj_t data_in, mp_obj_t addr_in) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "UDP not supported"));
return mp_const_none;
} |
functions | mp_obj_t esp_socket_recvfrom(mp_obj_t self_in, mp_obj_t len_in) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "UDP not supported"));
return mp_const_none;
} |
functions | mp_obj_t esp_socket_getpeername(mp_obj_t self_in) {
esp_socket_obj_t *s = self_in;
if (s->espconn->state == ESPCONN_NONE) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"not connected"));
} |
functions | mp_obj_t esp_socket_onconnect(mp_obj_t self_in, mp_obj_t lambda_in) {
esp_socket_obj_t *s = self_in;
s->cb_connect = lambda_in;
if (s->connlist != NULL) {
do {
mp_uint_t len;
mp_obj_t *items;
mp_obj_list_get(s->connlist, &len, &items);
if (len == 0) ... |
functions | mp_obj_t esp_socket_onrecv(mp_obj_t self_in, mp_obj_t lambda_in) {
esp_socket_obj_t *s = self_in;
s->cb_recv = lambda_in;
if (s->recvbuf != NULL) {
call_function_2_protected(s->cb_recv, s,
mp_obj_new_bytes((byte *)s->recvbuf, s->recvbuf_len));
s->recvbuf = NULL;
} |
functions | mp_obj_t esp_socket_onsent(mp_obj_t self_in, mp_obj_t lambda_in) {
esp_socket_obj_t *s = self_in;
s->cb_sent = lambda_in;
return mp_const_none;
} |
functions | mp_obj_t esp_socket_ondisconnect(mp_obj_t self_in, mp_obj_t lambda_in) {
esp_socket_obj_t *s = self_in;
s->cb_disconnect = lambda_in;
if (s->espconn->state == ESPCONN_CLOSE) {
call_function_1_protected(s->cb_disconnect, s);
} |
functions | void esp_getaddrinfo_cb(const char *name, ip_addr_t *ipaddr, void *arg) {
mp_obj_t namestr = mp_obj_new_str(name, strlen(name), true);
if (ipaddr != NULL) {
uint8_t ip[4];
ip[0] = (ipaddr->addr >> 24) & 0xff;
ip[1] = (ipaddr->addr >> 16) & 0xff;
ip[2] = (ipaddr->addr >> 8) & 0xf... |
functions | mp_obj_t esp_getaddrinfo(mp_obj_t host_in, mp_obj_t port_in,
mp_obj_t lambda_in) {
mp_uint_t hlen;
const char *host = mp_obj_str_get_data(host_in, &hlen);
ip_addr_t ipaddr;
esp_getaddrinfo_cb_struct.lambda = lambda_in;
esp_getaddrinfo_cb_struct.port = mp_obj_get_int(port_in);
err_t ret = e... |
functions | void error_check(bool status, const char *msg) {
if (!status) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, msg));
} |
functions | mp_obj_t esp_wifi_mode(mp_uint_t n_args, const mp_obj_t *args) {
if (n_args == 0) {
return mp_obj_new_int(wifi_get_opmode());
} |
functions | mp_obj_t esp_phy_mode(mp_uint_t n_args, const mp_obj_t *args) {
if (n_args == 0) {
return mp_obj_new_int(wifi_get_phy_mode());
} |
functions | mp_obj_t esp_sleep_type(mp_uint_t n_args, const mp_obj_t *args) {
if (n_args == 0) {
return mp_obj_new_int(wifi_get_sleep_type());
} |
functions | mp_obj_t esp_deepsleep(mp_uint_t n_args, const mp_obj_t *args) {
system_deep_sleep(n_args > 0 ? mp_obj_get_int(args[0]) : 0);
return mp_const_none;
} |
functions | mp_obj_t esp_flash_id() {
return mp_obj_new_int(spi_flash_get_id());
} |
functions | mp_obj_t esp_flash_read(mp_obj_t offset_in, mp_obj_t len_in) {
mp_int_t offset = mp_obj_get_int(offset_in);
mp_int_t len = mp_obj_get_int(len_in);
byte *buf = m_new(byte, len);
// We know that allocation will be 4-byte aligned for sure
SpiFlashOpResult res = spi_flash_read(offset, (uint32_t*)buf, le... |
functions | mp_obj_t esp_flash_write(mp_obj_t offset_in, const mp_obj_t buf_in) {
mp_int_t offset = mp_obj_get_int(offset_in);
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_READ);
SpiFlashOpResult res = spi_flash_write(offset, bufinfo.buf, bufinfo.len);
if (res == SPI_FLASH_RESULT_OK... |
functions | mp_obj_t esp_flash_erase(mp_obj_t sector_in) {
mp_int_t sector = mp_obj_get_int(sector_in);
SpiFlashOpResult res = spi_flash_erase_sector(sector);
if (res == SPI_FLASH_RESULT_OK) {
return mp_const_none;
} |
includes | #include <asn_internal.h> |
includes | #include <constr_SET_OF.h> |
includes | #include <asn_SET_OF.h> |
defines | #define LEFT ((size<(size_t)ctx->left)?size:(size_t)ctx->left) |
defines | #define SIZE_VIOLATION (ctx->left >= 0 && (size_t)ctx->left <= size) |
defines | #define ADVANCE(num_bytes) do { \ |
defines | #define NEXT_PHASE(ctx) do { \ |
defines | #define PHASE_OUT(ctx) do { ctx->phase = 10; } while(0) |
defines | #define RETURN(_code) do { \ |
defines | #define XER_ADVANCE(num_bytes) do { \ |
structs | struct _el_buffer {
uint8_t *buf;
size_t length;
size_t size;
}; |
functions | asn_dec_rval_t
SET_OF_decode_ber(Allocator * allocator, asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
void **struct_ptr, const void *ptr, size_t size, int tag_mode) {
/*
* Bring closer parts of structure description.
*/
asn_SET_OF_specifics_t *specs = (asn_SET_OF_specifics_t *)td->specifics;
asn_TY... |
functions | int _el_addbytes(Allocator * allocator, const void *buffer, size_t size, void *el_buf_ptr) {
struct _el_buffer *el_buf = (struct _el_buffer *)el_buf_ptr;
if(el_buf->length + size > el_buf->size)
return -1;
memcpy(el_buf->buf + el_buf->length, buffer, size);
el_buf->length += size;
return 0;
} |
functions | int _el_buf_cmp(const void *ap, const void *bp) {
const struct _el_buffer *a = (const struct _el_buffer *)ap;
const struct _el_buffer *b = (const struct _el_buffer *)bp;
int ret;
size_t common_len;
if(a->length < b->length)
common_len = a->length;
else
common_len = b->length;
ret = memcmp(a->buf, b->buf, c... |
functions | asn_enc_rval_t
SET_OF_encode_der(Allocator * allocator, asn_TYPE_descriptor_t *td, void *ptr,
int tag_mode, ber_tlv_tag_t tag,
asn_app_consume_bytes_f *cb, void *app_key) {
asn_TYPE_member_t *elm = td->elements;
asn_TYPE_descriptor_t *elm_type = elm->type;
der_type_encoder_f *der_encoder = elm_type->der_encoder;
... |
functions | asn_dec_rval_t
SET_OF_decode_xer(Allocator * allocator, asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
void **struct_ptr, const char *opt_mname,
const void *buf_ptr, size_t size) {
/*
* Bring closer parts of structure description.
*/
asn_SET_OF_specifics_t *specs = (asn_SET_OF_specifics_t *)td->spe... |
functions | int
SET_OF_encode_xer_callback(Allocator * allocator,const void *buffer, size_t size, void *key) {
xer_tmp_enc_t *t = (xer_tmp_enc_t *)key;
if(t->offset + size >= t->size) {
size_t newsize = (t->size << 2) + size;
void *p = CXX_ALLOC_WRAP REALLOC(t->buffer, t->size, newsize);
if(!p) return -1;
t->buffer = p;
... |
functions | int
SET_OF_xer_order(const void *aptr, const void *bptr) {
const xer_tmp_enc_t *a = (const xer_tmp_enc_t *)aptr;
const xer_tmp_enc_t *b = (const xer_tmp_enc_t *)bptr;
size_t minlen = a->offset;
int ret;
if(b->offset < minlen) minlen = b->offset;
/* Well-formed UTF-8 has this nice lexicographical property... */
r... |
functions | asn_enc_rval_t
SET_OF_encode_xer(Allocator * allocator, asn_TYPE_descriptor_t *td, void *sptr,
int ilevel, enum xer_encoder_flags_e flags,
asn_app_consume_bytes_f *cb, void *app_key) {
asn_enc_rval_t er;
asn_SET_OF_specifics_t *specs = (asn_SET_OF_specifics_t *)td->specifics;
asn_TYPE_member_t *elm = td->elements... |
functions | int
SET_OF_print(Allocator * allocator, asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
asn_app_consume_bytes_f *cb, void *app_key) {
asn_TYPE_member_t *elm = td->elements;
const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);
int ret;
int i;
if(!sptr) return (cb(allocator, "<absent>", 8, app_key) ... |
functions | void
SET_OF_free(Allocator * allocator, asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
if(td && ptr) {
asn_SET_OF_specifics_t *specs;
asn_TYPE_member_t *elm = td->elements;
asn_anonymous_set_ *list = _A_SET_FROM_VOID(ptr);
asn_struct_ctx_t *ctx; /* Decoder context */
int i;
/*
* Could not u... |
functions | int
SET_OF_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
asn_TYPE_member_t *elm = td->elements;
asn_constr_check_f *constr;
const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);
int i;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
"%s: valu... |
functions | asn_dec_rval_t
SET_OF_decode_uper(Allocator * allocator, asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
asn_dec_rval_t rv;
asn_SET_OF_specifics_t *specs = (asn_SET_OF_specifics_t *)td->specifics;
asn_TYPE_member_t *elm ... |
includes |
#include <windows.h> |
includes |
#include <stdio.h> |
includes | #include <stdarg.h> |
includes | #include <conio.h> |
includes | #include <fcntl.h> |
functions | int serial_init(const char *port, unsigned long baud)
{
char fullPort[20];
DCB state;
sprintf(fullPort, "\\\\.\\%s", port);
hSerial = CreateFile(
fullPort,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
0,
NULL);
if (h... |
functions | void serial_done(void)
{
FlushFileBuffers(hSerial);
CloseHandle(hSerial);
} |
functions | int tx(uint8_t* buff, int n)
{
DWORD dwBytes = 0;
if(!WriteFile(hSerial, buff, n, &dwBytes, NULL)){
printf("Error writing port\n");
ShowLastError();
return 0;
} |
functions | int rx(uint8_t* buff, int n)
{
DWORD dwBytes = 0;
SetCommTimeouts(hSerial, &original_timeouts);
if(!ReadFile(hSerial, buff, n, &dwBytes, NULL)){
printf("Error reading port\n");
ShowLastError();
return 0;
} |
functions | int rx_timeout(uint8_t* buff, int n, int timeout)
{
DWORD dwBytes = 0;
timeouts.ReadTotalTimeoutConstant = timeout;
SetCommTimeouts(hSerial, &timeouts);
if(!ReadFile(hSerial, buff, n, &dwBytes, NULL)){
printf("Error reading port\n");
ShowLastError();
return 0;
} |
functions | void hwreset(void)
{
EscapeCommFunction(hSerial, SETDTR);
Sleep(100);
EscapeCommFunction(hSerial, CLRDTR);
Sleep(50);
/* Purge here after reset to get rid of buffered data. Prevents "Lost HW Contact 0 f9" */
PurgeComm(hSerial, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR)... |
functions | long getms()
{
LARGE_INTEGER ticksPerSecond;
LARGE_INTEGER tick; // A point in time
LARGE_INTEGER time; // For converting tick into real time
// get the high resolution counter's accuracy
QueryPerformanceFrequency(&ticksPerSecond);
if(ticksPerSecond.QuadPart < 1000) {
printf(... |
functions | void msleep(int ms)
{
unsigned long t = getms();
while((t+ms+10) > getms())
;
} |
functions | void ShowLastError(void)
{
LPVOID lpMsgBuf;
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR)&lpMsgBuf,
... |
functions | int console_kbhit(void)
{
return _kbhit();
} |
functions | int console_getch(void)
{
return _getch();
} |
functions | void console_putch(int ch)
{
_putch(ch);
} |
functions | uint8_t USBD_CUSTOM_HID_Init (USBD_HandleTypeDef *pdev,
uint8_t cfgidx)
{
uint8_t ret = 0;
USBD_CUSTOM_HID_HandleTypeDef *hhid;
/* Open EP IN */
USBD_LL_OpenEP(pdev,
CUSTOM_HID_EPIN_ADDR,
USBD_EP_TYPE_INTR,
CUSTOM_HID_EPIN_S... |
functions | uint8_t USBD_CUSTOM_HID_DeInit (USBD_HandleTypeDef *pdev,
uint8_t cfgidx)
{
/* Close CUSTOM_HID EP IN */
USBD_LL_CloseEP(pdev,
CUSTOM_HID_EPIN_ADDR);
/* Close CUSTOM_HID EP OUT */
USBD_LL_CloseEP(pdev,
CUSTOM_HID_EPOUT_ADDR);
/* FRee... |
functions | uint8_t USBD_CUSTOM_HID_Setup (USBD_HandleTypeDef *pdev,
USBD_SetupReqTypedef *req)
{
uint16_t len = 0;
uint8_t *pbuf = NULL;
USBD_CUSTOM_HID_HandleTypeDef *hhid = (USBD_CUSTOM_HID_HandleTypeDef*)pdev->pClassData;
switch (req->bmRequest & USB_REQ_TYPE_MASK)
{
case USB... |
functions | else if( req->wValue >> 8 == CUSTOM_HID_DESCRIPTOR_TYPE)
{
pbuf = USBD_CUSTOM_HID_Desc;
len = MIN(USB_CUSTOM_HID_DESC_SIZ , req->wLength);
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.