diff options
| -rw-r--r-- | Android.mk | 69 | ||||
| -rw-r--r-- | adnc_strm.c | 492 | ||||
| -rw-r--r-- | adnc_strm.h | 20 | ||||
| -rw-r--r-- | cvq_ioctl.h | 149 | ||||
| -rw-r--r-- | cvq_util.c | 588 | ||||
| -rw-r--r-- | ia_constants.h | 375 | ||||
| -rw-r--r-- | iaxxx-odsp.h | 88 | ||||
| -rw-r--r-- | iaxxx-sysid-defs.h | 251 | ||||
| -rw-r--r-- | iaxxx-system-identifiers.h | 342 | ||||
| -rw-r--r-- | iaxxx-systemids.h | 1823 | ||||
| -rw-r--r-- | iaxxx-tunnel-intf.h | 82 | ||||
| -rw-r--r-- | sound_trigger_hw_iaxxx.c | 1096 | ||||
| -rwxr-xr-x | tests/conversion_routines.c | 71 | ||||
| -rwxr-xr-x | tests/conversion_routines.h | 13 | ||||
| -rw-r--r-- | tests/tunnel_test.c | 606 | ||||
| -rw-r--r-- | tunnel.c | 127 | ||||
| -rw-r--r-- | tunnel.h | 75 |
17 files changed, 6267 insertions, 0 deletions
diff --git a/Android.mk b/Android.mk new file mode 100644 index 0000000..61e4125 --- /dev/null +++ b/Android.mk @@ -0,0 +1,69 @@ +# Copyright (C) 2014 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_MODULE := sound_trigger.primary.msmnile +LOCAL_MODULE_RELATIVE_PATH := hw +LOCAL_SRC_FILES := sound_trigger_hw_iaxxx.c cvq_util.c +LOCAL_VENDOR_MODULE := true +LOCAL_C_INCLUDES += external/tinyalsa/include $(call include-path-for, audio-route) + +LOCAL_HEADER_LIBRARIES := libhardware_headers + +LOCAL_SHARED_LIBRARIES := liblog libcutils libtinyalsa +LOCAL_MODULE_TAGS := optional +ifneq (,$(findstring $(PLATFORM_VERSION), P)) +LOCAL_PROPRIETARY_MODULE := true +LOCAL_CFLAGS += -DANDROID_P +endif + +include $(BUILD_SHARED_LIBRARY) + +include $(CLEAR_VARS) + +LOCAL_MODULE := adnc_strm.primary.default +LOCAL_MODULE_RELATIVE_PATH := hw +LOCAL_VENDOR_MODULE := true +LOCAL_SRC_FILES := adnc_strm.c +LOCAL_SHARED_LIBRARIES := liblog libcutils libtinyalsa libtunnel +LOCAL_MODULE_TAGS := optional +ifneq (,$(findstring $(PLATFORM_VERSION), P)) +LOCAL_PROPRIETARY_MODULE := true +endif + +include $(BUILD_SHARED_LIBRARY) + +include $(CLEAR_VARS) +LOCAL_MODULE := libtunnel +LOCAL_VENDOR_MODULE := true +LOCAL_SRC_FILES := tunnel.c + +LOCAL_SHARED_LIBRARIES := liblog libcutils + +include $(BUILD_SHARED_LIBRARY) + + +include $(CLEAR_VARS) + +LOCAL_PRELINK_MODULE := false +LOCAL_MODULE := tunneling_hal_test +LOCAL_VENDOR_MODULE := true +LOCAL_SRC_FILES := ./tests/tunnel_test.c \ + ./tests/conversion_routines.c +LOCAL_32_BIT_ONLY := true +LOCAL_SHARED_LIBRARIES := liblog libcutils libtunnel +include $(BUILD_EXECUTABLE) diff --git a/adnc_strm.c b/adnc_strm.c new file mode 100644 index 0000000..83b5a3c --- /dev/null +++ b/adnc_strm.c @@ -0,0 +1,492 @@ +#include <stdio.h> +#include <stdint.h> +#include <stdlib.h> +#include <stdbool.h> +#include <string.h> +#include <math.h> +#include <errno.h> + +#define LOG_TAG "SoundTriggerKnowles_HAL_adnc" +//#define LOG_NDEBUG 0 +//#define LOG_NDDEBUG 0 + +#include <cutils/log.h> +#include "iaxxx-system-identifiers.h" +#include "adnc_strm.h" +#include "tunnel.h" + +#define MAX_TUNNELS (32) +#define BUF_SIZE (8192) +#define CVQ_ENDPOINT (IAXXX_SYSID_PLUGIN_1_OUT_EP_0) +#define CVQ_TUNNEL_ID (1) +#define TNL_Q15 (0xF) + +#define UNPARSED_OUTPUT_FILE "/data/data/unparsed_output" +// By defining this macros, dumps will be enabled at key points to help in debugging +//#define ENABLE_DEBUG_DUMPS + +struct raf_format_type { + uint16_t frameSizeInBytes; /* Frame length in bytes */ + uint8_t encoding; /* Encoding */ + uint8_t sampleRate; /* Sample rate */ +}; + +struct raf_frame_type { + uint64_t timeStamp; /* Timestamp of the frame */ + uint32_t seqNo; /* Optional sequence number of the frame */ + + struct raf_format_type format; /* Format information for the frame */ + uint32_t data[0]; /* Start of the variable size payload. + It must start at 128 bit aligned address for all the frames */ +}; + +struct adnc_strm_device { + struct ia_tunneling_hal *tun_hdl; + int end_point; + int idx; + int mode; + int encode; + + bool enable_stripping; + unsigned int kw_start_frame; + + void *pcm_buf; + int pcm_buf_size; + int pcm_avail_size; + int pcm_read_offset; + + void *unparsed_buf; + int unparsed_buf_size; + int unparsed_avail_size; + +#ifdef DUMP_UNPARSED_OUTPUT + FILE *dump_file; +#endif +}; + +static void kst_split_aft( + uint32_t *pAfloat, + int32_t *exp, + int64_t *mant, + int32_t *sign) +{ + uint32_t uAft = *pAfloat; + + *exp = (uAft >> 25) & 0x3F; + *mant = uAft & 0x1FFFFFF; + *sign = uAft >> 31; + if (*exp || *mant) + { + *mant |= 1 << 25; + } +} + +static void kst_aft_to_dbl( + void *pDouble, + void *pAfloat) +{ + uint64_t uDbl; + int32_t exp; + int32_t sign; + int64_t mant; + + kst_split_aft((uint32_t *)pAfloat, &exp, &mant, &sign); + if (exp || mant) + { + uDbl = ((uint64_t)sign << 63) | + ((uint64_t)(exp + (1023 - (1 << 5))) << 52) | + ((uint64_t)(mant & ((1 << 25) - 1)) << (52 - 25)); + } + else + { + uDbl = (uint64_t)sign << 63; + } + *((uint64_t *)pDouble) = uDbl; +} + +void kst_float_to_q15_vector( + void *pDst, + void *pSrc, + uint32_t elCnt) +{ + uint32_t *pSrcT; + int16_t *pDstT; + uint32_t idx; + double smp; + + pSrcT = (uint32_t *)pSrc; + pDstT = (int16_t *)pDst; + for (idx = 0; idx<elCnt; idx++) + { + kst_aft_to_dbl(&smp, &(pSrcT[idx])); + smp = smp * 32768.0; + pDstT[idx] = ((smp < 32767.0) ? ((smp > -32768.0) ? ((int16_t)smp) : -32768) : 32767); + } +} + +void parse_audio_tunnel_data(unsigned char *buf_itr, unsigned char *pcm_buf_itr, int frame_sz_in_bytes, + bool is_q15_conversion_required) +{ + //char q16_buf[BUF_SIZE]; // This can be smaller but by how much? + int frameSizeInWords = (frame_sz_in_bytes + 3) >> 2; + + if (NULL == buf_itr || NULL == pcm_buf_itr) { + ALOGE("%s: Buffer is NULL", __func__); + return; + } + + if (true == is_q15_conversion_required) { + kst_float_to_q15_vector(pcm_buf_itr, buf_itr, frameSizeInWords); + } else { + memcpy(pcm_buf_itr, buf_itr, frame_sz_in_bytes); + } +#ifdef ENABLE_DEBUG_DUMPS + out_fp = fopen("/data/data/com.audience.voiceqmultikeyword/files/pcm_dump", "ab"); + if (out_fp) { + ALOGE("Dumping to pcm_dump"); + fwrite(pcm_buf_itr, (frameSizeInWords * 2), 1, out_fp); + fflush(out_fp); + fclose(out_fp); + } else { + ALOGE("Failed to open the out_fp file %s", strerror(errno)); + ALOGE("out_fp is NULL"); + } +#endif +} + +static int parse_tunnel_buf(struct adnc_strm_device *adnc_strm_dev) +{ + // The magic number is ROME in ASCII reversed. So we are looking for EMOR in the byte stream + const unsigned char magic_num[4] = {0x45, 0x4D, 0x4F, 0x52}; + unsigned short int tunnel_id; + unsigned char *start_frame = NULL; + bool valid_frame = true; + unsigned char *buf_itr = adnc_strm_dev->unparsed_buf; + // Minimum bytes required is the magic number + tunnel id + reserved and crc + raf struct + int min_bytes_req = 4 + 2 + 6 + sizeof(struct raf_frame_type); + int bytes_avail = adnc_strm_dev->unparsed_avail_size; + unsigned char *pcm_buf_itr = NULL; + int curr_pcm_frame_size; + bool is_q15_conversion_required = false; + + if (NULL == buf_itr) { + ALOGE("Invalid input sent to parse_tunnel_buf"); + return 0; + } + + do { + // Check for MagicNumber 0x454D4F52 + while (buf_itr[0] != magic_num[0] || buf_itr[1] != magic_num[1] || + buf_itr[2] != magic_num[2] || buf_itr[3] != magic_num[3]) { + buf_itr++; + bytes_avail--; + if (bytes_avail <= 0) { + ALOGE("Could not find the magic number, reading again"); + ALOGE("buf_itr[0] %x buf_itr[1] %x buf_itr[2] %x buf_itr[3] %x ", + buf_itr[0], buf_itr[1], buf_itr[2], buf_itr[3]); + return 0; + } + } + + start_frame = buf_itr; + + // Skip the magic number + buf_itr += 4; + bytes_avail -= 4; + + // Read the tunnelID + tunnel_id = ((unsigned char) (buf_itr[0]) | + (unsigned char) (buf_itr[1]) << 8); + + // Skip tunnelID + buf_itr += 2; + bytes_avail -= 2; + + // Skip Reserved field and CRC - 6 bytes in total + buf_itr += 6; + bytes_avail -= 6; + + valid_frame = true; + // There is only one tunnel data we are looking + if (tunnel_id > MAX_TUNNELS ) { + ALOGE("Invalid tunnel id %d\n", tunnel_id); + valid_frame = false; + } + + struct raf_frame_type rft; + memcpy(&rft, buf_itr, sizeof(struct raf_frame_type)); + + bool skip_extra_data = false; + if (true == adnc_strm_dev->enable_stripping && rft.seqNo < adnc_strm_dev->kw_start_frame) { + skip_extra_data = true; + } + + // 1 indicates that it is afloat encoding and F indicates it is in q15 encoding + if (1 == rft.format.encoding) { + is_q15_conversion_required = true; + curr_pcm_frame_size = rft.format.frameSizeInBytes / 2; + } else { + is_q15_conversion_required = false; + curr_pcm_frame_size = rft.format.frameSizeInBytes; + } + + // Skip the raf_frame_type + buf_itr += sizeof(struct raf_frame_type); + bytes_avail -= sizeof(struct raf_frame_type); + + if (bytes_avail < rft.format.frameSizeInBytes) { + ALOGD("Incomplete frame received bytes_avail %d framesize %d", bytes_avail, rft.format.frameSizeInBytes); + bytes_avail += min_bytes_req; + break; + } + + if (true == valid_frame && false == skip_extra_data) { + if ((adnc_strm_dev->pcm_avail_size + curr_pcm_frame_size) < adnc_strm_dev->pcm_buf_size) { + pcm_buf_itr = (unsigned char*) adnc_strm_dev->pcm_buf + adnc_strm_dev->pcm_avail_size; + parse_audio_tunnel_data(buf_itr, pcm_buf_itr, rft.format.frameSizeInBytes, is_q15_conversion_required); + adnc_strm_dev->pcm_avail_size += curr_pcm_frame_size; + } else { + ALOGD("Not enough PCM buffer available break now"); + bytes_avail += min_bytes_req; + break; + } + } + + // Skip the data + buf_itr += rft.format.frameSizeInBytes; + bytes_avail -= rft.format.frameSizeInBytes; + } while (bytes_avail > min_bytes_req); + + return bytes_avail; +} + + +__attribute__ ((visibility ("default"))) +size_t adnc_strm_read(long handle, void *buffer, size_t bytes) +{ + int ret = 0; + struct adnc_strm_device *adnc_strm_dev = (struct adnc_strm_device *) handle; + int bytes_read, bytes_rem; + + if (NULL == adnc_strm_dev) { + ALOGE("Invalid handle"); + ret = 0; + goto exit; + } + + if (bytes > adnc_strm_dev->pcm_avail_size) { + // We don't have enough PCM data, read more from the device. + // First copy the remainder of the PCM buffer to the front of the PCM buffer + if (0 != adnc_strm_dev->pcm_avail_size) { + ALOGD("Copying to the front of the buffer pcm_avail_size %d pcm_read_offset %d", adnc_strm_dev->pcm_avail_size, adnc_strm_dev->pcm_read_offset); + memcpy(adnc_strm_dev->pcm_buf, + ((unsigned char*)adnc_strm_dev->pcm_buf + adnc_strm_dev->pcm_read_offset), + adnc_strm_dev->pcm_avail_size); + } + // Always read from the start of the PCM buffer at this point of time + adnc_strm_dev->pcm_read_offset = 0; + +read_again: + // Read data from the kernel, account for the leftover data from previous run + bytes_read = ia_read_tunnel_data(adnc_strm_dev->tun_hdl, + (void *)((unsigned char *)adnc_strm_dev->unparsed_buf + adnc_strm_dev->unparsed_avail_size), + BUF_SIZE); + if (bytes_read <= 0) { + ALOGE("Failed to read data from tunnel"); + ret = 0; // TODO should we try to read a couple of times? + goto exit; + } + + // Parse the data to get PCM data + adnc_strm_dev->unparsed_avail_size += bytes_read; + bytes_rem = parse_tunnel_buf(adnc_strm_dev); + +#ifdef ENABLE_DEBUG_DUMPS + if (0 != adnc_strm_dev->pcm_avail_size) { + FILE *out_fp = fopen("/data/data/com.audience.voiceqmultikeyword/files/pcm_dump2", "ab"); + if (out_fp) { + ALOGE("Dumping to pcm_dump2"); + fwrite(((unsigned char*) adnc_strm_dev->pcm_buf + adnc_strm_dev->pcm_avail_size), adnc_strm_dev->pcm_avail_size, 1, out_fp); + fflush(out_fp); + fclose(out_fp); + } else { + ALOGE("Failed to open the pcm_dump2 file %s", strerror(errno)); + } + } +#endif + + // Copy the left over unparsed data to the front of the buffer + if (0 != bytes_rem) { + int offset = adnc_strm_dev->unparsed_avail_size - bytes_rem; + memcpy(adnc_strm_dev->unparsed_buf, + ((unsigned char*)adnc_strm_dev->unparsed_buf + offset), + bytes_rem); + } + adnc_strm_dev->unparsed_avail_size = bytes_rem; + + // If stripping is enabled then we didn't read anything to the pcm buffer so read again + // or if we still don't have enough bytes then read data again. + if (adnc_strm_dev->pcm_avail_size <= 0 || + adnc_strm_dev->pcm_avail_size < bytes) { + ALOGD("Calling read_again pcm_avail_size %d pcm_read_offset %d", adnc_strm_dev->pcm_avail_size, adnc_strm_dev->pcm_read_offset); + goto read_again; + } + } + + // Copy the PCM data to output buffer and return + memcpy(buffer, + ((unsigned char *)adnc_strm_dev->pcm_buf + adnc_strm_dev->pcm_read_offset), + bytes); + +#ifdef ENABLE_DEBUG_DUMPS + FILE *out_fp = fopen("/data/data/com.audience.voiceqmultikeyword/files/adnc_dump", "ab"); + if (out_fp) { + ALOGE("Dumping to adnc_dump"); + fwrite(buffer, bytes, 1, out_fp); + fflush(out_fp); + fclose(out_fp); + } else { + ALOGE("Failed to open the adnc_dump file %s", strerror(errno)); + } +#endif + + adnc_strm_dev->pcm_avail_size -= bytes; + adnc_strm_dev->pcm_read_offset += bytes; + +exit: + return bytes; +} + + +__attribute__ ((visibility ("default"))) +long adnc_strm_open(bool enable_stripping, unsigned int kw_start_frame) +{ + int ret = 0, err; + struct adnc_strm_device *adnc_strm_dev = NULL; + + adnc_strm_dev = (struct adnc_strm_device *) malloc(sizeof(struct adnc_strm_device)); + if (NULL == adnc_strm_dev) { + ALOGE("Failed to allocate memory for adnc_strm_dev"); + ret = 0; + goto exit_on_error; + } + + adnc_strm_dev->end_point = CVQ_ENDPOINT; + adnc_strm_dev->idx = 0; + adnc_strm_dev->mode = 0; + adnc_strm_dev->encode = TNL_Q15; + adnc_strm_dev->enable_stripping = enable_stripping; + adnc_strm_dev->kw_start_frame = kw_start_frame; + adnc_strm_dev->tun_hdl = NULL; + adnc_strm_dev->pcm_buf = NULL; + adnc_strm_dev->unparsed_buf = NULL; + + adnc_strm_dev->tun_hdl = ia_start_tunneling(640); + if (NULL == adnc_strm_dev->tun_hdl) { + ALOGE("Failed to start tunneling"); + ret = 0; + goto exit_on_error; + } + + ret = ia_enable_tunneling_source(adnc_strm_dev->tun_hdl, + adnc_strm_dev->end_point, + adnc_strm_dev->mode, + adnc_strm_dev->encode); + if (0 != ret) { + ALOGE("Failed to enable tunneling for CVQ tunl_id %u src_id %u mode %u", + adnc_strm_dev->idx, adnc_strm_dev->end_point, adnc_strm_dev->mode); + ret = 0; + goto exit_on_error; + } + + adnc_strm_dev->unparsed_buf_size = BUF_SIZE * 2; + adnc_strm_dev->unparsed_avail_size = 0; + adnc_strm_dev->unparsed_buf = malloc(adnc_strm_dev->unparsed_buf_size); + if (NULL == adnc_strm_dev->unparsed_buf) { + ret = 0; + ALOGE("Failed to allocate memory for unparsed buffer"); + goto exit_on_error; + } + + adnc_strm_dev->pcm_buf_size = BUF_SIZE * 2; + adnc_strm_dev->pcm_avail_size = 0; + adnc_strm_dev->pcm_read_offset = 0; + adnc_strm_dev->pcm_buf = malloc(adnc_strm_dev->pcm_buf_size); + if (NULL == adnc_strm_dev->pcm_buf) { + ret = 0; + ALOGE("Failed to allocate memory for pcm buffer"); + goto exit_on_error; + } + + return (long)adnc_strm_dev; + +exit_on_error: + if (adnc_strm_dev->pcm_buf) { + free(adnc_strm_dev->pcm_buf); + } + + if (adnc_strm_dev->unparsed_buf) { + free(adnc_strm_dev->unparsed_buf); + } + + err = ia_disable_tunneling_source(adnc_strm_dev->tun_hdl, + adnc_strm_dev->end_point, + adnc_strm_dev->mode, + adnc_strm_dev->encode); + if (0 != err) { + ALOGE("Failed to disable the tunneling source"); + } + + err = ia_stop_tunneling(adnc_strm_dev->tun_hdl); + if (0 != err) { + ALOGE("Failed to stop tunneling"); + } + + if (adnc_strm_dev) { + free(adnc_strm_dev); + } + + return ret; +} + +__attribute__ ((visibility ("default"))) +int adnc_strm_close(long handle) +{ + int ret = 0; + struct adnc_strm_device *adnc_strm_dev = (struct adnc_strm_device *)handle; + + if (NULL == adnc_strm_dev) { + ALOGE("Invalid handle"); + ret = -1; + goto exit; + } + + if (adnc_strm_dev->pcm_buf) { + free(adnc_strm_dev->pcm_buf); + } + + if (adnc_strm_dev->unparsed_buf) { + free(adnc_strm_dev->unparsed_buf); + } + + ret = ia_disable_tunneling_source(adnc_strm_dev->tun_hdl, + adnc_strm_dev->end_point, + adnc_strm_dev->mode, + adnc_strm_dev->encode); + if (0 != ret) { + ALOGE("Failed to disable the tunneling source"); + } + + ret = ia_stop_tunneling(adnc_strm_dev->tun_hdl); + if (0 != ret) { + ALOGE("Failed to stop tunneling"); + } + + if (adnc_strm_dev) { + free(adnc_strm_dev); + } + +exit: + return ret; +} + diff --git a/adnc_strm.h b/adnc_strm.h new file mode 100644 index 0000000..e3da181 --- /dev/null +++ b/adnc_strm.h @@ -0,0 +1,20 @@ +// Audience CVQ implementation + +#ifndef ADNC_STRM_H +#define ADNC_STRM_H + +#include <stdio.h> +#include <pthread.h> + +#ifdef __cplusplus +extern "C" { +#endif + +#define DUMP_UNPARSED_OUTPUT + +#ifdef __cplusplus +} +#endif + + +#endif diff --git a/cvq_ioctl.h b/cvq_ioctl.h new file mode 100644 index 0000000..d6cfc11 --- /dev/null +++ b/cvq_ioctl.h @@ -0,0 +1,149 @@ +#ifndef _CVQ_IOCTL_H +#define _CVQ_IOCTL_H + +/* KW model files info */ +#define IA_INIT_PARAMS _IO('T', 0x011) +#define IA_CVQ_START _IO('T', 0x012) +#define IA_LOAD_KEYWORDS _IO('T', 0x013) +#define IA_UNLOAD_KEYWORDS _IO('T', 0x014) +#define IA_CVQ_STOP _IO('T', 0x015) +#define IA_GET_KW_ID _IO('T', 0x016) +#define IA_IS_PERFMODE _IO('T', 0x017) + +/* Voice Id has two models, hence total models is 4 (1 OEM + 1 VoiceId + 1 user) +*/ +#define MAX_KW_MODELS 5 + +struct ia_kw_priv { + uint64_t kw_buff_addr; + + /* Actual length in bytes after adding wdb headers and padding bytes */ + uint32_t kw_size; + /* Length in bytes without the padding bytes and the wdb headers */ + uint32_t wdb_size; + +}; + +struct ia_kw_info { + struct ia_kw_priv kw[MAX_KW_MODELS]; + uint32_t kw_count; +}; + +enum ia_cvq_rate { + IA_8KHZ = 0, + IA_16KHZ = 1, + IA_24KHZ = 2, + IA_48KHZ = 4, +}; + +enum ia_vq_mode { + IA_VS_MODE = 0, + IA_CVQ_MODE, +}; + +enum ia_kw_preserve { + IA_IGNORE_KW = 0, + IA_PRESERVE_KW, +}; + +enum ia_format { + IA_FORMAT_Q11 = 1, + IA_FORMAT_Q15 = 2, +}; + +enum ia_frame_size { + IA_1MS_FRAME = 1, + IA_2MS_FRAME = 2, + IA_8MS_FRAME = 8, + IA_10MS_FRAME = 10, + IA_15MS_FRAME = 15, + IA_16MS_FRAME = 16, +}; + +enum ia_vad_mode { + IA_NO_VAD = 0, + IA_MIC_VAD, +}; + +struct ia_cvq_params { + uint8_t rate; + uint8_t mode; + uint8_t format; + uint8_t frame_size; + uint8_t kw_preserve; + uint8_t vad; + uint8_t preset; +}; + +typedef enum _ia_perf_mode_e { + IA_NON_PERF_MODE = 0, + IA_I2S_PERF_MODE, +}ia_perf_mode_e; + +static inline bool isvalid_frame_size(uint8_t frame_size) +{ + bool valid = false; + switch (frame_size) { + case IA_1MS_FRAME: + case IA_2MS_FRAME: + case IA_8MS_FRAME: + case IA_10MS_FRAME: + case IA_15MS_FRAME: + case IA_16MS_FRAME: + valid = true; + break; + } + + return valid; +} + +static inline bool isvalid_rate(uint8_t rate) +{ + bool valid = false; + switch (rate) { + case IA_8KHZ: + case IA_16KHZ: + case IA_24KHZ: + case IA_48KHZ: + valid = true; + break; + } + + return valid; +} + +static inline bool isvalid_format(uint8_t format) +{ + if (format != IA_FORMAT_Q11 && format != IA_FORMAT_Q15) + return false; + return true; +} + +static inline bool isvalid_mode(uint8_t mode) +{ + if (mode != IA_VS_MODE && mode != IA_CVQ_MODE) + return false; + + return true; +} + +static inline bool isvalid_kw_option(uint8_t option) +{ + if (option != IA_IGNORE_KW && option != IA_PRESERVE_KW) + return false; + + return true; +} + +int start_cvq(void); +int stop_cvq(void); +int init_params(); +int write_model(unsigned char *data, int length); +int flush_model(void); +int get_event(struct iaxxx_get_event *ge); +int unload_all_models(); +int setup_mic_routes(); +int enable_mic_route(int enable); +int set_sensor_route(bool enable); + +#endif /* _CVQ_IOCTL_H */ diff --git a/cvq_util.c b/cvq_util.c new file mode 100644 index 0000000..b3ecdaf --- /dev/null +++ b/cvq_util.c @@ -0,0 +1,588 @@ +#define LOG_TAG "SoundTriggerKnowles_HAL_util" +#define LOG_NDEBUG 0 + +#include <stdio.h> +#include <stdint.h> +#include <stdlib.h> +#include <stdbool.h> +#include <string.h> +#include <signal.h> +#include <sys/stat.h> +#include <cutils/log.h> + +#include <errno.h> +#include <linux/errno.h> +#include <sys/ioctl.h> +#include <tinyalsa/asoundlib.h> + +#include "iaxxx-odsp.h" +#include "iaxxx-system-identifiers.h" +#include "cvq_ioctl.h" +#include "ia_constants.h" + +#define CVQ_NODE "/dev/iaxxx-odsp-celldrv" + +static FILE *cvq_node; + +#define PLUGIN_SRC_ID 0x303F +#define PLUGIN3_SRC_ID 0x30FF + +#define DSP_VQ_PROCESS_MODE (0) +#define DSP_VQ_RESET (4) + +#define CARD_NUM (0) +#define DEV_NODE "/dev/iaxxx-odsp-celldrv" +#define BUFFER_PACKAGE "audience/iaxxx/BufferPackage.bin" +#define BUFFER_CONFIG_VAL "audience/iaxxx/BufferConfigVal.bin" +#define BUFFER_CONFIG_OSLO_VAL "audience/iaxxx/BufferConfigValOslo.bin" +#define OK_GOOGLE_PACKAGE "audience/iaxxx/OkGooglePackage.bin" +#define SENSOR_PACKAGE "audience/iaxxx/DummySensorPackage.bin" + +int start_cvq(void) +{ + ALOGE("%s: Entering", __func__); + int err = 0; + struct iaxxx_plugin_param pp; + int kw_id = 0; + + ALOGI("Setting PROCESSMODE to 0"); + ALOGD("+%s+", __func__); + + pp.inst_id = 0; + pp.param_id = 1; + pp.param_val = 1; // 1 is detect_KW + pp.block_id = 1; + err = ioctl(fileno(cvq_node), ODSP_PLG_SET_PARAM, (unsigned long) &pp); + if (-1 == err) { + ALOGE("%s: ERROR: ODSP_PLG_SET_PARAM IOCTL failed with error %d(%s)", __func__, errno, strerror(errno)); + return err; + } + + err = ioctl(fileno(cvq_node), ODSP_START_RECOGNITION, (unsigned long) &kw_id); + if (-1 == err) { + printf("%s: ERROR: ODSP_START_RECOGNITION IOCTL failed with error %d(%s)", __func__, errno, strerror(errno)); + } + + ALOGD("-%s-", __func__); + return err; +} + +int stop_cvq(void) +{ + ALOGE("%s: Entering", __func__); + int err = 0; + struct iaxxx_plugin_param pp; + int kw_id = 0; + + ALOGI("Setting PROCESSMODE to 1"); + ALOGD("+%s+", __func__); + pp.inst_id = 0; + pp.param_id = 1; + pp.param_val = 0; // 1 is detect_KW + pp.block_id = 1; + err = ioctl(fileno(cvq_node), ODSP_PLG_SET_PARAM, (unsigned long) &pp); + if (-1 == err) { + ALOGE("%s: ERROR: ODSP_PLG_SET_PARAM IOCTL failed with error %d(%s)", __func__, errno, strerror(errno)); + return err; + } + + err = ioctl(fileno(cvq_node), ODSP_STOP_RECOGNITION, (unsigned long) &kw_id); + if (-1 == err) { + printf("%s: ERROR: ODSP_STOP_RECOGNITION IOCTL failed with error %d(%s)", __func__, errno, strerror(errno)); + } + + ALOGD("-%s-", __func__); + return err; +} + +int init_params() +{ + struct iaxxx_set_event se; + struct iaxxx_evt_info ei; + int err = 0; + ALOGD("+%s+", __func__); + /* open the cvq node to send ioctl */ + if (NULL == cvq_node) { + if((cvq_node = fopen(CVQ_NODE, "rw")) == NULL) { + ALOGE("file %s open for write error: %s\n", CVQ_NODE, + strerror(errno)); + return -EIO; + } + } + + // Set the events and params + se.inst_id = 0; + se.event_enable_mask = 0x1; + se.block_id = 1; + err = ioctl(fileno(cvq_node), ODSP_PLG_SET_EVENT, (unsigned long) &se); + if (-1 == err) { + ALOGE("%s: ERROR: ODSP_PLG_SET_EVENT IOCTL failed with error %d(%s)", __func__, errno, strerror(errno)); + return err; + } + + ALOGD("Registering for 1 event\n"); + + // Subscribe for events + ei.src_id = PLUGIN_SRC_ID; + ei.event_id = 0; // 0 - Keyword detection + ei.dst_id = IAXXX_SYSID_HOST; + ei.dst_opaque = 0; + err = ioctl(fileno(cvq_node), ODSP_EVENT_SUBSCRIBE, (unsigned long) &ei); + if (-1 == err) { + ALOGE("%s: ERROR: ODSP_EVENT_SUBSCRIBE (for event_id %d, src_id %d) IOCTL failed with error %d(%s)", + __func__, ei.event_id, ei.src_id, errno, strerror(errno)); + return err; + } + + return err; +} + +int write_model(unsigned char *data, int length) +{ + int ret; + struct iaxxx_plugin_param_blk ppb; + ALOGD("+%s+", __func__); + ppb.block_id = 1; + ppb.inst_id = 0; + ppb.param_size = length; + ppb.param_blk = (uintptr_t)data; + ppb.id = (uint32_t) 0; + ret = ioctl(fileno(cvq_node), ODSP_PLG_SET_PARAM_BLK, &ppb); + if (ret < 0) + ALOGE("err. Failed to load the keyword with error %s\n", strerror(errno)); + ALOGD("-%s-", __func__); + return ret; +} + +int flush_model(void) +{ +#if 1 + ALOGE("%s: Ignore for now", __func__); + return 0; +#else + int rc; + + rc = ioctl(fileno(cvq_node), IA_UNLOAD_KEYWORDS, NULL); + if (rc < 0) + ALOGE("err. IA_UNLOAD_KEYWORDS: %s\n", strerror(errno)); + + return rc; +#endif +} + +int get_event(struct iaxxx_get_event *ge) +{ + int err = 0; + ALOGD("+%s+", __func__); + err = ioctl(fileno(cvq_node), ODSP_GET_EVENT, (unsigned long) ge); + if (-1 == err) { + ALOGE("%s: ERROR ODSP_GET_EVENT failed with error %d(%s)", __func__, errno, strerror(errno)); + return err; + } + ALOGD("-%s-", __func__); + return err; +} + +int unload_all_models() +{ + struct iaxxx_plugin_param pp; + int err; + + pp.inst_id = 0; + pp.block_id = 2; + pp.param_id = DSP_VQ_RESET; + pp.param_val = 1; + err = ioctl(fileno(cvq_node), ODSP_PLG_SET_PARAM, (unsigned long) &pp); + if (-1 == err) { + ALOGE("%s: ERROR: ODSP_PLG_SET_PARAM IOCTL failed with error %d(%s) for DSP_VQ_RESET", __func__, errno, strerror(errno)); + } + + return err; +} + +static struct mixer* open_mixer_ctl() +{ + return mixer_open(CARD_NUM); +} + +static void close_mixer_ctl(struct mixer *mixer) +{ + if (mixer) { + mixer_close(mixer); + } +} + +static int set_mixer_ctl_val(struct mixer *mixer, char *id, int value) +{ + struct mixer_ctl *ctl = NULL; + int err = 0; + + if ((NULL == mixer) || (NULL == id)) { + ALOGE("%s: ERROR Null argument passed", __func__); + err = -EINVAL; + goto exit; + } + + ctl = mixer_get_ctl_by_name(mixer, id); + if (NULL == ctl) { + ALOGE("%s: ERROR Invalid control name: %s", __func__, id); + err = -1; + goto exit; + } + + if (mixer_ctl_set_value(ctl, 0, value)) { + ALOGE("%s: ERROR Invalid value for %s", __func__, id); + err = -1; + goto exit; + } + +exit: + return err; +} + +static int set_mixer_ctl_string(struct mixer *mixer, char *id, const char *string) +{ + struct mixer_ctl *ctl = NULL; + int err = 0; + + if ((NULL == mixer) || (NULL == id)) { + ALOGE("%s: ERROR Null argument passed", __func__); + err = -EINVAL; + goto exit; + } + + ctl = mixer_get_ctl_by_name(mixer, id); + if (NULL == ctl) { + ALOGE("%s: ERROR Invalid control name: %s", __func__, id); + err = -1; + goto exit; + } + + if (mixer_ctl_set_enum_by_string(ctl, string)) { + ALOGE("%s: ERROR Invalid string for %s", __func__, id); + err = -1; + goto exit; + } + +exit: + return err; +} + +int set_sensor_route(bool enable) +{ + ALOGD("+%s+", __func__); + struct mixer *mixer = open_mixer_ctl(); + if (NULL == mixer) { + ALOGE("%s: ERROR: Failed to open the mixer control", __func__); + return -1; + } + + if (enable) { + set_mixer_ctl_val(mixer, "sensor0 En", 1); + + set_mixer_ctl_string(mixer, "Plgin2Ip Ep0 Conf", "SensorOut0"); + set_mixer_ctl_string(mixer, "Plgin3Ip Ep0 Conf", "plugin2Out0"); + + set_mixer_ctl_val(mixer, "Plgin2Blk1En", 1); + set_mixer_ctl_val(mixer, "Plgin3Blk1En", 1); + } else { + // TODO: Add teardown route + } + + close_mixer_ctl(mixer); + + ALOGD("-%s-", __func__); + return 0; +} + +int sensor_event_init_params() +{ + struct iaxxx_set_event se; + struct iaxxx_evt_info ei; + int err = 0; + + ALOGD("+%s+", __func__); + + // Set the events and params + se.inst_id = 3; + se.event_enable_mask = 0x7; + se.block_id = 1; + err = ioctl(fileno(cvq_node), ODSP_PLG_SET_EVENT, (unsigned long) &se); + if (-1 == err) { + ALOGE("%s: ERROR: ODSP_PLG_SET_EVENT IOCTL failed with error %d(%s)", __func__, errno, strerror(errno)); + return err; + } + + ALOGD("Registering for 1 event\n"); + + // Subscribe for events + ei.src_id = PLUGIN3_SRC_ID; + ei.event_id = 0; // 0 - Keyword detection + ei.dst_id = IAXXX_SYSID_SCRIPT_MGR; + ei.dst_opaque = 0x1201; + err = ioctl(fileno(cvq_node), ODSP_EVENT_SUBSCRIBE, (unsigned long) &ei); + if (-1 == err) { + ALOGE("%s: ERROR: ODSP_EVENT_SUBSCRIBE (for event_id %d, src_id %d) IOCTL failed with error %d(%s)", + __func__, ei.event_id, ei.src_id, errno, strerror(errno)); + return err; + } + + // Subscribe for events + ei.src_id = PLUGIN3_SRC_ID; + ei.event_id = 1; // 2 - Keyword detection + ei.dst_id = IAXXX_SYSID_SCRIPT_MGR; + ei.dst_opaque = 0x1202; + err = ioctl(fileno(cvq_node), ODSP_EVENT_SUBSCRIBE, (unsigned long) &ei); + if (-1 == err) { + ALOGE("%s: ERROR: ODSP_EVENT_SUBSCRIBE (for event_id %d, src_id %d) IOCTL failed with error %d(%s)", + __func__, ei.event_id, ei.src_id, errno, strerror(errno)); + return err; + } + + // Subscribe for events + ei.src_id = PLUGIN3_SRC_ID; + ei.event_id = 2; // 2 - Keyword detection + ei.dst_id = IAXXX_SYSID_HOST; // update this to HOST_1 for Customer + ei.dst_opaque = 0; + err = ioctl(fileno(cvq_node), ODSP_EVENT_SUBSCRIBE, (unsigned long) &ei); + if (-1 == err) { + ALOGE("%s: ERROR: ODSP_EVENT_SUBSCRIBE (for event_id %d, src_id %d) IOCTL failed with error %d(%s)", + __func__, ei.event_id, ei.src_id, errno, strerror(errno)); + return err; + } + + return err; +} + +int setup_mic_routes() +{ + struct iaxxx_plugin_info pi; + struct iaxxx_plugin_create_cfg pcc; + struct iaxxx_pkg_mgmt_info pkg_info; + int err; + uint32_t buffer_id; + uint32_t ok_google_id; + uint32_t sensor_pkg_id; + + ALOGE("Entering setup_mic_routes"); + + /* open the cvq node to send ioctl */ + if (NULL == cvq_node) { + if((cvq_node = fopen(CVQ_NODE, "rw")) == NULL) { + ALOGE("file %s open for write error: %s\n", CVQ_NODE, + strerror(errno)); + return -EIO; + } + } + /* OK google */ + // Download packages + strcpy(pkg_info.pkg_name, OK_GOOGLE_PACKAGE); + pkg_info.pkg_id = 11; + pkg_info.proc_id = 0; + err = ioctl(fileno(cvq_node), ODSP_LOAD_PACKAGE, (unsigned long) &pkg_info); + if (-1 == err) { + ALOGE("%s: ERROR: ODSP_LOAD_PACKAGE failed %d(%s)", __func__, errno, strerror(errno)); + return err; + } + ALOGE("%s: Ok google ODSP_LOAD_PACKAGE %x\n", __func__, pkg_info.proc_id); + ok_google_id = pkg_info.proc_id; + + + strcpy(pkg_info.pkg_name, BUFFER_PACKAGE); + pkg_info.pkg_id = 4; + pkg_info.proc_id = 0; + err = ioctl(fileno(cvq_node), ODSP_LOAD_PACKAGE, (unsigned long) &pkg_info); + if (-1 == err) { + ALOGE("%s: ERROR: Buffer ODSP_LOAD_PACKAGE failed %d(%s)", __func__, errno, strerror(errno)); + return err; + } + ALOGE("%s: Buffer ODSP_LOAD_PACKAGE %x\n", __func__, pkg_info.proc_id); + buffer_id = pkg_info.proc_id; + + /* Create plugins */ + strcpy(pcc.file_name, BUFFER_CONFIG_VAL); + pcc.inst_id = 1; + pcc.block_id = 1; + pcc.cfg_size = 12; + pcc.cfg_val = 0; + + ALOGE("%s: 1 Configuration size is %u", __func__, pcc.cfg_size); + err = ioctl(fileno(cvq_node), ODSP_PLG_SET_CREATE_CFG, (unsigned long) &pcc); + if (-1 == err) { + ALOGE("%s: ERROR: ODSP_PLG_SET_CREATE_CFG IOCTL failed to set create config %d(%s)", __func__, errno, strerror(errno)); + return err; + } + + // Create Buffer plugin + pi.plg_idx = 0; + pi.pkg_id = buffer_id; + pi.block_id = 1; + pi.inst_id = 1; + pi.priority = BUFFER_PRIORITY; + err = ioctl(fileno(cvq_node), ODSP_PLG_CREATE, (unsigned long) &pi); + if (-1 == err) { + ALOGE("%s: ERROR: ODSP_PLG_CREATE IOCTL failed to create Buffer Plugin with error %d(%s)", __func__, errno, strerror(errno)); + return err; + } + + // Create ok google plugin + pi.plg_idx = 0; + pi.pkg_id = ok_google_id; + pi.block_id = 1; + pi.inst_id = 0; + pi.priority = BUFFER_PRIORITY; + err = ioctl(fileno(cvq_node), ODSP_PLG_CREATE, (unsigned long) &pi); + if (-1 == err) { + ALOGE("%s: ERROR: ODSP_PLG_CREATE IOCTL failed to createok google Plugin with error %d(%s)", __func__, errno, strerror(errno)); + return err; + } + + /* SENSOR MANAGER PACKAGE LOAD AND ROUTE SETUP */ + // Download packages + strcpy(pkg_info.pkg_name, SENSOR_PACKAGE); + pkg_info.pkg_id = 0; + pkg_info.proc_id = 0; + err = ioctl(fileno(cvq_node), ODSP_LOAD_PACKAGE, (unsigned long) &pkg_info); + if (-1 == err) { + ALOGE("%s: ERROR: SENSOR ODSP_LOAD_PACKAGE failed %d(%s)", __func__, errno, strerror(errno)); + return err; + } + ALOGE("%s: SENSOR ODSP_LOAD_PACKAGE %x\n", __func__, pkg_info.proc_id); + sensor_pkg_id = pkg_info.proc_id; + + /* TODO Need to have a check if buffer package is not loaded then we have to load it here */ + /* if buffer plugin Loaded */ + /* Create plugins */ + strcpy(pcc.file_name, BUFFER_CONFIG_OSLO_VAL); + pcc.inst_id = 2; + pcc.block_id = 1; + pcc.cfg_size = 12; + pcc.cfg_val = 0; + + ALOGE("%s: 1 Configuration size is %u", __func__, pcc.cfg_size); + err = ioctl(fileno(cvq_node), ODSP_PLG_SET_CREATE_CFG, (unsigned long) &pcc); + if (-1 == err) { + ALOGE("%s: ERROR: ODSP_PLG_SET_CREATE_CFG IOCTL failed to set create config %d(%s)", __func__, errno, strerror(errno)); + return err; + } + + // Create Buffer plugin + pi.plg_idx = 0; + pi.pkg_id = buffer_id; + pi.block_id = 1; + pi.inst_id = 2; + pi.priority = BUFFER_PRIORITY; + err = ioctl(fileno(cvq_node), ODSP_PLG_CREATE, (unsigned long) &pi); + if (-1 == err) { + ALOGE("%s: ERROR: ODSP_PLG_CREATE IOCTL failed to create Buffer Plugin with error %d(%s)", __func__, errno, strerror(errno)); + return err; + } + + // Create ok google plugin + pi.plg_idx = 0; + pi.pkg_id = sensor_pkg_id; + pi.block_id = 1; + pi.inst_id = 3; + pi.priority = BUFFER_PRIORITY; + err = ioctl(fileno(cvq_node), ODSP_PLG_CREATE, (unsigned long) &pi); + if (-1 == err) { + ALOGE("%s: ERROR: ODSP_PLG_CREATE IOCTL failed to create sensor Plugin with error %d(%s)", __func__, errno, strerror(errno)); + return err; + } + + err = sensor_event_init_params(); + if (err) { + ALOGE("%s: ERROR: Sensor event init failed %d", __func__, err); + return err; + } + /* SENSOR MANAGER ROUTE END */ + + return 0; +} + +int enable_mic_route(int enable) +{ + struct mixer *mixer = open_mixer_ctl(); + + if (NULL == mixer) { + ALOGE("%s: ERROR: Failed to open the mixer control", __func__); + return -1; + } + ALOGE("Entering enable_mic_route %d ", enable); + + if (enable) + { + // Setup the PDM port config + set_mixer_ctl_val(mixer, PORTB_MICBIAS, 1); + set_mixer_ctl_val(mixer, PORTC_MICBIAS, 1); + set_mixer_ctl_string(mixer, PDM_BCLK, "IAXXX_PDM_CLK_3P_072MHZ"); + set_mixer_ctl_string(mixer, PDM_PORT_ACLK, "IAXXX_AUD_PORT_32K"); + set_mixer_ctl_val(mixer, PDM_PORTB_SETUP,1); + set_mixer_ctl_val(mixer, PDM_PORTC_SETUP,1); + set_mixer_ctl_val(mixer, "Pdm CDC Setup", 1); + set_mixer_ctl_val(mixer, PDM_PORTC_DMIC0_EN, 1); + set_mixer_ctl_val(mixer, PDM_PORTB_DMIC0_EN, 1); + set_mixer_ctl_val(mixer, PDM_HOS, 0x50); + set_mixer_ctl_val(mixer, "PDM CDC0 Start", 0x50); + + // Channel 0 + set_mixer_ctl_string(mixer, "Rx0Chan GnRmp", "STEP_2000"); + set_mixer_ctl_val(mixer, "Rx0Ch EpGain", 40); + set_mixer_ctl_val(mixer, "Rx0Chan Gain En", 1); + + // STREAM 0 INPUT Channels + set_mixer_ctl_string(mixer, "strm0 ASRC Mode", "REDBOX_2-1"); + set_mixer_ctl_string(mixer, "strm0 Master Strm Id", "STREAMID_0"); + set_mixer_ctl_string(mixer, "strm0 Format FrLn", "16K_10MS"); + set_mixer_ctl_string(mixer, "strm0 Format Sr", "RATE_16K"); + set_mixer_ctl_string(mixer, "strm0 Format Enc", "ENCODING_AFLOAT"); + set_mixer_ctl_val(mixer, "strm0 Dir", 0); + set_mixer_ctl_val(mixer, "strm0 inter strm delay", 0); + set_mixer_ctl_string(mixer, "strm0 Port", "PDMI4"); + set_mixer_ctl_string(mixer, "strm0 Port Enc", "ENCODING_Q23"); + set_mixer_ctl_val(mixer, "strm0 CH Mask En", 1); + + set_mixer_ctl_string(mixer, "strm1 ASRC Mode", "REDBOX_2-1"); + set_mixer_ctl_string(mixer, "strm1 Master Strm Id", "STREAMID_1"); + set_mixer_ctl_string(mixer, "strm1 Format FrLn", "16K_10MS"); + set_mixer_ctl_string(mixer, "strm1 Format Sr", "RATE_16K"); + set_mixer_ctl_string(mixer, "strm1 Format Enc", "ENCODING_AFLOAT"); + set_mixer_ctl_val(mixer, "strm1 Dir", 0); + set_mixer_ctl_val(mixer, "strm1 inter strm delay", 0); + set_mixer_ctl_string(mixer, "strm1 Port", "PDMI6"); + set_mixer_ctl_string(mixer, "strm1 Port Enc", "ENCODING_Q23"); + set_mixer_ctl_val(mixer, "strm1 CH Mask En", 2); + + set_mixer_ctl_string(mixer, PLGIN0IP_EP0_CONF, "RX0_ChanMgr"); + set_mixer_ctl_string(mixer, PLGIN0IP_EP1_CONF, "RX1_ChanMgr"); + set_mixer_ctl_string(mixer, PLGIN0EN, "Rx0Plgin0On"); + set_mixer_ctl_val(mixer, PLGIN0BLK1EN, 1); + + // Buffer Plugin OP End point + set_mixer_ctl_string(mixer, PLGIN1IP_EP0_CONF, "RX0_ChanMgr"); + set_mixer_ctl_val(mixer, PLGIN1BLK1EN, 1); + set_mixer_ctl_string(mixer, PLGIN1EN, "Rx0Plgin1On"); + set_mixer_ctl_string(mixer, "Rx0 Mux Port", "PDMI4"); + set_mixer_ctl_val(mixer, "Route Status", 1); + set_mixer_ctl_val(mixer, "strm0 En", 1); + set_mixer_ctl_val(mixer, "strm1 En", 1); + } + else { + set_mixer_ctl_val(mixer, "strm1 En", 0); + set_mixer_ctl_val(mixer, "strm0 En", 0); + set_mixer_ctl_val(mixer, PLGIN1BLK1EN, 0); + set_mixer_ctl_val(mixer, PLGIN0BLK1EN, 0); + set_mixer_ctl_val(mixer, "PDM CDC0 Start", 0); + set_mixer_ctl_val(mixer, PDM_PORTB_SETUP,0); + set_mixer_ctl_val(mixer, PDM_PORTC_SETUP,0); + set_mixer_ctl_val(mixer, "Pdm CDC Setup", 0); + set_mixer_ctl_val(mixer, PDM_PORTC_DMIC0_EN, 0); + set_mixer_ctl_val(mixer, PDM_PORTB_DMIC0_EN, 0); + set_mixer_ctl_val(mixer, PDM_HOS, 0); + set_mixer_ctl_val(mixer, PORTC_MICBIAS, 0); + set_mixer_ctl_val(mixer, PORTB_MICBIAS, 0); + } + + close_mixer_ctl(mixer); + return 0; +} diff --git a/ia_constants.h b/ia_constants.h new file mode 100644 index 0000000..66f8ba0 --- /dev/null +++ b/ia_constants.h @@ -0,0 +1,375 @@ +#ifndef _IA_CONSTANTS_H_ +#define _IA_CONSTANTS_H_ + +#define PLUGIN_0_PKG_ID "Plgin0Pkg ID" +#define PLUGIN_0_INST_PRIORITY "Plgin0inst priority" +#define PLUGIN_0_ORIGIN_PLUGIN_IDX "Plgin0Origin Plugin Idx" +#define PLUGIN_0_CREATE_2 "Plgin0Create2" + +#define PDM_BCLK "PDM BCLK" +#define PDM_PORT_ACLK "PDM Port ACLK" +#define PDM_PORTB_SETUP "Pdm PortB Setup" +#define PDM_PORTC_SETUP "Pdm PortC Setup" +#define PDM_PORTB_DMIC0_EN "Pdm PortB DMic0 En" +#define PDM_PORTB_DMIC1_EN "Pdm PortB DMic1 En" +#define PDM_PORTB_DMIC2_EN "Pdm PortB DMic2 En" +#define PDM_PORTB_DMIC3_EN "Pdm PortB DMic3 En" +#define PDM_PORTC_DMIC0_EN "Pdm PortC DMic0 En" +#define PDM_PORTC_DMIC1_EN "Pdm PortC DMic1 En" +#define PDM_PORTC_DMIC2_EN "Pdm PortC DMic2 En" +#define PDM_PORTC_DMIC3_EN "Pdm PortC DMic3 En" +#define PDM_PORTB_START "PDM PortB Start" +#define PDM_PORTC_START "PDM PortC Start" +#define PDM_HOS "PDM Hos" + +#define PDM_PORTB_CLR "PDM PortB CLR" +#define PDM_PORTC_CLR "PDM PortC CLR" + +#define PORTC_MICBIAS "PortC MicBias" +#define PORTB_MICBIAS "PortB MicBias" + + +#define RX0CHAN_STRM_ID "Rx0Chan Strm Id" +#define RX0CHAN_STRM_IDX "Rx0Chan Strm Idx" +#define RX0CH_EPGAIN "Rx0Ch EpGain" +#define RX0CHAN_GNREEVT "Rx0Chan GnReEvt" +#define RX0CHAN_GNRMP "Rx0Chan GnRmp" +#define RX0CHAN_PORT_IDX "Rx0Chan Port Idx" +#define RX0CHAN_OPEPENC "Rx0Chan OpEpEnc" +#define RX0CHAN_OPEPSR "Rx0Chan OpEpSr" +#define RX0CHAN_OPEPFRLN "Rx0Chan OpEpFrLn" +#define RX0_MUX_PORT "Rx0 Mux Port" +#define RX0_MUX_EN "Rx0 Mux En" + +#define RX1CHAN_STRM_ID "Rx1Chan Strm Id" +#define RX1CHAN_STRM_IDX "Rx1Chan Strm Idx" +#define RX1CH_EPGAIN "Rx1Ch EpGain" +#define RX1CHAN_GNREEVT "Rx1Chan GnReEvt" +#define RX1CHAN_GNRMP "Rx1Chan GnRmp" +#define RX1CHAN_PORT_IDX "Rx1Chan Port Idx" +#define RX1CHAN_OPEPENC "Rx1Chan OpEpEnc" +#define RX1CHAN_OPEPSR "Rx1Chan OpEpSr" +#define RX1CHAN_OPEPFRLN "Rx1Chan OpEpFrLn" +#define RX1_MUX_PORT "Rx1 Mux Port" +#define RX1_MUX_EN "Rx1 Mux En" + +#define RX2CHAN_STRM_ID "Rx2Chan Strm Id" +#define RX2CHAN_STRM_IDX "Rx2Chan Strm Idx" +#define RX2CH_EPGAIN "Rx2Ch EpGain" +#define RX2CHAN_GNREEVT "Rx2Chan GnReEvt" +#define RX2CHAN_GNRMP "Rx2Chan GnRmp" +#define RX2CHAN_PORT_IDX "Rx2Chan Port Idx" +#define RX2CHAN_OPEPENC "Rx2Chan OpEpEnc" +#define RX2CHAN_OPEPSR "Rx2Chan OpEpSr" +#define RX2CHAN_OPEPFRLN "Rx2Chan OpEpFrLn" +#define RX2_MUX_PORT "Rx2 Mux Port" +#define RX2_MUX_EN "Rx2 Mux En" + +#define RX3CHAN_STRM_ID "Rx3Chan Strm Id" +#define RX3CHAN_STRM_IDX "Rx3Chan Strm Idx" +#define RX3CH_EPGAIN "Rx3Ch EpGain" +#define RX3CHAN_GNREEVT "Rx3Chan GnReEvt" +#define RX3CHAN_GNRMP "Rx3Chan GnRmp" +#define RX3CHAN_PORT_IDX "Rx3Chan Port Idx" +#define RX3CHAN_OPEPENC "Rx3Chan OpEpEnc" +#define RX3CHAN_OPEPSR "Rx3Chan OpEpSr" +#define RX3CHAN_OPEPFRLN "Rx3Chan OpEpFrLn" +#define RX3_MUX_PORT "Rx3 Mux Port" +#define RX3_MUX_EN "Rx3 Mux En" + +#define RX6CHAN_STRM_ID "Rx6Chan Strm Id" +#define RX6CHAN_STRM_IDX "Rx6Chan Strm Idx" +#define RX6CH_EPGAIN "Rx6Ch EpGain" +#define RX6CHAN_GNREEVT "Rx6Chan GnReEvt" +#define RX6CHAN_GNRMP "Rx6Chan GnRmp" +#define RX6CHAN_PORT_IDX "Rx6Chan Port Idx" +#define RX6CHAN_OPEPENC "Rx6Chan OpEpEnc" +#define RX6CHAN_OPEPSR "Rx6Chan OpEpSr" +#define RX6CHAN_OPEPFRLN "Rx6Chan OpEpFrLn" +#define RX6_MUX_PORT "Rx6 Mux Port" +#define RX6_MUX_EN "Rx6 Mux En" + +#define RX7CHAN_STRM_ID "Rx7Chan Strm Id" +#define RX7CHAN_STRM_IDX "Rx7Chan Strm Idx" +#define RX7CH_EPGAIN "Rx7Ch EpGain" +#define RX7CHAN_GNREEVT "Rx7Chan GnReEvt" +#define RX7CHAN_GNRMP "Rx7Chan GnRmp" +#define RX7CHAN_PORT_IDX "Rx7Chan Port Idx" +#define RX7CHAN_OPEPENC "Rx7Chan OpEpEnc" +#define RX7CHAN_OPEPSR "Rx7Chan OpEpSr" +#define RX7CHAN_OPEPFRLN "Rx7Chan OpEpFrLn" +#define RX7_MUX_PORT "Rx7 Mux Port" +#define RX7_MUX_EN "Rx7 Mux En" + +#define RX8CHAN_STRM_ID "Rx8Chan Strm Id" +#define RX8CHAN_STRM_IDX "Rx8Chan Strm Idx" +#define RX8CH_EPGAIN "Rx8Ch EpGain" +#define RX8CHAN_GNREEVT "Rx8Chan GnReEvt" +#define RX8CHAN_GNRMP "Rx8Chan GnRmp" +#define RX8CHAN_PORT_IDX "Rx8Chan Port Idx" +#define RX8CHAN_OPEPENC "Rx8Chan OpEpEnc" +#define RX8CHAN_OPEPSR "Rx8Chan OpEpSr" +#define RX8CHAN_OPEPFRLN "Rx8Chan OpEpFrLn" +#define RX8_MUX_PORT "Rx8 Mux Port" +#define RX8_MUX_EN "Rx8 Mux En" + +#define RX9CHAN_STRM_ID "Rx9Chan Strm Id" +#define RX9CHAN_STRM_IDX "Rx9Chan Strm Idx" +#define RX9CH_EPGAIN "Rx9Ch EpGain" +#define RX9CHAN_GNREEVT "Rx9Chan GnReEvt" +#define RX9CHAN_GNRMP "Rx9Chan GnRmp" +#define RX9CHAN_PORT_IDX "Rx9Chan Port Idx" +#define RX9CHAN_OPEPENC "Rx9Chan OpEpEnc" +#define RX9CHAN_OPEPSR "Rx9Chan OpEpSr" +#define RX9CHAN_OPEPFRLN "Rx9Chan OpEpFrLn" +#define RX9_MUX_PORT "Rx9 Mux Port" +#define RX9_MUX_EN "Rx9 Mux En" + +#define RX4CHAN_STRM_ID "Rx4Chan Strm Id" +#define RX4CHAN_STRM_IDX "Rx4Chan Strm Idx" +#define RX4CH_EPGAIN "Rx4Ch EpGain" +#define RX4CHAN_GNREEVT "Rx4Chan GnReEvt" +#define RX4CHAN_GNRMP "Rx4Chan GnRmp" +#define RX4CHAN_PORT_IDX "Rx4Chan Port Idx" +#define RX4CHAN_OPEPENC "Rx4Chan OpEpEnc" +#define RX4CHAN_OPEPSR "Rx4Chan OpEpSr" +#define RX4CHAN_OPEPFRLN "Rx4Chan OpEpFrLn" +#define RX4_MUX_PORT "Rx4 Mux Port" +#define RX4_MUX_EN "Rx4 Mux En" + +#define RX5CHAN_STRM_ID "Rx5Chan Strm Id" +#define RX5CHAN_STRM_IDX "Rx5Chan Strm Idx" +#define RX5CH_EPGAIN "Rx5Ch EpGain" +#define RX5CHAN_GNREEVT "Rx5Chan GnReEvt" +#define RX5CHAN_GNRMP "Rx5Chan GnRmp" +#define RX5CHAN_PORT_IDX "Rx5Chan Port Idx" +#define RX5CHAN_OPEPENC "Rx5Chan OpEpEnc" +#define RX5CHAN_OPEPSR "Rx5Chan OpEpSr" +#define RX5CHAN_OPEPFRLN "Rx5Chan OpEpFrLn" +#define RX5_MUX_PORT "Rx5 Mux Port" +#define RX5_MUX_EN "Rx5 Mux En" + +#define TX0CHAN_STRM_ID "Tx0Chan Strm Id" +#define TX0CHAN_STRM_IDX "Tx0Chan Strm Idx" +#define TX0CHAN_GNREEVT "Tx0Chan GnReEvt" +#define TX0CHAN_GNRMP "Tx0Chan GnRmp" +#define TX0CHAN_PORT_IDX "Tx0Chan Port Idx" +#define TX0CHAN_PORT_DIR "Tx0Chan Port Dir" +#define TX0CH_EPGAIN "Tx0Ch EpGain" +#define TX0IP_SRC_ID "Tx0ip src id" +#define TX0_MUX_PORT "Tx0 Mux Port" +#define TX0_MUX_EN "Tx0 Mux En" + +#define TX1CHAN_STRM_ID "Tx1Chan Strm Id" +#define TX1CHAN_STRM_IDX "Tx1Chan Strm Idx" +#define TX1CHAN_GNREEVT "Tx1Chan GnReEvt" +#define TX1CHAN_GNRMP "Tx1Chan GnRmp" +#define TX1CHAN_PORT_IDX "Tx1Chan Port Idx" +#define TX1CHAN_PORT_DIR "Tx1Chan Port Dir" +#define TX1CH_EPGAIN "Tx1Ch EpGain" +#define TX1IP_SRC_ID "Tx1ip src id" +#define TX1_MUX_PORT "Tx1 Mux Port" +#define TX1_MUX_EN "Tx1 Mux En" + +#define STRM0ASRC_MODE "strm0ASRC Mode" +#define STRM0MASTER_STRM_ID "strm0Master Strm Id" +#define STRM0DC_BLOCK_EN "strm0DC block en" +#define STRM0FORMAT_FRLN "strm0Format FrLn" +#define STRM0DROOP_COMP_EN "strm0droop comp en" +#define STRM0FORMAT_SR "strm0Format Sr" +#define STRM0FORMAT_ENC "strm0Format Enc" +#define STRM0TONE_GEN_EN "strm0tone gen en" +#define STRM0STRM_DIR "strm0Strm Dir" +#define STRM0INTER_STRM_DELAY "strm0inter strm delay" +#define STRM0EN "strm0En" + +#define STRM1ASRC_MODE "strm1ASRC Mode" +#define STRM1MASTER_STRM_ID "strm1Master Strm Id" +#define STRM1DC_BLOCK_EN "strm1DC block en" +#define STRM1FORMAT_FRLN "strm1Format FrLn" +#define STRM1DROOP_COMP_EN "strm1droop comp en" +#define STRM1FORMAT_SR "strm1Format Sr" +#define STRM1FORMAT_ENC "strm1Format Enc" +#define STRM1TONE_GEN_EN "strm1tone gen en" +#define STRM1STRM_DIR "strm1Strm Dir" +#define STRM1INTER_STRM_DELAY "strm1inter strm delay" +#define STRM1EN "strm1En" + +#define STRM2ASRC_MODE "strm2ASRC Mode" +#define STRM2MASTER_STRM_ID "strm2Master Strm Id" +#define STRM2DC_BLOCK_EN "strm2DC block en" +#define STRM2FORMAT_FRLN "strm2Format FrLn" +#define STRM2DROOP_COMP_EN "strm2droop comp en" +#define STRM2FORMAT_SR "strm2Format Sr" +#define STRM2FORMAT_ENC "strm2Format Enc" +#define STRM2TONE_GEN_EN "strm2tone gen en" +#define STRM2STRM_DIR "strm2Strm Dir" +#define STRM2INTER_STRM_DELAY "strm2inter strm delay" +#define STRM2EN "strm2En" + +#define STRM3ASRC_MODE "strm3ASRC Mode" +#define STRM3MASTER_STRM_ID "strm3Master Strm Id" +#define STRM3DC_BLOCK_EN "strm3DC block en" +#define STRM3FORMAT_FRLN "strm3Format FrLn" +#define STRM3DROOP_COMP_EN "strm3droop comp en" +#define STRM3FORMAT_SR "strm3Format Sr" +#define STRM3FORMAT_ENC "strm3Format Enc" +#define STRM3TONE_GEN_EN "strm3tone gen en" +#define STRM3STRM_DIR "strm3Strm Dir" +#define STRM3INTER_STRM_DELAY "strm3inter strm delay" +#define STRM3EN "strm3En" + +#define STRM4ASRC_MODE "strm4ASRC Mode" +#define STRM4MASTER_STRM_ID "strm4Master Strm Id" +#define STRM4DC_BLOCK_EN "strm4DC block en" +#define STRM4FORMAT_FRLN "strm4Format FrLn" +#define STRM4DROOP_COMP_EN "strm4droop comp en" +#define STRM4FORMAT_SR "strm4Format Sr" +#define STRM4FORMAT_ENC "strm4Format Enc" +#define STRM4TONE_GEN_EN "strm4tone gen en" +#define STRM4STRM_DIR "strm4Strm Dir" +#define STRM4INTER_STRM_DELAY "strm4inter strm delay" +#define STRM4EN "strm4En" + +#define STRM8EN "strm8En" +#define STRM8TONE_GEN_EN "strm8tone gen en" +#define STRM8DROOP_COMP_EN "strm8droop comp en" +#define STRM8FORMAT_SR "strm8Format Sr" +#define STRM8FORMAT_FRLN "strm8Format FrLn" +#define STRM8DC_BLOCK_EN "strm8DC block en" +#define STRM8_FORMAT_ENC "strm8Format Enc" +#define STRM8ASRC_MODE "strm8ASRC Mode" +#define STRM8MASTER_STRM_ID "strm8Master Strm Id" +#define STRM8INTER_STRM_DELAY "strm8inter strm delay" +#define STRM8STRM_DIR "strm8Strm Dir" +#define TX0_PORTMUX_EN "Tx0 PortMux En" +#define TX1_PORTMUX_EN "Tx1 PortMux En" + +#define PLGIN0IP_EP0_CONF "Plgin0Ip Ep0 Conf" +#define PLGIN0IP_EP1_CONF "Plgin0Ip Ep1 Conf" +#define PLGIN0IP_EP2_CONF "Plgin0Ip Ep2 Conf" +#define PLGIN0IP_EP3_CONF "Plgin0Ip Ep3 Conf" +#define PLGIN0IP_EP4_CONF "Plgin0Ip Ep4 Conf" +#define PLGIN0IP_EP5_CONF "Plgin0Ip Ep5 Conf" + +#define PLGIN1IP_EP0_CONF "Plgin1Ip Ep0 Conf" +#define PLGIN1IP_EP1_CONF "Plgin1Ip Ep1 Conf" +#define PLGIN1IP_EP2_CONF "Plgin1Ip Ep2 Conf" +#define PLGIN1IP_EP3_CONF "Plgin1Ip Ep3 Conf" +#define PLGIN1IP_EP4_CONF "Plgin1Ip Ep4 Conf" +#define PLGIN1IP_EP5_CONF "Plgin1Ip Ep5 Conf" + +#define PLUGIN1OP_EP0_SR "Plgin1Op Ep0 Sr" +#define PLUGIN1OP_EP0_ENC "Plgin1Op Ep0 Enc" +#define PLUGIN1OP_EP0_FRLN "Plgin1Op Ep0 FrLn" +#define PLGIN0OP_EP0_SR "Plgin0Op Ep0 Sr" +#define PLGIN0OP_EP0_ENC "Plgin0Op Ep0 Enc" +#define PLGIN0OP_EP0_FRLN "Plgin0Op Ep0 FrLn" +#define PLGIN0OP_EP1_SR "Plgin0Op Ep1 Sr" +#define PLGIN0OP_EP1_ENC "Plgin0Op Ep1 Enc" +#define PLGIN0OP_EP1_FRLN "Plgin0Op Ep1 FrLn" + +#define UPDATE_BLOCK2_REQ "Update Block2 Req" +#define UPDATE_BLOCK0_REQ "Update Block0 Req" +#define UPDATE_BLOCK1_REQ "Update Block1 Req" + +#define PLGIN0BLK2_PARAM_ID "Plgin0Blk2 Param Id" +#define PLGIN0BLK2_PARAM_VAL "Plgin0Blk2 Param Val" + +#define RX0CHAN_GAIN_EN "Rx0Chan Gain En" +#define RX1CHAN_GAIN_EN "Rx1Chan Gain En" +#define RX2CHAN_GAIN_EN "Rx2Chan Gain En" +#define RX3CHAN_GAIN_EN "Rx3Chan Gain En" +#define RX4CHAN_GAIN_EN "Rx4Chan Gain En" +#define RX5CHAN_GAIN_EN "Rx5Chan Gain En" +#define RX6CHAN_GAIN_EN "Rx6Chan Gain En" +#define RX7CHAN_GAIN_EN "Rx7Chan Gain En" +#define RX8CHAN_GAIN_EN "Rx8Chan Gain En" +#define RX9CHAN_GAIN_EN "Rx9Chan Gain En" + +#define PLGIN1OP_EP0_SR "Plgin1Op Ep0 Sr" +#define PLGIN1OP_EP0_ENC "Plgin1Op Ep0 Enc" +#define PLGIN1OP_EP0_FRLN "Plgin1Op Ep0 FrLn" +#define PLGIN1OP_EP1_SR "Plgin1Op Ep1 Sr" +#define PLGIN1OP_EP1_ENC "Plgin1Op Ep1 Enc" +#define PLGIN1OP_EP1_FRLN "Plgin1Op Ep1 FrLn" +#define PLGIN1OP_EP2_SR "Plgin1Op Ep2 Sr" +#define PLGIN1OP_EP2_ENC "Plgin1Op Ep2 Enc" +#define PLGIN1OP_EP2_FRLN "Plgin1Op Ep2 FrLn" + +#define PLGIN0EN "Plgin0En" +#define PLGIN0BLK2EN "Plgin0Blk2En" +#define PLGIN0BLK1EN "Plgin0Blk1En" + +#define PLGIN1EN "Plgin1En" +#define PLGIN1BLK2EN "Plgin1Blk2En" +#define PLGIN1BLK1EN "Plgin1Blk1En" + +#define PLGIN2IP_EP0_CONF "Plgin2Ip Ep0 Conf" +#define PLUGIN2OP_EP0_SR "Plgin2Op Ep0 Sr" +#define PLUGIN2OP_EP0_ENC "Plgin2Op Ep0 Enc" +#define PLUGIN2OP_EP0_FRLN "Plgin2Op Ep0 FrLn" + +#define PLUGIN2EN "Plgin2En" +#define PLUGIN2BLK2EN "Plgin2Blk2En" + +#define PLGIN3IP_EP0_CONF "Plgin3Ip Ep0 Conf" +#define PLGIN3IP_EP1_CONF "Plgin3Ip Ep1 Conf" +#define PLGIN3OP_EP0_SR "Plgin3Op Ep0 Sr" +#define PLGIN3OP_EP0_ENC "Plgin3Op Ep0 Enc" +#define PLGIN3OP_EP0_FRLN "Plgin3Op Ep0 FrLn" + +#define PLGIN3EN "Plgin3En" +#define PLGIN3BLK2EN "Plgin3Blk2En" + +#define PLGIN4IP_EP0_CONF "Plgin4Ip Ep0 Conf" +#define PLGIN4OP_EP0_SR "Plgin4Op Ep0 Sr" +#define PLGIN4OP_EP0_ENC "Plgin4Op Ep0 Enc" +#define PLGIN4OP_EP0_FRLN "Plgin4Op Ep0 FrLn" +#define PLGIN4EN "Plgin4En" +#define PLGIN4BLK2EN "Plgin4Blk2En" + +#define PLGIN5IP_EP0_CONF "Plgin5Ip Ep0 Conf" +#define PLGIN5OP_EP0_SR "Plgin5Op Ep0 Sr" +#define PLGIN5OP_EP0_ENC "Plgin5Op Ep0 Enc" +#define PLGIN5OP_EP0_FRLN "Plgin5Op Ep0 FrLn" +#define PLGIN5EN "Plgin5En" +#define PLGIN5BLK2EN "Plgin5Blk2En" + +#define VQ_PLUGIN_IDX (1) +#define VQ_PKG_ID (0x5005) +#define VQ_BLOCK_ID (2) +#define VQ_INST_ID (0) +#define VQ_PRIORITY (1) + +#define VP_PLUGIN_IDX (0) +#define VP_PKG_ID (0x5005) +#define VP_BLOCK_ID (2) +#define VP_INST_ID (1) +#define VP_PRIORITY (1) + +#define BUFFER_PLUGIN_IDX (0) +#define BUFFER_PKG_ID (0x5004) +#define BUFFER_BLOCK_ID (2) +#define BUFFER_INST_ID (2) +#define BUFFER_PRIORITY (1) + +#define MIXER_PLUGIN_IDX (0) +#define MIXER_PKG_ID (0x5006) +#define MIXER_BLOCK_ID (2) +#define MIXER_INST_ID (3) +#define MIXER_PRIORITY (1) + +#define MBC_PLUGIN_IDX (3) +#define MBC_PKG_ID (0x5005) +#define MBC_BLOCK_ID (2) +#define MBC_INST_ID (4) +#define MBC_PRIORITY (1) + +#define PEQ_PLUGIN_IDX (2) +#define PEQ_PKG_ID (0x5005) +#define PEQ_BLOCK_ID (2) +#define PEQ_INST_ID (5) +#define PEQ_PRIORITY (1) + +#endif // #ifndef _IA_CONSTANTS_H_ diff --git a/iaxxx-odsp.h b/iaxxx-odsp.h new file mode 100644 index 0000000..d15487b --- /dev/null +++ b/iaxxx-odsp.h @@ -0,0 +1,88 @@ +/**************************************************************************** + **************************************************************************** + *** + *** This header was automatically generated from a Linux kernel header + *** of the same name, to make information necessary for userspace to + *** call into the kernel available to libc. It contains only constants, + *** structures, and macros generated from the original header, and thus, + *** contains no copyrightable information. + *** + *** To edit the content of this header, modify the corresponding + *** source file (e.g. under external/kernel-headers/original/) then + *** run bionic/libc/kernel/tools/update_all.py + *** + *** Any manual change here will be lost the next time this script will + *** be run. You've been warned! + *** + **************************************************************************** + ****************************************************************************/ +#ifndef __IAXXX_ODSP_H__ +#define __IAXXX_ODSP_H__ +struct iaxxx_plugin_info { + uint32_t plg_idx; + uint32_t pkg_id; + uint32_t block_id; + uint32_t inst_id; + uint32_t priority; +}; +struct iaxxx_plugin_param { + uint32_t inst_id; + uint32_t param_id; + uint32_t param_val; + uint8_t block_id; +}; +struct iaxxx_plugin_param_blk { + uint32_t inst_id; + uint32_t param_size; + uint64_t param_blk; + uint8_t block_id; + uint32_t id; +}; +struct iaxxx_plugin_create_cfg { + char file_name[256]; + uint32_t inst_id; + uint32_t cfg_size; + uint64_t cfg_val; + uint8_t block_id; +}; +struct iaxxx_set_event { + uint8_t inst_id; + uint32_t event_enable_mask; + uint32_t block_id; +}; +struct iaxxx_evt_info { + uint16_t src_id; + uint16_t event_id; + uint16_t dst_id; + uint32_t dst_opaque; +}; +struct iaxxx_get_event { + uint16_t event_id; + uint32_t data; +}; +struct iaxxx_pkg_mgmt_info { + char pkg_name[256]; + uint32_t pkg_id; + uint32_t proc_id; +}; +#define IAXXX_IOCTL_MAGIC 'I' +#define ODSP_PLG_CREATE _IO(IAXXX_IOCTL_MAGIC, 0x11) +#define ODSP_PLG_RESET _IO(IAXXX_IOCTL_MAGIC, 0x12) +#define ODSP_PLG_ENABLE _IO(IAXXX_IOCTL_MAGIC, 0x13) +#define ODSP_PLG_DISABLE _IO(IAXXX_IOCTL_MAGIC, 0x14) +#define ODSP_PLG_DESTROY _IO(IAXXX_IOCTL_MAGIC, 0x15) +#define ODSP_PLG_SET_PARAM _IO(IAXXX_IOCTL_MAGIC, 0x16) +#define ODSP_PLG_GET_PARAM _IO(IAXXX_IOCTL_MAGIC, 0x17) +#define ODSP_PLG_SET_PARAM_BLK _IO(IAXXX_IOCTL_MAGIC, 0x18) +#define ODSP_PLG_SET_CREATE_CFG _IO(IAXXX_IOCTL_MAGIC, 0x19) +#define ODSP_PLG_SET_EVENT _IO(IAXXX_IOCTL_MAGIC, 0x1A) +#define ODSP_EVENT_SUBSCRIBE _IO(IAXXX_IOCTL_MAGIC, 0x1B) +#define ODSP_GET_EVENT _IO(IAXXX_IOCTL_MAGIC, 0x1C) +#define ODSP_EVENT_UNSUBSCRIBE _IO(IAXXX_IOCTL_MAGIC, 0x1D) +#define ODSP_LOAD_PACKAGE _IO(IAXXX_IOCTL_MAGIC, 0x1E) +#define ODSP_UNLOAD_PACKAGE _IO(IAXXX_IOCTL_MAGIC, 0x1F) +#define ODSP_UNLOAD_KW_MODEL _IO(IAXXX_IOCTL_MAGIC, 0x20) +#define ODSP_START_RECOGNITION _IO(IAXXX_IOCTL_MAGIC, 0x21) +#define ODSP_STOP_RECOGNITION _IO(IAXXX_IOCTL_MAGIC, 0x22) +#define ODSP_GET_KW_RECOGNIZE_BITMAP _IO(IAXXX_IOCTL_MAGIC, 0x23) +#endif diff --git a/iaxxx-sysid-defs.h b/iaxxx-sysid-defs.h new file mode 100644 index 0000000..b01086c --- /dev/null +++ b/iaxxx-sysid-defs.h @@ -0,0 +1,251 @@ +/**************************************************************************** + **************************************************************************** + *** + *** This header was automatically generated from a Linux kernel header + *** of the same name, to make information necessary for userspace to + *** call into the kernel available to libc. It contains only constants, + *** structures, and macros generated from the original header, and thus, + *** contains no copyrightable information. + *** + *** To edit the content of this header, modify the corresponding + *** source file (e.g. under external/kernel-headers/original/) then + *** run bionic/libc/kernel/tools/update_all.py + *** + *** Any manual change here will be lost the next time this script will + *** be run. You've been warned! + *** + **************************************************************************** + ****************************************************************************/ +#ifndef __IAXXX_SYSTEMID_H__ +#define __IAXXX_SYSTEMID_H__ +#include <linux/kernel.h> +#include <limits.h> +enum { + IAXXX_SYSID_RESOURCE_TYPE_SPECIAL = 0x0, + IAXXX_SYSID_RESOURCE_TYPE_DRIVER, + IAXXX_SYSID_RESOURCE_TYPE_MODULE, + IAXXX_SYSID_RESOURCE_TYPE_PLUGIN, + IAXXX_SYSID_RESOURCE_TYPE_CHANNEL, + IAXXX_SYSID_RESOURCE_TYPE_TUNNEL, + IAXXX_SYSID_RESOURCE_TYPE_STREAM, + IAXXX_SYSID_RESOURCE_TYPE_DEVICE, + IAXXX_SYSID_RESOURCE_TYPE_BT, + IAXXX_SYSID_RESOURCE_TYPE_SENSOR, + IAXXX_SYSID_RESOURCE_TYPE_DEBUG, + IAXXX_SYSID_RESOURCE_TYPE_NUM, + IAXXX_SYSID_RESOURCE_TYPE_FORCE_SIZE = INT_MAX, +}; +enum sysid_driver_type_e { + IAXXX_SYSID_DRIVER_TYPE_NONE = 0, + IAXXX_SYSID_DRIVER_TYPE_I2C, + IAXXX_SYSID_DRIVER_TYPE_SPI, + IAXXX_SYSID_DRIVER_TYPE_UART, + IAXXX_SYSID_DRIVER_TYPE_SLIMBUS_CTRL, + IAXXX_SYSID_DRIVER_TYPE_SOUNDWIRE_CTRL, + IAXXX_SYSID_DRIVER_TYPE_I3C_CTRL, + IAXXX_SYSID_DRIVER_TYPE_PCM, + IAXXX_SYSID_DRIVER_TYPE_PDM_IN, + IAXXX_SYSID_DRIVER_TYPE_PDM_OUT, + IAXXX_SYSID_DRIVER_TYPE_I2S, + IAXXX_SYSID_DRIVER_TYPE_SLIMBUS_DATA, + IAXXX_SYSID_DRIVER_TYPE_SOUNDWIRE_DATA, + IAXXX_SYSID_DRIVER_TYPE_I3C_DATA, + IAXXX_SYSID_DRIVER_TYPE_SSP, + IAXXX_SYSID_DRIVER_TYPE_AF, + IAXXX_SYSID_DRIVER_TYPE_ADC, + IAXXX_SYSID_DRIVER_TYPE_DAC, + IAXXX_SYSID_DRIVER_TYPE_A400, + IAXXX_SYSID_DRIVER_TYPE_FILTER_IN, + IAXXX_SYSID_DRIVER_TYPE_FILTER_OUT, + IAXXX_SYSID_DRIVER_TYPE_STMR_TIMER, + IAXXX_SYSID_DRIVER_TYPE_STMR_PT, + IAXXX_SYSID_DRIVER_TYPE_SW_TIMER, + IAXXX_SYSID_DRIVER_TYPE_TIMER, + IAXXX_SYSID_DRIVER_TYPE_PLL, + IAXXX_SYSID_DRIVER_TYPE_DMA, + IAXXX_SYSID_DRIVER_TYPE_GPIOA, + IAXXX_SYSID_DRIVER_TYPE_GPIOB, + IAXXX_SYSID_DRIVER_TYPE_REGMAP, + IAXXX_SYSID_DRIVER_TYPE_FLASHDRV, + IAXXX_SYSID_DRIVER_TYPE_BUTTON, + IAXXX_SYSID_DRIVER_TYPE_LED, + IAXXX_SYSID_DRIVER_TYPE_ADAU1361, + IAXXX_SYSID_DRIVER_TYPE_USBDRV, + IAXXX_SYSID_DRIVER_TYPE_CSR8811, + IAXXX_SYSID_DRIVER_TYPE_CYW20707, + IAXXX_SYSID_DRIVER_TYPE_MAC, + IAXXX_SYSID_DRIVER_TYPE_BQ27425, + IAXXX_SYSID_DRIVER_TYPE_SENSOR, + IAXXX_SYSID_DRIVER_TYPE_DMA_STRM, + IAXXX_SYSID_DRIVER_TYPE_CPUSTRMDRV, + IAXXX_SYSID_DRIVER_TYPE_NUM, + IAXXX_SYSID_DRIVER_TYPE_FORCE_SIZE = INT_MAX, +}; +enum sysid_iaxxx_device_type_e { + IAXXX_SYSID_DEVICE_TYPE_BUTTON, + IAXXX_SYSID_DEVICE_TYPE_LED, + IAXXX_SYSID_DEVICE_TYPE_FLASH, + IAXXX_SYSID_DEVICE_TYPE_CODEC, + IAXXX_SYSID_DEVICE_TYPE_SENSOR, + IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, + IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, + IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, + IAXXX_SYSID_DEVICE_TYPE_STMR_PT, + IAXXX_SYSID_DEVICE_TYPE_INTERFACE, + IAXXX_SYSID_DEVICE_TYPE_USB, + IAXXX_SYSID_DEVICE_TYPE_BT, + IAXXX_SYSID_DEVICE_TYPE_BATTERY, + IAXXX_SYSID_DEVICE_TYPE_NUM, + IAXXX_SYSID_DEVICE_TYPE_FORCE_SIZE = INT_MAX, +}; +enum sysid_special_type_e { + IAXXX_SYSID_SPECIAL_TYPE_INVALID = 0, + IAXXX_SYSID_SPECIAL_TYPE_HOST, + IAXXX_SYSID_SPECIAL_TYPE_ALL = 0xF, + IAXXX_SYSID_SPECIAL_TYPE_NUM, + IAXXX_SYSID_SPECIAL_TYPE_FORCE_SIZE = INT_MAX, +}; +enum sysid_dir_e { + IAXXX_SYSID_DIR_IN = 0, + IAXXX_SYSID_DIR_OUT, + IAXXX_SYSID_DIR_FORCE_SIZE = INT_MAX, +}; +#define IAXXX_SYSID_POS_RESOURCE_TYPE (12) +#define IAXXX_SYSID_MASK_RESOURCE_TYPE (0xF000) +#define IAXXX_SYSID_POS_SPECIAL_TYPE (8) +#define IAXXX_SYSID_MASK_SPECIAL_TYPE (0x0F00) +#define IAXXX_SYSID_POS_SPECIAL_INST_INDEX (0) +#define IAXXX_SYSID_MASK_SPECIAL_INST_INDEX (0x00FF) +#define IAXXX_SYSID_POS_DRIVER_TYPE (5) +#define IAXXX_SYSID_MASK_DRIVER_TYPE (0x0FE0) +#define IAXXX_SYSID_POS_DRIVER_INST_INDEX (0) +#define IAXXX_SYSID_MASK_DRIVER_INST_INDEX (0x001F) +#define IAXXX_SYSID_POS_MODULE_PROC_ID (9) +#define IAXXX_SYSID_MASK_MODULE_PROC_ID (0x0E00) +#define IAXXX_SYSID_POS_MODULE_TYPE (4) +#define IAXXX_SYSID_MASK_MODULE_TYPE (0x01F0) +#define IAXXX_SYSID_POS_MODULE_INST (0) +#define IAXXX_SYSID_MASK_MODULE_INST (0x000F) +#define IAXXX_SYSID_POS_PLUGIN_ID (6) +#define IAXXX_SYSID_MASK_PLUGIN_ID (0x0FC0) +#define IAXXX_SYSID_POS_PLUGIN_EP_DIR (5) +#define IAXXX_SYSID_MASK_PLUGIN_EP_DIR (0x0020) +#define IAXXX_SYSID_POS_PLUGIN_EP_INDEX (0) +#define IAXXX_SYSID_MASK_PLUGIN_EP_INDEX (0x001F) +#define IAXXX_SYSID_POS_CHANNEL_ID (6) +#define IAXXX_SYSID_MASK_CHANNEL_ID (0x0FC0) +#define IAXXX_SYSID_POS_CHANNEL_EP_DIR (5) +#define IAXXX_SYSID_MASK_CHANNEL_EP_DIR (0x0020) +#define IAXXX_SYSID_POS_CHANNEL_EP_INDEX (0) +#define IAXXX_SYSID_MASK_CHANNEL_EP_INDEX (0x001F) +#define IAXXX_SYSID_POS_TUNNEL_ID (6) +#define IAXXX_SYSID_MASK_TUNNEL_ID (0x0FC0) +#define IAXXX_SYSID_POS_TUNNEL_EP_DIR (5) +#define IAXXX_SYSID_MASK_TUNNEL_EP_DIR (0x0020) +#define IAXXX_SYSID_POS_TUNNEL_EP_INDEX (0) +#define IAXXX_SYSID_MASK_TUNNEL_EP_INDEX (0x001F) +#define IAXXX_SYSID_POS_BT_ID (6) +#define IAXXX_SYSID_MASK_BT_ID (0x0FC0) +#define IAXXX_SYSID_POS_BT_EP_DIR (5) +#define IAXXX_SYSID_MASK_BT_EP_DIR (0x0020) +#define IAXXX_SYSID_POS_BT_EP_INDEX (0) +#define IAXXX_SYSID_MASK_BT_EP_INDEX (0x001F) +#define IAXXX_SYSID_POS_SENSOR_ID (6) +#define IAXXX_SYSID_MASK_SENSOR_ID (0x0FC0) +#define IAXXX_SYSID_POS_SENSOR_EP_DIR (5) +#define IAXXX_SYSID_MASK_SENSOR_EP_DIR (0x0020) +#define IAXXX_SYSID_POS_SENSOR_EP_INDEX (0) +#define IAXXX_SYSID_MASK_SENSOR_EP_INDEX (0x001F) +#define IAXXX_SYSID_POS_DEBUG_PROC_ID (9) +#define IAXXX_SYSID_MASK_DEBUG_PROC_ID (0x0E00) +#define IAXXX_SYSID_POS_DEBUG_TYPE_DIR (6) +#define IAXXX_SYSID_MASK_DEBUG_TYPE_DIR (0x01C0) +#define IAXXX_SYSID_POS_DEBUG_EP_DIR (5) +#define IAXXX_SYSID_MASK_DEBUG_EP_DIR (0x0020) +#define IAXXX_SYSID_POS_DEBUG_EP_INDEX (0) +#define IAXXX_SYSID_MASK_DEBUG_EP_INDEX (0x001F) +#define IAXXX_SYSID_POS_STREAM_ID (0) +#define IAXXX_SYSID_MASK_STREAM_ID (0x001F) +#define IAXXX_SYSID_POS_DEVICE_ID (6) +#define IAXXX_SYSID_MASK_DEVICE_ID (0x0FC0) +#define IAXXX_SYSID_POS_DEVICE_INST (0) +#define IAXXX_SYSID_MASK_DEVICE_INST (0x003F) +#define IAXXX_SYSID_GET_RESOURCE_TYPE(id) (((id) & IAXXX_SYSID_MASK_RESOURCE_TYPE) >> IAXXX_SYSID_POS_RESOURCE_TYPE) +#define IAXXX_SYSID_IS_SPECIAL(id) (IAXXX_SYSID_GET_RESOURCE_TYPE(id) == IAXXX_SYSID_RESOURCE_TYPE_SPECIAL) +#define IAXXX_SYSID_IS_DRIVER(id) (IAXXX_SYSID_GET_RESOURCE_TYPE(id) == IAXXX_SYSID_RESOURCE_TYPE_DRIVER) +#define IAXXX_SYSID_IS_DEVICE(id) (IAXXX_SYSID_GET_RESOURCE_TYPE(id) == IAXXX_SYSID_RESOURCE_TYPE_DEVICE) +#define IAXXX_SYSID_IS_MODULE(id) (IAXXX_SYSID_GET_RESOURCE_TYPE(id) == IAXXX_SYSID_RESOURCE_TYPE_MODULE) +#define IAXXX_SYSID_IS_PLUGIN(id) (IAXXX_SYSID_GET_RESOURCE_TYPE(id) == IAXXX_SYSID_RESOURCE_TYPE_PLUGIN) +#define IAXXX_SYSID_IS_CHANNEL(id) (IAXXX_SYSID_GET_RESOURCE_TYPE(id) == IAXXX_SYSID_RESOURCE_TYPE_CHANNEL) +#define IAXXX_SYSID_IS_TUNNEL(id) (IAXXX_SYSID_GET_RESOURCE_TYPE(id) == IAXXX_SYSID_RESOURCE_TYPE_TUNNEL) +#define IAXXX_SYSID_IS_STREAM(id) (IAXXX_SYSID_GET_RESOURCE_TYPE(id) == IAXXX_SYSID_RESOURCE_TYPE_STREAM) +#define IAXXX_SYSID_IS_BT(id) (IAXXX_SYSID_GET_RESOURCE_TYPE(id) == IAXXX_SYSID_RESOURCE_TYPE_BT) +#define IAXXX_SYSID_IS_SENSOR(id) (IAXXX_SYSID_GET_RESOURCE_TYPE(id) == IAXXX_SYSID_RESOURCE_TYPE_SENSOR) +#define IAXXX_SYSID_IS_DEBUG(id) (IAXXX_SYSID_GET_RESOURCE_TYPE(id) == IAXXX_SYSID_RESOURCE_TYPE_DEBUG) +#define IAXXX_SYSID_IS_HOST(id) ((IAXXX_SYSID_IS_SPECIAL(id)) && (IAXXX_SYSID_GET_SPECIAL_TYPE(id) == IAXXX_SYSID_SPECIAL_TYPE_HOST)) +#define IAXXX_SYSID_GEN_SPECIAL_SYSID(type,index) (((IAXXX_SYSID_RESOURCE_TYPE_SPECIAL << IAXXX_SYSID_POS_RESOURCE_TYPE) & IAXXX_SYSID_MASK_RESOURCE_TYPE) | (((type) << IAXXX_SYSID_POS_SPECIAL_TYPE) & IAXXX_SYSID_MASK_SPECIAL_TYPE) | (((index) << IAXXX_SYSID_POS_SPECIAL_INST_INDEX) & IAXXX_SYSID_MASK_SPECIAL_INST_INDEX)) +#define IAXXX_SYSID_GET_SPECIAL_TYPE(sysId) (((sysId) & IAXXX_SYSID_MASK_SPECIAL_TYPE) >> IAXXX_SYSID_POS_SPECIAL_TYPE) +#define IAXXX_SYSID_GET_SPECIAL_INST_INDEX(sysId) (((sysId) & IAXXX_SYSID_MASK_SPECIAL_INST_INDEX) >> IAXXX_SYSID_POS_SPECIAL_INST_INDEX) +#define IAXXX_SYSID_GET_HOST_ID(sysId) IAXXX_SYSID_GET_SPECIAL_INST_INDEX(sysId) +#define IAXXX_SYSID_GEN_DRIVER_SYSID(type,index) (((IAXXX_SYSID_RESOURCE_TYPE_DRIVER << IAXXX_SYSID_POS_RESOURCE_TYPE) & IAXXX_SYSID_MASK_RESOURCE_TYPE) | (((type) << IAXXX_SYSID_POS_DRIVER_TYPE) & IAXXX_SYSID_MASK_DRIVER_TYPE) | (((index) << IAXXX_SYSID_POS_DRIVER_INST_INDEX) & IAXXX_SYSID_MASK_DRIVER_INST_INDEX)) +#define IAXXX_SYSID_GET_DRIVER_TYPE(sysId) (((sysId) & IAXXX_SYSID_MASK_DRIVER_TYPE) >> IAXXX_SYSID_POS_DRIVER_TYPE) +#define IAXXX_SYSID_GET_DRIVER_INST_INDEX(sysId) (((sysId) & IAXXX_SYSID_MASK_DRIVER_INST_INDEX) >> IAXXX_SYSID_POS_DRIVER_INST_INDEX) +#define IAXXX_SYSID_GEN_MODULE_SYSID(procId,modType,modInst) (((IAXXX_SYSID_RESOURCE_TYPE_MODULE << IAXXX_SYSID_POS_RESOURCE_TYPE) & IAXXX_SYSID_MASK_RESOURCE_TYPE) | (((procId) << IAXXX_SYSID_POS_MODULE_PROC_ID) & IAXXX_SYSID_MASK_MODULE_PROC_ID) | (((modType) << IAXXX_SYSID_POS_MODULE_TYPE) & IAXXX_SYSID_MASK_MODULE_TYPE) | (((modInst) << IAXXX_SYSID_POS_MODULE_INST) & IAXXX_SYSID_MASK_MODULE_INST)) +#define IAXXX_SYSID_GET_MODULE_PROC_ID(sysId) \ +(((sysId) & IAXXX_SYSID_MASK_MODULE_PROC_ID) >> IAXXX_SYSID_POS_MODULE_PROC_ID) +#define IAXXX_SYSID_GET_MODULE_TYPE(sysId) \ +(((sysId) & IAXXX_SYSID_MASK_MODULE_TYPE) >> IAXXX_SYSID_POS_MODULE_TYPE) +#define IAXXX_SYSID_GET_MODULE_INST(sysId) \ +(((sysId) & IAXXX_SYSID_MASK_MODULE_INST) >> IAXXX_SYSID_POS_MODULE_INST) +#define IAXXX_SYSID_INDEX_VALUE_PLUGIN_INST (0x001F) +#define IAXXX_SYSID_GEN_PLUGIN_SYSID(pluginId,dir,index) (((IAXXX_SYSID_RESOURCE_TYPE_PLUGIN << IAXXX_SYSID_POS_RESOURCE_TYPE) & IAXXX_SYSID_MASK_RESOURCE_TYPE) | (((pluginId) << IAXXX_SYSID_POS_PLUGIN_ID) & IAXXX_SYSID_MASK_PLUGIN_ID) | (((dir) << IAXXX_SYSID_POS_PLUGIN_EP_DIR) & IAXXX_SYSID_MASK_PLUGIN_EP_DIR) | (((index) << IAXXX_SYSID_POS_PLUGIN_EP_INDEX) & IAXXX_SYSID_MASK_PLUGIN_EP_INDEX)) +#define IAXXX_SYSID_GET_PLUGIN_ID(sysId) (((sysId) & IAXXX_SYSID_MASK_PLUGIN_ID) >> IAXXX_SYSID_POS_PLUGIN_ID) +#define IAXXX_SYSID_GET_PLUGIN_EP_DIR(sysId) (((sysId) & IAXXX_SYSID_MASK_PLUGIN_EP_DIR) >> IAXXX_SYSID_POS_PLUGIN_EP_DIR) +#define IAXXX_SYSID_GET_PLUGIN_EP_INDEX(sysId) (((sysId) & IAXXX_SYSID_MASK_PLUGIN_EP_INDEX) >> IAXXX_SYSID_POS_PLUGIN_EP_INDEX) +#define IAXXX_SYSID_INDEX_VALUE_CHANNEL (0x001F) +#define IAXXX_SYSID_GEN_CHANNEL_SYSID(channelId,dir,index) (((IAXXX_SYSID_RESOURCE_TYPE_CHANNEL << IAXXX_SYSID_POS_RESOURCE_TYPE) & IAXXX_SYSID_MASK_RESOURCE_TYPE) | (((channelId) << IAXXX_SYSID_POS_CHANNEL_ID) & IAXXX_SYSID_MASK_CHANNEL_ID) | (((dir) << IAXXX_SYSID_POS_CHANNEL_EP_DIR) & IAXXX_SYSID_MASK_CHANNEL_EP_DIR) | (((index) << IAXXX_SYSID_POS_CHANNEL_EP_INDEX) & IAXXX_SYSID_MASK_CHANNEL_EP_INDEX)) +#define IAXXX_SYSID_GET_CHANNEL_ID(sysId) (((sysId) & IAXXX_SYSID_MASK_CHANNEL_ID) >> IAXXX_SYSID_POS_CHANNEL_ID) +#define IAXXX_SYSID_GET_CHANNEL_EP_DIR(sysId) (((sysId) & IAXXX_SYSID_MASK_CHANNEL_EP_DIR) >> IAXXX_SYSID_POS_CHANNEL_EP_DIR) +#define IAXXX_SYSID_GET_CHANNEL_EP_INDEX(sysId) (((sysId) & IAXXX_SYSID_MASK_CHANNEL_EP_INDEX) >> IAXXX_SYSID_POS_CHANNEL_EP_INDEX) +#define IAXXX_SYSID_INDEX_VALUE_TUNNEL (0x001F) +#define IAXXX_SYSID_GEN_TUNNEL_SYSID(tunnelId,dir,index) (((IAXXX_SYSID_RESOURCE_TYPE_TUNNEL << IAXXX_SYSID_POS_RESOURCE_TYPE) & IAXXX_SYSID_MASK_RESOURCE_TYPE) | (((tunnelId) << IAXXX_SYSID_POS_TUNNEL_ID) & IAXXX_SYSID_MASK_TUNNEL_ID) | (((dir) << IAXXX_SYSID_POS_TUNNEL_EP_DIR) & IAXXX_SYSID_MASK_TUNNEL_EP_DIR) | (((index) << IAXXX_SYSID_POS_TUNNEL_EP_INDEX) & IAXXX_SYSID_MASK_TUNNEL_EP_INDEX)) +#define IAXXX_SYSID_GET_TUNNEL_ID(sysId) \ +(((sysId) & IAXXX_SYSID_MASK_TUNNEL_ID) >> IAXXX_SYSID_POS_TUNNEL_ID) +#define IAXXX_SYSID_GET_TUNNEL_EP_DIR(sysId) \ +(((sysId) & IAXXX_SYSID_MASK_TUNNEL_EP_DIR) >> IAXXX_SYSID_POS_TUNNEL_EP_DIR) +#define IAXXX_SYSID_GET_TUNNEL_EP_INDEX(sysId) (((sysId) & IAXXX_SYSID_MASK_TUNNEL_EP_INDEX) >> IAXXX_SYSID_POS_TUNNEL_EP_INDEX) +#define IAXXX_SYSID_GEN_BT_SYSID(btId,dir,index) (((IAXXX_SYSID_RESOURCE_TYPE_BT << IAXXX_SYSID_POS_RESOURCE_TYPE) & IAXXX_SYSID_MASK_RESOURCE_TYPE) | (((btId) << IAXXX_SYSID_POS_BT_ID) & IAXXX_SYSID_MASK_BT_ID) | (((dir) << IAXXX_SYSID_POS_BT_EP_DIR) & IAXXX_SYSID_MASK_BT_EP_DIR) | (((index) << IAXXX_SYSID_POS_BT_EP_INDEX) & IAXXX_SYSID_MASK_BT_EP_INDEX)) +#define IAXXX_SYSID_GET_BT_ID(sysId) \ +(((sysId) & IAXXX_SYSID_MASK_BT_ID) >> IAXXX_SYSID_POS_BT_ID) +#define IAXXX_SYSID_GET_BT_EP_DIR(sysId) \ +(((sysId) & IAXXX_SYSID_MASK_BT_EP_DIR) >> IAXXX_SYSID_POS_BT_EP_DIR) +#define IAXXX_SYSID_GET_BT_EP_INDEX(sysId) \ +{ ((sysId) & IAXXX_SYSID_MASK_BT_EP_INDEX) >> IAXXX_SYSID_POS_BT_EP_INDEX) } +#define IAXXX_SYSID_GEN_SENSOR_SYSID(sensorId,dir,index) (((IAXXX_SYSID_RESOURCE_TYPE_SENSOR << IAXXX_SYSID_POS_RESOURCE_TYPE) & IAXXX_SYSID_MASK_RESOURCE_TYPE) | (((sensorId) << IAXXX_SYSID_POS_SENSOR_ID) & IAXXX_SYSID_MASK_SENSOR_ID) | (((dir) << IAXXX_SYSID_POS_SENSOR_EP_DIR) & IAXXX_SYSID_MASK_SENSOR_EP_DIR) | (((index) << IAXXX_SYSID_POS_SENSOR_EP_INDEX) & IAXXX_SYSID_MASK_SENSOR_EP_INDEX)) +#define IAXXX_SYSID_GET_SENSOR_ID(sysId) \ +(((sysId) & IAXXX_SYSID_MASK_SENSOR_ID) >> IAXXX_SYSID_POS_SENSOR_ID) +#define IAXXX_SYSID_GET_SENSOR_EP_DIR(sysId) \ +(((sysId) & IAXXX_SYSID_MASK_SENSOR_EP_DIR) >> IAXXX_SYSID_POS_SENSOR_EP_DIR) +#define IAXXX_SYSID_GET_SENSOR_EP_INDEX(sysId) (((sysId) & IAXXX_SYSID_MASK_SENSOR_EP_INDEX) >> IAXXX_SYSID_POS_SENSOR_EP_INDEX) +#define IAXXX_SYSID_GEN_DEBUG_SYSID(procId,type,dir,index) (((IAXXX_SYSID_RESOURCE_TYPE_DEBUG << IAXXX_SYSID_POS_RESOURCE_TYPE) & IAXXX_SYSID_MASK_RESOURCE_TYPE) | (((procId) << IAXXX_SYSID_POS_DEBUG_PROC_ID) & IAXXX_SYSID_MASK_DEBUG_PROC_ID) | (((type) << IAXXX_SYSID_POS_DEBUG_TYPE_DIR) & IAXXX_SYSID_MASK_DEBUG_TYPE_DIR) | (((dir) << IAXXX_SYSID_POS_DEBUG_EP_DIR) & IAXXX_SYSID_MASK_DEBUG_EP_DIR) | (((index) << IAXXX_SYSID_POS_DEBUG_EP_INDEX) & IAXXX_SYSID_MASK_DEBUG_EP_INDEX)) +#define IAXXX_SYSID_GET_DEBUG_CORE(sysId) \ +(((sysId) & IAXXX_SYSID_MASK_DEBUG_PROC_ID) >> IAXXX_SYSID_POS_DEBUG_PROC_ID) +#define IAXXX_SYSID_GET_DEBUG_TYPE(sysId) \ +(((sysId) & IAXXX_SYSID_MASK_DEBUG_TYPE_DIR) >> IAXXX_SYSID_POS_DEBUG_TYPE_DIR) +#define IAXXX_SYSID_GET_DEBUG_EP_DIR(sysId) \ +(((sysId) & IAXXX_SYSID_MASK_DEBUG_EP_DIR) >> IAXXX_SYSID_POS_DEBUG_EP_DIR) +#define IAXXX_SYSID_GET_DEBUG_EP_INDEX(sysId) \ +(((sysId) & IAXXX_SYSID_MASK_DEBUG_EP_INDEX) >> IAXXX_SYSID_POS_DEBUG_EP_INDEX) +#define IAXXX_SYSID_GEN_STREAM_SYSID(streamId) (((IAXXX_SYSID_RESOURCE_TYPE_STREAM << IAXXX_SYSID_POS_RESOURCE_TYPE) & IAXXX_SYSID_MASK_RESOURCE_TYPE) | (((streamId) << IAXXX_SYSID_POS_STREAM_ID) & IAXXX_SYSID_MASK_STREAM_ID)) +#define IAXXX_SYSID_GET_STREAM_ID(sysId) (((sysId) & IAXXX_SYSID_MASK_STREAM_ID) >> IAXXX_SYSID_POS_STREAM_ID) +#define IAXXX_SYSID_GEN_DEVICE_SYSID(deviceId,inst) (((IAXXX_SYSID_RESOURCE_TYPE_DEVICE << IAXXX_SYSID_POS_RESOURCE_TYPE) & IAXXX_SYSID_MASK_RESOURCE_TYPE) | (((deviceId) << IAXXX_SYSID_POS_DEVICE_ID) & IAXXX_SYSID_MASK_DEVICE_ID) | (((inst) << IAXXX_SYSID_POS_DEVICE_INST) & IAXXX_SYSID_MASK_DEVICE_INST)) +#define IAXXX_SYSID_GET_DEVICE_ID(sysId) \ +(((sysId) & IAXXX_SYSID_MASK_DEVICE_ID) >> IAXXX_SYSID_POS_DEVICE_ID) +#define IAXXX_SYSID_GET_DEVICE_INST(sysId) \ +(((sysId) & IAXXX_SYSID_MASK_DEVICE_INST) >> IAXXX_SYSID_POS_DEVICE_INST) +#define IAXXX_SYSID_INVALID IAXXX_SYSID_GEN_SPECIAL_SYSID(IAXXX_SYSID_SPECIAL_TYPE_INVALID, 0) +#define IAXXX_SYSID_HOST IAXXX_SYSID_GEN_SPECIAL_SYSID(IAXXX_SYSID_SPECIAL_TYPE_HOST, 0) +#define IAXXX_SYSID_HOST_0 IAXXX_SYSID_GEN_SPECIAL_SYSID(IAXXX_SYSID_SPECIAL_TYPE_HOST, 0) +#define IAXXX_SYSID_HOST_1 IAXXX_SYSID_GEN_SPECIAL_SYSID(IAXXX_SYSID_SPECIAL_TYPE_HOST, 1) +typedef uint16_t iaxxx_system_id_t; +#endif diff --git a/iaxxx-system-identifiers.h b/iaxxx-system-identifiers.h new file mode 100644 index 0000000..069d747 --- /dev/null +++ b/iaxxx-system-identifiers.h @@ -0,0 +1,342 @@ +/**************************************************************************** + **************************************************************************** + *** + *** This header was automatically generated from a Linux kernel header + *** of the same name, to make information necessary for userspace to + *** call into the kernel available to libc. It contains only constants, + *** structures, and macros generated from the original header, and thus, + *** contains no copyrightable information. + *** + *** To edit the content of this header, modify the corresponding + *** source file (e.g. under external/kernel-headers/original/) then + *** run bionic/libc/kernel/tools/update_all.py + *** + *** Any manual change here will be lost the next time this script will + *** be run. You've been warned! + *** + **************************************************************************** + ****************************************************************************/ +#ifndef __IAXXX_SYSTEM_IDENTIFIERS_H__ +#define __IAXXX_SYSTEM_IDENTIFIERS_H__ +#include "iaxxx-systemids.h" +#define IAXXX_SYSID_CHANNEL_RX_0_EP_0 IAXXX_SYSID_GEN_CHANNEL_SYSID(0, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_CHANNEL_RX_1_EP_0 IAXXX_SYSID_GEN_CHANNEL_SYSID(1, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_CHANNEL_RX_2_EP_0 IAXXX_SYSID_GEN_CHANNEL_SYSID(2, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_CHANNEL_RX_3_EP_0 IAXXX_SYSID_GEN_CHANNEL_SYSID(3, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_CHANNEL_RX_4_EP_0 IAXXX_SYSID_GEN_CHANNEL_SYSID(4, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_CHANNEL_RX_5_EP_0 IAXXX_SYSID_GEN_CHANNEL_SYSID(5, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_CHANNEL_RX_6_EP_0 IAXXX_SYSID_GEN_CHANNEL_SYSID(6, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_CHANNEL_RX_7_EP_0 IAXXX_SYSID_GEN_CHANNEL_SYSID(7, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_CHANNEL_RX_8_EP_0 IAXXX_SYSID_GEN_CHANNEL_SYSID(8, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_CHANNEL_RX_9_EP_0 IAXXX_SYSID_GEN_CHANNEL_SYSID(9, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_CHANNEL_RX_10_EP_0 IAXXX_SYSID_GEN_CHANNEL_SYSID(10, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_CHANNEL_RX_11_EP_0 IAXXX_SYSID_GEN_CHANNEL_SYSID(11, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_CHANNEL_RX_12_EP_0 IAXXX_SYSID_GEN_CHANNEL_SYSID(12, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_CHANNEL_RX_13_EP_0 IAXXX_SYSID_GEN_CHANNEL_SYSID(13, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_CHANNEL_RX_14_EP_0 IAXXX_SYSID_GEN_CHANNEL_SYSID(14, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_CHANNEL_RX_15_EP_0 IAXXX_SYSID_GEN_CHANNEL_SYSID(15, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_PLUGIN_0_OUT_EP_0 IAXXX_SYSID_GEN_PLUGIN_SYSID(0, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_PLUGIN_0_OUT_EP_1 IAXXX_SYSID_GEN_PLUGIN_SYSID(0, IAXXX_SYSID_DIR_OUT, 1) +#define IAXXX_SYSID_PLUGIN_0_OUT_EP_2 IAXXX_SYSID_GEN_PLUGIN_SYSID(0, IAXXX_SYSID_DIR_OUT, 2) +#define IAXXX_SYSID_PLUGIN_0_OUT_EP_3 IAXXX_SYSID_GEN_PLUGIN_SYSID(0, IAXXX_SYSID_DIR_OUT, 3) +#define IAXXX_SYSID_PLUGIN_0_OUT_EP_4 IAXXX_SYSID_GEN_PLUGIN_SYSID(0, IAXXX_SYSID_DIR_OUT, 4) +#define IAXXX_SYSID_PLUGIN_0_OUT_EP_5 IAXXX_SYSID_GEN_PLUGIN_SYSID(0, IAXXX_SYSID_DIR_OUT, 5) +#define IAXXX_SYSID_PLUGIN_0_OUT_EP_6 IAXXX_SYSID_GEN_PLUGIN_SYSID(0, IAXXX_SYSID_DIR_OUT, 6) +#define IAXXX_SYSID_PLUGIN_0_OUT_EP_7 IAXXX_SYSID_GEN_PLUGIN_SYSID(0, IAXXX_SYSID_DIR_OUT, 7) +#define IAXXX_SYSID_PLUGIN_0_OUT_EP_8 IAXXX_SYSID_GEN_PLUGIN_SYSID(0, IAXXX_SYSID_DIR_OUT, 8) +#define IAXXX_SYSID_PLUGIN_0_OUT_EP_9 IAXXX_SYSID_GEN_PLUGIN_SYSID(0, IAXXX_SYSID_DIR_OUT, 9) +#define IAXXX_SYSID_PLUGIN_0_OUT_EP_10 IAXXX_SYSID_GEN_PLUGIN_SYSID(0, IAXXX_SYSID_DIR_OUT, 10) +#define IAXXX_SYSID_PLUGIN_0_OUT_EP_11 IAXXX_SYSID_GEN_PLUGIN_SYSID(0, IAXXX_SYSID_DIR_OUT, 11) +#define IAXXX_SYSID_PLUGIN_0_OUT_EP_12 IAXXX_SYSID_GEN_PLUGIN_SYSID(0, IAXXX_SYSID_DIR_OUT, 12) +#define IAXXX_SYSID_PLUGIN_0_OUT_EP_13 IAXXX_SYSID_GEN_PLUGIN_SYSID(0, IAXXX_SYSID_DIR_OUT, 13) +#define IAXXX_SYSID_PLUGIN_0_OUT_EP_14 IAXXX_SYSID_GEN_PLUGIN_SYSID(0, IAXXX_SYSID_DIR_OUT, 14) +#define IAXXX_SYSID_PLUGIN_0_OUT_EP_15 IAXXX_SYSID_GEN_PLUGIN_SYSID(0, IAXXX_SYSID_DIR_OUT, 15) +#define IAXXX_SYSID_PLUGIN_1_OUT_EP_0 IAXXX_SYSID_GEN_PLUGIN_SYSID(1, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_PLUGIN_1_OUT_EP_1 IAXXX_SYSID_GEN_PLUGIN_SYSID(1, IAXXX_SYSID_DIR_OUT, 1) +#define IAXXX_SYSID_PLUGIN_1_OUT_EP_2 IAXXX_SYSID_GEN_PLUGIN_SYSID(1, IAXXX_SYSID_DIR_OUT, 2) +#define IAXXX_SYSID_PLUGIN_1_OUT_EP_3 IAXXX_SYSID_GEN_PLUGIN_SYSID(1, IAXXX_SYSID_DIR_OUT, 3) +#define IAXXX_SYSID_PLUGIN_1_OUT_EP_4 IAXXX_SYSID_GEN_PLUGIN_SYSID(1, IAXXX_SYSID_DIR_OUT, 4) +#define IAXXX_SYSID_PLUGIN_1_OUT_EP_5 IAXXX_SYSID_GEN_PLUGIN_SYSID(1, IAXXX_SYSID_DIR_OUT, 5) +#define IAXXX_SYSID_PLUGIN_1_OUT_EP_6 IAXXX_SYSID_GEN_PLUGIN_SYSID(1, IAXXX_SYSID_DIR_OUT, 6) +#define IAXXX_SYSID_PLUGIN_1_OUT_EP_7 IAXXX_SYSID_GEN_PLUGIN_SYSID(1, IAXXX_SYSID_DIR_OUT, 7) +#define IAXXX_SYSID_PLUGIN_1_OUT_EP_8 IAXXX_SYSID_GEN_PLUGIN_SYSID(1, IAXXX_SYSID_DIR_OUT, 8) +#define IAXXX_SYSID_PLUGIN_1_OUT_EP_9 IAXXX_SYSID_GEN_PLUGIN_SYSID(1, IAXXX_SYSID_DIR_OUT, 9) +#define IAXXX_SYSID_PLUGIN_1_OUT_EP_10 IAXXX_SYSID_GEN_PLUGIN_SYSID(1, IAXXX_SYSID_DIR_OUT, 10) +#define IAXXX_SYSID_PLUGIN_1_OUT_EP_11 IAXXX_SYSID_GEN_PLUGIN_SYSID(1, IAXXX_SYSID_DIR_OUT, 11) +#define IAXXX_SYSID_PLUGIN_1_OUT_EP_12 IAXXX_SYSID_GEN_PLUGIN_SYSID(1, IAXXX_SYSID_DIR_OUT, 12) +#define IAXXX_SYSID_PLUGIN_1_OUT_EP_13 IAXXX_SYSID_GEN_PLUGIN_SYSID(1, IAXXX_SYSID_DIR_OUT, 13) +#define IAXXX_SYSID_PLUGIN_1_OUT_EP_14 IAXXX_SYSID_GEN_PLUGIN_SYSID(1, IAXXX_SYSID_DIR_OUT, 14) +#define IAXXX_SYSID_PLUGIN_1_OUT_EP_15 IAXXX_SYSID_GEN_PLUGIN_SYSID(1, IAXXX_SYSID_DIR_OUT, 15) +#define IAXXX_SYSID_PLUGIN_2_OUT_EP_0 IAXXX_SYSID_GEN_PLUGIN_SYSID(2, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_PLUGIN_2_OUT_EP_1 IAXXX_SYSID_GEN_PLUGIN_SYSID(2, IAXXX_SYSID_DIR_OUT, 1) +#define IAXXX_SYSID_PLUGIN_2_OUT_EP_2 IAXXX_SYSID_GEN_PLUGIN_SYSID(2, IAXXX_SYSID_DIR_OUT, 2) +#define IAXXX_SYSID_PLUGIN_2_OUT_EP_3 IAXXX_SYSID_GEN_PLUGIN_SYSID(2, IAXXX_SYSID_DIR_OUT, 3) +#define IAXXX_SYSID_PLUGIN_2_OUT_EP_4 IAXXX_SYSID_GEN_PLUGIN_SYSID(2, IAXXX_SYSID_DIR_OUT, 4) +#define IAXXX_SYSID_PLUGIN_2_OUT_EP_5 IAXXX_SYSID_GEN_PLUGIN_SYSID(2, IAXXX_SYSID_DIR_OUT, 5) +#define IAXXX_SYSID_PLUGIN_2_OUT_EP_6 IAXXX_SYSID_GEN_PLUGIN_SYSID(2, IAXXX_SYSID_DIR_OUT, 6) +#define IAXXX_SYSID_PLUGIN_2_OUT_EP_7 IAXXX_SYSID_GEN_PLUGIN_SYSID(2, IAXXX_SYSID_DIR_OUT, 7) +#define IAXXX_SYSID_PLUGIN_2_OUT_EP_8 IAXXX_SYSID_GEN_PLUGIN_SYSID(2, IAXXX_SYSID_DIR_OUT, 8) +#define IAXXX_SYSID_PLUGIN_2_OUT_EP_9 IAXXX_SYSID_GEN_PLUGIN_SYSID(2, IAXXX_SYSID_DIR_OUT, 9) +#define IAXXX_SYSID_PLUGIN_2_OUT_EP_10 IAXXX_SYSID_GEN_PLUGIN_SYSID(2, IAXXX_SYSID_DIR_OUT, 10) +#define IAXXX_SYSID_PLUGIN_2_OUT_EP_11 IAXXX_SYSID_GEN_PLUGIN_SYSID(2, IAXXX_SYSID_DIR_OUT, 11) +#define IAXXX_SYSID_PLUGIN_2_OUT_EP_12 IAXXX_SYSID_GEN_PLUGIN_SYSID(2, IAXXX_SYSID_DIR_OUT, 12) +#define IAXXX_SYSID_PLUGIN_2_OUT_EP_13 IAXXX_SYSID_GEN_PLUGIN_SYSID(2, IAXXX_SYSID_DIR_OUT, 13) +#define IAXXX_SYSID_PLUGIN_2_OUT_EP_14 IAXXX_SYSID_GEN_PLUGIN_SYSID(2, IAXXX_SYSID_DIR_OUT, 14) +#define IAXXX_SYSID_PLUGIN_2_OUT_EP_15 IAXXX_SYSID_GEN_PLUGIN_SYSID(2, IAXXX_SYSID_DIR_OUT, 15) +#define IAXXX_SYSID_PLUGIN_3_OUT_EP_0 IAXXX_SYSID_GEN_PLUGIN_SYSID(3, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_PLUGIN_3_OUT_EP_1 IAXXX_SYSID_GEN_PLUGIN_SYSID(3, IAXXX_SYSID_DIR_OUT, 1) +#define IAXXX_SYSID_PLUGIN_3_OUT_EP_2 IAXXX_SYSID_GEN_PLUGIN_SYSID(3, IAXXX_SYSID_DIR_OUT, 2) +#define IAXXX_SYSID_PLUGIN_3_OUT_EP_3 IAXXX_SYSID_GEN_PLUGIN_SYSID(3, IAXXX_SYSID_DIR_OUT, 3) +#define IAXXX_SYSID_PLUGIN_3_OUT_EP_4 IAXXX_SYSID_GEN_PLUGIN_SYSID(3, IAXXX_SYSID_DIR_OUT, 4) +#define IAXXX_SYSID_PLUGIN_3_OUT_EP_5 IAXXX_SYSID_GEN_PLUGIN_SYSID(3, IAXXX_SYSID_DIR_OUT, 5) +#define IAXXX_SYSID_PLUGIN_3_OUT_EP_6 IAXXX_SYSID_GEN_PLUGIN_SYSID(3, IAXXX_SYSID_DIR_OUT, 6) +#define IAXXX_SYSID_PLUGIN_3_OUT_EP_7 IAXXX_SYSID_GEN_PLUGIN_SYSID(3, IAXXX_SYSID_DIR_OUT, 7) +#define IAXXX_SYSID_PLUGIN_3_OUT_EP_8 IAXXX_SYSID_GEN_PLUGIN_SYSID(3, IAXXX_SYSID_DIR_OUT, 8) +#define IAXXX_SYSID_PLUGIN_3_OUT_EP_9 IAXXX_SYSID_GEN_PLUGIN_SYSID(3, IAXXX_SYSID_DIR_OUT, 9) +#define IAXXX_SYSID_PLUGIN_3_OUT_EP_10 IAXXX_SYSID_GEN_PLUGIN_SYSID(3, IAXXX_SYSID_DIR_OUT, 10) +#define IAXXX_SYSID_PLUGIN_3_OUT_EP_11 IAXXX_SYSID_GEN_PLUGIN_SYSID(3, IAXXX_SYSID_DIR_OUT, 11) +#define IAXXX_SYSID_PLUGIN_3_OUT_EP_12 IAXXX_SYSID_GEN_PLUGIN_SYSID(3, IAXXX_SYSID_DIR_OUT, 12) +#define IAXXX_SYSID_PLUGIN_3_OUT_EP_13 IAXXX_SYSID_GEN_PLUGIN_SYSID(3, IAXXX_SYSID_DIR_OUT, 13) +#define IAXXX_SYSID_PLUGIN_3_OUT_EP_14 IAXXX_SYSID_GEN_PLUGIN_SYSID(3, IAXXX_SYSID_DIR_OUT, 14) +#define IAXXX_SYSID_PLUGIN_3_OUT_EP_15 IAXXX_SYSID_GEN_PLUGIN_SYSID(3, IAXXX_SYSID_DIR_OUT, 15) +#define IAXXX_SYSID_PLUGIN_4_OUT_EP_0 IAXXX_SYSID_GEN_PLUGIN_SYSID(4, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_PLUGIN_4_OUT_EP_1 IAXXX_SYSID_GEN_PLUGIN_SYSID(4, IAXXX_SYSID_DIR_OUT, 1) +#define IAXXX_SYSID_PLUGIN_4_OUT_EP_2 IAXXX_SYSID_GEN_PLUGIN_SYSID(4, IAXXX_SYSID_DIR_OUT, 2) +#define IAXXX_SYSID_PLUGIN_4_OUT_EP_3 IAXXX_SYSID_GEN_PLUGIN_SYSID(4, IAXXX_SYSID_DIR_OUT, 3) +#define IAXXX_SYSID_PLUGIN_4_OUT_EP_4 IAXXX_SYSID_GEN_PLUGIN_SYSID(4, IAXXX_SYSID_DIR_OUT, 4) +#define IAXXX_SYSID_PLUGIN_4_OUT_EP_5 IAXXX_SYSID_GEN_PLUGIN_SYSID(4, IAXXX_SYSID_DIR_OUT, 5) +#define IAXXX_SYSID_PLUGIN_4_OUT_EP_6 IAXXX_SYSID_GEN_PLUGIN_SYSID(4, IAXXX_SYSID_DIR_OUT, 6) +#define IAXXX_SYSID_PLUGIN_4_OUT_EP_7 IAXXX_SYSID_GEN_PLUGIN_SYSID(4, IAXXX_SYSID_DIR_OUT, 7) +#define IAXXX_SYSID_PLUGIN_4_OUT_EP_8 IAXXX_SYSID_GEN_PLUGIN_SYSID(4, IAXXX_SYSID_DIR_OUT, 8) +#define IAXXX_SYSID_PLUGIN_4_OUT_EP_9 IAXXX_SYSID_GEN_PLUGIN_SYSID(4, IAXXX_SYSID_DIR_OUT, 9) +#define IAXXX_SYSID_PLUGIN_4_OUT_EP_10 IAXXX_SYSID_GEN_PLUGIN_SYSID(4, IAXXX_SYSID_DIR_OUT, 10) +#define IAXXX_SYSID_PLUGIN_4_OUT_EP_11 IAXXX_SYSID_GEN_PLUGIN_SYSID(4, IAXXX_SYSID_DIR_OUT, 11) +#define IAXXX_SYSID_PLUGIN_4_OUT_EP_12 IAXXX_SYSID_GEN_PLUGIN_SYSID(4, IAXXX_SYSID_DIR_OUT, 12) +#define IAXXX_SYSID_PLUGIN_4_OUT_EP_13 IAXXX_SYSID_GEN_PLUGIN_SYSID(4, IAXXX_SYSID_DIR_OUT, 13) +#define IAXXX_SYSID_PLUGIN_4_OUT_EP_14 IAXXX_SYSID_GEN_PLUGIN_SYSID(4, IAXXX_SYSID_DIR_OUT, 14) +#define IAXXX_SYSID_PLUGIN_4_OUT_EP_15 IAXXX_SYSID_GEN_PLUGIN_SYSID(4, IAXXX_SYSID_DIR_OUT, 15) +#define IAXXX_SYSID_PLUGIN_5_OUT_EP_0 IAXXX_SYSID_GEN_PLUGIN_SYSID(5, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_PLUGIN_5_OUT_EP_1 IAXXX_SYSID_GEN_PLUGIN_SYSID(5, IAXXX_SYSID_DIR_OUT, 1) +#define IAXXX_SYSID_PLUGIN_5_OUT_EP_2 IAXXX_SYSID_GEN_PLUGIN_SYSID(5, IAXXX_SYSID_DIR_OUT, 2) +#define IAXXX_SYSID_PLUGIN_5_OUT_EP_3 IAXXX_SYSID_GEN_PLUGIN_SYSID(5, IAXXX_SYSID_DIR_OUT, 3) +#define IAXXX_SYSID_PLUGIN_5_OUT_EP_4 IAXXX_SYSID_GEN_PLUGIN_SYSID(5, IAXXX_SYSID_DIR_OUT, 4) +#define IAXXX_SYSID_PLUGIN_5_OUT_EP_5 IAXXX_SYSID_GEN_PLUGIN_SYSID(5, IAXXX_SYSID_DIR_OUT, 5) +#define IAXXX_SYSID_PLUGIN_5_OUT_EP_6 IAXXX_SYSID_GEN_PLUGIN_SYSID(5, IAXXX_SYSID_DIR_OUT, 6) +#define IAXXX_SYSID_PLUGIN_5_OUT_EP_7 IAXXX_SYSID_GEN_PLUGIN_SYSID(5, IAXXX_SYSID_DIR_OUT, 7) +#define IAXXX_SYSID_PLUGIN_5_OUT_EP_8 IAXXX_SYSID_GEN_PLUGIN_SYSID(5, IAXXX_SYSID_DIR_OUT, 8) +#define IAXXX_SYSID_PLUGIN_5_OUT_EP_9 IAXXX_SYSID_GEN_PLUGIN_SYSID(5, IAXXX_SYSID_DIR_OUT, 9) +#define IAXXX_SYSID_PLUGIN_5_OUT_EP_10 IAXXX_SYSID_GEN_PLUGIN_SYSID(5, IAXXX_SYSID_DIR_OUT, 10) +#define IAXXX_SYSID_PLUGIN_5_OUT_EP_11 IAXXX_SYSID_GEN_PLUGIN_SYSID(5, IAXXX_SYSID_DIR_OUT, 11) +#define IAXXX_SYSID_PLUGIN_5_OUT_EP_12 IAXXX_SYSID_GEN_PLUGIN_SYSID(5, IAXXX_SYSID_DIR_OUT, 12) +#define IAXXX_SYSID_PLUGIN_5_OUT_EP_13 IAXXX_SYSID_GEN_PLUGIN_SYSID(5, IAXXX_SYSID_DIR_OUT, 13) +#define IAXXX_SYSID_PLUGIN_5_OUT_EP_14 IAXXX_SYSID_GEN_PLUGIN_SYSID(5, IAXXX_SYSID_DIR_OUT, 14) +#define IAXXX_SYSID_PLUGIN_5_OUT_EP_15 IAXXX_SYSID_GEN_PLUGIN_SYSID(5, IAXXX_SYSID_DIR_OUT, 15) +#define IAXXX_SYSID_PLUGIN_6_OUT_EP_0 IAXXX_SYSID_GEN_PLUGIN_SYSID(6, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_PLUGIN_6_OUT_EP_1 IAXXX_SYSID_GEN_PLUGIN_SYSID(6, IAXXX_SYSID_DIR_OUT, 1) +#define IAXXX_SYSID_PLUGIN_6_OUT_EP_2 IAXXX_SYSID_GEN_PLUGIN_SYSID(6, IAXXX_SYSID_DIR_OUT, 2) +#define IAXXX_SYSID_PLUGIN_6_OUT_EP_3 IAXXX_SYSID_GEN_PLUGIN_SYSID(6, IAXXX_SYSID_DIR_OUT, 3) +#define IAXXX_SYSID_PLUGIN_6_OUT_EP_4 IAXXX_SYSID_GEN_PLUGIN_SYSID(6, IAXXX_SYSID_DIR_OUT, 4) +#define IAXXX_SYSID_PLUGIN_6_OUT_EP_5 IAXXX_SYSID_GEN_PLUGIN_SYSID(6, IAXXX_SYSID_DIR_OUT, 5) +#define IAXXX_SYSID_PLUGIN_6_OUT_EP_6 IAXXX_SYSID_GEN_PLUGIN_SYSID(6, IAXXX_SYSID_DIR_OUT, 6) +#define IAXXX_SYSID_PLUGIN_6_OUT_EP_7 IAXXX_SYSID_GEN_PLUGIN_SYSID(6, IAXXX_SYSID_DIR_OUT, 7) +#define IAXXX_SYSID_PLUGIN_6_OUT_EP_8 IAXXX_SYSID_GEN_PLUGIN_SYSID(6, IAXXX_SYSID_DIR_OUT, 8) +#define IAXXX_SYSID_PLUGIN_6_OUT_EP_9 IAXXX_SYSID_GEN_PLUGIN_SYSID(6, IAXXX_SYSID_DIR_OUT, 9) +#define IAXXX_SYSID_PLUGIN_6_OUT_EP_10 IAXXX_SYSID_GEN_PLUGIN_SYSID(6, IAXXX_SYSID_DIR_OUT, 10) +#define IAXXX_SYSID_PLUGIN_6_OUT_EP_11 IAXXX_SYSID_GEN_PLUGIN_SYSID(6, IAXXX_SYSID_DIR_OUT, 11) +#define IAXXX_SYSID_PLUGIN_6_OUT_EP_12 IAXXX_SYSID_GEN_PLUGIN_SYSID(6, IAXXX_SYSID_DIR_OUT, 12) +#define IAXXX_SYSID_PLUGIN_6_OUT_EP_13 IAXXX_SYSID_GEN_PLUGIN_SYSID(6, IAXXX_SYSID_DIR_OUT, 13) +#define IAXXX_SYSID_PLUGIN_6_OUT_EP_14 IAXXX_SYSID_GEN_PLUGIN_SYSID(6, IAXXX_SYSID_DIR_OUT, 14) +#define IAXXX_SYSID_PLUGIN_6_OUT_EP_15 IAXXX_SYSID_GEN_PLUGIN_SYSID(6, IAXXX_SYSID_DIR_OUT, 15) +#define IAXXX_SYSID_PLUGIN_7_OUT_EP_0 IAXXX_SYSID_GEN_PLUGIN_SYSID(7, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_PLUGIN_7_OUT_EP_1 IAXXX_SYSID_GEN_PLUGIN_SYSID(7, IAXXX_SYSID_DIR_OUT, 1) +#define IAXXX_SYSID_PLUGIN_7_OUT_EP_2 IAXXX_SYSID_GEN_PLUGIN_SYSID(7, IAXXX_SYSID_DIR_OUT, 2) +#define IAXXX_SYSID_PLUGIN_7_OUT_EP_3 IAXXX_SYSID_GEN_PLUGIN_SYSID(7, IAXXX_SYSID_DIR_OUT, 3) +#define IAXXX_SYSID_PLUGIN_7_OUT_EP_4 IAXXX_SYSID_GEN_PLUGIN_SYSID(7, IAXXX_SYSID_DIR_OUT, 4) +#define IAXXX_SYSID_PLUGIN_7_OUT_EP_5 IAXXX_SYSID_GEN_PLUGIN_SYSID(7, IAXXX_SYSID_DIR_OUT, 5) +#define IAXXX_SYSID_PLUGIN_7_OUT_EP_6 IAXXX_SYSID_GEN_PLUGIN_SYSID(7, IAXXX_SYSID_DIR_OUT, 6) +#define IAXXX_SYSID_PLUGIN_7_OUT_EP_7 IAXXX_SYSID_GEN_PLUGIN_SYSID(7, IAXXX_SYSID_DIR_OUT, 7) +#define IAXXX_SYSID_PLUGIN_7_OUT_EP_8 IAXXX_SYSID_GEN_PLUGIN_SYSID(7, IAXXX_SYSID_DIR_OUT, 8) +#define IAXXX_SYSID_PLUGIN_7_OUT_EP_9 IAXXX_SYSID_GEN_PLUGIN_SYSID(7, IAXXX_SYSID_DIR_OUT, 9) +#define IAXXX_SYSID_PLUGIN_7_OUT_EP_10 IAXXX_SYSID_GEN_PLUGIN_SYSID(7, IAXXX_SYSID_DIR_OUT, 10) +#define IAXXX_SYSID_PLUGIN_7_OUT_EP_11 IAXXX_SYSID_GEN_PLUGIN_SYSID(7, IAXXX_SYSID_DIR_OUT, 11) +#define IAXXX_SYSID_PLUGIN_7_OUT_EP_12 IAXXX_SYSID_GEN_PLUGIN_SYSID(7, IAXXX_SYSID_DIR_OUT, 12) +#define IAXXX_SYSID_PLUGIN_7_OUT_EP_13 IAXXX_SYSID_GEN_PLUGIN_SYSID(7, IAXXX_SYSID_DIR_OUT, 13) +#define IAXXX_SYSID_PLUGIN_7_OUT_EP_14 IAXXX_SYSID_GEN_PLUGIN_SYSID(7, IAXXX_SYSID_DIR_OUT, 14) +#define IAXXX_SYSID_PLUGIN_7_OUT_EP_15 IAXXX_SYSID_GEN_PLUGIN_SYSID(7, IAXXX_SYSID_DIR_OUT, 15) +#define IAXXX_SYSID_PLUGIN_8_OUT_EP_0 IAXXX_SYSID_GEN_PLUGIN_SYSID(8, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_PLUGIN_8_OUT_EP_1 IAXXX_SYSID_GEN_PLUGIN_SYSID(8, IAXXX_SYSID_DIR_OUT, 1) +#define IAXXX_SYSID_PLUGIN_8_OUT_EP_2 IAXXX_SYSID_GEN_PLUGIN_SYSID(8, IAXXX_SYSID_DIR_OUT, 2) +#define IAXXX_SYSID_PLUGIN_8_OUT_EP_3 IAXXX_SYSID_GEN_PLUGIN_SYSID(8, IAXXX_SYSID_DIR_OUT, 3) +#define IAXXX_SYSID_PLUGIN_8_OUT_EP_4 IAXXX_SYSID_GEN_PLUGIN_SYSID(8, IAXXX_SYSID_DIR_OUT, 4) +#define IAXXX_SYSID_PLUGIN_8_OUT_EP_5 IAXXX_SYSID_GEN_PLUGIN_SYSID(8, IAXXX_SYSID_DIR_OUT, 5) +#define IAXXX_SYSID_PLUGIN_8_OUT_EP_6 IAXXX_SYSID_GEN_PLUGIN_SYSID(8, IAXXX_SYSID_DIR_OUT, 6) +#define IAXXX_SYSID_PLUGIN_8_OUT_EP_7 IAXXX_SYSID_GEN_PLUGIN_SYSID(8, IAXXX_SYSID_DIR_OUT, 7) +#define IAXXX_SYSID_PLUGIN_8_OUT_EP_8 IAXXX_SYSID_GEN_PLUGIN_SYSID(8, IAXXX_SYSID_DIR_OUT, 8) +#define IAXXX_SYSID_PLUGIN_8_OUT_EP_9 IAXXX_SYSID_GEN_PLUGIN_SYSID(8, IAXXX_SYSID_DIR_OUT, 9) +#define IAXXX_SYSID_PLUGIN_8_OUT_EP_10 IAXXX_SYSID_GEN_PLUGIN_SYSID(8, IAXXX_SYSID_DIR_OUT, 10) +#define IAXXX_SYSID_PLUGIN_8_OUT_EP_11 IAXXX_SYSID_GEN_PLUGIN_SYSID(8, IAXXX_SYSID_DIR_OUT, 11) +#define IAXXX_SYSID_PLUGIN_8_OUT_EP_12 IAXXX_SYSID_GEN_PLUGIN_SYSID(8, IAXXX_SYSID_DIR_OUT, 12) +#define IAXXX_SYSID_PLUGIN_8_OUT_EP_13 IAXXX_SYSID_GEN_PLUGIN_SYSID(8, IAXXX_SYSID_DIR_OUT, 13) +#define IAXXX_SYSID_PLUGIN_8_OUT_EP_14 IAXXX_SYSID_GEN_PLUGIN_SYSID(8, IAXXX_SYSID_DIR_OUT, 14) +#define IAXXX_SYSID_PLUGIN_8_OUT_EP_15 IAXXX_SYSID_GEN_PLUGIN_SYSID(8, IAXXX_SYSID_DIR_OUT, 15) +#define IAXXX_SYSID_PLUGIN_9_OUT_EP_0 IAXXX_SYSID_GEN_PLUGIN_SYSID(9, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_PLUGIN_9_OUT_EP_1 IAXXX_SYSID_GEN_PLUGIN_SYSID(9, IAXXX_SYSID_DIR_OUT, 1) +#define IAXXX_SYSID_PLUGIN_9_OUT_EP_2 IAXXX_SYSID_GEN_PLUGIN_SYSID(9, IAXXX_SYSID_DIR_OUT, 2) +#define IAXXX_SYSID_PLUGIN_9_OUT_EP_3 IAXXX_SYSID_GEN_PLUGIN_SYSID(9, IAXXX_SYSID_DIR_OUT, 3) +#define IAXXX_SYSID_PLUGIN_9_OUT_EP_4 IAXXX_SYSID_GEN_PLUGIN_SYSID(9, IAXXX_SYSID_DIR_OUT, 4) +#define IAXXX_SYSID_PLUGIN_9_OUT_EP_5 IAXXX_SYSID_GEN_PLUGIN_SYSID(9, IAXXX_SYSID_DIR_OUT, 5) +#define IAXXX_SYSID_PLUGIN_9_OUT_EP_6 IAXXX_SYSID_GEN_PLUGIN_SYSID(9, IAXXX_SYSID_DIR_OUT, 6) +#define IAXXX_SYSID_PLUGIN_9_OUT_EP_7 IAXXX_SYSID_GEN_PLUGIN_SYSID(9, IAXXX_SYSID_DIR_OUT, 7) +#define IAXXX_SYSID_PLUGIN_9_OUT_EP_8 IAXXX_SYSID_GEN_PLUGIN_SYSID(9, IAXXX_SYSID_DIR_OUT, 8) +#define IAXXX_SYSID_PLUGIN_9_OUT_EP_9 IAXXX_SYSID_GEN_PLUGIN_SYSID(9, IAXXX_SYSID_DIR_OUT, 9) +#define IAXXX_SYSID_PLUGIN_9_OUT_EP_10 IAXXX_SYSID_GEN_PLUGIN_SYSID(9, IAXXX_SYSID_DIR_OUT, 10) +#define IAXXX_SYSID_PLUGIN_9_OUT_EP_11 IAXXX_SYSID_GEN_PLUGIN_SYSID(9, IAXXX_SYSID_DIR_OUT, 11) +#define IAXXX_SYSID_PLUGIN_9_OUT_EP_12 IAXXX_SYSID_GEN_PLUGIN_SYSID(9, IAXXX_SYSID_DIR_OUT, 12) +#define IAXXX_SYSID_PLUGIN_9_OUT_EP_13 IAXXX_SYSID_GEN_PLUGIN_SYSID(9, IAXXX_SYSID_DIR_OUT, 13) +#define IAXXX_SYSID_PLUGIN_9_OUT_EP_14 IAXXX_SYSID_GEN_PLUGIN_SYSID(9, IAXXX_SYSID_DIR_OUT, 14) +#define IAXXX_SYSID_PLUGIN_9_OUT_EP_15 IAXXX_SYSID_GEN_PLUGIN_SYSID(9, IAXXX_SYSID_DIR_OUT, 15) +#define IAXXX_SYSID_PLUGIN_10_OUT_EP_0 IAXXX_SYSID_GEN_PLUGIN_SYSID(10, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_PLUGIN_10_OUT_EP_1 IAXXX_SYSID_GEN_PLUGIN_SYSID(10, IAXXX_SYSID_DIR_OUT, 1) +#define IAXXX_SYSID_PLUGIN_10_OUT_EP_2 IAXXX_SYSID_GEN_PLUGIN_SYSID(10, IAXXX_SYSID_DIR_OUT, 2) +#define IAXXX_SYSID_PLUGIN_10_OUT_EP_3 IAXXX_SYSID_GEN_PLUGIN_SYSID(10, IAXXX_SYSID_DIR_OUT, 3) +#define IAXXX_SYSID_PLUGIN_10_OUT_EP_4 IAXXX_SYSID_GEN_PLUGIN_SYSID(10, IAXXX_SYSID_DIR_OUT, 4) +#define IAXXX_SYSID_PLUGIN_10_OUT_EP_5 IAXXX_SYSID_GEN_PLUGIN_SYSID(10, IAXXX_SYSID_DIR_OUT, 5) +#define IAXXX_SYSID_PLUGIN_10_OUT_EP_6 IAXXX_SYSID_GEN_PLUGIN_SYSID(10, IAXXX_SYSID_DIR_OUT, 6) +#define IAXXX_SYSID_PLUGIN_10_OUT_EP_7 IAXXX_SYSID_GEN_PLUGIN_SYSID(10, IAXXX_SYSID_DIR_OUT, 7) +#define IAXXX_SYSID_PLUGIN_10_OUT_EP_8 IAXXX_SYSID_GEN_PLUGIN_SYSID(10, IAXXX_SYSID_DIR_OUT, 8) +#define IAXXX_SYSID_PLUGIN_10_OUT_EP_9 IAXXX_SYSID_GEN_PLUGIN_SYSID(10, IAXXX_SYSID_DIR_OUT, 9) +#define IAXXX_SYSID_PLUGIN_10_OUT_EP_10 IAXXX_SYSID_GEN_PLUGIN_SYSID(10, IAXXX_SYSID_DIR_OUT, 10) +#define IAXXX_SYSID_PLUGIN_10_OUT_EP_11 IAXXX_SYSID_GEN_PLUGIN_SYSID(10, IAXXX_SYSID_DIR_OUT, 11) +#define IAXXX_SYSID_PLUGIN_10_OUT_EP_12 IAXXX_SYSID_GEN_PLUGIN_SYSID(10, IAXXX_SYSID_DIR_OUT, 12) +#define IAXXX_SYSID_PLUGIN_10_OUT_EP_13 IAXXX_SYSID_GEN_PLUGIN_SYSID(10, IAXXX_SYSID_DIR_OUT, 13) +#define IAXXX_SYSID_PLUGIN_10_OUT_EP_14 IAXXX_SYSID_GEN_PLUGIN_SYSID(10, IAXXX_SYSID_DIR_OUT, 14) +#define IAXXX_SYSID_PLUGIN_10_OUT_EP_15 IAXXX_SYSID_GEN_PLUGIN_SYSID(10, IAXXX_SYSID_DIR_OUT, 15) +#define IAXXX_SYSID_PLUGIN_11_OUT_EP_0 IAXXX_SYSID_GEN_PLUGIN_SYSID(11, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_PLUGIN_11_OUT_EP_1 IAXXX_SYSID_GEN_PLUGIN_SYSID(11, IAXXX_SYSID_DIR_OUT, 1) +#define IAXXX_SYSID_PLUGIN_11_OUT_EP_2 IAXXX_SYSID_GEN_PLUGIN_SYSID(11, IAXXX_SYSID_DIR_OUT, 2) +#define IAXXX_SYSID_PLUGIN_11_OUT_EP_3 IAXXX_SYSID_GEN_PLUGIN_SYSID(11, IAXXX_SYSID_DIR_OUT, 3) +#define IAXXX_SYSID_PLUGIN_11_OUT_EP_4 IAXXX_SYSID_GEN_PLUGIN_SYSID(11, IAXXX_SYSID_DIR_OUT, 4) +#define IAXXX_SYSID_PLUGIN_11_OUT_EP_5 IAXXX_SYSID_GEN_PLUGIN_SYSID(11, IAXXX_SYSID_DIR_OUT, 5) +#define IAXXX_SYSID_PLUGIN_11_OUT_EP_6 IAXXX_SYSID_GEN_PLUGIN_SYSID(11, IAXXX_SYSID_DIR_OUT, 6) +#define IAXXX_SYSID_PLUGIN_11_OUT_EP_7 IAXXX_SYSID_GEN_PLUGIN_SYSID(11, IAXXX_SYSID_DIR_OUT, 7) +#define IAXXX_SYSID_PLUGIN_11_OUT_EP_8 IAXXX_SYSID_GEN_PLUGIN_SYSID(11, IAXXX_SYSID_DIR_OUT, 8) +#define IAXXX_SYSID_PLUGIN_11_OUT_EP_9 IAXXX_SYSID_GEN_PLUGIN_SYSID(11, IAXXX_SYSID_DIR_OUT, 9) +#define IAXXX_SYSID_PLUGIN_11_OUT_EP_10 IAXXX_SYSID_GEN_PLUGIN_SYSID(11, IAXXX_SYSID_DIR_OUT, 10) +#define IAXXX_SYSID_PLUGIN_11_OUT_EP_11 IAXXX_SYSID_GEN_PLUGIN_SYSID(11, IAXXX_SYSID_DIR_OUT, 11) +#define IAXXX_SYSID_PLUGIN_11_OUT_EP_12 IAXXX_SYSID_GEN_PLUGIN_SYSID(11, IAXXX_SYSID_DIR_OUT, 12) +#define IAXXX_SYSID_PLUGIN_11_OUT_EP_13 IAXXX_SYSID_GEN_PLUGIN_SYSID(11, IAXXX_SYSID_DIR_OUT, 13) +#define IAXXX_SYSID_PLUGIN_11_OUT_EP_14 IAXXX_SYSID_GEN_PLUGIN_SYSID(11, IAXXX_SYSID_DIR_OUT, 14) +#define IAXXX_SYSID_PLUGIN_11_OUT_EP_15 IAXXX_SYSID_GEN_PLUGIN_SYSID(11, IAXXX_SYSID_DIR_OUT, 15) +#define IAXXX_SYSID_PLUGIN_12_OUT_EP_0 IAXXX_SYSID_GEN_PLUGIN_SYSID(12, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_PLUGIN_12_OUT_EP_1 IAXXX_SYSID_GEN_PLUGIN_SYSID(12, IAXXX_SYSID_DIR_OUT, 1) +#define IAXXX_SYSID_PLUGIN_12_OUT_EP_2 IAXXX_SYSID_GEN_PLUGIN_SYSID(12, IAXXX_SYSID_DIR_OUT, 2) +#define IAXXX_SYSID_PLUGIN_12_OUT_EP_3 IAXXX_SYSID_GEN_PLUGIN_SYSID(12, IAXXX_SYSID_DIR_OUT, 3) +#define IAXXX_SYSID_PLUGIN_12_OUT_EP_4 IAXXX_SYSID_GEN_PLUGIN_SYSID(12, IAXXX_SYSID_DIR_OUT, 4) +#define IAXXX_SYSID_PLUGIN_12_OUT_EP_5 IAXXX_SYSID_GEN_PLUGIN_SYSID(12, IAXXX_SYSID_DIR_OUT, 5) +#define IAXXX_SYSID_PLUGIN_12_OUT_EP_6 IAXXX_SYSID_GEN_PLUGIN_SYSID(12, IAXXX_SYSID_DIR_OUT, 6) +#define IAXXX_SYSID_PLUGIN_12_OUT_EP_7 IAXXX_SYSID_GEN_PLUGIN_SYSID(12, IAXXX_SYSID_DIR_OUT, 7) +#define IAXXX_SYSID_PLUGIN_12_OUT_EP_8 IAXXX_SYSID_GEN_PLUGIN_SYSID(12, IAXXX_SYSID_DIR_OUT, 8) +#define IAXXX_SYSID_PLUGIN_12_OUT_EP_9 IAXXX_SYSID_GEN_PLUGIN_SYSID(12, IAXXX_SYSID_DIR_OUT, 9) +#define IAXXX_SYSID_PLUGIN_12_OUT_EP_10 IAXXX_SYSID_GEN_PLUGIN_SYSID(12, IAXXX_SYSID_DIR_OUT, 10) +#define IAXXX_SYSID_PLUGIN_12_OUT_EP_11 IAXXX_SYSID_GEN_PLUGIN_SYSID(12, IAXXX_SYSID_DIR_OUT, 11) +#define IAXXX_SYSID_PLUGIN_12_OUT_EP_12 IAXXX_SYSID_GEN_PLUGIN_SYSID(12, IAXXX_SYSID_DIR_OUT, 12) +#define IAXXX_SYSID_PLUGIN_12_OUT_EP_13 IAXXX_SYSID_GEN_PLUGIN_SYSID(12, IAXXX_SYSID_DIR_OUT, 13) +#define IAXXX_SYSID_PLUGIN_12_OUT_EP_14 IAXXX_SYSID_GEN_PLUGIN_SYSID(12, IAXXX_SYSID_DIR_OUT, 14) +#define IAXXX_SYSID_PLUGIN_12_OUT_EP_15 IAXXX_SYSID_GEN_PLUGIN_SYSID(12, IAXXX_SYSID_DIR_OUT, 15) +#define IAXXX_SYSID_PLUGIN_13_OUT_EP_0 IAXXX_SYSID_GEN_PLUGIN_SYSID(13, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_PLUGIN_13_OUT_EP_1 IAXXX_SYSID_GEN_PLUGIN_SYSID(13, IAXXX_SYSID_DIR_OUT, 1) +#define IAXXX_SYSID_PLUGIN_13_OUT_EP_2 IAXXX_SYSID_GEN_PLUGIN_SYSID(13, IAXXX_SYSID_DIR_OUT, 2) +#define IAXXX_SYSID_PLUGIN_13_OUT_EP_3 IAXXX_SYSID_GEN_PLUGIN_SYSID(13, IAXXX_SYSID_DIR_OUT, 3) +#define IAXXX_SYSID_PLUGIN_13_OUT_EP_4 IAXXX_SYSID_GEN_PLUGIN_SYSID(13, IAXXX_SYSID_DIR_OUT, 4) +#define IAXXX_SYSID_PLUGIN_13_OUT_EP_5 IAXXX_SYSID_GEN_PLUGIN_SYSID(13, IAXXX_SYSID_DIR_OUT, 5) +#define IAXXX_SYSID_PLUGIN_13_OUT_EP_6 IAXXX_SYSID_GEN_PLUGIN_SYSID(13, IAXXX_SYSID_DIR_OUT, 6) +#define IAXXX_SYSID_PLUGIN_13_OUT_EP_7 IAXXX_SYSID_GEN_PLUGIN_SYSID(13, IAXXX_SYSID_DIR_OUT, 7) +#define IAXXX_SYSID_PLUGIN_13_OUT_EP_8 IAXXX_SYSID_GEN_PLUGIN_SYSID(13, IAXXX_SYSID_DIR_OUT, 8) +#define IAXXX_SYSID_PLUGIN_13_OUT_EP_9 IAXXX_SYSID_GEN_PLUGIN_SYSID(13, IAXXX_SYSID_DIR_OUT, 9) +#define IAXXX_SYSID_PLUGIN_13_OUT_EP_10 IAXXX_SYSID_GEN_PLUGIN_SYSID(13, IAXXX_SYSID_DIR_OUT, 10) +#define IAXXX_SYSID_PLUGIN_13_OUT_EP_11 IAXXX_SYSID_GEN_PLUGIN_SYSID(13, IAXXX_SYSID_DIR_OUT, 11) +#define IAXXX_SYSID_PLUGIN_13_OUT_EP_12 IAXXX_SYSID_GEN_PLUGIN_SYSID(13, IAXXX_SYSID_DIR_OUT, 12) +#define IAXXX_SYSID_PLUGIN_13_OUT_EP_13 IAXXX_SYSID_GEN_PLUGIN_SYSID(13, IAXXX_SYSID_DIR_OUT, 13) +#define IAXXX_SYSID_PLUGIN_13_OUT_EP_14 IAXXX_SYSID_GEN_PLUGIN_SYSID(13, IAXXX_SYSID_DIR_OUT, 14) +#define IAXXX_SYSID_PLUGIN_13_OUT_EP_15 IAXXX_SYSID_GEN_PLUGIN_SYSID(13, IAXXX_SYSID_DIR_OUT, 15) +#define IAXXX_SYSID_PLUGIN_14_OUT_EP_0 IAXXX_SYSID_GEN_PLUGIN_SYSID(14, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_PLUGIN_14_OUT_EP_1 IAXXX_SYSID_GEN_PLUGIN_SYSID(14, IAXXX_SYSID_DIR_OUT, 1) +#define IAXXX_SYSID_PLUGIN_14_OUT_EP_2 IAXXX_SYSID_GEN_PLUGIN_SYSID(14, IAXXX_SYSID_DIR_OUT, 2) +#define IAXXX_SYSID_PLUGIN_14_OUT_EP_3 IAXXX_SYSID_GEN_PLUGIN_SYSID(14, IAXXX_SYSID_DIR_OUT, 3) +#define IAXXX_SYSID_PLUGIN_14_OUT_EP_4 IAXXX_SYSID_GEN_PLUGIN_SYSID(14, IAXXX_SYSID_DIR_OUT, 4) +#define IAXXX_SYSID_PLUGIN_14_OUT_EP_5 IAXXX_SYSID_GEN_PLUGIN_SYSID(14, IAXXX_SYSID_DIR_OUT, 5) +#define IAXXX_SYSID_PLUGIN_14_OUT_EP_6 IAXXX_SYSID_GEN_PLUGIN_SYSID(14, IAXXX_SYSID_DIR_OUT, 6) +#define IAXXX_SYSID_PLUGIN_14_OUT_EP_7 IAXXX_SYSID_GEN_PLUGIN_SYSID(14, IAXXX_SYSID_DIR_OUT, 7) +#define IAXXX_SYSID_PLUGIN_14_OUT_EP_8 IAXXX_SYSID_GEN_PLUGIN_SYSID(14, IAXXX_SYSID_DIR_OUT, 8) +#define IAXXX_SYSID_PLUGIN_14_OUT_EP_9 IAXXX_SYSID_GEN_PLUGIN_SYSID(14, IAXXX_SYSID_DIR_OUT, 9) +#define IAXXX_SYSID_PLUGIN_14_OUT_EP_10 IAXXX_SYSID_GEN_PLUGIN_SYSID(14, IAXXX_SYSID_DIR_OUT, 10) +#define IAXXX_SYSID_PLUGIN_14_OUT_EP_11 IAXXX_SYSID_GEN_PLUGIN_SYSID(14, IAXXX_SYSID_DIR_OUT, 11) +#define IAXXX_SYSID_PLUGIN_14_OUT_EP_12 IAXXX_SYSID_GEN_PLUGIN_SYSID(14, IAXXX_SYSID_DIR_OUT, 12) +#define IAXXX_SYSID_PLUGIN_14_OUT_EP_13 IAXXX_SYSID_GEN_PLUGIN_SYSID(14, IAXXX_SYSID_DIR_OUT, 13) +#define IAXXX_SYSID_PLUGIN_14_OUT_EP_14 IAXXX_SYSID_GEN_PLUGIN_SYSID(14, IAXXX_SYSID_DIR_OUT, 14) +#define IAXXX_SYSID_PLUGIN_14_OUT_EP_15 IAXXX_SYSID_GEN_PLUGIN_SYSID(14, IAXXX_SYSID_DIR_OUT, 15) +#define IAXXX_SYSID_PLUGIN_15_OUT_EP_0 IAXXX_SYSID_GEN_PLUGIN_SYSID(15, IAXXX_SYSID_DIR_OUT, 0) +#define IAXXX_SYSID_PLUGIN_15_OUT_EP_1 IAXXX_SYSID_GEN_PLUGIN_SYSID(15, IAXXX_SYSID_DIR_OUT, 1) +#define IAXXX_SYSID_PLUGIN_15_OUT_EP_2 IAXXX_SYSID_GEN_PLUGIN_SYSID(15, IAXXX_SYSID_DIR_OUT, 2) +#define IAXXX_SYSID_PLUGIN_15_OUT_EP_3 IAXXX_SYSID_GEN_PLUGIN_SYSID(15, IAXXX_SYSID_DIR_OUT, 3) +#define IAXXX_SYSID_PLUGIN_15_OUT_EP_4 IAXXX_SYSID_GEN_PLUGIN_SYSID(15, IAXXX_SYSID_DIR_OUT, 4) +#define IAXXX_SYSID_PLUGIN_15_OUT_EP_5 IAXXX_SYSID_GEN_PLUGIN_SYSID(15, IAXXX_SYSID_DIR_OUT, 5) +#define IAXXX_SYSID_PLUGIN_15_OUT_EP_6 IAXXX_SYSID_GEN_PLUGIN_SYSID(15, IAXXX_SYSID_DIR_OUT, 6) +#define IAXXX_SYSID_PLUGIN_15_OUT_EP_7 IAXXX_SYSID_GEN_PLUGIN_SYSID(15, IAXXX_SYSID_DIR_OUT, 7) +#define IAXXX_SYSID_PLUGIN_15_OUT_EP_8 IAXXX_SYSID_GEN_PLUGIN_SYSID(15, IAXXX_SYSID_DIR_OUT, 8) +#define IAXXX_SYSID_PLUGIN_15_OUT_EP_9 IAXXX_SYSID_GEN_PLUGIN_SYSID(15, IAXXX_SYSID_DIR_OUT, 9) +#define IAXXX_SYSID_PLUGIN_15_OUT_EP_10 IAXXX_SYSID_GEN_PLUGIN_SYSID(15, IAXXX_SYSID_DIR_OUT, 10) +#define IAXXX_SYSID_PLUGIN_15_OUT_EP_11 IAXXX_SYSID_GEN_PLUGIN_SYSID(15, IAXXX_SYSID_DIR_OUT, 11) +#define IAXXX_SYSID_PLUGIN_15_OUT_EP_12 IAXXX_SYSID_GEN_PLUGIN_SYSID(15, IAXXX_SYSID_DIR_OUT, 12) +#define IAXXX_SYSID_PLUGIN_15_OUT_EP_13 IAXXX_SYSID_GEN_PLUGIN_SYSID(15, IAXXX_SYSID_DIR_OUT, 13) +#define IAXXX_SYSID_PLUGIN_15_OUT_EP_14 IAXXX_SYSID_GEN_PLUGIN_SYSID(15, IAXXX_SYSID_DIR_OUT, 14) +#define IAXXX_SYSID_PLUGIN_15_OUT_EP_15 IAXXX_SYSID_GEN_PLUGIN_SYSID(15, IAXXX_SYSID_DIR_OUT, 15) +#define IAXXX_SYSID_EP_INDEX_PLUGIN_INSTANCE (31) +#define IAXXX_SYSID_PLUGIN_INSTANCE_0 IAXXX_SYSID_GEN_PLUGIN_SYSID(0, IAXXX_SYSID_DIR_OUT, IAXXX_SYSID_EP_INDEX_PLUGIN_INSTANCE) +#define IAXXX_SYSID_PLUGIN_INSTANCE_1 IAXXX_SYSID_GEN_PLUGIN_SYSID(1, IAXXX_SYSID_DIR_OUT, IAXXX_SYSID_EP_INDEX_PLUGIN_INSTANCE) +#define IAXXX_SYSID_PLUGIN_INSTANCE_2 IAXXX_SYSID_GEN_PLUGIN_SYSID(2, IAXXX_SYSID_DIR_OUT, IAXXX_SYSID_EP_INDEX_PLUGIN_INSTANCE) +#define IAXXX_SYSID_PLUGIN_INSTANCE_3 IAXXX_SYSID_GEN_PLUGIN_SYSID(3, IAXXX_SYSID_DIR_OUT, IAXXX_SYSID_EP_INDEX_PLUGIN_INSTANCE) +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define IAXXX_SYSID_PLUGIN_INSTANCE_4 IAXXX_SYSID_GEN_PLUGIN_SYSID(4, IAXXX_SYSID_DIR_OUT, IAXXX_SYSID_EP_INDEX_PLUGIN_INSTANCE) +#define IAXXX_SYSID_PLUGIN_INSTANCE_5 IAXXX_SYSID_GEN_PLUGIN_SYSID(5, IAXXX_SYSID_DIR_OUT, IAXXX_SYSID_EP_INDEX_PLUGIN_INSTANCE) +#define IAXXX_SYSID_PLUGIN_INSTANCE_6 IAXXX_SYSID_GEN_PLUGIN_SYSID(6, IAXXX_SYSID_DIR_OUT, IAXXX_SYSID_EP_INDEX_PLUGIN_INSTANCE) +#define IAXXX_SYSID_PLUGIN_INSTANCE_7 IAXXX_SYSID_GEN_PLUGIN_SYSID(7, IAXXX_SYSID_DIR_OUT, IAXXX_SYSID_EP_INDEX_PLUGIN_INSTANCE) +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define IAXXX_SYSID_PLUGIN_INSTANCE_8 IAXXX_SYSID_GEN_PLUGIN_SYSID(8, IAXXX_SYSID_DIR_OUT, IAXXX_SYSID_EP_INDEX_PLUGIN_INSTANCE) + +enum iaxxx_proc_id_e { + IAXXX_NO_PROC, + IAXXX_BOSS_ID, + IAXXX_SSP_ID, + IAXXX_CM4_ID, + IAXXX_HMD_ID, + IAXXX_DMX_ID, + IAXXX_PROC_ID_NUM, + IAXXX_PROC_ID_FORCE_SIZE = INT_MAX, +}; +#define IAXXX_MODULE_TYPE_TUNNEL_MANAGER (7) +#define IAXXX_MODULE_INSTANCE_ID_TUNNEL_MANAGER (0) +#define IAXXX_PROC_ID_TUNNEL_MANAGER (IAXXX_CM4_ID) +#define IAXXX_SYSID_TUNNEL_EVENT (IAXXX_SYSID_GEN_MODULE_SYSID(IAXXX_PROC_ID_TUNNEL_MANAGER, IAXXX_MODULE_TYPE_TUNNEL_MANAGER, IAXXX_MODULE_INSTANCE_ID_TUNNEL_MANAGER)) +#define IAXXX_PROC_ID_SENSOR_MANAGER (IAXXX_CM4_ID) +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define IAXXX_MODULE_TYPE_SENSOR_MANAGER (18) +#define IAXXX_MODULE_INSTANCE_ID_SENSOR_MANAGER (0) +#define IAXXX_SYSID_SENSOR_MGR (IAXXX_SYSID_GEN_MODULE_SYSID(IAXXX_PROC_ID_SENSOR_MANAGER, IAXXX_MODULE_TYPE_SENSOR_MANAGER, IAXXX_MODULE_INSTANCE_ID_SENSOR_MANAGER)) +#define IAXXX_SYSID_SENSOR_OUTPUT_0 IAXXX_SYSID_GEN_SENSOR_SYSID(0, IAXXX_SYSID_DIR_OUT, 0) +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define IAXXX_SYSID_SENSOR_OUTPUT_1 IAXXX_SYSID_GEN_SENSOR_SYSID(0, IAXXX_SYSID_DIR_OUT, 1) +#define IAXXX_SYSID_SENSOR_OUTPUT_2 IAXXX_SYSID_GEN_SENSOR_SYSID(0, IAXXX_SYSID_DIR_OUT, 2) +#define IAXXX_SYSID_SENSOR_OUTPUT_3 IAXXX_SYSID_GEN_SENSOR_SYSID(0, IAXXX_SYSID_DIR_OUT, 3) +#define IAXXX_PROC_ID_SCRIPT_MANAGER (IAXXX_CM4_ID) +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define IAXXX_MODULE_TYPE_SCRIPT_MANAGER (2) +#define IAXXX_MODULE_INSTANCE_ID_SCRIPT_MANAGER (0) +#define IAXXX_SYSID_SCRIPT_MGR (IAXXX_SYSID_GEN_MODULE_SYSID(IAXXX_PROC_ID_SCRIPT_MANAGER, IAXXX_MODULE_TYPE_SCRIPT_MANAGER, IAXXX_MODULE_INSTANCE_ID_SCRIPT_MANAGER)) +#define IAXXX_PROC_ID_TO_BLOCK_ID(x) (x - IAXXX_CM4_ID) +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define IAXXX_BLOCK_ID_TO_PROC_ID(x) (x + IAXXX_CM4_ID) +#define IAXXX_DMX_BLOCK_ID (IAXXX_PROC_ID_TO_BLOCK_ID(IAXXX_DMX_ID)) +#define IAXXX_HMD_BLOCK_ID (IAXXX_PROC_ID_TO_BLOCK_ID(IAXXX_HMD_ID)) +#endif +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ diff --git a/iaxxx-systemids.h b/iaxxx-systemids.h new file mode 100644 index 0000000..6b3496c --- /dev/null +++ b/iaxxx-systemids.h @@ -0,0 +1,1823 @@ +/**************************************************************************** + **************************************************************************** + *** + *** This header was automatically generated from a Linux kernel header + *** of the same name, to make information necessary for userspace to + *** call into the kernel available to libc. It contains only constants, + *** structures, and macros generated from the original header, and thus, + *** contains no copyrightable information. + *** + *** To edit the content of this header, modify the corresponding + *** source file (e.g. under external/kernel-headers/original/) then + *** run bionic/libc/kernel/tools/update_all.py + *** + *** Any manual change here will be lost the next time this script will + *** be run. You've been warned! + *** + **************************************************************************** + ****************************************************************************/ +#ifndef __IAXXX_RESMGR_SYSIDS_H__ +#define __IAXXX_RESMGR_SYSIDS_H__ +#include "iaxxx-sysid-defs.h" +#define IAXXX_DEV_SINGLE_INSTANCE (0) +enum iaxxx_device_type_e { + IAXXX_DEV_IO = 0, + IAXXX_DEV_DATA, + IAXXX_DEV_GENERIC, + IAXXX_DEV_RESERVED, + IAXXX_DEV_NUM_TYPES, + IAXXX_DEV_TYPE_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_data_subtypes_e { + IAXXX_DEV_DATA_PCM = 0, + IAXXX_DEV_DATA_PDMI, + IAXXX_DEV_DATA_PDMO, + IAXXX_DEV_DATA_I2S, + IAXXX_DEV_DATA_SLBUS, + IAXXX_DEV_DATA_FILTER_IN, + IAXXX_DEV_DATA_FILTER_OUT, + IAXXX_DEV_DATA_A400, + IAXXX_DEV_NUM_DATA_SUBTYPES, + IAXXX_DEV_DATA_SUBTYPES_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_io_subtypes_e { + IAXXX_DEV_IO_I2C = 0, + IAXXX_DEV_IO_UART, + IAXXX_DEV_IO_SPI, + IAXXX_DEV_IO_SLBUS, + IAXXX_DEV_IO_SWIRE, + IAXXX_DEV_IO_I3C, + IAXXX_DEV_NUM_IO_SUBTYPES, + IAXXX_DEV_IO_SUBTYPES_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_generic_subtypes_e { + IAXXX_DEV_GENERIC_GPIO = 0, + IAXXX_DEV_GENERIC_TIMER, + IAXXX_DEV_GENERIC_STMR, + IAXXX_DEV_GENERIC_PLL, + IAXXX_DEV_GENERIC_CLK, + IAXXX_DEV_GERNEIC_DMA, + IAXXX_DEV_GENERIC_ADC, + IAXXX_DEV_GENERIC_DAC, + IAXXX_DEV_GENERIC_AF, + IAXXX_DEV_GENERIC_SSP, + IAXXX_DEV_GENERIC_PWR_CLK, + IAXXX_DEV_GENERIC_GPIO_A, + IAXXX_DEV_GENERIC_GPIO_B, + IAXXX_DEV_GENERIC_REGMAP, + IAXXX_DEV_GENERIC_MAC, + IAXXX_DEV_GENERIC_CPUSTRMDRV, + IAXXX_DEV_NUM_GENERIC_SUBTYPES, + IAXXX_DEV_GENERIC_SUBTYPES_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_i2c_e { + IAXXX_DEV_INSTANCE_I2C0 = 0, + IAXXX_DEV_INSTANCE_I2C1, + IAXXX_DEV_INSTANCE_I2C2, + IAXXX_DEV_INSTANCE_I2C3, + IAXXX_DEV_INSTANCE_I2C4, + IAXXX_DEV_NUM_INSTANCE_I2C, + IAXXX_DEV_INSTANCE_I2C_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_uart_e { + IAXXX_DEV_INSTANCE_UART0 = 0, + IAXXX_DEV_INSTANCE_UART1, + IAXXX_DEV_NUM_INSTANCE_UART, + IAXXX_DEV_INSTANCE_UART_FORCE_SIZE = INT_MAX, +}; +enum IAXXX_DEV_instance_spi_e { + IAXXX_DEV_INSTANCE_SPI0 = 0, + IAXXX_DEV_INSTANCE_SPI1, + IAXXX_DEV_INSTANCE_SPI2, + IAXXX_DEV_NUM_INSTANCE_SPI, + IAXXX_DEV_INSTANCE_SPI_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_slimbus_e { + IAXXX_DEV_INSTANCE_SLBUS0 = 0, + IAXXX_DEV_NUM_INSTANCE_SLBUS, + IAXXX_DEV_INSTANCE_SLIMBUS_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_pcm_e { + IAXXX_DEV_INSTANCE_PCM0 = 0, + IAXXX_DEV_INSTANCE_PCM1, + IAXXX_DEV_INSTANCE_PCM2, + IAXXX_DEV_INSTANCE_PCM3, + IAXXX_DEV_INSTANCE_PCM4, + IAXXX_DEV_INSTANCE_PCM5, + IAXXX_DEV_NUM_INSTANCE_PCM, + IAXXX_DEV_INSTANCE_PCM_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_filter_in_e { + IAXXX_DEV_INSTANCE_FILTER_IN0 = 0, + IAXXX_DEV_INSTANCE_FILTER_IN1, + IAXXX_DEV_INSTANCE_FILTER_IN2, + IAXXX_DEV_INSTANCE_FILTER_IN3, + IAXXX_DEV_INSTANCE_FILTER_IN4, + IAXXX_DEV_INSTANCE_FILTER_IN5, + IAXXX_DEV_INSTANCE_FILTER_IN6, + IAXXX_DEV_INSTANCE_FILTER_IN7, + IAXXX_DEV_NUM_INSTANCE_FILTER_IN, + IAXXX_EV_INSTANCE_FILTER_IN_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_filter_out_e { + IAXXX_DEV_INSTANCE_FILTER_OUT0 = 0, + IAXXX_DEV_INSTANCE_FILTER_OUT1, + IAXXX_DEV_NUM_INSTANCE_FILTER_OUT, + IAXXX_DEV_INSTANCE_FILTER_OUT_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_i2s_e { + IAXXX_DEV_INSTANCE_I2S0 = 0, + IAXXX_DEV_INSTANCE_I2S1, + IAXXX_DEV_INSTANCE_I2S2, + IAXXX_DEV_INSTANCE_I2S3, + IAXXX_DEV_INSTANCE_I2S4, + IAXXX_DEV_INSTANCE_I2S5, + IAXXX_DEV_INSTANCE_I2S6, + IAXXX_DEV_NUM_INSTANCE_I2S, + IAXXX_DEV_INSTANCE_I2S_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_pdmi_e { + IAXXX_DEV_INSTANCE_PDMI0 = 0, + IAXXX_DEV_INSTANCE_PDMI1, + IAXXX_DEV_INSTANCE_PDMI2, + IAXXX_DEV_INSTANCE_PDMI3, + IAXXX_DEV_INSTANCE_PDMI4, + IAXXX_DEV_INSTANCE_PDMI5, + IAXXX_DEV_INSTANCE_PDMI6, + IAXXX_DEV_INSTANCE_PDMI7, + IAXXX_DEV_NUM_INSTANCE_PDMI, + IAXXX_DEV_INSTANCE_PDMI_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_pdmo_e { + IAXXX_DEV_INSTANCE_PDMO0 = 0, + IAXXX_DEV_INSTANCE_PDMO1, + IAXXX_DEV_NUM_INSTANCE_PDMO, + IAXXX_DEV_INSTANCE_PDMO_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_adc_e { + IAXXX_DEV_INSTANCE_ADC0_IN0 = 0, + IAXXX_DEV_INSTANCE_ADC1_IN1, + IAXXX_DEV_INSTANCE_ADC2_IN2, + IAXXX_DEV_INSTANCE_ADC3_IN3, + IAXXX_DEV_INSTANCE_ADC0_IN4, + IAXXX_DEV_INSTANCE_ADC1_IN5, + IAXXX_DEV_INSTANCE_ADC2_IN6, + IAXXX_DEV_INSTANCE_ADC3_IN7, + IAXXX_DEV_NUM_INSTANCE_ADC, + IAXXX_DEV_INSTANCE_ADC_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_dac_e { + IAXXX_DEV_INSTANCE_DAC0 = 0, + IAXXX_DEV_INSTANCE_DAC1, + IAXXX_DEV_NUM_INSTANCE_DAC, + IAXXX_DEV_INSTANCE_DAC_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_gpio_a_e { + IAXXX_DEV_INSTANCE_GPIOA0 = 0, + IAXXX_DEV_INSTANCE_GPIOA1, + IAXXX_DEV_INSTANCE_GPIOA2, + IAXXX_DEV_INSTANCE_GPIOA3, + IAXXX_DEV_INSTANCE_GPIOA4, + IAXXX_DEV_INSTANCE_GPIOA5, + IAXXX_DEV_INSTANCE_GPIOA6, + IAXXX_DEV_INSTANCE_GPIOA7, + IAXXX_DEV_INSTANCE_GPIOA8, + IAXXX_DEV_INSTANCE_GPIOA9, + IAXXX_DEV_INSTANCE_GPIOA10, + IAXXX_DEV_INSTANCE_GPIOA11, + IAXXX_DEV_INSTANCE_GPIOA12, + IAXXX_DEV_INSTANCE_GPIOA13, + IAXXX_DEV_INSTANCE_GPIOA14, + IAXXX_DEV_INSTANCE_GPIOA15, + IAXXX_DEV_INSTANCE_GPIOA16, + IAXXX_DEV_INSTANCE_GPIOA17, + IAXXX_DEV_INSTANCE_GPIOA18, + IAXXX_DEV_INSTANCE_GPIOA19, + IAXXX_DEV_INSTANCE_GPIOA20, + IAXXX_DEV_INSTANCE_GPIOA21, + IAXXX_DEV_INSTANCE_GPIOA22, + IAXXX_DEV_INSTANCE_GPIOA23, + IAXXX_DEV_INSTANCE_GPIOA24, + IAXXX_DEV_INSTANCE_GPIOA25, + IAXXX_DEV_INSTANCE_GPIOA26, + IAXXX_DEV_INSTANCE_GPIOA27, + IAXXX_DEV_INSTANCE_GPIOA28, + IAXXX_DEV_INSTANCE_GPIOA29, + IAXXX_DEV_INSTANCE_GPIOA30, + IAXXX_DEV_INSTANCE_GPIOA31, + IAXXX_DEV_NUM_GPIOA_PINS, + IAXXX_DEV_INSTANCE_GPIO_PORTA_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_gpio_b_e { + IAXXX_DEV_INSTANCE_GPIOB0 = 0, + IAXXX_DEV_INSTANCE_GPIOB1, + IAXXX_DEV_INSTANCE_GPIOB2, + IAXXX_DEV_INSTANCE_GPIOB3, + IAXXX_DEV_INSTANCE_GPIOB4, + IAXXX_DEV_INSTANCE_GPIOB5, + IAXXX_DEV_INSTANCE_GPIOB6, + IAXXX_DEV_INSTANCE_GPIOB7, + IAXXX_DEV_INSTANCE_GPIOB8, + IAXXX_DEV_INSTANCE_GPIOB9, + IAXXX_DEV_INSTANCE_GPIOB10, + IAXXX_DEV_INSTANCE_GPIOB11, + IAXXX_DEV_INSTANCE_GPIOB12, + IAXXX_DEV_INSTANCE_GPIOB13, + IAXXX_DEV_INSTANCE_GPIOB14, + IAXXX_DEV_INSTANCE_GPIOB15, + IAXXX_DEV_INSTANCE_GPIOB16, + IAXXX_DEV_INSTANCE_GPIOB17, + IAXXX_DEV_INSTANCE_GPIOB18, + IAXXX_DEV_INSTANCE_GPIOB19, + IAXXX_DEV_INSTANCE_GPIOB20, + IAXXX_DEV_INSTANCE_GPIOB21, + IAXXX_DEV_INSTANCE_GPIOB22, + IAXXX_DEV_INSTANCE_GPIOB23, + IAXXX_DEV_INSTANCE_GPIOB24, + IAXXX_DEV_INSTANCE_GPIOB25, + IAXXX_DEV_INSTANCE_GPIOB26, + IAXXX_DEV_INSTANCE_GPIOB27, + IAXXX_DEV_INSTANCE_GPIOB28, + IAXXX_DEV_NUM_GPIOB_PINS, + IAXXX_DEV_INSTANCE_GPIOB_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_af_e { + IAXXX_DEV_INSTANCE_AF0 = 0, + IAXXX_DEV_INSTANCE_AF_PATCH, + IAXXX_DEV_INSTANCE_AF_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_timer_e { + IAXXX_DEV_INSTANCE_TIMER0 = 0, + IAXXX_DEV_INSTANCE_TIMER1, + IAXXX_DEV_INSTANCE_TIMER2, + IAXXX_DEV_INSTANCE_TIMER3, + IAXXX_DEV_INSTANCE_TIMER4, + IAXXX_DEV_INSTANCE_TIMER5, + IAXXX_DEV_INSTANCE_TIMER6, + IAXXX_DEV_INSTANCE_TIMER7, + IAXXX_DEV_INSTANCE_TIMER_FORCE_SIZE = INT_MAX, +}; +#define IAXXX_SYSID_I2C0 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_I2C, IAXXX_DEV_INSTANCE_I2C0)) +#define IAXXX_SYSID_I2C1 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_I2C, IAXXX_DEV_INSTANCE_I2C1)) +#define IAXXX_SYSID_I2C2 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_I2C, IAXXX_DEV_INSTANCE_I2C2)) +#define IAXXX_SYSID_I2C3 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_I2C, IAXXX_DEV_INSTANCE_I2C3)) +#define IAXXX_SYSID_I2C4 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_I2C, IAXXX_DEV_INSTANCE_I2C4)) +#define IAXXX_SYSID_UART0 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_UART, IAXXX_DEV_INSTANCE_UART0)) +#define IAXXX_SYSID_UART1 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_UART, IAXXX_DEV_INSTANCE_UART1)) +#define IAXXX_SYSID_SPI0 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_SPI, IAXXX_DEV_INSTANCE_SPI0)) +#define IAXXX_SYSID_SPI1 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_SPI, IAXXX_DEV_INSTANCE_SPI1)) +#define IAXXX_SYSID_SPI2 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_SPI, IAXXX_DEV_INSTANCE_SPI2)) +#define IAXXX_SYSID_SLBUS_C (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_SLIMBUS_CTRL, IAXXX_DEV_INSTANCE_SLBUS0)) +#define IAXXX_SYSID_GPIO (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_GPIO, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_SSP (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_SSP, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_AF0 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_AF, IAXXX_DEV_INSTANCE_AF0)) +#define IAXXX_SYSID_DMA_STRM (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_DMA_STRM, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_FILTER_IN0 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_FILTER_IN, IAXXX_DEV_INSTANCE_FILTER_IN0)) +#define IAXXX_SYSID_FILTER_IN1 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_FILTER_IN, IAXXX_DEV_INSTANCE_FILTER_IN1)) +#define IAXXX_SYSID_FILTER_IN2 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_FILTER_IN, IAXXX_DEV_INSTANCE_FILTER_IN2)) +#define IAXXX_SYSID_FILTER_IN3 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_FILTER_IN, IAXXX_DEV_INSTANCE_FILTER_IN3)) +#define IAXXX_SYSID_FILTER_IN4 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_FILTER_IN, IAXXX_DEV_INSTANCE_FILTER_IN4)) +#define IAXXX_SYSID_FILTER_IN5 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_FILTER_IN, IAXXX_DEV_INSTANCE_FILTER_IN5)) +#define IAXXX_SYSID_FILTER_IN6 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_FILTER_IN, IAXXX_DEV_INSTANCE_FILTER_IN6)) +#define IAXXX_SYSID_FILTER_IN7 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_FILTER_IN, IAXXX_DEV_INSTANCE_FILTER_IN7)) +#define IAXXX_SYSID_FILTER_OUT0 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_FILTER_OUT, IAXXX_DEV_INSTANCE_FILTER_OUT0)) +#define IAXXX_SYSID_FILTER_OUT1 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_FILTER_OUT, IAXXX_DEV_INSTANCE_FILTER_OUT1)) +#define IAXXX_SYSID_STMR_TIMER (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_STMR_TIMER, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_STMR_PT (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_STMR_PT, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_SW_TIMER (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_SW_TIMER, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_TIMER(n) (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_TIMER, IAXXX_DEV_INSTANCE_TIMER ##n)) +#define IAXXX_SYSID_DMA (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_DMA, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_PCM0 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_PCM, IAXXX_DEV_INSTANCE_PCM0)) +#define IAXXX_SYSID_PCM1 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_PCM, IAXXX_DEV_INSTANCE_PCM1)) +#define IAXXX_SYSID_PCM2 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_PCM, IAXXX_DEV_INSTANCE_PCM2)) +#define IAXXX_SYSID_PCM3 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_PCM, IAXXX_DEV_INSTANCE_PCM3)) +#define IAXXX_SYSID_PCM4 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_PCM, IAXXX_DEV_INSTANCE_PCM4)) +#define IAXXX_SYSID_PCM5 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_PCM, IAXXX_DEV_INSTANCE_PCM5)) +#define IAXXX_SYSID_SLBUS_D (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_SLIMBUS_DATA, IAXXX_DEV_INSTANCE_SLBUS0)) +#define IAXXX_SYSID_PDMI0 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_PDM_IN, IAXXX_DEV_INSTANCE_PDMI0)) +#define IAXXX_SYSID_PDMI1 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_PDM_IN, IAXXX_DEV_INSTANCE_PDMI1)) +#define IAXXX_SYSID_PDMI2 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_PDM_IN, IAXXX_DEV_INSTANCE_PDMI2)) +#define IAXXX_SYSID_PDMI3 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_PDM_IN, IAXXX_DEV_INSTANCE_PDMI3)) +#define IAXXX_SYSID_PDMI4 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_PDM_IN, IAXXX_DEV_INSTANCE_PDMI4)) +#define IAXXX_SYSID_PDMI5 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_PDM_IN, IAXXX_DEV_INSTANCE_PDMI5)) +#define IAXXX_SYSID_PDMI6 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_PDM_IN, IAXXX_DEV_INSTANCE_PDMI6)) +#define IAXXX_SYSID_PDMI7 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_PDM_IN, IAXXX_DEV_INSTANCE_PDMI7)) +#define IAXXX_SYSID_PDMO0 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_PDM_OUT, IAXXX_DEV_INSTANCE_PDMO0)) +#define IAXXX_SYSID_PDMO1 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_PDM_OUT, IAXXX_DEV_INSTANCE_PDMO1)) +#define IAXXX_SYSID_ADC0_IN0 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_ADC, IAXXX_DEV_INSTANCE_ADC0_IN0)) +#define IAXXX_SYSID_ADC1_IN1 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_ADC, IAXXX_DEV_INSTANCE_ADC1_IN1)) +#define IAXXX_SYSID_ADC2_IN2 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_ADC, IAXXX_DEV_INSTANCE_ADC2_IN2)) +#define IAXXX_SYSID_ADC3_IN3 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_ADC, IAXXX_DEV_INSTANCE_ADC3_IN3)) +#define IAXXX_SYSID_ADC0_IN4 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_ADC, IAXXX_DEV_INSTANCE_ADC0_IN4)) +#define IAXXX_SYSID_ADC1_IN5 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_ADC, IAXXX_DEV_INSTANCE_ADC1_IN5)) +#define IAXXX_SYSID_ADC2_IN6 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_ADC, IAXXX_DEV_INSTANCE_ADC2_IN6)) +#define IAXXX_SYSID_ADC3_IN7 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_ADC, IAXXX_DEV_INSTANCE_ADC3_IN7)) +#define IAXXX_SYSID_DAC0 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_DAC, IAXXX_DEV_INSTANCE_DAC0)) +#define IAXXX_SYSID_DAC1 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_DAC, IAXXX_DEV_INSTANCE_DAC1)) +#define IAXXX_SYSID_A400 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_A400, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_FLASHDRV (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_FLASHDRV, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_USBDRV (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_USBDRV, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_CSR8811DRV (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_CSR8811, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_CYW20707DRV (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_CYW20707, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_I2S0 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_I2S, IAXXX_DEV_INSTANCE_I2S0)) +#define IAXXX_SYSID_I2S1 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_I2S, IAXXX_DEV_INSTANCE_I2S1)) +#define IAXXX_SYSID_I2S2 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_I2S, IAXXX_DEV_INSTANCE_I2S2)) +#define IAXXX_SYSID_I2S3 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_I2S, IAXXX_DEV_INSTANCE_I2S3)) +#define IAXXX_SYSID_I2S4 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_I2S, IAXXX_DEV_INSTANCE_I2S4)) +#define IAXXX_SYSID_I2S5 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_I2S, IAXXX_DEV_INSTANCE_I2S5)) +#define IAXXX_SYSID_I2S6 (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_I2S, IAXXX_DEV_INSTANCE_I2S6)) +#define IAXXX_SYSID_REGMAP (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_REGMAP, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_GPIO_A (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_GPIOA, IAXXX_DEV_INSTANCE_GPIOA0)) +#define IAXXX_SYSID_GPIO_B (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_GPIOB, IAXXX_DEV_INSTANCE_GPIOB0)) +#define IAXXX_SYSID_BUTTON (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_BUTTON, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_LED (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_LED, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_ADAU1361DRV (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_ADAU1361, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_MAC (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_MAC, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_BQ27425DRV (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_BQ27425, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_SENSORDRV (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_SENSOR, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_SYSID_CPUSTRMDRV (IAXXX_SYSID_GEN_DRIVER_SYSID(IAXXX_SYSID_DRIVER_TYPE_CPUSTRMDRV, IAXXX_DEV_SINGLE_INSTANCE)) +#define IAXXX_PORT_NUM_INSTANCES (IAXXX_DEV_NUM_INSTANCE_PCM + IAXXX_DEV_NUM_INSTANCE_SLBUS + IAXXX_DEV_NUM_INSTANCE_PDMI + IAXXX_DEV_NUM_INSTANCE_PDMO + IAXXX_DEV_NUM_INSTANCE_ADC + IAXXX_DEV_NUM_INSTANCE_DAC + IAXXX_DEV_NUM_INSTANCE_I2S) +enum iaxxx_device_instance_button_e { + IAXXX_DEV_INSTANCE_BUTTON0 = 0, + IAXXX_DEV_INSTANCE_BUTTON1, + IAXXX_DEV_INSTANCE_BUTTON2, + IAXXX_DEV_INSTANCE_BUTTON3, + IAXXX_DEV_INSTANCE_BUTTON4, + IAXXX_DEV_INSTANCE_BUTTON5, + IAXXX_DEV_INSTANCE_BUTTON6, + IAXXX_DEV_INSTANCE_BUTTON7, + IAXXX_DEV_INSTANCE_BUTTON8, + IAXXX_DEV_INSTANCE_BUTTON9, + IAXXX_DEV_INSTANCE_BUTTON10, + IAXXX_DEV_INSTANCE_BUTTON11, + IAXXX_DEV_INSTANCE_BUTTON12, + IAXXX_DEV_INSTANCE_BUTTON13, + IAXXX_DEV_INSTANCE_BUTTON14, + IAXXX_DEV_INSTANCE_BUTTON15, + IAXXX_DEV_INSTANCE_BUTTON16, + IAXXX_DEV_INSTANCE_BUTTON17, + IAXXX_DEV_INSTANCE_BUTTON18, + IAXXX_DEV_INSTANCE_BUTTON19, + IAXXX_DEV_INSTANCE_BUTTON20, + IAXXX_DEV_INSTANCE_BUTTON21, + IAXXX_DEV_INSTANCE_BUTTON22, + IAXXX_DEV_INSTANCE_BUTTON23, + IAXXX_DEV_INSTANCE_BUTTON24, + IAXXX_DEV_INSTANCE_BUTTON25, + IAXXX_DEV_INSTANCE_BUTTON26, + IAXXX_DEV_INSTANCE_BUTTON27, + IAXXX_DEV_INSTANCE_BUTTON28, + IAXXX_DEV_INSTANCE_BUTTON29, + IAXXX_DEV_INSTANCE_BUTTON30, + IAXXX_DEV_INSTANCE_BUTTON31, + IAXXX_DEV_INSTANCE_BUTTON32, + IAXXX_DEV_INSTANCE_BUTTON33, + IAXXX_DEV_INSTANCE_BUTTON34, + IAXXX_DEV_INSTANCE_BUTTON35, + IAXXX_DEV_INSTANCE_BUTTON36, + IAXXX_DEV_INSTANCE_BUTTON37, + IAXXX_DEV_INSTANCE_BUTTON38, + IAXXX_DEV_INSTANCE_BUTTON39, + IAXXX_DEV_INSTANCE_BUTTON40, + IAXXX_DEV_INSTANCE_BUTTON41, + IAXXX_DEV_INSTANCE_BUTTON42, + IAXXX_DEV_INSTANCE_BUTTON43, + IAXXX_DEV_INSTANCE_BUTTON44, + IAXXX_DEV_INSTANCE_BUTTON45, + IAXXX_DEV_INSTANCE_BUTTON46, + IAXXX_DEV_INSTANCE_BUTTON47, + IAXXX_DEV_INSTANCE_BUTTON48, + IAXXX_DEV_INSTANCE_BUTTON49, + IAXXX_DEV_INSTANCE_BUTTON50, + IAXXX_DEV_INSTANCE_BUTTON51, + IAXXX_DEV_INSTANCE_BUTTON52, + IAXXX_DEV_INSTANCE_BUTTON53, + IAXXX_DEV_INSTANCE_BUTTON54, + IAXXX_DEV_INSTANCE_BUTTON55, + IAXXX_DEV_INSTANCE_BUTTON56, + IAXXX_DEV_INSTANCE_BUTTON57, + IAXXX_DEV_INSTANCE_BUTTON58, + IAXXX_DEV_INSTANCE_BUTTON59, + IAXXX_DEV_INSTANCE_BUTTON60, + IAXXX_DEV_INSTANCE_BUTTON61, + IAXXX_DEV_INSTANCE_BUTTON62, + IAXXX_DEV_INSTANCE_BUTTON63, + IAXXX_DEV_NUM_INSTANCE_BUTTON, + IAXXX_DEV_INSTANCE_BUTTON_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_led_e { + IAXXX_DEV_INSTANCE_LED0 = 0, + IAXXX_DEV_INSTANCE_LED1, + IAXXX_DEV_INSTANCE_LED2, + IAXXX_DEV_INSTANCE_LED3, + IAXXX_DEV_INSTANCE_LED4, + IAXXX_DEV_INSTANCE_LED5, + IAXXX_DEV_INSTANCE_LED6, + IAXXX_DEV_INSTANCE_LED7, + IAXXX_DEV_INSTANCE_LED8, + IAXXX_DEV_INSTANCE_LED9, + IAXXX_DEV_INSTANCE_LED10, + IAXXX_DEV_INSTANCE_LED11, + IAXXX_DEV_INSTANCE_LED12, + IAXXX_DEV_INSTANCE_LED13, + IAXXX_DEV_INSTANCE_LED14, + IAXXX_DEV_INSTANCE_LED15, + IAXXX_DEV_INSTANCE_LED16, + IAXXX_DEV_INSTANCE_LED17, + IAXXX_DEV_INSTANCE_LED18, + IAXXX_DEV_INSTANCE_LED19, + IAXXX_DEV_INSTANCE_LED20, + IAXXX_DEV_INSTANCE_LED21, + IAXXX_DEV_INSTANCE_LED22, + IAXXX_DEV_INSTANCE_LED23, + IAXXX_DEV_INSTANCE_LED24, + IAXXX_DEV_INSTANCE_LED25, + IAXXX_DEV_INSTANCE_LED26, + IAXXX_DEV_INSTANCE_LED27, + IAXXX_DEV_INSTANCE_LED28, + IAXXX_DEV_INSTANCE_LED29, + IAXXX_DEV_INSTANCE_LED30, + IAXXX_DEV_INSTANCE_LED31, + IAXXX_DEV_INSTANCE_LED32, + IAXXX_DEV_INSTANCE_LED33, + IAXXX_DEV_INSTANCE_LED34, + IAXXX_DEV_INSTANCE_LED35, + IAXXX_DEV_INSTANCE_LED36, + IAXXX_DEV_INSTANCE_LED37, + IAXXX_DEV_INSTANCE_LED38, + IAXXX_DEV_INSTANCE_LED39, + IAXXX_DEV_INSTANCE_LED40, + IAXXX_DEV_INSTANCE_LED41, + IAXXX_DEV_INSTANCE_LED42, + IAXXX_DEV_INSTANCE_LED43, + IAXXX_DEV_INSTANCE_LED44, + IAXXX_DEV_INSTANCE_LED45, + IAXXX_DEV_INSTANCE_LED46, + IAXXX_DEV_INSTANCE_LED47, + IAXXX_DEV_INSTANCE_LED48, + IAXXX_DEV_INSTANCE_LED49, + IAXXX_DEV_INSTANCE_LED50, + IAXXX_DEV_INSTANCE_LED51, + IAXXX_DEV_INSTANCE_LED52, + IAXXX_DEV_INSTANCE_LED53, + IAXXX_DEV_INSTANCE_LED54, + IAXXX_DEV_INSTANCE_LED55, + IAXXX_DEV_INSTANCE_LED56, + IAXXX_DEV_INSTANCE_LED57, + IAXXX_DEV_INSTANCE_LED58, + IAXXX_DEV_INSTANCE_LED59, + IAXXX_DEV_INSTANCE_LED60, + IAXXX_DEV_INSTANCE_LED61, + IAXXX_DEV_INSTANCE_LED62, + IAXXX_DEV_INSTANCE_LED63, + IAXXX_DEV_NUM_INSTANCE_LED, + IAXXX_DEV_INSTANCE_LED_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_flash_e { + IAXXX_DEV_INSTANCE_FLASH0 = 0, + IAXXX_DEV_INSTANCE_FLASH1, + IAXXX_DEV_INSTANCE_FLASH2, + IAXXX_DEV_INSTANCE_FLASH3, + IAXXX_DEV_INSTANCE_FLASH4, + IAXXX_DEV_INSTANCE_FLASH5, + IAXXX_DEV_INSTANCE_FLASH6, + IAXXX_DEV_INSTANCE_FLASH7, + IAXXX_DEV_INSTANCE_FLASH8, + IAXXX_DEV_INSTANCE_FLASH9, + IAXXX_DEV_INSTANCE_FLASH10, + IAXXX_DEV_INSTANCE_FLASH11, + IAXXX_DEV_INSTANCE_FLASH12, + IAXXX_DEV_INSTANCE_FLASH13, + IAXXX_DEV_INSTANCE_FLASH14, + IAXXX_DEV_INSTANCE_FLASH15, + IAXXX_DEV_INSTANCE_FLASH16, + IAXXX_DEV_INSTANCE_FLASH17, + IAXXX_DEV_INSTANCE_FLASH18, + IAXXX_DEV_INSTANCE_FLASH19, + IAXXX_DEV_INSTANCE_FLASH20, + IAXXX_DEV_INSTANCE_FLASH21, + IAXXX_DEV_INSTANCE_FLASH22, + IAXXX_DEV_INSTANCE_FLASH23, + IAXXX_DEV_INSTANCE_FLASH24, + IAXXX_DEV_INSTANCE_FLASH25, + IAXXX_DEV_INSTANCE_FLASH26, + IAXXX_DEV_INSTANCE_FLASH27, + IAXXX_DEV_INSTANCE_FLASH28, + IAXXX_DEV_INSTANCE_FLASH29, + IAXXX_DEV_INSTANCE_FLASH30, + IAXXX_DEV_INSTANCE_FLASH31, + IAXXX_DEV_INSTANCE_FLASH32, + IAXXX_DEV_INSTANCE_FLASH33, + IAXXX_DEV_INSTANCE_FLASH34, + IAXXX_DEV_INSTANCE_FLASH35, + IAXXX_DEV_INSTANCE_FLASH36, + IAXXX_DEV_INSTANCE_FLASH37, + IAXXX_DEV_INSTANCE_FLASH38, + IAXXX_DEV_INSTANCE_FLASH39, + IAXXX_DEV_INSTANCE_FLASH40, + IAXXX_DEV_INSTANCE_FLASH41, + IAXXX_DEV_INSTANCE_FLASH42, + IAXXX_DEV_INSTANCE_FLASH43, + IAXXX_DEV_INSTANCE_FLASH44, + IAXXX_DEV_INSTANCE_FLASH45, + IAXXX_DEV_INSTANCE_FLASH46, + IAXXX_DEV_INSTANCE_FLASH47, + IAXXX_DEV_INSTANCE_FLASH48, + IAXXX_DEV_INSTANCE_FLASH49, + IAXXX_DEV_INSTANCE_FLASH50, + IAXXX_DEV_INSTANCE_FLASH51, + IAXXX_DEV_INSTANCE_FLASH52, + IAXXX_DEV_INSTANCE_FLASH53, + IAXXX_DEV_INSTANCE_FLASH54, + IAXXX_DEV_INSTANCE_FLASH55, + IAXXX_DEV_INSTANCE_FLASH56, + IAXXX_DEV_INSTANCE_FLASH57, + IAXXX_DEV_INSTANCE_FLASH58, + IAXXX_DEV_INSTANCE_FLASH59, + IAXXX_DEV_INSTANCE_FLASH60, + IAXXX_DEV_INSTANCE_FLASH61, + IAXXX_DEV_INSTANCE_FLASH62, + IAXXX_DEV_INSTANCE_FLASH63, + IAXXX_DEV_NUM_INSTANCE_FLASH, + IAXXX_DEV_INSTANCE_FLASH_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_codec_e { + IAXXX_DEV_INSTANCE_CODEC0 = 0, + IAXXX_DEV_INSTANCE_CODEC1, + IAXXX_DEV_INSTANCE_CODEC2, + IAXXX_DEV_INSTANCE_CODEC3, + IAXXX_DEV_INSTANCE_CODEC4, + IAXXX_DEV_INSTANCE_CODEC5, + IAXXX_DEV_INSTANCE_CODEC6, + IAXXX_DEV_INSTANCE_CODEC7, + IAXXX_DEV_INSTANCE_CODEC8, + IAXXX_DEV_INSTANCE_CODEC9, + IAXXX_DEV_INSTANCE_CODEC10, + IAXXX_DEV_INSTANCE_CODEC11, + IAXXX_DEV_INSTANCE_CODEC12, + IAXXX_DEV_INSTANCE_CODEC13, + IAXXX_DEV_INSTANCE_CODEC14, + IAXXX_DEV_INSTANCE_CODEC15, + IAXXX_DEV_INSTANCE_CODEC16, + IAXXX_DEV_INSTANCE_CODEC17, + IAXXX_DEV_INSTANCE_CODEC18, + IAXXX_DEV_INSTANCE_CODEC19, + IAXXX_DEV_INSTANCE_CODEC20, + IAXXX_DEV_INSTANCE_CODEC21, + IAXXX_DEV_INSTANCE_CODEC22, + IAXXX_DEV_INSTANCE_CODEC23, + IAXXX_DEV_INSTANCE_CODEC24, + IAXXX_DEV_INSTANCE_CODEC25, + IAXXX_DEV_INSTANCE_CODEC26, + IAXXX_DEV_INSTANCE_CODEC27, + IAXXX_DEV_INSTANCE_CODEC28, + IAXXX_DEV_INSTANCE_CODEC29, + IAXXX_DEV_INSTANCE_CODEC30, + IAXXX_DEV_INSTANCE_CODEC31, + IAXXX_DEV_INSTANCE_CODEC32, + IAXXX_DEV_INSTANCE_CODEC33, + IAXXX_DEV_INSTANCE_CODEC34, + IAXXX_DEV_INSTANCE_CODEC35, + IAXXX_DEV_INSTANCE_CODEC36, + IAXXX_DEV_INSTANCE_CODEC37, + IAXXX_DEV_INSTANCE_CODEC38, + IAXXX_DEV_INSTANCE_CODEC39, + IAXXX_DEV_INSTANCE_CODEC40, + IAXXX_DEV_INSTANCE_CODEC41, + IAXXX_DEV_INSTANCE_CODEC42, + IAXXX_DEV_INSTANCE_CODEC43, + IAXXX_DEV_INSTANCE_CODEC44, + IAXXX_DEV_INSTANCE_CODEC45, + IAXXX_DEV_INSTANCE_CODEC46, + IAXXX_DEV_INSTANCE_CODEC47, + IAXXX_DEV_INSTANCE_CODEC48, + IAXXX_DEV_INSTANCE_CODEC49, + IAXXX_DEV_INSTANCE_CODEC50, + IAXXX_DEV_INSTANCE_CODEC51, + IAXXX_DEV_INSTANCE_CODEC52, + IAXXX_DEV_INSTANCE_CODEC53, + IAXXX_DEV_INSTANCE_CODEC54, + IAXXX_DEV_INSTANCE_CODEC55, + IAXXX_DEV_INSTANCE_CODEC56, + IAXXX_DEV_INSTANCE_CODEC57, + IAXXX_DEV_INSTANCE_CODEC58, + IAXXX_DEV_INSTANCE_CODEC59, + IAXXX_DEV_INSTANCE_CODEC60, + IAXXX_DEV_INSTANCE_CODEC61, + IAXXX_DEV_INSTANCE_CODEC62, + IAXXX_DEV_INSTANCE_CODEC63, + IAXXX_DEV_NUM_INSTANCE_CODEC, + IAXXX_DEV_INSTANCE_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_sensor_e { + IAXXX_DEV_INSTANCE_SENSOR0 = 0, + IAXXX_DEV_INSTANCE_SENSOR1, + IAXXX_DEV_INSTANCE_SENSOR2, + IAXXX_DEV_INSTANCE_SENSOR3, + IAXXX_DEV_INSTANCE_SENSOR4, + IAXXX_DEV_INSTANCE_SENSOR5, + IAXXX_DEV_INSTANCE_SENSOR6, + IAXXX_DEV_INSTANCE_SENSOR7, + IAXXX_DEV_INSTANCE_SENSOR8, + IAXXX_DEV_INSTANCE_SENSOR9, + IAXXX_DEV_INSTANCE_SENSOR10, + IAXXX_DEV_INSTANCE_SENSOR11, + IAXXX_DEV_INSTANCE_SENSOR12, + IAXXX_DEV_INSTANCE_SENSOR13, + IAXXX_DEV_INSTANCE_SENSOR14, + IAXXX_DEV_INSTANCE_SENSOR15, + IAXXX_DEV_INSTANCE_SENSOR16, + IAXXX_DEV_INSTANCE_SENSOR17, + IAXXX_DEV_INSTANCE_SENSOR18, + IAXXX_DEV_INSTANCE_SENSOR19, + IAXXX_DEV_INSTANCE_SENSOR20, + IAXXX_DEV_INSTANCE_SENSOR21, + IAXXX_DEV_INSTANCE_SENSOR22, + IAXXX_DEV_INSTANCE_SENSOR23, + IAXXX_DEV_INSTANCE_SENSOR24, + IAXXX_DEV_INSTANCE_SENSOR25, + IAXXX_DEV_INSTANCE_SENSOR26, + IAXXX_DEV_INSTANCE_SENSOR27, + IAXXX_DEV_INSTANCE_SENSOR28, + IAXXX_DEV_INSTANCE_SENSOR29, + IAXXX_DEV_INSTANCE_SENSOR30, + IAXXX_DEV_INSTANCE_SENSOR31, + IAXXX_DEV_INSTANCE_SENSOR32, + IAXXX_DEV_INSTANCE_SENSOR33, + IAXXX_DEV_INSTANCE_SENSOR34, + IAXXX_DEV_INSTANCE_SENSOR35, + IAXXX_DEV_INSTANCE_SENSOR36, + IAXXX_DEV_INSTANCE_SENSOR37, + IAXXX_DEV_INSTANCE_SENSOR38, + IAXXX_DEV_INSTANCE_SENSOR39, + IAXXX_DEV_INSTANCE_SENSOR40, + IAXXX_DEV_INSTANCE_SENSOR41, + IAXXX_DEV_INSTANCE_SENSOR42, + IAXXX_DEV_INSTANCE_SENSOR43, + IAXXX_DEV_INSTANCE_SENSOR44, + IAXXX_DEV_INSTANCE_SENSOR45, + IAXXX_DEV_INSTANCE_SENSOR46, + IAXXX_DEV_INSTANCE_SENSOR47, + IAXXX_DEV_INSTANCE_SENSOR48, + IAXXX_DEV_INSTANCE_SENSOR49, + IAXXX_DEV_INSTANCE_SENSOR50, + IAXXX_DEV_INSTANCE_SENSOR51, + IAXXX_DEV_INSTANCE_SENSOR52, + IAXXX_DEV_INSTANCE_SENSOR53, + IAXXX_DEV_INSTANCE_SENSOR54, + IAXXX_DEV_INSTANCE_SENSOR55, + IAXXX_DEV_INSTANCE_SENSOR56, + IAXXX_DEV_INSTANCE_SENSOR57, + IAXXX_DEV_INSTANCE_SENSOR58, + IAXXX_DEV_INSTANCE_SENSOR59, + IAXXX_DEV_INSTANCE_SENSOR60, + IAXXX_DEV_INSTANCE_SENSOR61, + IAXXX_DEV_INSTANCE_SENSOR62, + IAXXX_DEV_INSTANCE_SENSOR63, + IAXXX_DEV_NUM_INSTANCE_SENSOR, + IAXXX_DEV_INSTANCE_SENSOR_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_input_pin_e { + IAXXX_DEV_INSTANCE_INPUT_PIN0 = 0, + IAXXX_DEV_INSTANCE_INPUT_PIN1, + IAXXX_DEV_INSTANCE_INPUT_PIN2, + IAXXX_DEV_INSTANCE_INPUT_PIN3, + IAXXX_DEV_INSTANCE_INPUT_PIN4, + IAXXX_DEV_INSTANCE_INPUT_PIN5, + IAXXX_DEV_INSTANCE_INPUT_PIN6, + IAXXX_DEV_INSTANCE_INPUT_PIN7, + IAXXX_DEV_INSTANCE_INPUT_PIN8, + IAXXX_DEV_INSTANCE_INPUT_PIN9, + IAXXX_DEV_INSTANCE_INPUT_PIN10, + IAXXX_DEV_INSTANCE_INPUT_PIN11, + IAXXX_DEV_INSTANCE_INPUT_PIN12, + IAXXX_DEV_INSTANCE_INPUT_PIN13, + IAXXX_DEV_INSTANCE_INPUT_PIN14, + IAXXX_DEV_INSTANCE_INPUT_PIN15, + IAXXX_DEV_INSTANCE_INPUT_PIN16, + IAXXX_DEV_INSTANCE_INPUT_PIN17, + IAXXX_DEV_INSTANCE_INPUT_PIN18, + IAXXX_DEV_INSTANCE_INPUT_PIN19, + IAXXX_DEV_INSTANCE_INPUT_PIN20, + IAXXX_DEV_INSTANCE_INPUT_PIN21, + IAXXX_DEV_INSTANCE_INPUT_PIN22, + IAXXX_DEV_INSTANCE_INPUT_PIN23, + IAXXX_DEV_INSTANCE_INPUT_PIN24, + IAXXX_DEV_INSTANCE_INPUT_PIN25, + IAXXX_DEV_INSTANCE_INPUT_PIN26, + IAXXX_DEV_INSTANCE_INPUT_PIN27, + IAXXX_DEV_INSTANCE_INPUT_PIN28, + IAXXX_DEV_INSTANCE_INPUT_PIN29, + IAXXX_DEV_INSTANCE_INPUT_PIN30, + IAXXX_DEV_INSTANCE_INPUT_PIN31, + IAXXX_DEV_INSTANCE_INPUT_PIN32, + IAXXX_DEV_INSTANCE_INPUT_PIN33, + IAXXX_DEV_INSTANCE_INPUT_PIN34, + IAXXX_DEV_INSTANCE_INPUT_PIN35, + IAXXX_DEV_INSTANCE_INPUT_PIN36, + IAXXX_DEV_INSTANCE_INPUT_PIN37, + IAXXX_DEV_INSTANCE_INPUT_PIN38, + IAXXX_DEV_INSTANCE_INPUT_PIN39, + IAXXX_DEV_INSTANCE_INPUT_PIN40, + IAXXX_DEV_INSTANCE_INPUT_PIN41, + IAXXX_DEV_INSTANCE_INPUT_PIN42, + IAXXX_DEV_INSTANCE_INPUT_PIN43, + IAXXX_DEV_INSTANCE_INPUT_PIN44, + IAXXX_DEV_INSTANCE_INPUT_PIN45, + IAXXX_DEV_INSTANCE_INPUT_PIN46, + IAXXX_DEV_INSTANCE_INPUT_PIN47, + IAXXX_DEV_INSTANCE_INPUT_PIN48, + IAXXX_DEV_INSTANCE_INPUT_PIN49, + IAXXX_DEV_INSTANCE_INPUT_PIN50, + IAXXX_DEV_INSTANCE_INPUT_PIN51, + IAXXX_DEV_INSTANCE_INPUT_PIN52, + IAXXX_DEV_INSTANCE_INPUT_PIN53, + IAXXX_DEV_INSTANCE_INPUT_PIN54, + IAXXX_DEV_INSTANCE_INPUT_PIN55, + IAXXX_DEV_INSTANCE_INPUT_PIN56, + IAXXX_DEV_INSTANCE_INPUT_PIN57, + IAXXX_DEV_INSTANCE_INPUT_PIN58, + IAXXX_DEV_INSTANCE_INPUT_PIN59, + IAXXX_DEV_INSTANCE_INPUT_PIN60, + IAXXX_DEV_INSTANCE_INPUT_PIN61, + IAXXX_DEV_INSTANCE_INPUT_PIN62, + IAXXX_DEV_INSTANCE_INPUT_PIN63, + IAXXX_DEV_NUM_INSTANCE_INPUT_PIN, + IAXXX_DEV_INSTANCE_INPUT_PIN_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_output_pin_e { + IAXXX_DEV_INSTANCE_OUTPUT_PIN0 = 0, + IAXXX_DEV_INSTANCE_OUTPUT_PIN1, + IAXXX_DEV_INSTANCE_OUTPUT_PIN2, + IAXXX_DEV_INSTANCE_OUTPUT_PIN3, + IAXXX_DEV_INSTANCE_OUTPUT_PIN4, + IAXXX_DEV_INSTANCE_OUTPUT_PIN5, + IAXXX_DEV_INSTANCE_OUTPUT_PIN6, + IAXXX_DEV_INSTANCE_OUTPUT_PIN7, + IAXXX_DEV_INSTANCE_OUTPUT_PIN8, + IAXXX_DEV_INSTANCE_OUTPUT_PIN9, + IAXXX_DEV_INSTANCE_OUTPUT_PIN10, + IAXXX_DEV_INSTANCE_OUTPUT_PIN11, + IAXXX_DEV_INSTANCE_OUTPUT_PIN12, + IAXXX_DEV_INSTANCE_OUTPUT_PIN13, + IAXXX_DEV_INSTANCE_OUTPUT_PIN14, + IAXXX_DEV_INSTANCE_OUTPUT_PIN15, + IAXXX_DEV_INSTANCE_OUTPUT_PIN16, + IAXXX_DEV_INSTANCE_OUTPUT_PIN17, + IAXXX_DEV_INSTANCE_OUTPUT_PIN18, + IAXXX_DEV_INSTANCE_OUTPUT_PIN19, + IAXXX_DEV_INSTANCE_OUTPUT_PIN20, + IAXXX_DEV_INSTANCE_OUTPUT_PIN21, + IAXXX_DEV_INSTANCE_OUTPUT_PIN22, + IAXXX_DEV_INSTANCE_OUTPUT_PIN23, + IAXXX_DEV_INSTANCE_OUTPUT_PIN24, + IAXXX_DEV_INSTANCE_OUTPUT_PIN25, + IAXXX_DEV_INSTANCE_OUTPUT_PIN26, + IAXXX_DEV_INSTANCE_OUTPUT_PIN27, + IAXXX_DEV_INSTANCE_OUTPUT_PIN28, + IAXXX_DEV_INSTANCE_OUTPUT_PIN29, + IAXXX_DEV_INSTANCE_OUTPUT_PIN30, + IAXXX_DEV_INSTANCE_OUTPUT_PIN31, + IAXXX_DEV_INSTANCE_OUTPUT_PIN32, + IAXXX_DEV_INSTANCE_OUTPUT_PIN33, + IAXXX_DEV_INSTANCE_OUTPUT_PIN34, + IAXXX_DEV_INSTANCE_OUTPUT_PIN35, + IAXXX_DEV_INSTANCE_OUTPUT_PIN36, + IAXXX_DEV_INSTANCE_OUTPUT_PIN37, + IAXXX_DEV_INSTANCE_OUTPUT_PIN38, + IAXXX_DEV_INSTANCE_OUTPUT_PIN39, + IAXXX_DEV_INSTANCE_OUTPUT_PIN40, + IAXXX_DEV_INSTANCE_OUTPUT_PIN41, + IAXXX_DEV_INSTANCE_OUTPUT_PIN42, + IAXXX_DEV_INSTANCE_OUTPUT_PIN43, + IAXXX_DEV_INSTANCE_OUTPUT_PIN44, + IAXXX_DEV_INSTANCE_OUTPUT_PIN45, + IAXXX_DEV_INSTANCE_OUTPUT_PIN46, + IAXXX_DEV_INSTANCE_OUTPUT_PIN47, + IAXXX_DEV_INSTANCE_OUTPUT_PIN48, + IAXXX_DEV_INSTANCE_OUTPUT_PIN49, + IAXXX_DEV_INSTANCE_OUTPUT_PIN50, + IAXXX_DEV_INSTANCE_OUTPUT_PIN51, + IAXXX_DEV_INSTANCE_OUTPUT_PIN52, + IAXXX_DEV_INSTANCE_OUTPUT_PIN53, + IAXXX_DEV_INSTANCE_OUTPUT_PIN54, + IAXXX_DEV_INSTANCE_OUTPUT_PIN55, + IAXXX_DEV_INSTANCE_OUTPUT_PIN56, + IAXXX_DEV_INSTANCE_OUTPUT_PIN57, + IAXXX_DEV_INSTANCE_OUTPUT_PIN58, + IAXXX_DEV_INSTANCE_OUTPUT_PIN59, + IAXXX_DEV_INSTANCE_OUTPUT_PIN60, + IAXXX_DEV_INSTANCE_OUTPUT_PIN61, + IAXXX_DEV_INSTANCE_OUTPUT_PIN62, + IAXXX_DEV_INSTANCE_OUTPUT_PIN63, + IAXXX_DEV_NUM_INSTANCE_OUTPUT_PIN, + IAXXX_DEV_INSTANCE_OUTPUT_PIN_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_stmr_timer_e { + IAXXX_DEV_INSTANCE_STMR_TMR0 = 0, + IAXXX_DEV_INSTANCE_STMR_TMR1, + IAXXX_DEV_INSTANCE_STMR_TMR2, + IAXXX_DEV_INSTANCE_STMR_TMR3, + IAXXX_DEV_INSTANCE_STMR_TMR4, + IAXXX_DEV_INSTANCE_STMR_TMR5, + IAXXX_DEV_INSTANCE_STMR_TMR6, + IAXXX_DEV_INSTANCE_STMR_TMR7, + IAXXX_DEV_INSTANCE_STMR_TMR8, + IAXXX_DEV_INSTANCE_STMR_TMR9, + IAXXX_DEV_INSTANCE_STMR_TMR10, + IAXXX_DEV_INSTANCE_STMR_TMR11, + IAXXX_DEV_INSTANCE_STMR_TMR12, + IAXXX_DEV_INSTANCE_STMR_TMR13, + IAXXX_DEV_INSTANCE_STMR_TMR14, + IAXXX_DEV_INSTANCE_STMR_TMR15, + IAXXX_DEV_INSTANCE_STMR_TMR16, + IAXXX_DEV_INSTANCE_STMR_TMR17, + IAXXX_DEV_INSTANCE_STMR_TMR18, + IAXXX_DEV_INSTANCE_STMR_TMR19, + IAXXX_DEV_INSTANCE_STMR_TMR20, + IAXXX_DEV_INSTANCE_STMR_TMR21, + IAXXX_DEV_INSTANCE_STMR_TMR22, + IAXXX_DEV_INSTANCE_STMR_TMR23, + IAXXX_DEV_INSTANCE_STMR_TMR24, + IAXXX_DEV_INSTANCE_STMR_TMR25, + IAXXX_DEV_INSTANCE_STMR_TMR26, + IAXXX_DEV_INSTANCE_STMR_TMR27, + IAXXX_DEV_INSTANCE_STMR_TMR28, + IAXXX_DEV_INSTANCE_STMR_TMR29, + IAXXX_DEV_INSTANCE_STMR_TMR30, + IAXXX_DEV_INSTANCE_STMR_TMR31, + IAXXX_DEV_INSTANCE_STMR_TMR32, + IAXXX_DEV_INSTANCE_STMR_TMR33, + IAXXX_DEV_INSTANCE_STMR_TMR34, + IAXXX_DEV_INSTANCE_STMR_TMR35, + IAXXX_DEV_INSTANCE_STMR_TMR36, + IAXXX_DEV_INSTANCE_STMR_TMR37, + IAXXX_DEV_INSTANCE_STMR_TMR38, + IAXXX_DEV_INSTANCE_STMR_TMR39, + IAXXX_DEV_INSTANCE_STMR_TMR40, + IAXXX_DEV_INSTANCE_STMR_TMR41, + IAXXX_DEV_INSTANCE_STMR_TMR42, + IAXXX_DEV_INSTANCE_STMR_TMR43, + IAXXX_DEV_INSTANCE_STMR_TMR44, + IAXXX_DEV_INSTANCE_STMR_TMR45, + IAXXX_DEV_INSTANCE_STMR_TMR46, + IAXXX_DEV_INSTANCE_STMR_TMR47, + IAXXX_DEV_INSTANCE_STMR_TMR48, + IAXXX_DEV_INSTANCE_STMR_TMR49, + IAXXX_DEV_INSTANCE_STMR_TMR50, + IAXXX_DEV_INSTANCE_STMR_TMR51, + IAXXX_DEV_INSTANCE_STMR_TMR52, + IAXXX_DEV_INSTANCE_STMR_TMR53, + IAXXX_DEV_INSTANCE_STMR_TMR54, + IAXXX_DEV_INSTANCE_STMR_TMR55, + IAXXX_DEV_INSTANCE_STMR_TMR56, + IAXXX_DEV_INSTANCE_STMR_TMR57, + IAXXX_DEV_INSTANCE_STMR_TMR58, + IAXXX_DEV_INSTANCE_STMR_TMR59, + IAXXX_DEV_INSTANCE_STMR_TMR60, + IAXXX_DEV_INSTANCE_STMR_TMR61, + IAXXX_DEV_INSTANCE_STMR_TMR62, + IAXXX_DEV_INSTANCE_STMR_TMR63, + IAXXX_DEV_NUM_INSTANCE_STMR_TMR, + IAXXX_DEV_INSTANCE_STMR_TMR_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_stmr_pt_e { + IAXXX_DEV_INSTANCE_STMR_PT0 = 0, + IAXXX_DEV_INSTANCE_STMR_PT1, + IAXXX_DEV_INSTANCE_STMR_PT2, + IAXXX_DEV_INSTANCE_STMR_PT3, + IAXXX_DEV_INSTANCE_STMR_PT4, + IAXXX_DEV_INSTANCE_STMR_PT5, + IAXXX_DEV_INSTANCE_STMR_PT6, + IAXXX_DEV_INSTANCE_STMR_PT7, + IAXXX_DEV_INSTANCE_STMR_PT8, + IAXXX_DEV_INSTANCE_STMR_PT9, + IAXXX_DEV_INSTANCE_STMR_PT10, + IAXXX_DEV_INSTANCE_STMR_PT11, + IAXXX_DEV_INSTANCE_STMR_PT12, + IAXXX_DEV_INSTANCE_STMR_PT13, + IAXXX_DEV_INSTANCE_STMR_PT14, + IAXXX_DEV_INSTANCE_STMR_PT15, + IAXXX_DEV_INSTANCE_STMR_PT16, + IAXXX_DEV_INSTANCE_STMR_PT17, + IAXXX_DEV_INSTANCE_STMR_PT18, + IAXXX_DEV_INSTANCE_STMR_PT19, + IAXXX_DEV_INSTANCE_STMR_PT20, + IAXXX_DEV_INSTANCE_STMR_PT21, + IAXXX_DEV_INSTANCE_STMR_PT22, + IAXXX_DEV_INSTANCE_STMR_PT23, + IAXXX_DEV_INSTANCE_STMR_PT24, + IAXXX_DEV_INSTANCE_STMR_PT25, + IAXXX_DEV_INSTANCE_STMR_PT26, + IAXXX_DEV_INSTANCE_STMR_PT27, + IAXXX_DEV_INSTANCE_STMR_PT28, + IAXXX_DEV_INSTANCE_STMR_PT29, + IAXXX_DEV_INSTANCE_STMR_PT30, + IAXXX_DEV_INSTANCE_STMR_PT31, + IAXXX_DEV_INSTANCE_STMR_PT32, + IAXXX_DEV_INSTANCE_STMR_PT33, + IAXXX_DEV_INSTANCE_STMR_PT34, + IAXXX_DEV_INSTANCE_STMR_PT35, + IAXXX_DEV_INSTANCE_STMR_PT36, + IAXXX_DEV_INSTANCE_STMR_PT37, + IAXXX_DEV_INSTANCE_STMR_PT38, + IAXXX_DEV_INSTANCE_STMR_PT39, + IAXXX_DEV_INSTANCE_STMR_PT40, + IAXXX_DEV_INSTANCE_STMR_PT41, + IAXXX_DEV_INSTANCE_STMR_PT42, + IAXXX_DEV_INSTANCE_STMR_PT43, + IAXXX_DEV_INSTANCE_STMR_PT44, + IAXXX_DEV_INSTANCE_STMR_PT45, + IAXXX_DEV_INSTANCE_STMR_PT46, + IAXXX_DEV_INSTANCE_STMR_PT47, + IAXXX_DEV_INSTANCE_STMR_PT48, + IAXXX_DEV_INSTANCE_STMR_PT49, + IAXXX_DEV_INSTANCE_STMR_PT50, + IAXXX_DEV_INSTANCE_STMR_PT51, + IAXXX_DEV_INSTANCE_STMR_PT52, + IAXXX_DEV_INSTANCE_STMR_PT53, + IAXXX_DEV_INSTANCE_STMR_PT54, + IAXXX_DEV_INSTANCE_STMR_PT55, + IAXXX_DEV_INSTANCE_STMR_PT56, + IAXXX_DEV_INSTANCE_STMR_PT57, + IAXXX_DEV_INSTANCE_STMR_PT58, + IAXXX_DEV_INSTANCE_STMR_PT59, + IAXXX_DEV_INSTANCE_STMR_PT60, + IAXXX_DEV_INSTANCE_STMR_PT61, + IAXXX_DEV_INSTANCE_STMR_PT62, + IAXXX_DEV_INSTANCE_STMR_PT63, + IAXXX_DEV_NUM_INSTANCE_STMR_PT, + IAXXX_DEV_INSTANCE_STMR_PT_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_interface_e { + IAXXX_DEV_INSTANCE_INTERFACE0 = 0, + IAXXX_DEV_INSTANCE_INTERFACE1, + IAXXX_DEV_INSTANCE_INTERFACE2, + IAXXX_DEV_INSTANCE_INTERFACE3, + IAXXX_DEV_INSTANCE_INTERFACE4, + IAXXX_DEV_INSTANCE_INTERFACE5, + IAXXX_DEV_INSTANCE_INTERFACE6, + IAXXX_DEV_INSTANCE_INTERFACE7, + IAXXX_DEV_INSTANCE_INTERFACE8, + IAXXX_DEV_INSTANCE_INTERFACE9, + IAXXX_DEV_INSTANCE_INTERFACE10, + IAXXX_DEV_INSTANCE_INTERFACE11, + IAXXX_DEV_INSTANCE_INTERFACE12, + IAXXX_DEV_INSTANCE_INTERFACE13, + IAXXX_DEV_INSTANCE_INTERFACE14, + IAXXX_DEV_INSTANCE_INTERFACE15, + IAXXX_DEV_INSTANCE_INTERFACE16, + IAXXX_DEV_INSTANCE_INTERFACE17, + IAXXX_DEV_INSTANCE_INTERFACE18, + IAXXX_DEV_INSTANCE_INTERFACE19, + IAXXX_DEV_INSTANCE_INTERFACE20, + IAXXX_DEV_INSTANCE_INTERFACE21, + IAXXX_DEV_INSTANCE_INTERFACE22, + IAXXX_DEV_INSTANCE_INTERFACE23, + IAXXX_DEV_INSTANCE_INTERFACE24, + IAXXX_DEV_INSTANCE_INTERFACE25, + IAXXX_DEV_INSTANCE_INTERFACE26, + IAXXX_DEV_INSTANCE_INTERFACE27, + IAXXX_DEV_INSTANCE_INTERFACE28, + IAXXX_DEV_INSTANCE_INTERFACE29, + IAXXX_DEV_INSTANCE_INTERFACE30, + IAXXX_DEV_INSTANCE_INTERFACE31, + IAXXX_DEV_INSTANCE_INTERFACE32, + IAXXX_DEV_INSTANCE_INTERFACE33, + IAXXX_DEV_INSTANCE_INTERFACE34, + IAXXX_DEV_INSTANCE_INTERFACE35, + IAXXX_DEV_INSTANCE_INTERFACE36, + IAXXX_DEV_INSTANCE_INTERFACE37, + IAXXX_DEV_INSTANCE_INTERFACE38, + IAXXX_DEV_INSTANCE_INTERFACE39, + IAXXX_DEV_INSTANCE_INTERFACE40, + IAXXX_DEV_INSTANCE_INTERFACE41, + IAXXX_DEV_INSTANCE_INTERFACE42, + IAXXX_DEV_INSTANCE_INTERFACE43, + IAXXX_DEV_INSTANCE_INTERFACE44, + IAXXX_DEV_INSTANCE_INTERFACE45, + IAXXX_DEV_INSTANCE_INTERFACE46, + IAXXX_DEV_INSTANCE_INTERFACE47, + IAXXX_DEV_INSTANCE_INTERFACE48, + IAXXX_DEV_INSTANCE_INTERFACE49, + IAXXX_DEV_INSTANCE_INTERFACE50, + IAXXX_DEV_INSTANCE_INTERFACE51, + IAXXX_DEV_INSTANCE_INTERFACE52, + IAXXX_DEV_INSTANCE_INTERFACE53, + IAXXX_DEV_INSTANCE_INTERFACE54, + IAXXX_DEV_INSTANCE_INTERFACE55, + IAXXX_DEV_INSTANCE_INTERFACE56, + IAXXX_DEV_INSTANCE_INTERFACE57, + IAXXX_DEV_INSTANCE_INTERFACE58, + IAXXX_DEV_INSTANCE_INTERFACE59, + IAXXX_DEV_INSTANCE_INTERFACE60, + IAXXX_DEV_INSTANCE_INTERFACE61, + IAXXX_DEV_INSTANCE_INTERFACE62, + IAXXX_DEV_INSTANCE_INTERFACE63, + IAXXX_DEV_NUM_INSTANCE_INTERFACE, + IAXXX_DEV_INSTANCE_INTERFACE_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_usb_e { + IAXXX_DEV_INSTANCE_USB0 = 0, + IAXXX_DEV_INSTANCE_USB1, + IAXXX_DEV_INSTANCE_USB2, + IAXXX_DEV_INSTANCE_USB3, + IAXXX_DEV_INSTANCE_USB4, + IAXXX_DEV_INSTANCE_USB5, + IAXXX_DEV_INSTANCE_USB6, + IAXXX_DEV_INSTANCE_USB7, + IAXXX_DEV_INSTANCE_USB8, + IAXXX_DEV_INSTANCE_USB9, + IAXXX_DEV_INSTANCE_USB10, + IAXXX_DEV_INSTANCE_USB11, + IAXXX_DEV_INSTANCE_USB12, + IAXXX_DEV_INSTANCE_USB13, + IAXXX_DEV_INSTANCE_USB14, + IAXXX_DEV_INSTANCE_USB15, + IAXXX_DEV_INSTANCE_USB16, + IAXXX_DEV_INSTANCE_USB17, + IAXXX_DEV_INSTANCE_USB18, + IAXXX_DEV_INSTANCE_USB19, + IAXXX_DEV_INSTANCE_USB20, + IAXXX_DEV_INSTANCE_USB21, + IAXXX_DEV_INSTANCE_USB22, + IAXXX_DEV_INSTANCE_USB23, + IAXXX_DEV_INSTANCE_USB24, + IAXXX_DEV_INSTANCE_USB25, + IAXXX_DEV_INSTANCE_USB26, + IAXXX_DEV_INSTANCE_USB27, + IAXXX_DEV_INSTANCE_USB28, + IAXXX_DEV_INSTANCE_USB29, + IAXXX_DEV_INSTANCE_USB30, + IAXXX_DEV_INSTANCE_USB31, + IAXXX_DEV_INSTANCE_USB32, + IAXXX_DEV_INSTANCE_USB33, + IAXXX_DEV_INSTANCE_USB34, + IAXXX_DEV_INSTANCE_USB35, + IAXXX_DEV_INSTANCE_USB36, + IAXXX_DEV_INSTANCE_USB37, + IAXXX_DEV_INSTANCE_USB38, + IAXXX_DEV_INSTANCE_USB39, + IAXXX_DEV_INSTANCE_USB40, + IAXXX_DEV_INSTANCE_USB41, + IAXXX_DEV_INSTANCE_USB42, + IAXXX_DEV_INSTANCE_USB43, + IAXXX_DEV_INSTANCE_USB44, + IAXXX_DEV_INSTANCE_USB45, + IAXXX_DEV_INSTANCE_USB46, + IAXXX_DEV_INSTANCE_USB47, + IAXXX_DEV_INSTANCE_USB48, + IAXXX_DEV_INSTANCE_USB49, + IAXXX_DEV_INSTANCE_USB50, + IAXXX_DEV_INSTANCE_USB51, + IAXXX_DEV_INSTANCE_USB52, + IAXXX_DEV_INSTANCE_USB53, + IAXXX_DEV_INSTANCE_USB54, + IAXXX_DEV_INSTANCE_USB55, + IAXXX_DEV_INSTANCE_USB56, + IAXXX_DEV_INSTANCE_USB57, + IAXXX_DEV_INSTANCE_USB58, + IAXXX_DEV_INSTANCE_USB59, + IAXXX_DEV_INSTANCE_USB60, + IAXXX_DEV_INSTANCE_USB61, + IAXXX_DEV_INSTANCE_USB62, + IAXXX_DEV_INSTANCE_USB63, + IAXXX_DEV_NUM_INSTANCE_USB, + IAXXX_DEV_INSTANCE_USB_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_bt_e { + IAXXX_DEV_INSTANCE_BT0 = 0, + IAXXX_DEV_NUM_INSTANCE_BT, + IAXXX_DEV_INSTANCE_BT_FORCE_SIZE = INT_MAX, +}; +enum iaxxx_device_instance_Battery_e { + IAXXX_DEV_INSTANCE_BATTERY0 = 0, + IAXXX_DEV_NUM_INSTANCE_BATTERY, + IAXXX_DEV_INSTANCE_BATTERY_FORCE_SIZE = INT_MAX, +}; +#define IAXXX_SYSID_DEV_BUTTON0 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON0)) +#define IAXXX_SYSID_DEV_BUTTON1 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON1)) +#define IAXXX_SYSID_DEV_BUTTON2 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON2)) +#define IAXXX_SYSID_DEV_BUTTON3 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON3)) +#define IAXXX_SYSID_DEV_BUTTON4 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON4)) +#define IAXXX_SYSID_DEV_BUTTON5 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON5)) +#define IAXXX_SYSID_DEV_BUTTON6 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON6)) +#define IAXXX_SYSID_DEV_BUTTON7 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON7)) +#define IAXXX_SYSID_DEV_BUTTON8 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON8)) +#define IAXXX_SYSID_DEV_BUTTON9 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON9)) +#define IAXXX_SYSID_DEV_BUTTON10 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON10)) +#define IAXXX_SYSID_DEV_BUTTON11 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON11)) +#define IAXXX_SYSID_DEV_BUTTON12 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON12)) +#define IAXXX_SYSID_DEV_BUTTON13 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON13)) +#define IAXXX_SYSID_DEV_BUTTON14 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON14)) +#define IAXXX_SYSID_DEV_BUTTON15 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON15)) +#define IAXXX_SYSID_DEV_BUTTON16 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON16)) +#define IAXXX_SYSID_DEV_BUTTON17 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON17)) +#define IAXXX_SYSID_DEV_BUTTON18 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON18)) +#define IAXXX_SYSID_DEV_BUTTON19 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON19)) +#define IAXXX_SYSID_DEV_BUTTON20 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON20)) +#define IAXXX_SYSID_DEV_BUTTON21 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON21)) +#define IAXXX_SYSID_DEV_BUTTON22 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON22)) +#define IAXXX_SYSID_DEV_BUTTON23 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON23)) +#define IAXXX_SYSID_DEV_BUTTON24 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON24)) +#define IAXXX_SYSID_DEV_BUTTON25 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON25)) +#define IAXXX_SYSID_DEV_BUTTON26 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON26)) +#define IAXXX_SYSID_DEV_BUTTON27 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON27)) +#define IAXXX_SYSID_DEV_BUTTON28 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON28)) +#define IAXXX_SYSID_DEV_BUTTON29 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON29)) +#define IAXXX_SYSID_DEV_BUTTON30 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON30)) +#define IAXXX_SYSID_DEV_BUTTON31 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON31)) +#define IAXXX_SYSID_DEV_BUTTON32 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON32)) +#define IAXXX_SYSID_DEV_BUTTON33 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON33)) +#define IAXXX_SYSID_DEV_BUTTON34 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON34)) +#define IAXXX_SYSID_DEV_BUTTON35 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON35)) +#define IAXXX_SYSID_DEV_BUTTON36 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON36)) +#define IAXXX_SYSID_DEV_BUTTON37 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON37)) +#define IAXXX_SYSID_DEV_BUTTON38 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON38)) +#define IAXXX_SYSID_DEV_BUTTON39 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON39)) +#define IAXXX_SYSID_DEV_BUTTON40 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON40)) +#define IAXXX_SYSID_DEV_BUTTON41 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON41)) +#define IAXXX_SYSID_DEV_BUTTON42 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON42)) +#define IAXXX_SYSID_DEV_BUTTON43 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON43)) +#define IAXXX_SYSID_DEV_BUTTON44 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON44)) +#define IAXXX_SYSID_DEV_BUTTON45 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON45)) +#define IAXXX_SYSID_DEV_BUTTON46 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON46)) +#define IAXXX_SYSID_DEV_BUTTON47 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON47)) +#define IAXXX_SYSID_DEV_BUTTON48 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON48)) +#define IAXXX_SYSID_DEV_BUTTON49 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON49)) +#define IAXXX_SYSID_DEV_BUTTON50 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON50)) +#define IAXXX_SYSID_DEV_BUTTON51 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON51)) +#define IAXXX_SYSID_DEV_BUTTON52 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON52)) +#define IAXXX_SYSID_DEV_BUTTON53 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON53)) +#define IAXXX_SYSID_DEV_BUTTON54 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON54)) +#define IAXXX_SYSID_DEV_BUTTON55 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON55)) +#define IAXXX_SYSID_DEV_BUTTON56 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON56)) +#define IAXXX_SYSID_DEV_BUTTON57 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON57)) +#define IAXXX_SYSID_DEV_BUTTON58 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON58)) +#define IAXXX_SYSID_DEV_BUTTON59 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON59)) +#define IAXXX_SYSID_DEV_BUTTON60 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON60)) +#define IAXXX_SYSID_DEV_BUTTON61 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON61)) +#define IAXXX_SYSID_DEV_BUTTON62 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON62)) +#define IAXXX_SYSID_DEV_BUTTON63 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BUTTON, IAXXX_DEV_INSTANCE_BUTTON63)) +#define IAXXX_SYSID_DEV_LED0 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED0)) +#define IAXXX_SYSID_DEV_LED1 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED1)) +#define IAXXX_SYSID_DEV_LED2 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED2)) +#define IAXXX_SYSID_DEV_LED3 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED3)) +#define IAXXX_SYSID_DEV_LED4 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED4)) +#define IAXXX_SYSID_DEV_LED5 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED5)) +#define IAXXX_SYSID_DEV_LED6 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED6)) +#define IAXXX_SYSID_DEV_LED7 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED7)) +#define IAXXX_SYSID_DEV_LED8 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED8)) +#define IAXXX_SYSID_DEV_LED9 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED9)) +#define IAXXX_SYSID_DEV_LED10 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED10)) +#define IAXXX_SYSID_DEV_LED11 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED11)) +#define IAXXX_SYSID_DEV_LED12 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED12)) +#define IAXXX_SYSID_DEV_LED13 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED13)) +#define IAXXX_SYSID_DEV_LED14 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED14)) +#define IAXXX_SYSID_DEV_LED15 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED15)) +#define IAXXX_SYSID_DEV_LED16 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED16)) +#define IAXXX_SYSID_DEV_LED17 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED17)) +#define IAXXX_SYSID_DEV_LED18 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED18)) +#define IAXXX_SYSID_DEV_LED19 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED19)) +#define IAXXX_SYSID_DEV_LED20 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED20)) +#define IAXXX_SYSID_DEV_LED21 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED21)) +#define IAXXX_SYSID_DEV_LED22 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED22)) +#define IAXXX_SYSID_DEV_LED23 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED23)) +#define IAXXX_SYSID_DEV_LED24 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED24)) +#define IAXXX_SYSID_DEV_LED25 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED25)) +#define IAXXX_SYSID_DEV_LED26 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED26)) +#define IAXXX_SYSID_DEV_LED27 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED27)) +#define IAXXX_SYSID_DEV_LED28 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED28)) +#define IAXXX_SYSID_DEV_LED29 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED29)) +#define IAXXX_SYSID_DEV_LED30 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED30)) +#define IAXXX_SYSID_DEV_LED31 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED31)) +#define IAXXX_SYSID_DEV_LED32 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED32)) +#define IAXXX_SYSID_DEV_LED33 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED33)) +#define IAXXX_SYSID_DEV_LED34 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED34)) +#define IAXXX_SYSID_DEV_LED35 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED35)) +#define IAXXX_SYSID_DEV_LED36 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED36)) +#define IAXXX_SYSID_DEV_LED37 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED37)) +#define IAXXX_SYSID_DEV_LED38 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED38)) +#define IAXXX_SYSID_DEV_LED39 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED39)) +#define IAXXX_SYSID_DEV_LED40 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED40)) +#define IAXXX_SYSID_DEV_LED41 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED41)) +#define IAXXX_SYSID_DEV_LED42 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED42)) +#define IAXXX_SYSID_DEV_LED43 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED43)) +#define IAXXX_SYSID_DEV_LED44 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED44)) +#define IAXXX_SYSID_DEV_LED45 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED45)) +#define IAXXX_SYSID_DEV_LED46 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED46)) +#define IAXXX_SYSID_DEV_LED47 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED47)) +#define IAXXX_SYSID_DEV_LED48 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED48)) +#define IAXXX_SYSID_DEV_LED49 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED49)) +#define IAXXX_SYSID_DEV_LED50 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED50)) +#define IAXXX_SYSID_DEV_LED51 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED51)) +#define IAXXX_SYSID_DEV_LED52 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED52)) +#define IAXXX_SYSID_DEV_LED53 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED53)) +#define IAXXX_SYSID_DEV_LED54 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED54)) +#define IAXXX_SYSID_DEV_LED55 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED55)) +#define IAXXX_SYSID_DEV_LED56 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED56)) +#define IAXXX_SYSID_DEV_LED57 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED57)) +#define IAXXX_SYSID_DEV_LED58 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED58)) +#define IAXXX_SYSID_DEV_LED59 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED59)) +#define IAXXX_SYSID_DEV_LED60 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED60)) +#define IAXXX_SYSID_DEV_LED61 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED61)) +#define IAXXX_SYSID_DEV_LED62 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED62)) +#define IAXXX_SYSID_DEV_LED63 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_LED, IAXXX_DEV_INSTANCE_LED63)) +#define IAXXX_SYSID_DEV_FLASH0 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH0)) +#define IAXXX_SYSID_DEV_FLASH1 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH1)) +#define IAXXX_SYSID_DEV_FLASH2 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH2)) +#define IAXXX_SYSID_DEV_FLASH3 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH3)) +#define IAXXX_SYSID_DEV_FLASH4 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH4)) +#define IAXXX_SYSID_DEV_FLASH5 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH5)) +#define IAXXX_SYSID_DEV_FLASH6 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH6)) +#define IAXXX_SYSID_DEV_FLASH7 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH7)) +#define IAXXX_SYSID_DEV_FLASH8 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH8)) +#define IAXXX_SYSID_DEV_FLASH9 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH9)) +#define IAXXX_SYSID_DEV_FLASH10 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH10)) +#define IAXXX_SYSID_DEV_FLASH11 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH11)) +#define IAXXX_SYSID_DEV_FLASH12 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH12)) +#define IAXXX_SYSID_DEV_FLASH13 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH13)) +#define IAXXX_SYSID_DEV_FLASH14 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH14)) +#define IAXXX_SYSID_DEV_FLASH15 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH15)) +#define IAXXX_SYSID_DEV_FLASH16 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH16)) +#define IAXXX_SYSID_DEV_FLASH17 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH17)) +#define IAXXX_SYSID_DEV_FLASH18 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH18)) +#define IAXXX_SYSID_DEV_FLASH19 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH19)) +#define IAXXX_SYSID_DEV_FLASH20 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH20)) +#define IAXXX_SYSID_DEV_FLASH21 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH21)) +#define IAXXX_SYSID_DEV_FLASH22 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH22)) +#define IAXXX_SYSID_DEV_FLASH23 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH23)) +#define IAXXX_SYSID_DEV_FLASH24 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH24)) +#define IAXXX_SYSID_DEV_FLASH25 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH25)) +#define IAXXX_SYSID_DEV_FLASH26 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH26)) +#define IAXXX_SYSID_DEV_FLASH27 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH27)) +#define IAXXX_SYSID_DEV_FLASH28 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH28)) +#define IAXXX_SYSID_DEV_FLASH29 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH29)) +#define IAXXX_SYSID_DEV_FLASH30 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH30)) +#define IAXXX_SYSID_DEV_FLASH31 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH31)) +#define IAXXX_SYSID_DEV_FLASH32 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH32)) +#define IAXXX_SYSID_DEV_FLASH33 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH33)) +#define IAXXX_SYSID_DEV_FLASH34 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH34)) +#define IAXXX_SYSID_DEV_FLASH35 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH35)) +#define IAXXX_SYSID_DEV_FLASH36 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH36)) +#define IAXXX_SYSID_DEV_FLASH37 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH37)) +#define IAXXX_SYSID_DEV_FLASH38 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH38)) +#define IAXXX_SYSID_DEV_FLASH39 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH39)) +#define IAXXX_SYSID_DEV_FLASH40 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH40)) +#define IAXXX_SYSID_DEV_FLASH41 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH41)) +#define IAXXX_SYSID_DEV_FLASH42 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH42)) +#define IAXXX_SYSID_DEV_FLASH43 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH43)) +#define IAXXX_SYSID_DEV_FLASH44 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH44)) +#define IAXXX_SYSID_DEV_FLASH45 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH45)) +#define IAXXX_SYSID_DEV_FLASH46 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH46)) +#define IAXXX_SYSID_DEV_FLASH47 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH47)) +#define IAXXX_SYSID_DEV_FLASH48 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH48)) +#define IAXXX_SYSID_DEV_FLASH49 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH49)) +#define IAXXX_SYSID_DEV_FLASH50 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH50)) +#define IAXXX_SYSID_DEV_FLASH51 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH51)) +#define IAXXX_SYSID_DEV_FLASH52 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH52)) +#define IAXXX_SYSID_DEV_FLASH53 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH53)) +#define IAXXX_SYSID_DEV_FLASH54 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH54)) +#define IAXXX_SYSID_DEV_FLASH55 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH55)) +#define IAXXX_SYSID_DEV_FLASH56 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH56)) +#define IAXXX_SYSID_DEV_FLASH57 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH57)) +#define IAXXX_SYSID_DEV_FLASH58 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH58)) +#define IAXXX_SYSID_DEV_FLASH59 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH59)) +#define IAXXX_SYSID_DEV_FLASH60 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH60)) +#define IAXXX_SYSID_DEV_FLASH61 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH61)) +#define IAXXX_SYSID_DEV_FLASH62 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH62)) +#define IAXXX_SYSID_DEV_FLASH63 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_FLASH, IAXXX_DEV_INSTANCE_FLASH63)) +#define IAXXX_SYSID_DEV_CODEC0 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC0)) +#define IAXXX_SYSID_DEV_CODEC1 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC1)) +#define IAXXX_SYSID_DEV_CODEC2 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC2)) +#define IAXXX_SYSID_DEV_CODEC3 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC3)) +#define IAXXX_SYSID_DEV_CODEC4 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC4)) +#define IAXXX_SYSID_DEV_CODEC5 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC5)) +#define IAXXX_SYSID_DEV_CODEC6 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC6)) +#define IAXXX_SYSID_DEV_CODEC7 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC7)) +#define IAXXX_SYSID_DEV_CODEC8 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC8)) +#define IAXXX_SYSID_DEV_CODEC9 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC9)) +#define IAXXX_SYSID_DEV_CODEC10 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC10)) +#define IAXXX_SYSID_DEV_CODEC11 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC11)) +#define IAXXX_SYSID_DEV_CODEC12 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC12)) +#define IAXXX_SYSID_DEV_CODEC13 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC13)) +#define IAXXX_SYSID_DEV_CODEC14 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC14)) +#define IAXXX_SYSID_DEV_CODEC15 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC15)) +#define IAXXX_SYSID_DEV_CODEC16 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC16)) +#define IAXXX_SYSID_DEV_CODEC17 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC17)) +#define IAXXX_SYSID_DEV_CODEC18 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC18)) +#define IAXXX_SYSID_DEV_CODEC19 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC19)) +#define IAXXX_SYSID_DEV_CODEC20 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC20)) +#define IAXXX_SYSID_DEV_CODEC21 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC21)) +#define IAXXX_SYSID_DEV_CODEC22 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC22)) +#define IAXXX_SYSID_DEV_CODEC23 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC23)) +#define IAXXX_SYSID_DEV_CODEC24 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC24)) +#define IAXXX_SYSID_DEV_CODEC25 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC25)) +#define IAXXX_SYSID_DEV_CODEC26 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC26)) +#define IAXXX_SYSID_DEV_CODEC27 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC27)) +#define IAXXX_SYSID_DEV_CODEC28 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC28)) +#define IAXXX_SYSID_DEV_CODEC29 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC29)) +#define IAXXX_SYSID_DEV_CODEC30 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC30)) +#define IAXXX_SYSID_DEV_CODEC31 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC31)) +#define IAXXX_SYSID_DEV_CODEC32 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC32)) +#define IAXXX_SYSID_DEV_CODEC33 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC33)) +#define IAXXX_SYSID_DEV_CODEC34 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC34)) +#define IAXXX_SYSID_DEV_CODEC35 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC35)) +#define IAXXX_SYSID_DEV_CODEC36 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC36)) +#define IAXXX_SYSID_DEV_CODEC37 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC37)) +#define IAXXX_SYSID_DEV_CODEC38 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC38)) +#define IAXXX_SYSID_DEV_CODEC39 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC39)) +#define IAXXX_SYSID_DEV_CODEC40 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC40)) +#define IAXXX_SYSID_DEV_CODEC41 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC41)) +#define IAXXX_SYSID_DEV_CODEC42 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC42)) +#define IAXXX_SYSID_DEV_CODEC43 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC43)) +#define IAXXX_SYSID_DEV_CODEC44 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC44)) +#define IAXXX_SYSID_DEV_CODEC45 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC45)) +#define IAXXX_SYSID_DEV_CODEC46 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC46)) +#define IAXXX_SYSID_DEV_CODEC47 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC47)) +#define IAXXX_SYSID_DEV_CODEC48 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC48)) +#define IAXXX_SYSID_DEV_CODEC49 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC49)) +#define IAXXX_SYSID_DEV_CODEC50 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC50)) +#define IAXXX_SYSID_DEV_CODEC51 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC51)) +#define IAXXX_SYSID_DEV_CODEC52 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC52)) +#define IAXXX_SYSID_DEV_CODEC53 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC53)) +#define IAXXX_SYSID_DEV_CODEC54 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC54)) +#define IAXXX_SYSID_DEV_CODEC55 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC55)) +#define IAXXX_SYSID_DEV_CODEC56 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC56)) +#define IAXXX_SYSID_DEV_CODEC57 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC57)) +#define IAXXX_SYSID_DEV_CODEC58 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC58)) +#define IAXXX_SYSID_DEV_CODEC59 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC59)) +#define IAXXX_SYSID_DEV_CODEC60 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC60)) +#define IAXXX_SYSID_DEV_CODEC61 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC61)) +#define IAXXX_SYSID_DEV_CODEC62 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC62)) +#define IAXXX_SYSID_DEV_CODEC63 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_CODEC, IAXXX_DEV_INSTANCE_CODEC63)) +#define IAXXX_SYSID_DEV_SENSOR0 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR0)) +#define IAXXX_SYSID_DEV_SENSOR1 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR1)) +#define IAXXX_SYSID_DEV_SENSOR2 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR2)) +#define IAXXX_SYSID_DEV_SENSOR3 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR3)) +#define IAXXX_SYSID_DEV_SENSOR4 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR4)) +#define IAXXX_SYSID_DEV_SENSOR5 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR5)) +#define IAXXX_SYSID_DEV_SENSOR6 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR6)) +#define IAXXX_SYSID_DEV_SENSOR7 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR7)) +#define IAXXX_SYSID_DEV_SENSOR8 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR8)) +#define IAXXX_SYSID_DEV_SENSOR9 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR9)) +#define IAXXX_SYSID_DEV_SENSOR10 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR10)) +#define IAXXX_SYSID_DEV_SENSOR11 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR11)) +#define IAXXX_SYSID_DEV_SENSOR12 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR12)) +#define IAXXX_SYSID_DEV_SENSOR13 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR13)) +#define IAXXX_SYSID_DEV_SENSOR14 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR14)) +#define IAXXX_SYSID_DEV_SENSOR15 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR15)) +#define IAXXX_SYSID_DEV_SENSOR16 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR16)) +#define IAXXX_SYSID_DEV_SENSOR17 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR17)) +#define IAXXX_SYSID_DEV_SENSOR18 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR18)) +#define IAXXX_SYSID_DEV_SENSOR19 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR19)) +#define IAXXX_SYSID_DEV_SENSOR20 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR20)) +#define IAXXX_SYSID_DEV_SENSOR21 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR21)) +#define IAXXX_SYSID_DEV_SENSOR22 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR22)) +#define IAXXX_SYSID_DEV_SENSOR23 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR23)) +#define IAXXX_SYSID_DEV_SENSOR24 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR24)) +#define IAXXX_SYSID_DEV_SENSOR25 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR25)) +#define IAXXX_SYSID_DEV_SENSOR26 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR26)) +#define IAXXX_SYSID_DEV_SENSOR27 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR27)) +#define IAXXX_SYSID_DEV_SENSOR28 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR28)) +#define IAXXX_SYSID_DEV_SENSOR29 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR29)) +#define IAXXX_SYSID_DEV_SENSOR30 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR30)) +#define IAXXX_SYSID_DEV_SENSOR31 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR31)) +#define IAXXX_SYSID_DEV_SENSOR32 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR32)) +#define IAXXX_SYSID_DEV_SENSOR33 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR33)) +#define IAXXX_SYSID_DEV_SENSOR34 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR34)) +#define IAXXX_SYSID_DEV_SENSOR35 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR35)) +#define IAXXX_SYSID_DEV_SENSOR36 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR36)) +#define IAXXX_SYSID_DEV_SENSOR37 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR37)) +#define IAXXX_SYSID_DEV_SENSOR38 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR38)) +#define IAXXX_SYSID_DEV_SENSOR39 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR39)) +#define IAXXX_SYSID_DEV_SENSOR40 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR40)) +#define IAXXX_SYSID_DEV_SENSOR41 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR41)) +#define IAXXX_SYSID_DEV_SENSOR42 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR42)) +#define IAXXX_SYSID_DEV_SENSOR43 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR43)) +#define IAXXX_SYSID_DEV_SENSOR44 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR44)) +#define IAXXX_SYSID_DEV_SENSOR45 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR45)) +#define IAXXX_SYSID_DEV_SENSOR46 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR46)) +#define IAXXX_SYSID_DEV_SENSOR47 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR47)) +#define IAXXX_SYSID_DEV_SENSOR48 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR48)) +#define IAXXX_SYSID_DEV_SENSOR49 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR49)) +#define IAXXX_SYSID_DEV_SENSOR50 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR50)) +#define IAXXX_SYSID_DEV_SENSOR51 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR51)) +#define IAXXX_SYSID_DEV_SENSOR52 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR52)) +#define IAXXX_SYSID_DEV_SENSOR53 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR53)) +#define IAXXX_SYSID_DEV_SENSOR54 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR54)) +#define IAXXX_SYSID_DEV_SENSOR55 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR55)) +#define IAXXX_SYSID_DEV_SENSOR56 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR56)) +#define IAXXX_SYSID_DEV_SENSOR57 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR57)) +#define IAXXX_SYSID_DEV_SENSOR58 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR58)) +#define IAXXX_SYSID_DEV_SENSOR59 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR59)) +#define IAXXX_SYSID_DEV_SENSOR60 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR60)) +#define IAXXX_SYSID_DEV_SENSOR61 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR61)) +#define IAXXX_SYSID_DEV_SENSOR62 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR62)) +#define IAXXX_SYSID_DEV_SENSOR63 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_SENSOR, IAXXX_DEV_INSTANCE_SENSOR63)) +#define IAXXX_SYSID_DEV_INPUT_PIN0 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN0)) +#define IAXXX_SYSID_DEV_INPUT_PIN1 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN1)) +#define IAXXX_SYSID_DEV_INPUT_PIN2 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN2)) +#define IAXXX_SYSID_DEV_INPUT_PIN3 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN3)) +#define IAXXX_SYSID_DEV_INPUT_PIN4 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN4)) +#define IAXXX_SYSID_DEV_INPUT_PIN5 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN5)) +#define IAXXX_SYSID_DEV_INPUT_PIN6 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN6)) +#define IAXXX_SYSID_DEV_INPUT_PIN7 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN7)) +#define IAXXX_SYSID_DEV_INPUT_PIN8 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN8)) +#define IAXXX_SYSID_DEV_INPUT_PIN9 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN9)) +#define IAXXX_SYSID_DEV_INPUT_PIN10 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN10)) +#define IAXXX_SYSID_DEV_INPUT_PIN11 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN11)) +#define IAXXX_SYSID_DEV_INPUT_PIN12 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN12)) +#define IAXXX_SYSID_DEV_INPUT_PIN13 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN13)) +#define IAXXX_SYSID_DEV_INPUT_PIN14 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN14)) +#define IAXXX_SYSID_DEV_INPUT_PIN15 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN15)) +#define IAXXX_SYSID_DEV_INPUT_PIN16 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN16)) +#define IAXXX_SYSID_DEV_INPUT_PIN17 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN17)) +#define IAXXX_SYSID_DEV_INPUT_PIN18 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN18)) +#define IAXXX_SYSID_DEV_INPUT_PIN19 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN19)) +#define IAXXX_SYSID_DEV_INPUT_PIN20 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN20)) +#define IAXXX_SYSID_DEV_INPUT_PIN21 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN21)) +#define IAXXX_SYSID_DEV_INPUT_PIN22 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN22)) +#define IAXXX_SYSID_DEV_INPUT_PIN23 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN23)) +#define IAXXX_SYSID_DEV_INPUT_PIN24 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN24)) +#define IAXXX_SYSID_DEV_INPUT_PIN25 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN25)) +#define IAXXX_SYSID_DEV_INPUT_PIN26 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN26)) +#define IAXXX_SYSID_DEV_INPUT_PIN27 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN27)) +#define IAXXX_SYSID_DEV_INPUT_PIN28 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN28)) +#define IAXXX_SYSID_DEV_INPUT_PIN29 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN29)) +#define IAXXX_SYSID_DEV_INPUT_PIN30 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN30)) +#define IAXXX_SYSID_DEV_INPUT_PIN31 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN31)) +#define IAXXX_SYSID_DEV_INPUT_PIN32 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN32)) +#define IAXXX_SYSID_DEV_INPUT_PIN33 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN33)) +#define IAXXX_SYSID_DEV_INPUT_PIN34 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN34)) +#define IAXXX_SYSID_DEV_INPUT_PIN35 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN35)) +#define IAXXX_SYSID_DEV_INPUT_PIN36 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN36)) +#define IAXXX_SYSID_DEV_INPUT_PIN37 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN37)) +#define IAXXX_SYSID_DEV_INPUT_PIN38 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN38)) +#define IAXXX_SYSID_DEV_INPUT_PIN39 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN39)) +#define IAXXX_SYSID_DEV_INPUT_PIN40 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN40)) +#define IAXXX_SYSID_DEV_INPUT_PIN41 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN41)) +#define IAXXX_SYSID_DEV_INPUT_PIN42 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN42)) +#define IAXXX_SYSID_DEV_INPUT_PIN43 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN43)) +#define IAXXX_SYSID_DEV_INPUT_PIN44 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN44)) +#define IAXXX_SYSID_DEV_INPUT_PIN45 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN45)) +#define IAXXX_SYSID_DEV_INPUT_PIN46 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN46)) +#define IAXXX_SYSID_DEV_INPUT_PIN47 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN47)) +#define IAXXX_SYSID_DEV_INPUT_PIN48 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN48)) +#define IAXXX_SYSID_DEV_INPUT_PIN49 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN49)) +#define IAXXX_SYSID_DEV_INPUT_PIN50 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN50)) +#define IAXXX_SYSID_DEV_INPUT_PIN51 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN51)) +#define IAXXX_SYSID_DEV_INPUT_PIN52 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN52)) +#define IAXXX_SYSID_DEV_INPUT_PIN53 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN53)) +#define IAXXX_SYSID_DEV_INPUT_PIN54 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN54)) +#define IAXXX_SYSID_DEV_INPUT_PIN55 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN55)) +#define IAXXX_SYSID_DEV_INPUT_PIN56 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN56)) +#define IAXXX_SYSID_DEV_INPUT_PIN57 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN57)) +#define IAXXX_SYSID_DEV_INPUT_PIN58 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN58)) +#define IAXXX_SYSID_DEV_INPUT_PIN59 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN59)) +#define IAXXX_SYSID_DEV_INPUT_PIN60 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN60)) +#define IAXXX_SYSID_DEV_INPUT_PIN61 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN61)) +#define IAXXX_SYSID_DEV_INPUT_PIN62 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN62)) +#define IAXXX_SYSID_DEV_INPUT_PIN63 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INPUT_PIN, IAXXX_DEV_INSTANCE_INPUT_PIN63)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN0 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN0)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN1 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN1)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN2 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN2)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN3 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN3)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN4 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN4)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN5 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN5)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN6 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN6)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN7 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN7)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN8 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN8)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN9 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN9)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN10 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN10)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN11 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN11)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN12 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN12)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN13 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN13)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN14 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN14)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN15 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN15)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN16 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN16)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN17 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN17)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN18 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN18)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN19 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN19)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN20 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN20)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN21 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN21)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN22 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN22)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN23 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN23)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN24 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN24)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN25 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN25)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN26 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN26)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN27 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN27)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN28 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN28)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN29 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN29)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN30 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN30)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN31 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN31)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN32 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN32)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN33 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN33)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN34 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN34)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN35 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN35)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN36 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN36)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN37 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN37)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN38 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN38)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN39 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN39)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN40 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN40)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN41 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN41)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN42 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN42)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN43 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN43)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN44 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN44)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN45 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN45)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN46 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN46)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN47 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN47)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN48 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN48)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN49 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN49)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN50 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN50)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN51 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN51)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN52 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN52)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN53 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN53)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN54 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN54)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN55 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN55)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN56 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN56)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN57 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN57)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN58 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN58)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN59 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN59)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN60 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN60)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN61 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN61)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN62 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN62)) +#define IAXXX_SYSID_DEV_OUTPUT_PIN63 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_OUTPUT_PIN, IAXXX_DEV_INSTANCE_OUTPUT_PIN63)) +#define IAXXX_SYSID_DEV_STMR_TMR0 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR0)) +#define IAXXX_SYSID_DEV_STMR_TMR1 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR1)) +#define IAXXX_SYSID_DEV_STMR_TMR2 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR2)) +#define IAXXX_SYSID_DEV_STMR_TMR3 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR3)) +#define IAXXX_SYSID_DEV_STMR_TMR4 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR4)) +#define IAXXX_SYSID_DEV_STMR_TMR5 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR5)) +#define IAXXX_SYSID_DEV_STMR_TMR6 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR6)) +#define IAXXX_SYSID_DEV_STMR_TMR7 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR7)) +#define IAXXX_SYSID_DEV_STMR_TMR8 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR8)) +#define IAXXX_SYSID_DEV_STMR_TMR9 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR9)) +#define IAXXX_SYSID_DEV_STMR_TMR10 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR10)) +#define IAXXX_SYSID_DEV_STMR_TMR11 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR11)) +#define IAXXX_SYSID_DEV_STMR_TMR12 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR12)) +#define IAXXX_SYSID_DEV_STMR_TMR13 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR13)) +#define IAXXX_SYSID_DEV_STMR_TMR14 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR14)) +#define IAXXX_SYSID_DEV_STMR_TMR15 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR15)) +#define IAXXX_SYSID_DEV_STMR_TMR16 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR16)) +#define IAXXX_SYSID_DEV_STMR_TMR17 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR17)) +#define IAXXX_SYSID_DEV_STMR_TMR18 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR18)) +#define IAXXX_SYSID_DEV_STMR_TMR19 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR19)) +#define IAXXX_SYSID_DEV_STMR_TMR20 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR20)) +#define IAXXX_SYSID_DEV_STMR_TMR21 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR21)) +#define IAXXX_SYSID_DEV_STMR_TMR22 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR22)) +#define IAXXX_SYSID_DEV_STMR_TMR23 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR23)) +#define IAXXX_SYSID_DEV_STMR_TMR24 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR24)) +#define IAXXX_SYSID_DEV_STMR_TMR25 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR25)) +#define IAXXX_SYSID_DEV_STMR_TMR26 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR26)) +#define IAXXX_SYSID_DEV_STMR_TMR27 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR27)) +#define IAXXX_SYSID_DEV_STMR_TMR28 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR28)) +#define IAXXX_SYSID_DEV_STMR_TMR29 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR29)) +#define IAXXX_SYSID_DEV_STMR_TMR30 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR30)) +#define IAXXX_SYSID_DEV_STMR_TMR31 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR31)) +#define IAXXX_SYSID_DEV_STMR_TMR32 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR32)) +#define IAXXX_SYSID_DEV_STMR_TMR33 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR33)) +#define IAXXX_SYSID_DEV_STMR_TMR34 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR34)) +#define IAXXX_SYSID_DEV_STMR_TMR35 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR35)) +#define IAXXX_SYSID_DEV_STMR_TMR36 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR36)) +#define IAXXX_SYSID_DEV_STMR_TMR37 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR37)) +#define IAXXX_SYSID_DEV_STMR_TMR38 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR38)) +#define IAXXX_SYSID_DEV_STMR_TMR39 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR39)) +#define IAXXX_SYSID_DEV_STMR_TMR40 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR40)) +#define IAXXX_SYSID_DEV_STMR_TMR41 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR41)) +#define IAXXX_SYSID_DEV_STMR_TMR42 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR42)) +#define IAXXX_SYSID_DEV_STMR_TMR43 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR43)) +#define IAXXX_SYSID_DEV_STMR_TMR44 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR44)) +#define IAXXX_SYSID_DEV_STMR_TMR45 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR45)) +#define IAXXX_SYSID_DEV_STMR_TMR46 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR46)) +#define IAXXX_SYSID_DEV_STMR_TMR47 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR47)) +#define IAXXX_SYSID_DEV_STMR_TMR48 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR48)) +#define IAXXX_SYSID_DEV_STMR_TMR49 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR49)) +#define IAXXX_SYSID_DEV_STMR_TMR50 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR50)) +#define IAXXX_SYSID_DEV_STMR_TMR51 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR51)) +#define IAXXX_SYSID_DEV_STMR_TMR52 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR52)) +#define IAXXX_SYSID_DEV_STMR_TMR53 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR53)) +#define IAXXX_SYSID_DEV_STMR_TMR54 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR54)) +#define IAXXX_SYSID_DEV_STMR_TMR55 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR55)) +#define IAXXX_SYSID_DEV_STMR_TMR56 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR56)) +#define IAXXX_SYSID_DEV_STMR_TMR57 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR57)) +#define IAXXX_SYSID_DEV_STMR_TMR58 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR58)) +#define IAXXX_SYSID_DEV_STMR_TMR59 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR59)) +#define IAXXX_SYSID_DEV_STMR_TMR60 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR60)) +#define IAXXX_SYSID_DEV_STMR_TMR61 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR61)) +#define IAXXX_SYSID_DEV_STMR_TMR62 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR62)) +#define IAXXX_SYSID_DEV_STMR_TMR63 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_TMR, IAXXX_DEV_INSTANCE_STMR_TMR63)) +#define IAXXX_SYSID_DEV_STMR_PT0 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT0)) +#define IAXXX_SYSID_DEV_STMR_PT1 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT1)) +#define IAXXX_SYSID_DEV_STMR_PT2 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT2)) +#define IAXXX_SYSID_DEV_STMR_PT3 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT3)) +#define IAXXX_SYSID_DEV_STMR_PT4 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT4)) +#define IAXXX_SYSID_DEV_STMR_PT5 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT5)) +#define IAXXX_SYSID_DEV_STMR_PT6 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT6)) +#define IAXXX_SYSID_DEV_STMR_PT7 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT7)) +#define IAXXX_SYSID_DEV_STMR_PT8 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT8)) +#define IAXXX_SYSID_DEV_STMR_PT9 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT9)) +#define IAXXX_SYSID_DEV_STMR_PT10 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT10)) +#define IAXXX_SYSID_DEV_STMR_PT11 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT11)) +#define IAXXX_SYSID_DEV_STMR_PT12 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT12)) +#define IAXXX_SYSID_DEV_STMR_PT13 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT13)) +#define IAXXX_SYSID_DEV_STMR_PT14 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT14)) +#define IAXXX_SYSID_DEV_STMR_PT15 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT15)) +#define IAXXX_SYSID_DEV_STMR_PT16 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT16)) +#define IAXXX_SYSID_DEV_STMR_PT17 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT17)) +#define IAXXX_SYSID_DEV_STMR_PT18 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT18)) +#define IAXXX_SYSID_DEV_STMR_PT19 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT19)) +#define IAXXX_SYSID_DEV_STMR_PT20 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT20)) +#define IAXXX_SYSID_DEV_STMR_PT21 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT21)) +#define IAXXX_SYSID_DEV_STMR_PT22 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT22)) +#define IAXXX_SYSID_DEV_STMR_PT23 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT23)) +#define IAXXX_SYSID_DEV_STMR_PT24 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT24)) +#define IAXXX_SYSID_DEV_STMR_PT25 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT25)) +#define IAXXX_SYSID_DEV_STMR_PT26 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT26)) +#define IAXXX_SYSID_DEV_STMR_PT27 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT27)) +#define IAXXX_SYSID_DEV_STMR_PT28 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT28)) +#define IAXXX_SYSID_DEV_STMR_PT29 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT29)) +#define IAXXX_SYSID_DEV_STMR_PT30 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT30)) +#define IAXXX_SYSID_DEV_STMR_PT31 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT31)) +#define IAXXX_SYSID_DEV_STMR_PT32 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT32)) +#define IAXXX_SYSID_DEV_STMR_PT33 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT33)) +#define IAXXX_SYSID_DEV_STMR_PT34 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT34)) +#define IAXXX_SYSID_DEV_STMR_PT35 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT35)) +#define IAXXX_SYSID_DEV_STMR_PT36 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT36)) +#define IAXXX_SYSID_DEV_STMR_PT37 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT37)) +#define IAXXX_SYSID_DEV_STMR_PT38 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT38)) +#define IAXXX_SYSID_DEV_STMR_PT39 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT39)) +#define IAXXX_SYSID_DEV_STMR_PT40 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT40)) +#define IAXXX_SYSID_DEV_STMR_PT41 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT41)) +#define IAXXX_SYSID_DEV_STMR_PT42 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT42)) +#define IAXXX_SYSID_DEV_STMR_PT43 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT43)) +#define IAXXX_SYSID_DEV_STMR_PT44 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT44)) +#define IAXXX_SYSID_DEV_STMR_PT45 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT45)) +#define IAXXX_SYSID_DEV_STMR_PT46 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT46)) +#define IAXXX_SYSID_DEV_STMR_PT47 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT47)) +#define IAXXX_SYSID_DEV_STMR_PT48 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT48)) +#define IAXXX_SYSID_DEV_STMR_PT49 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT49)) +#define IAXXX_SYSID_DEV_STMR_PT50 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT50)) +#define IAXXX_SYSID_DEV_STMR_PT51 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT51)) +#define IAXXX_SYSID_DEV_STMR_PT52 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT52)) +#define IAXXX_SYSID_DEV_STMR_PT53 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT53)) +#define IAXXX_SYSID_DEV_STMR_PT54 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT54)) +#define IAXXX_SYSID_DEV_STMR_PT55 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT55)) +#define IAXXX_SYSID_DEV_STMR_PT56 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT56)) +#define IAXXX_SYSID_DEV_STMR_PT57 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT57)) +#define IAXXX_SYSID_DEV_STMR_PT58 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT58)) +#define IAXXX_SYSID_DEV_STMR_PT59 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT59)) +#define IAXXX_SYSID_DEV_STMR_PT60 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT60)) +#define IAXXX_SYSID_DEV_STMR_PT61 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT61)) +#define IAXXX_SYSID_DEV_STMR_PT62 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT62)) +#define IAXXX_SYSID_DEV_STMR_PT63 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_STMR_PT, IAXXX_DEV_INSTANCE_STMR_PT63)) +#define IAXXX_SYSID_DEV_INTERFACE0 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE0)) +#define IAXXX_SYSID_DEV_INTERFACE1 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE1)) +#define IAXXX_SYSID_DEV_INTERFACE2 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE2)) +#define IAXXX_SYSID_DEV_INTERFACE3 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE3)) +#define IAXXX_SYSID_DEV_INTERFACE4 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE4)) +#define IAXXX_SYSID_DEV_INTERFACE5 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE5)) +#define IAXXX_SYSID_DEV_INTERFACE6 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE6)) +#define IAXXX_SYSID_DEV_INTERFACE7 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE7)) +#define IAXXX_SYSID_DEV_INTERFACE8 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE8)) +#define IAXXX_SYSID_DEV_INTERFACE9 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE9)) +#define IAXXX_SYSID_DEV_INTERFACE10 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE10)) +#define IAXXX_SYSID_DEV_INTERFACE11 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE11)) +#define IAXXX_SYSID_DEV_INTERFACE12 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE12)) +#define IAXXX_SYSID_DEV_INTERFACE13 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE13)) +#define IAXXX_SYSID_DEV_INTERFACE14 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE14)) +#define IAXXX_SYSID_DEV_INTERFACE15 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE15)) +#define IAXXX_SYSID_DEV_INTERFACE16 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE16)) +#define IAXXX_SYSID_DEV_INTERFACE17 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE17)) +#define IAXXX_SYSID_DEV_INTERFACE18 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE18)) +#define IAXXX_SYSID_DEV_INTERFACE19 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE19)) +#define IAXXX_SYSID_DEV_INTERFACE20 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE20)) +#define IAXXX_SYSID_DEV_INTERFACE21 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE21)) +#define IAXXX_SYSID_DEV_INTERFACE22 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE22)) +#define IAXXX_SYSID_DEV_INTERFACE23 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE23)) +#define IAXXX_SYSID_DEV_INTERFACE24 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE24)) +#define IAXXX_SYSID_DEV_INTERFACE25 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE25)) +#define IAXXX_SYSID_DEV_INTERFACE26 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE26)) +#define IAXXX_SYSID_DEV_INTERFACE27 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE27)) +#define IAXXX_SYSID_DEV_INTERFACE28 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE28)) +#define IAXXX_SYSID_DEV_INTERFACE29 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE29)) +#define IAXXX_SYSID_DEV_INTERFACE30 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE30)) +#define IAXXX_SYSID_DEV_INTERFACE31 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE31)) +#define IAXXX_SYSID_DEV_INTERFACE32 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE32)) +#define IAXXX_SYSID_DEV_INTERFACE33 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE33)) +#define IAXXX_SYSID_DEV_INTERFACE34 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE34)) +#define IAXXX_SYSID_DEV_INTERFACE35 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE35)) +#define IAXXX_SYSID_DEV_INTERFACE36 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE36)) +#define IAXXX_SYSID_DEV_INTERFACE37 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE37)) +#define IAXXX_SYSID_DEV_INTERFACE38 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE38)) +#define IAXXX_SYSID_DEV_INTERFACE39 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE39)) +#define IAXXX_SYSID_DEV_INTERFACE40 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE40)) +#define IAXXX_SYSID_DEV_INTERFACE41 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE41)) +#define IAXXX_SYSID_DEV_INTERFACE42 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE42)) +#define IAXXX_SYSID_DEV_INTERFACE43 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE43)) +#define IAXXX_SYSID_DEV_INTERFACE44 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE44)) +#define IAXXX_SYSID_DEV_INTERFACE45 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE45)) +#define IAXXX_SYSID_DEV_INTERFACE46 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE46)) +#define IAXXX_SYSID_DEV_INTERFACE47 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE47)) +#define IAXXX_SYSID_DEV_INTERFACE48 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE48)) +#define IAXXX_SYSID_DEV_INTERFACE49 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE49)) +#define IAXXX_SYSID_DEV_INTERFACE50 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE50)) +#define IAXXX_SYSID_DEV_INTERFACE51 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE51)) +#define IAXXX_SYSID_DEV_INTERFACE52 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE52)) +#define IAXXX_SYSID_DEV_INTERFACE53 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE53)) +#define IAXXX_SYSID_DEV_INTERFACE54 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE54)) +#define IAXXX_SYSID_DEV_INTERFACE55 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE55)) +#define IAXXX_SYSID_DEV_INTERFACE56 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE56)) +#define IAXXX_SYSID_DEV_INTERFACE57 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE57)) +#define IAXXX_SYSID_DEV_INTERFACE58 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE58)) +#define IAXXX_SYSID_DEV_INTERFACE59 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE59)) +#define IAXXX_SYSID_DEV_INTERFACE60 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE60)) +#define IAXXX_SYSID_DEV_INTERFACE61 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE61)) +#define IAXXX_SYSID_DEV_INTERFACE62 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE62)) +#define IAXXX_SYSID_DEV_INTERFACE63 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_INTERFACE, IAXXX_DEV_INSTANCE_INTERFACE63)) +#define IAXXX_SYSID_DEV_USB0 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB0)) +#define IAXXX_SYSID_DEV_USB1 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB1)) +#define IAXXX_SYSID_DEV_USB2 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB2)) +#define IAXXX_SYSID_DEV_USB3 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB3)) +#define IAXXX_SYSID_DEV_USB4 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB4)) +#define IAXXX_SYSID_DEV_USB5 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB5)) +#define IAXXX_SYSID_DEV_USB6 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB6)) +#define IAXXX_SYSID_DEV_USB7 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB7)) +#define IAXXX_SYSID_DEV_USB8 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB8)) +#define IAXXX_SYSID_DEV_USB9 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB9)) +#define IAXXX_SYSID_DEV_USB10 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB10)) +#define IAXXX_SYSID_DEV_USB11 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB11)) +#define IAXXX_SYSID_DEV_USB12 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB12)) +#define IAXXX_SYSID_DEV_USB13 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB13)) +#define IAXXX_SYSID_DEV_USB14 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB14)) +#define IAXXX_SYSID_DEV_USB15 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB15)) +#define IAXXX_SYSID_DEV_USB16 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB16)) +#define IAXXX_SYSID_DEV_USB17 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB17)) +#define IAXXX_SYSID_DEV_USB18 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB18)) +#define IAXXX_SYSID_DEV_USB19 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB19)) +#define IAXXX_SYSID_DEV_USB20 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB20)) +#define IAXXX_SYSID_DEV_USB21 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB21)) +#define IAXXX_SYSID_DEV_USB22 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB22)) +#define IAXXX_SYSID_DEV_USB23 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB23)) +#define IAXXX_SYSID_DEV_USB24 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB24)) +#define IAXXX_SYSID_DEV_USB25 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB25)) +#define IAXXX_SYSID_DEV_USB26 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB26)) +#define IAXXX_SYSID_DEV_USB27 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB27)) +#define IAXXX_SYSID_DEV_USB28 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB28)) +#define IAXXX_SYSID_DEV_USB29 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB29)) +#define IAXXX_SYSID_DEV_USB30 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB30)) +#define IAXXX_SYSID_DEV_USB31 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB31)) +#define IAXXX_SYSID_DEV_USB32 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB32)) +#define IAXXX_SYSID_DEV_USB33 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB33)) +#define IAXXX_SYSID_DEV_USB34 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB34)) +#define IAXXX_SYSID_DEV_USB35 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB35)) +#define IAXXX_SYSID_DEV_USB36 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB36)) +#define IAXXX_SYSID_DEV_USB37 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB37)) +#define IAXXX_SYSID_DEV_USB38 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB38)) +#define IAXXX_SYSID_DEV_USB39 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB39)) +#define IAXXX_SYSID_DEV_USB40 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB40)) +#define IAXXX_SYSID_DEV_USB41 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB41)) +#define IAXXX_SYSID_DEV_USB42 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB42)) +#define IAXXX_SYSID_DEV_USB43 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB43)) +#define IAXXX_SYSID_DEV_USB44 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB44)) +#define IAXXX_SYSID_DEV_USB45 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB45)) +#define IAXXX_SYSID_DEV_USB46 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB46)) +#define IAXXX_SYSID_DEV_USB47 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB47)) +#define IAXXX_SYSID_DEV_USB48 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB48)) +#define IAXXX_SYSID_DEV_USB49 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB49)) +#define IAXXX_SYSID_DEV_USB50 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB50)) +#define IAXXX_SYSID_DEV_USB51 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB51)) +#define IAXXX_SYSID_DEV_USB52 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB52)) +#define IAXXX_SYSID_DEV_USB53 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB53)) +#define IAXXX_SYSID_DEV_USB54 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB54)) +#define IAXXX_SYSID_DEV_USB55 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB55)) +#define IAXXX_SYSID_DEV_USB56 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB56)) +#define IAXXX_SYSID_DEV_USB57 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB57)) +#define IAXXX_SYSID_DEV_USB58 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB58)) +#define IAXXX_SYSID_DEV_USB59 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB59)) +#define IAXXX_SYSID_DEV_USB60 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB60)) +#define IAXXX_SYSID_DEV_USB61 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB61)) +#define IAXXX_SYSID_DEV_USB62 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB62)) +#define IAXXX_SYSID_DEV_USB63 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_USB, IAXXX_DEV_INSTANCE_USB63)) +#define IAXXX_SYSID_DEV_BT0 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BT, IAXXX_DEV_INSTANCE_BT0)) +#define IAXXX_SYSID_DEV_BATTERY0 (IAXXX_SYSID_GEN_DEVICE_SYSID(IAXXX_SYSID_DEVICE_TYPE_BATTERY, IAXXX_DEV_INSTANCE_BATTERY0)) +enum iaxxx_drv_sys_id_range_e { + IAXXX_SYSID_PCM_START = IAXXX_SYSID_PCM0, + IAXXX_SYSID_PCM_END = IAXXX_SYSID_PCM5, + IAXXX_SYSID_I2S_START = IAXXX_SYSID_I2S0, + IAXXX_SYSID_I2S_END = IAXXX_SYSID_I2S6, + IAXXX_SYSID_PDMI_START = IAXXX_SYSID_PDMI0, + IAXXX_SYSID_PDMI_END = IAXXX_SYSID_PDMI7, + IAXXX_SYSID_PDMO_START = IAXXX_SYSID_PDMO0, + IAXXX_SYSID_PDMO_END = IAXXX_SYSID_PDMO1, + IAXXX_SYSID_ADC_START = IAXXX_SYSID_ADC0_IN0, + IAXXX_SYSID_ADC_END = IAXXX_SYSID_ADC3_IN7, + IAXXX_SYSID_DAC_START = IAXXX_SYSID_DAC0, + IAXXX_SYSID_DAC_END = IAXXX_SYSID_DAC1, + IAXXX_SYSID_SPI_START = IAXXX_SYSID_SPI0, + IAXXX_SYSID_SPI_END = IAXXX_SYSID_SPI2, + IAXXX_SYSID_FILTER_START = IAXXX_SYSID_FILTER_IN0, + IAXXX_SYSID_FILTER_END = IAXXX_SYSID_FILTER_OUT1, + IAXXX_DRV_SYSID_RANGE_FORCE_SIZE = INT_MAX, +}; +#endif diff --git a/iaxxx-tunnel-intf.h b/iaxxx-tunnel-intf.h new file mode 100644 index 0000000..311fec7 --- /dev/null +++ b/iaxxx-tunnel-intf.h @@ -0,0 +1,82 @@ +/**************************************************************************** + **************************************************************************** + *** + *** This header was automatically generated from a Linux kernel header + *** of the same name, to make information necessary for userspace to + *** call into the kernel available to libc. It contains only constants, + *** structures, and macros generated from the original header, and thus, + *** contains no copyrightable information. + *** + *** To edit the content of this header, modify the corresponding + *** source file (e.g. under external/kernel-headers/original/) then + *** run bionic/libc/kernel/tools/update_all.py + *** + *** Any manual change here will be lost the next time this script will + *** be run. You've been warned! + *** + **************************************************************************** + ****************************************************************************/ +#ifndef _IAXXX_TUNNEL_INTF_H +#define _IAXXX_TUNNEL_INTF_H +struct tunlMsg { + uint32_t tunlEP; + uint32_t tunlSrc; + uint32_t tunlMode; + uint32_t tunlEncode; +} __attribute__((packed)); +struct iaxxx_tunnel_header { + uint8_t magic[4]; + uint16_t tunnel_id; + uint8_t crc[6]; + uint64_t ts; + uint32_t seq_no; + uint16_t size; + uint8_t encoding; + uint8_t sample_rate; + char buf[0]; +} __attribute__((packed)); +struct iaxxx_tnl_evt_info { + uint16_t src_id; + uint16_t event_id; + uint16_t dst_id; + uint32_t dst_opaque; + uint32_t evt_threshold; +} __attribute__((packed)); +enum { + TNL_VQ_CONFIDENCE = 0, + TNL_CS_OUT1, + TNL_CS_OUT2, + TNL_DOA, + TNL_CVQ, + TNL_MIC1, + TNL_MIC2, + TNL_MIC3, + TNL_MIC4, + TNL_AEC_REF1, + TNL_AEC_REF2, + TNL_AEC_MIXER, + TNL_MIC1_Q15, + TNL_MIC2_Q15, + TNL_MIC3_Q15, + TNL_MIC4_Q15, + TNL_AEC_MIXER_Q15, + TNL_MBC, + TNL_PEQ, + TNL_VP_PARAM, + TNL_MAX, +}; +#define TUNNEL_SETUP _IOWR('K', 0x011, struct tunlMsg) +#define TUNNEL_TERMINATE _IOWR('K', 0x012, struct tunlMsg) +#define TUNNEL_SUBSCRIBE_META _IO('K', 0x013) +#define TUNNEL_SUBSCRIBE_ALL _IO('K', 0x014) +#define TUNNEL_SUBSCRIBE_CVQ _IO('K', 0x015) +#define TUNNEL_UNSUBSCRIBE_META _IO('K', 0x016) +#define TUNNEL_UNSUBSCRIBE_ALL _IO('K', 0x017) +#define TUNNEL_UNSUBSCRIBE_CVQ _IO('K', 0x018) +#define TUNNEL_SUBSCRIBE_META_DOA _IO('K', 0x019) +#define TUNNEL_SUBSCRIBE_META_VQ _IO('K', 0x01a) +#define TUNNEL_UNSUBSCRIBE_META_DOA _IO('K', 0x01b) +#define TUNNEL_UNSUBSCRIBE_META_VQ _IO('K', 0x01c) +#define TUNNEL_EVENT_SUBSCRIBE _IOWR('K', 0x01d, struct iaxxx_tnl_evt_info) +#define TUNNEL_EVENT_UNSUBSCRIBE _IOWR('K', 0x01e, struct iaxxx_tnl_evt_info) +#endif diff --git a/sound_trigger_hw_iaxxx.c b/sound_trigger_hw_iaxxx.c new file mode 100644 index 0000000..c62bd66 --- /dev/null +++ b/sound_trigger_hw_iaxxx.c @@ -0,0 +1,1096 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "SoundTriggerKnowles_HAL" +#define LOG_NDEBUG 0 + +#include <errno.h> +#include <fcntl.h> +#include <malloc.h> +#include <poll.h> +#include <pthread.h> +#include <sys/ioctl.h> +#include <sys/prctl.h> +#include <cutils/log.h> +#include <cutils/uevent.h> +#include <math.h> +#include <dlfcn.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <unistd.h> +#include <sys/timerfd.h> + +#include <hardware/hardware.h> +#include <system/sound_trigger.h> +#include <hardware/sound_trigger.h> + +#include "iaxxx-odsp.h" +#include "cvq_ioctl.h" + +#define ENABLE_KEYPHRASE_DETECTION + +#define MAX_GENERIC_SOUND_MODELS (3) +#define MAX_KEY_PHRASES (1) +#define MAX_MODELS (MAX_GENERIC_SOUND_MODELS + MAX_KEY_PHRASES) + +#define MAX_USERS (1) +#define MAX_BUFFER_MS (3000) +#define POWER_CONSUMPTION (0) // TBD +#define ST_HAL_VERSION (1) + +#define UEVENT_MSG_LEN (1024) + +#define EVENT_ID_KW_ID (0) + +#define IAXXX_VQ_EVENT_STR "IAXXX_VQ_EVENT" +#define IAXXX_RECOVERY_EVENT_STR "IAXXX_RECOVERY_EVENT" + +#ifdef __LP64__ +#define ADNC_STRM_LIBRARY_PATH "/vendor/lib64/hw/adnc_strm.primary.default.so" +#else +#define ADNC_STRM_LIBRARY_PATH "/vendor/lib/hw/adnc_strm.primary.default.so" +#endif + +#define SENSOR_MANAGER_MODEL "5c0c296d-204c-4c2b-9f85-e50746caf914" + +// Define this macro to enable test stub to simulate the Generic Sound Model +// form the SoundTrigger HAL. +#define SIMULATE_GSM_TEST_STUB + +static const struct sound_trigger_properties hw_properties = { + "Knowles Electronics", // implementor + "Continous VoiceQ", // description + 1, // version + { 0x80f7dcd5, 0xbb62, 0x4816, 0xa931, { 0x9c, 0xaa, 0x52, 0x5d, 0xf5, 0xc7 } }, // Version UUID + MAX_MODELS, // max_sound_models + MAX_KEY_PHRASES, // max_key_phrases + MAX_USERS, // max_users + RECOGNITION_MODE_VOICE_TRIGGER | // recognition_mode + RECOGNITION_MODE_GENERIC_TRIGGER, + true, // capture_transition + MAX_BUFFER_MS, // max_capture_ms + false, // concurrent_capture + false, // trigger_in_event + POWER_CONSUMPTION // power_consumption_mw +}; + +struct model_info { + void *recognition_cookie; + void *sound_model_cookie; + sound_model_handle_t model_handle; + sound_trigger_uuid_t uuid; + recognition_callback_t recognition_callback; + sound_model_callback_t sound_model_callback; + struct sound_trigger_recognition_config *config; + int kw_id; + sound_trigger_sound_model_type_t type; + + void *data; + int data_sz; + bool is_loaded; +}; + +struct knowles_sound_trigger_device { + struct sound_trigger_hw_device device; + struct model_info models[MAX_MODELS]; + sound_trigger_uuid_t authkw_model_uuid; + pthread_t callback_thread; + pthread_mutex_t lock; + bool is_recog_in_prog; + int opened; + int send_sock; + int recv_sock; + struct sound_trigger_recognition_config *last_keyword_detected_config; + + // Information about streaming + int is_streaming; + void *adnc_cvq_strm_lib; + int (*adnc_strm_open)(bool, int); + size_t (*adnc_strm_read)(long, void*, size_t); + int (*adnc_strm_close)(long); + long adnc_strm_handle; +#ifdef SIMULATE_GSM_TEST_STUB + int last_recog_model_id; +#endif + + sound_trigger_uuid_t sensor_model_uuid; +}; + +// Since there's only ever one sound_trigger_device, keep it as a global so that other people can +// dlopen this lib to get at the streaming audio. +static struct knowles_sound_trigger_device g_stdev = { .lock = PTHREAD_MUTEX_INITIALIZER }; + +static bool check_uuid_equality(sound_trigger_uuid_t uuid1, sound_trigger_uuid_t uuid2) { + if (uuid1.timeLow != uuid2.timeLow || + uuid1.timeMid != uuid2.timeMid || + uuid1.timeHiAndVersion != uuid2.timeHiAndVersion || + uuid1.clockSeq != uuid2.clockSeq) { + return false; + } + + for (int i = 0; i < 6; i++) { + if(uuid1.node[i] != uuid2.node[i]) { + return false; + } + } + + return true; +} + +bool str_to_uuid(char* uuid_str, sound_trigger_uuid_t* uuid) +{ + if (uuid_str == NULL) { + ALOGI("Invalid str_to_uuid input."); + return false; + } + + int tmp[10]; + if (sscanf(uuid_str, "%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x", + tmp, tmp+1, tmp+2, tmp+3, tmp+4, tmp+5, tmp+6, tmp+7, tmp+8, tmp+9) < 10) { + ALOGI("Invalid UUID, got: %s", uuid_str); + return false; + } + uuid->timeLow = (unsigned int)tmp[0]; + uuid->timeMid = (unsigned short)tmp[1]; + uuid->timeHiAndVersion = (unsigned short)tmp[2]; + uuid->clockSeq = (unsigned short)tmp[3]; + uuid->node[0] = (unsigned char)tmp[4]; + uuid->node[1] = (unsigned char)tmp[5]; + uuid->node[2] = (unsigned char)tmp[6]; + uuid->node[3] = (unsigned char)tmp[7]; + uuid->node[4] = (unsigned char)tmp[8]; + uuid->node[5] = (unsigned char)tmp[9]; + + return true; +} + +static int find_empty_model_slot(struct knowles_sound_trigger_device *st_dev) +{ + int i = -1; + for (i = 0; i < MAX_MODELS; i++) { + if (false == st_dev->models[i].is_loaded) + break; + } + + if (MAX_MODELS <= i) { + i = -1; + } + + return i; +} + +static int find_handle_for_kw_id(struct knowles_sound_trigger_device *st_dev, int kw_id) +{ + int i = 0; + for (i = 0; i < MAX_MODELS; i++) { + if (kw_id == st_dev->models[i].kw_id) + break; + } + + return i; +} + +static char *stdev_keyphrase_event_alloc(sound_model_handle_t handle, + struct sound_trigger_recognition_config *config, + int recognition_status) +{ + char *data; + struct sound_trigger_phrase_recognition_event *event; + data = (char *)calloc(1, sizeof(struct sound_trigger_phrase_recognition_event)); + if (!data) + return NULL; + event = (struct sound_trigger_phrase_recognition_event *)data; + event->common.status = recognition_status; + event->common.type = SOUND_MODEL_TYPE_KEYPHRASE; + event->common.model = handle; + event->common.capture_available = false; + + if (config) { + unsigned int i; + + event->num_phrases = config->num_phrases; + if (event->num_phrases > SOUND_TRIGGER_MAX_PHRASES) + event->num_phrases = SOUND_TRIGGER_MAX_PHRASES; + for (i = 0; i < event->num_phrases; i++) + memcpy(&event->phrase_extras[i], + &config->phrases[i], + sizeof(struct sound_trigger_phrase_recognition_extra)); + } + + event->num_phrases = 1; + event->phrase_extras[0].confidence_level = 100; + event->phrase_extras[0].num_levels = 1; + event->phrase_extras[0].levels[0].level = 100; + event->phrase_extras[0].levels[0].user_id = 0; + // Signify that all the data is comming through streaming, not through the buffer. + event->common.capture_available = true; + event->common.capture_delay_ms = 0; + event->common.capture_preamble_ms = 0; + event->common.audio_config = AUDIO_CONFIG_INITIALIZER; + event->common.audio_config.sample_rate = 16000; + event->common.audio_config.channel_mask = AUDIO_CHANNEL_IN_MONO; + event->common.audio_config.format = AUDIO_FORMAT_PCM_16_BIT; + + return data; +} + +static char *stdev_generic_event_alloc(int model_handle) +{ + char *data; + struct sound_trigger_generic_recognition_event *event; + + data = (char *)calloc(1, sizeof(struct sound_trigger_generic_recognition_event)); + if (!data) { + ALOGE("%s: Failed to allocate memory for recog event", __func__); + return NULL; + } + + event = (struct sound_trigger_generic_recognition_event *)data; + event->common.status = RECOGNITION_STATUS_SUCCESS; + event->common.type = SOUND_MODEL_TYPE_GENERIC; + event->common.model = model_handle; + + // Signify that all the data is comming through streaming, not through the buffer. + event->common.capture_available = true; + event->common.audio_config = AUDIO_CONFIG_INITIALIZER; + event->common.audio_config.sample_rate = 16000; + event->common.audio_config.channel_mask = AUDIO_CHANNEL_IN_MONO; + event->common.audio_config.format = AUDIO_FORMAT_PCM_16_BIT; + + return data; +} + +static void stdev_close_term_sock(struct knowles_sound_trigger_device *stdev) +{ + if (stdev->send_sock >= 0) { + close(stdev->send_sock); + stdev->send_sock = -1; + } + + if (stdev->recv_sock >= 0) { + close(stdev->recv_sock); + stdev->recv_sock = -1; + } +} + +// stdev needs to be locked before calling this function +static int restart_recognition(struct knowles_sound_trigger_device *stdev) +{ + int err = 0, i = 0; + + // Download all the keyword models files that were previously loaded + for (i = 0; i < MAX_MODELS; i++) { + if (true == stdev->models[i].is_loaded) { + err = write_model(stdev->models[i].data, stdev->models[i].data_sz); + if (-1 == err) { + ALOGE("%s: Failed to load the keyword model error - %d (%s)", + __func__, errno, strerror(errno)); + // How do we handle error during a recovery? + } + } + } + + if (true == stdev->is_recog_in_prog) { + err = start_cvq(); + if (enable_mic_route(true)) { + ALOGE("failed to enable mic route"); + } + } + + return err; +} + +// stdev needs to be locked before calling this function +static int fw_crash_recovery(struct knowles_sound_trigger_device *stdev) +{ + int err; + + err = setup_mic_routes(); + if (0 != err) { + ALOGE("%s: ERROR: Failed to download packages and setup routes", __func__); + goto exit; + } + + // Setup the VQ plugin + err = init_params(); + if (err < 0) { + ALOGE("%s: ERROR: Failed to setup the chip", __func__); + goto exit; + } + + // Redownload the keyword model files and start recognition + err = restart_recognition(stdev); + if (0 != err) { + ALOGE("%s: ERROR: Failed to download the keyword models and restarting recognition", __func__); + goto exit; + } + +exit: + return err; +} + +static void *callback_thread_loop(void *context) +{ + + struct knowles_sound_trigger_device *stdev = + (struct knowles_sound_trigger_device *)context; +#ifdef SIMULATE_GSM_TEST_STUB + struct pollfd fds[3]; + struct itimerspec ts; + struct timespec now; +#else + struct pollfd fds[2]; +#endif + char msg[UEVENT_MSG_LEN]; + int exit_sockets[2]; + int err = 0; + int i, n; + int kwid = 0; + struct iaxxx_get_event ge; + + ALOGI("%s", __func__); + prctl(PR_SET_NAME, (unsigned long)"sound trigger callback", 0, 0, 0); + + pthread_mutex_lock(&stdev->lock); + + ALOGD("%s stdev %p", __func__, stdev); + + if (socketpair(AF_UNIX, SOCK_STREAM, 0, exit_sockets) == -1) { + ALOGE("%s: Failed to create termination socket", __func__); + goto exit; + } + + stdev_close_term_sock(stdev); + stdev->send_sock = exit_sockets[0]; + stdev->recv_sock = exit_sockets[1]; + +#ifdef SIMULATE_GSM_TEST_STUB + memset(fds, 0, 3 * sizeof(struct pollfd)); +#else + memset(fds, 0, 2 * sizeof(struct pollfd)); +#endif // SIMULATE_GSM_TEST_STUB + int timeout = -1; // Wait for event indefinitely + fds[0].events = POLLIN; + fds[0].fd = uevent_open_socket(64*1024, true); + if (fds[0].fd == -1) { + ALOGE("Error opening socket for hotplug uevent errno %d(%s)", errno, strerror(errno)); + goto exit; + } + fds[1].events = POLLIN; + fds[1].fd = stdev->recv_sock; + +#ifdef SIMULATE_GSM_TEST_STUB + if (clock_gettime(CLOCK_REALTIME, &now) == -1) { + ALOGE("Failed to get the realtime clock"); + goto exit; + } + + fds[2].events = POLLIN; + fds[2].fd = timerfd_create(CLOCK_REALTIME, 0); + if (-1 == fds[2].fd) { + ALOGE("Failed to create the timer fd"); + goto exit; + } + + ts.it_interval.tv_sec = 5; + ts.it_interval.tv_nsec = 0; + ts.it_value.tv_sec = now.tv_sec + 5; + ts.it_value.tv_nsec = now.tv_nsec; + + if (timerfd_settime(fds[2].fd, TFD_TIMER_ABSTIME, &ts, NULL) < 0) { + ALOGE("timerfd_settime() failed: errno=%d\n", errno); + goto exit; + } +#endif // SIMULATE_GSM_TEST_STUB + + ge.event_id = -1; + + pthread_mutex_unlock(&stdev->lock); + + while (1) { +#ifdef SIMULATE_GSM_TEST_STUB + err = poll (fds, 3, timeout); +#else + err = poll (fds, 2, timeout); +#endif // SIMULATE_GSM_TEST_STUB + + if (0 == err) { + ALOGE("Timeout YAY!!"); + } + + pthread_mutex_lock(&stdev->lock); + if (err < 0) { + ALOGE("%s: Error in poll: %d (%s)", __func__, errno, strerror(errno)); + break; + } + + if (fds[0].revents & POLLIN) { + n = uevent_kernel_multicast_recv(fds[0].fd, msg, UEVENT_MSG_LEN); + if (n <= 0) { + pthread_mutex_unlock(&stdev->lock); + continue; + } + ALOGI("uevent msg is %s", msg); + for (i = 0; i < n;) { + if (strstr(msg + i, IAXXX_VQ_EVENT_STR)) { + ALOGI("%s", IAXXX_VQ_EVENT_STR); + + err = get_event(&ge); + if (0 == err) { + if (EVENT_ID_KW_ID == ge.event_id) { + ALOGD("Eventid received is EVENT_ID_KW_ID %d", ge.data); + kwid = ge.data; + break; + } else { + ALOGE("Unknown event id received, ignoring %d", ge.event_id); + } + } else { + ALOGE("get_event failed with error %d", err); + } + } else if (strstr(msg + i, IAXXX_RECOVERY_EVENT_STR)) { + ALOGE("Firmware has crashed, start the recovery"); + int err = fw_crash_recovery(stdev); + if (0 != err) { + ALOGE("Firmware crash recovery failed"); + } + } + + i += strlen(msg + i) + 1; + } + + if (EVENT_ID_KW_ID == ge.event_id) { + ALOGE("%s: Keyword ID %d", __func__, kwid); + int idx = find_handle_for_kw_id(stdev, kwid); + // TODO: Fix me!! remove this hardcoding + idx = 0; + ALOGE("The handle has been fixed to 0"); + + if (idx < MAX_MODELS) { + if (SOUND_MODEL_TYPE_KEYPHRASE == stdev->models[idx].type) { + struct sound_trigger_phrase_recognition_event *event; + event = (struct sound_trigger_phrase_recognition_event *) + stdev_keyphrase_event_alloc(stdev->models[idx].model_handle, + stdev->models[idx].config, + RECOGNITION_STATUS_SUCCESS); + if (event) { + struct model_info *model; + model = &stdev->models[idx]; + + ALOGD("Sending recognition callback for id %d", kwid); + model->recognition_callback(&event->common, model->recognition_cookie); + // Update the config so that it will be used during the streaming + stdev->last_keyword_detected_config = model->config; + + free(event); + } else { + ALOGE("Failed to allocate memory for the event"); + } + } else if (SOUND_MODEL_TYPE_GENERIC == stdev->models[idx].type) { + struct sound_trigger_generic_recognition_event *event; + event = (struct sound_trigger_generic_recognition_event *) + stdev_generic_event_alloc(stdev->models[idx].model_handle); + if (event) { + struct model_info *model; + model = &stdev->models[idx]; + + ALOGD("Sending recognition callback for id %d", kwid); + model->recognition_callback(&event->common, model->recognition_cookie); + // Update the config so that it will be used during the streaming + stdev->last_keyword_detected_config = model->config; + + free(event); + } else { + ALOGE("Failed to allocate memory for the event"); + } + } + } + ge.event_id = -1; + } + } else if (fds[1].revents & POLLIN) { + read(fds[1].fd, &n, sizeof(n)); /* clear the socket */ + ALOGI("%s: Termination message", __func__); + break; + } +#ifdef SIMULATE_GSM_TEST_STUB + else if (fds[2].revents & POLLIN) { + uint64_t temp; + // This means that the poll timed out, so check if we have any generic + // models, if yes then send and a recognition event for that + int k = 0; + for (k = 0; k < MAX_MODELS; k++) { + if (SOUND_MODEL_TYPE_GENERIC == stdev->models[k].type && + k != stdev->last_recog_model_id) { + break; + } + } + + if (MAX_MODELS == k && -1 != stdev->last_recog_model_id) + k = stdev->last_recog_model_id; + else + stdev->last_recog_model_id = k; + + if (k < MAX_MODELS) { + struct sound_trigger_generic_recognition_event *event; + event = (struct sound_trigger_generic_recognition_event *) + stdev_generic_event_alloc(stdev->models[k].model_handle); + if (event) { + struct model_info *model; + model = &stdev->models[k]; + + if (NULL != model->recognition_callback) { + ALOGD("Sending recognition callback for id %d", kwid); + model->recognition_callback(&event->common, model->recognition_cookie); + // Update the config so that it will be used during the streaming + stdev->last_keyword_detected_config = model->config; + } + free(event); + } else { + ALOGE("Failed to allocate memory for the event"); + } + } + + read(fds[2].fd, &temp, sizeof(uint64_t)); + } +#endif // SIMULATE_GSM_TEST_STUB + else { + ALOGI("%s: Message ignored", __func__); + } + pthread_mutex_unlock(&stdev->lock); + } + +exit: + stdev_close_term_sock(stdev); + pthread_mutex_unlock(&stdev->lock); + + return (void *)(long)err; +} + +static int stdev_get_properties(const struct sound_trigger_hw_device *dev __unused, + struct sound_trigger_properties *properties) +{ + ALOGD("+%s+", __func__); + if (properties == NULL) + return -EINVAL; + memcpy(properties, &hw_properties, sizeof(struct sound_trigger_properties)); + ALOGD("-%s-", __func__); + return 0; +} + +static int stdev_load_sound_model(const struct sound_trigger_hw_device *dev, + struct sound_trigger_sound_model *sound_model, + sound_model_callback_t callback, + void *cookie, + sound_model_handle_t *handle) +{ + struct knowles_sound_trigger_device *stdev = + (struct knowles_sound_trigger_device *)dev; + int ret = 0, err = 0; + int kw_model_sz = 0; + int i = 0; + + unsigned char *kw_buffer = NULL; + + + ALOGD("+%s+", __func__); + pthread_mutex_lock(&stdev->lock); + + ALOGD("%s stdev %p", __func__, stdev); + + if (handle == NULL || sound_model == NULL) { + ALOGE("%s: handle/sound_model is NULL", __func__); + ret = -EINVAL; + goto exit; + } + + if (sound_model->data_size == 0 || + sound_model->data_offset < sizeof(struct sound_trigger_sound_model)) { + ALOGE("%s: Invalid sound model data", __func__); + ret = -EINVAL; + goto exit; + } + + kw_buffer = (unsigned char *) sound_model + sound_model->data_offset; + kw_model_sz = sound_model->data_size; + ALOGV("%s: kw_model_sz %d", __func__, kw_model_sz); + + // Load the keyword model file + // Find an empty slot to load the model + i = find_empty_model_slot(stdev); + if (-1 == i) { + ALOGE("%s: Can't load model no free slots available", __func__); + ret = -ENOSYS; + goto exit; + } + + *handle = i; + ALOGV("%s: Loading keyword model handle(%d) type(%d)", __func__, *handle, sound_model->type); + // This will need to be replaced with UUID once they are fixed + stdev->models[i].kw_id = (i + 1); + stdev->models[i].model_handle = *handle; + stdev->models[i].type = sound_model->type; + stdev->models[i].uuid = sound_model->uuid; + stdev->models[i].sound_model_callback = callback; + stdev->models[i].sound_model_cookie = cookie; + stdev->models[i].recognition_callback = NULL; + stdev->models[i].recognition_cookie = NULL; + + stdev->models[i].data = malloc(kw_model_sz); + if (NULL == stdev->models[i].data) { + ALOGE("%s: Warning, could not allocate memory for keyword model data, cannot redownload on crash", __func__); + stdev->models[i].data_sz = 0; + } else { + memcpy(stdev->models[i].data, kw_buffer, kw_model_sz); + stdev->models[i].data_sz = kw_model_sz; + } + +#ifdef SIMULATE_GSM_TEST_STUB + if (SOUND_MODEL_TYPE_GENERIC != sound_model->type) { +#endif // SIMULATE_GSM_TEST_STUB + err = write_model(kw_buffer, kw_model_sz); + if (-1 == err) { + ALOGE("%s: Failed to load the keyword model error - %d (%s)", __func__, errno, strerror(errno)); + ret = errno; + if (stdev->models[i].data) { + free(stdev->models[i].data); + stdev->models[i].data = NULL; + stdev->models[i].data_sz = 0; + } + goto exit; + } +#ifdef SIMULATE_GSM_TEST_STUB + } +#endif // SIMULATE_GSM_TEST_STUB + + stdev->models[i].is_loaded = true; + +exit: + pthread_mutex_unlock(&stdev->lock); + ALOGD("-%s handle %d-", __func__, *handle); + return ret; +} + +static int stdev_unload_sound_model(const struct sound_trigger_hw_device *dev, + sound_model_handle_t handle) +{ + struct knowles_sound_trigger_device *stdev = + (struct knowles_sound_trigger_device *)dev; + int ret = 0; + + ALOGD("+%s handle %d+", __func__, handle); + pthread_mutex_lock(&stdev->lock); + + // Just confirm the model was previously loaded + if (false == stdev->models[handle].is_loaded) { + ALOGE("%s: Invalid model(%d) being called for unload", __func__, handle); + ret = -EINVAL; + goto exit; + } + + stdev->models[handle].sound_model_callback = NULL; + stdev->models[handle].sound_model_cookie = NULL; + stdev->models[handle].is_loaded = false; + if (stdev->models[handle].data) { + free(stdev->models[handle].data); + stdev->models[handle].data = NULL; + stdev->models[handle].data_sz = 0; + } + + ALOGE("%s: Successfully unloaded the model, handle - %d", __func__, handle); + + // To Do Need to unload the keyword model files + //unload_all_models(); +exit: + pthread_mutex_unlock(&stdev->lock); + ALOGD("-%s handle %d-", __func__, handle); + return ret; +} + +static int stdev_start_recognition(const struct sound_trigger_hw_device *dev, + sound_model_handle_t sound_model_handle, + const struct sound_trigger_recognition_config *config, + recognition_callback_t callback, + void *cookie) +{ + struct knowles_sound_trigger_device *stdev = + (struct knowles_sound_trigger_device *)dev; + int status = 0; + struct model_info *model = &stdev->models[sound_model_handle]; + + ALOGD("%s stdev %p", __func__, stdev); + ALOGD("+%s sound model %d+", __func__, sound_model_handle); + pthread_mutex_lock(&stdev->lock); + + if (NULL == callback) { + ALOGE("%s: recognition_callback is null", __func__); + status = -EINVAL; + goto exit; + } + + if (NULL != model->config) { + free(model->config); + model->config = NULL; + } + + if (NULL != config) { + model->config = (struct sound_trigger_recognition_config *) malloc (sizeof(*config)); + if (NULL == model->config) { + ALOGE("%s: Failed to allocate memory for model config", __func__); + status = -ENOMEM; + goto exit; + } + + memcpy(model->config, config, sizeof(*config)); + + ALOGE("%s: Is capture requested %d", __func__, config->capture_requested); + } else { + ALOGV("%s: config is null", __func__); + model->config = NULL; + } + + model->recognition_callback = callback; + model->recognition_cookie = cookie; + + if (check_uuid_equality(model->uuid, stdev->sensor_model_uuid)) { + set_sensor_route(true); + } else { +#ifdef SIMULATE_GSM_TEST_STUB + if (SOUND_MODEL_TYPE_GENERIC != model->type) { +#endif // SIMULATE_GSM_TEST_STUB + if (false == stdev->is_recog_in_prog) { + ALOGE("This is the first keyword so send the start recoginition to the chip"); + status = start_cvq(); + + stdev->is_recog_in_prog = true; + + if (enable_mic_route(true)) { + ALOGE("failed to enable mic route"); + } + } +#ifdef SIMULATE_GSM_TEST_STUB + } +#endif // SIMULATE_GSM_TEST_STUB + } + +exit: + pthread_mutex_unlock(&stdev->lock); + ALOGD("-%s sound model %d-", __func__, sound_model_handle); + return status; +} + +static int stdev_stop_recognition(const struct sound_trigger_hw_device *dev, + sound_model_handle_t sound_model_handle) +{ + struct knowles_sound_trigger_device *stdev = + (struct knowles_sound_trigger_device *)dev; + int status = 0; + struct model_info *model = &stdev->models[sound_model_handle]; + ALOGD("+%s sound model %d+", __func__, sound_model_handle); + pthread_mutex_lock(&stdev->lock); + + if (NULL != model->config) { + free(model->config); + model->config = NULL; + } + + model->recognition_callback = NULL; + model->recognition_cookie = NULL; + + if (check_uuid_equality(model->uuid, stdev->sensor_model_uuid)) { + set_sensor_route(false); + } else { +#ifdef SIMULATE_GSM_TEST_STUB + if (SOUND_MODEL_TYPE_GENERIC != model->type) { +#endif // SIMULATE_GSM_TEST_STUB + if (true == stdev->is_recog_in_prog) { + ALOGE("None of keywords are active so send the stop recoginition to the chip"); + if (enable_mic_route(false)) { + ALOGE("failed to disable mic route"); + } + status = stop_cvq(); + stdev->is_recog_in_prog = false; + } +#ifdef SIMULATE_GSM_TEST_STUB + } +#endif // SIMULATE_GSM_TEST_STUB + } + + pthread_mutex_unlock(&stdev->lock); + ALOGD("-%s sound model %d-", __func__, sound_model_handle); + return status; +} + +static int stdev_close(hw_device_t *device) +{ + struct knowles_sound_trigger_device *stdev = + (struct knowles_sound_trigger_device *)device; + int ret = 0; + ALOGD("+%s+", __func__); + pthread_mutex_lock(&stdev->lock); + + if (!stdev->opened) { + ALOGE("%s: device already closed", __func__); + ret = -EFAULT; + goto exit; + } + stdev->opened = false; + + if (stdev->send_sock >= 0) + write(stdev->send_sock, "T", 1); + pthread_join(stdev->callback_thread, (void **)NULL); + +exit: + pthread_mutex_unlock(&stdev->lock); + ALOGD("-%s-", __func__); + return ret; +} + +__attribute__ ((visibility ("default"))) +int stdev_open_for_streaming() +{ + struct knowles_sound_trigger_device *stdev = &g_stdev; + int ret = 0; + + ALOGI("%s: Entering", __func__); + pthread_mutex_lock(&stdev->lock); + if (false == stdev->opened) { + ALOGE("%s: Error SoundTrigger has not been opened", __func__); + goto exit; + } + + if (false == stdev->is_streaming) { + if (NULL == stdev->adnc_strm_open) { + ALOGE("%s: Error adnc streaming not supported", __func__); + } else { + bool keyword_stripping_enabled = false; + stdev->adnc_strm_handle = stdev->adnc_strm_open(keyword_stripping_enabled, 0); + if (stdev->adnc_strm_handle) { + ALOGD("Successfully opened adnc streaming"); + stdev->is_streaming = true; + ret = stdev->adnc_strm_handle; + } else { + ALOGE("%s: DSP is currently not streaming", __func__); + } + } + } + +exit: + pthread_mutex_unlock(&stdev->lock); + return ret; +} + +__attribute__ ((visibility ("default"))) +size_t stdev_read_samples(int audio_handle, void *buffer, size_t buffer_len) +{ + struct knowles_sound_trigger_device *stdev = &g_stdev; + size_t ret = 0; + + //ALOGI("%s: Entering", __func__); + pthread_mutex_lock(&stdev->lock); + + if (false == stdev->opened || false == stdev->is_streaming) { + ALOGE("%s: Error SoundTrigger has not been opened or DSP is not streaming", __func__); + ret = -EINVAL; + goto exit; + } + + if (0 == audio_handle || (audio_handle != stdev->adnc_strm_handle)) { + ALOGE("%s: Error - Invalid audio handle", __func__); + ret = -EINVAL; + goto exit; + } + + ALOGE("%s: soundtrigger HAL adnc_strm_read", __func__); + ret = stdev->adnc_strm_read(stdev->adnc_strm_handle, buffer, buffer_len); + ALOGV("%s: Sent %zu bytes to buffer", __func__, ret); + +exit: + pthread_mutex_unlock(&stdev->lock); + return ret; +} + +__attribute__ ((visibility ("default"))) +int stdev_close_for_streaming(int audio_handle) +{ + struct knowles_sound_trigger_device *stdev = &g_stdev; + int ret = 0; + + ALOGI("%s: Entering", __func__); + pthread_mutex_lock(&stdev->lock); + + if (0 == audio_handle || (audio_handle != stdev->adnc_strm_handle)) { + ALOGE("%s: Error - Invalid audio handle", __func__); + ret = -EINVAL; + goto exit; + } + + if (stdev->adnc_strm_handle) { + stdev->adnc_strm_close(stdev->adnc_strm_handle); + stdev->adnc_strm_handle = 0; + stdev->is_streaming = 0; + } + +exit: + pthread_mutex_unlock(&stdev->lock); + return ret; +} + +__attribute__ ((visibility ("default"))) +audio_io_handle_t stdev_get_audio_handle() +{ + if (NULL == g_stdev.last_keyword_detected_config) { + ALOGI("%s: Config is NULL so returning audio handle as 0", __func__); + return 0; + } + + ALOGI("%s: Audio Handle is %d", __func__, g_stdev.last_keyword_detected_config->capture_handle); + + return g_stdev.last_keyword_detected_config->capture_handle; +} + + +static int open_streaming_lib(struct knowles_sound_trigger_device *stdev) +{ + int ret = 0; + + if (access(ADNC_STRM_LIBRARY_PATH, R_OK) == 0) { + stdev->adnc_cvq_strm_lib = dlopen(ADNC_STRM_LIBRARY_PATH, RTLD_NOW); + if (stdev->adnc_cvq_strm_lib == NULL) { + char const *err_str = dlerror(); + ALOGE("%s: module = %s error = %s", __func__, ADNC_STRM_LIBRARY_PATH, err_str ? err_str : "unknown"); + ALOGE("%s: DLOPEN failed for %s", __func__, ADNC_STRM_LIBRARY_PATH); + } else { + ALOGV("%s: DLOPEN successful for %s", __func__, ADNC_STRM_LIBRARY_PATH); + stdev->adnc_strm_handle = 0; + stdev->adnc_strm_open = + (int (*)(bool, int))dlsym(stdev->adnc_cvq_strm_lib, + "adnc_strm_open"); + stdev->adnc_strm_read = + (size_t (*)(long, void *, size_t))dlsym(stdev->adnc_cvq_strm_lib, + "adnc_strm_read"); + stdev->adnc_strm_close = + (int (*)(long))dlsym(stdev->adnc_cvq_strm_lib, + "adnc_strm_close"); + if (!stdev->adnc_strm_open || !stdev->adnc_strm_read || !stdev->adnc_strm_close) { + ALOGE("%s: Error grabbing functions in %s", __func__, ADNC_STRM_LIBRARY_PATH); + stdev->adnc_strm_open = 0; + stdev->adnc_strm_read = 0; + stdev->adnc_strm_close = 0; + } + } + } + + return ret; +} + +static int stdev_open(const hw_module_t *module, const char *name, + hw_device_t **device) +{ + struct knowles_sound_trigger_device *stdev; + int ret = 0, i = 0; + + ALOGE("!! Knowles SoundTrigger v1!!"); + + if (strcmp(name, SOUND_TRIGGER_HARDWARE_INTERFACE) != 0) + return -EINVAL; + + stdev = &g_stdev; + pthread_mutex_lock(&stdev->lock); + + if (stdev->opened) { + ALOGE("%s: Only one sountrigger can be opened at a time", __func__); + ret = -EBUSY; + goto exit; + } + + ret = open_streaming_lib(stdev); + if (0 != ret) { + ALOGE("%s: Couldnot open the streaming library", __func__); + goto exit; + } + + stdev->device.common.tag = HARDWARE_DEVICE_TAG; + stdev->device.common.version = SOUND_TRIGGER_DEVICE_API_VERSION_1_0; + stdev->device.common.module = (struct hw_module_t *)module; + stdev->device.common.close = stdev_close; + stdev->device.get_properties = stdev_get_properties; + stdev->device.load_sound_model = stdev_load_sound_model; + stdev->device.unload_sound_model = stdev_unload_sound_model; + stdev->device.start_recognition = stdev_start_recognition; + stdev->device.stop_recognition = stdev_stop_recognition; + + stdev->is_recog_in_prog = false; + stdev->opened = true; + /* Initialize all member variable */ + for (i = 0; i < MAX_MODELS; i++) { + stdev->models[i].config = NULL; + stdev->models[i].data = NULL; + stdev->models[i].data_sz = 0; + stdev->models[i].is_loaded = false; + stdev->last_keyword_detected_config = NULL; + } + +#ifdef SIMULATE_GSM_TEST_STUB + stdev->last_recog_model_id = -1; +#endif // SIMULATE_GSM_TEST_STUB + + str_to_uuid(SENSOR_MANAGER_MODEL, &stdev->sensor_model_uuid); + + *device = &stdev->device.common; /* same address as stdev */ + + ALOGD("%s: Wait for Firmware download to be completed", __func__); + for(int max_attempts = 0; max_attempts < 300; max_attempts++) { + struct stat ready_stat; + const char *ready_path = "/sys/bus/spi/devices/spi1.0/iaxxx/fw_dl_complete"; + ALOGD("%s: Checking for %s", __func__, ready_path); + int ready_result = stat(ready_path, &ready_stat); + if (0 == ready_result) { + ALOGD("%s: Found %s", __func__, ready_path); + break; + } else { + ALOGD("%s: Didn't find %s, sleeping for one sec", __func__, ready_path); + sleep(1); + } + } + + setup_mic_routes(); + init_params(); + + ALOGD("stdev before pthread_create %p", stdev); + // Create a thread to handle all events from kernel + pthread_create(&stdev->callback_thread, (const pthread_attr_t *) NULL, + callback_thread_loop, stdev); + +exit: + pthread_mutex_unlock(&stdev->lock); + return ret; +} + +static struct hw_module_methods_t hal_module_methods = { + .open = stdev_open, +}; + +struct sound_trigger_module HAL_MODULE_INFO_SYM = { + .common = { + .tag = HARDWARE_MODULE_TAG, + .module_api_version = SOUND_TRIGGER_MODULE_API_VERSION_1_0, + .hal_api_version = HARDWARE_HAL_API_VERSION, + .id = SOUND_TRIGGER_HARDWARE_MODULE_ID, + .name = "Knowles Sound Trigger HAL", + .author = "Knowles Electronics", + .methods = &hal_module_methods, + }, +}; + diff --git a/tests/conversion_routines.c b/tests/conversion_routines.c new file mode 100755 index 0000000..dfd2d6d --- /dev/null +++ b/tests/conversion_routines.c @@ -0,0 +1,71 @@ +#include <stdint.h> + +static void kst_split_aft( + uint32_t* pAfloat, + int32_t* exp, + int64_t* mant, + int32_t* sign) +{ + uint32_t uAft = *pAfloat; + + *exp = (uAft >> 25) & 0x3F; + *mant = uAft & 0x1FFFFFF; + *sign = uAft >> 31; + if (*exp || *mant) + { + *mant |= 1 << 25; + } +} + +static void kst_aft_to_dbl( + void* pDouble, + void* pAfloat) +{ + uint64_t uDbl; + int32_t exp; + int32_t sign; + int64_t mant; + + kst_split_aft((uint32_t*)pAfloat, &exp, &mant, &sign); + if (exp || mant) + { + uDbl = ((uint64_t)sign << 63) | + ((uint64_t)(exp + (1023 - (1 << 5))) << 52) | + ((uint64_t)(mant & ((1 << 25) - 1)) << (52 - 25)); + } + else + { + uDbl = (uint64_t)sign << 63; + } + *((uint64_t*)pDouble) = uDbl; +} + +void kst_float_to_q15_vector( + void* pDst, + void* pSrc, + uint32_t elCnt) +{ + uint32_t* pSrcT; + int16_t* pDstT; + uint32_t idx; + double smp; + + pSrcT = (uint32_t*)pSrc; + pDstT = (int16_t*)pDst; + for (idx = 0; idx<elCnt; idx++) + { + kst_aft_to_dbl(&smp, &(pSrcT[idx])); + smp = smp * 32768.0; + pDstT[idx] = ((smp < 32767.0) ? ((smp > -32768.0) ? ((int16_t)smp) : -32768) : 32767); + } +} + +void kst_float_to_IEEE_float( + void* pDst, + void* pSrc) +{ + double dst; + + kst_aft_to_dbl(&dst, pSrc); + *((float*)pDst) = (float)dst; +}
\ No newline at end of file diff --git a/tests/conversion_routines.h b/tests/conversion_routines.h new file mode 100755 index 0000000..9153d2c --- /dev/null +++ b/tests/conversion_routines.h @@ -0,0 +1,13 @@ +#ifndef _CONVERSION_ROUTINES_H_ +#define _CONVERSION_ROUTINES_H_ + +void kst_float_to_q15_vector( + void* pDst, + void* pSrc, + uint32_t elCnt); + +void kst_float_to_IEEE_float( + void* pDst, + void* pSrc); + +#endif // ifndef _CONVERSION_ROUTINES_H_ diff --git a/tests/tunnel_test.c b/tests/tunnel_test.c new file mode 100644 index 0000000..9f2987a --- /dev/null +++ b/tests/tunnel_test.c @@ -0,0 +1,606 @@ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <signal.h> +#include <stdbool.h> +#include <errno.h> + +#define LOG_TAG "ia_tunneling_hal_test" + +#include <cutils/log.h> +#include "tunnel.h" +#include "conversion_routines.h" +#include "iaxxx-system-identifiers.h" + +/* + * To dump 4 MIC data, the source end points are + * 0x4020 0x40A0 0x4120 0x41A0 + */ + +#define DOA_TUNNEL_SRC (IAXXX_SYSID_PLUGIN_1_OUT_EP_2) + // Source end point for DOA meta data +#define VQ_TUNNEL_SRC (IAXXX_SYSID_PLUGIN_0_OUT_EP_0) + // Source end point for VQ confidence meta data +#define VP_PARAM_TUNNEL_SRC (IAXXX_SYSID_PLUGIN_1_OUT_EP_3) + // Source end point for VP Parameter data + +#define MIC1_TUNNEL_SRC (IAXXX_SYSID_CHANNEL_RX_0_EP_0) +#define MIC2_TUNNEL_SRC (IAXXX_SYSID_CHANNEL_RX_2_EP_0) +#define MIC3_TUNNEL_SRC (IAXXX_SYSID_CHANNEL_RX_4_EP_0) +#define MIC4_TUNNEL_SRC (IAXXX_SYSID_CHANNEL_RX_6_EP_0) +#define AEC_REF1_TUNNEL_SRC (IAXXX_SYSID_CHANNEL_RX_8_EP_0) +#define AEC_REF2_TUNNEL_SRC (IAXXX_SYSID_CHANNEL_RX_9_EP_0) + + +#define MAX_TUNNELS 32 +#define TUNNELS_THAT_NEED_SYNC 10 +#define BUF_SIZE 8192 +#define DOA_OUTPUT_FILE "/data/data/doa_tunnel_output" +#define VQ_CONFIDENCE_OUTPUT_FILE "/data/data/vq_conf_tunnel_output" +#define OUTPUT_FILE "/data/data/tnl_op" +#define UNPARSED_OUTPUT_FILE "/data/data/unparsed_output" +#define VP_PARAM_DUMP_FILE "/data/data/param_dump" + +#define SALIENCE "SALIENCE" +#define BEARING "BEARING" +#define TNL_SYNC_MODE 0 +#define TNL_ASYNC_MODE 1 +#define TNL_ENC_AFLOAT 1 +#define TNL_ENC_Q15 0xF + +struct raf_format_type { + uint16_t frameSizeInBytes; /*!< Frame length in bytes */ + uint8_t encoding; /*!< Encoding */ + uint8_t sampleRate; /*!< Sample rate */ +}; + +struct raf_frame_type { + uint64_t timeStamp; /*!< Timestamp of the frame */ + uint32_t seqNo; /*!< Optional sequence number of the frame */ + + struct raf_format_type format; /*!< Format information for the frame */ + uint32_t data[0]; /*!< Start of the variable size payload. + It must start at 128 bit aligned address for all the frames */ +}; + +volatile int capturing = 1; + +void sigint_handler(int sig __unused) { + ALOGE("Interrupted, setting the exit condition"); + capturing = 0; +} + +/* + * Buf idx Content + * 0 sdeNumDirections (1x1) + * [1, 4, 7,... (sdeNumDirections *3-2)] Bearing/Direction of Dominant Sources (sdeNumDirections x1) + * [2, 5, 8,... (sdeNumDirections *3-1)] Salience for the Dominant Sources (sdeNumDirections x1) + * [3, 6, 9,... (sdeNumDirections *3)] RMS Estimate: Level information per-source in dB FS + * + * [3*sdeNumDirections +1 : 3*sdeNumDirections +1+sdeNumAngles] SDE Frame Response (24x1) + * [2*sdeNumDirections +1+sdeNumAngles+1] Source Class (1x1) + * 0 - Ambient / Quiet + * 1 - Speech + * 2 - Echo + * 3 - Music + * 4 - Wanted / Un-wanted Noises + * [(3*sdeNumDirections)+sdeNumAngles+2 : SourceClassConfidence (4x1) + * (3*sdeNumDirections)+sdeNumAngles+5 ] + * [(3*sdeNumDirections)+sdeNumAngles+6 ] SNR Estimate in dB. And estimate of Signal to Noise Ratio (SNR) + * of the input signal, on a per frame basis + * [ (3*sdeNumDirections)+nAngles+7 ] rxVad. Status of VAD on AEC Ref + * 0 - OFF + * 1 - ON + * [ (3*sdeNumDirections)+nAngles+8: VP param ids and param vals + * (3*sdeNumDirections)+nAngles+22 ] + */ +void parse_doa_meta_data(FILE *out_fp, unsigned char *buf_itr) { + float bearing[3], salience[3], rms_estimate[3], num_directions, source_class; + // Frame response is for every 15 degrees, for 360 degrees we will have 24 values + const int sde_frame_response = 24; + const int num_of_src_class_conf = 4; + const int num_of_vp_params = 15; + float frame_response[sde_frame_response]; + float src_class_conf[num_of_src_class_conf]; + float snr_estimate_in_db; + float rx_vad; + int i; + float param_ids[num_of_vp_params]; + float param_vals[num_of_vp_params]; + + if (NULL == buf_itr || NULL == out_fp) { + ALOGE("%s: Buffer or file pointer is NULL", __func__); + return; + } + + kst_float_to_IEEE_float((void *)&num_directions, buf_itr); + buf_itr += 4; + + for (i = 0; i < num_directions; i++) { + kst_float_to_IEEE_float((void *)&bearing[i], buf_itr); + buf_itr += 4; + + kst_float_to_IEEE_float((void *)&salience[i], buf_itr); + buf_itr +=4; + + kst_float_to_IEEE_float((void *)&rms_estimate[i], buf_itr); + buf_itr +=4; + } + + for (i = 0; i < sde_frame_response; i++) { + kst_float_to_IEEE_float((void *)&frame_response[i], buf_itr); + buf_itr += 4; + } + + kst_float_to_IEEE_float((void *)&source_class, buf_itr); + buf_itr += 4; + + for (i = 0; i < num_of_src_class_conf; i++) { + kst_float_to_IEEE_float((void *)&src_class_conf[i], buf_itr); + buf_itr += 4; + } + + kst_float_to_IEEE_float((void *)&snr_estimate_in_db, buf_itr); + buf_itr += 4; + + kst_float_to_IEEE_float((void *)&rx_vad, buf_itr); + buf_itr += 4; + + for (i = 0; i < num_of_vp_params; i++) { + kst_float_to_IEEE_float((void *)¶m_ids[i], buf_itr); + buf_itr += 4; + + kst_float_to_IEEE_float((void *)¶m_vals[i], buf_itr); + buf_itr += 4; + } + + for (i = 0; i < num_directions; i++) { + fprintf(out_fp, " bearing %d = %f:", i, bearing[i]); + } + + for (i = 0; i < num_directions; i++) { + fprintf(out_fp, " Salience %d = %f:", i, salience[i]); + } + + for (i = 0; i < num_directions; i++) { + fprintf(out_fp, " RMS Estimate %d = %f:", i, rms_estimate[i]); + } + + for (i = 0; i < sde_frame_response; i++) { + fprintf(out_fp, " SDE Frame Response %d = %f:", i, frame_response[i]); + } + + fprintf(out_fp, " Source Class = %f:", source_class); + + for (i = 0; i < num_of_src_class_conf; i++) { + fprintf(out_fp, " Source Class Confidence %d = %f:", i, src_class_conf[i]); + } + + fprintf(out_fp, " SNR Estimate in dB = %f:", snr_estimate_in_db); + + fprintf(out_fp, " rxVad = %f:", rx_vad); + + for (i = 0; i < num_of_vp_params; i++) { + fprintf(out_fp, " Param ID 0x%X = %f:", (unsigned int)param_ids[i], param_vals[i]); + } + + fprintf(out_fp, "\n"); + fflush(out_fp); +} + +/* + * Buf idx Content + * 0 Number of keywords + * [ 1 : numKwSlots ] CS out Confidence level for the KWs present in that particular slot + * [ numKwSlots + 1 ] Number of events (numEvents) + * [ numKwSlots + 2 ] KW slot Index (AEC Ref instance KW_DETECT_EVENT0) + * [ numKwSlots + 3 ] Start Frame Sequence Number (AEC Ref instance START_FRM_EVENT1) + * [ numKwSlots + 4 ] End Frame Sequence Number (AEC Ref instance END_FRM_EVENT2) + * [ numKwSlots + 5 ] KW slot Index (AEC Ref instance TRUE_KW_EVENT3) + * [ numKwSlots + 6 ] KW slot Index (AEC Ref instance FA_KW_EVENT4) + * [ numKwSlots + 7 ] Peak confidence level (AEC Ref instance PEAK_CONF_LEVEL_EVENT5) + * [ numKwSlots + 8 ] Number of keywords (same as numKwsCsout) + * [ numKwSlots + 9 : + * numKwSlots + 9 + + * numKwSlots - 1] AEC Ref Confidence level for the KWs present in that particular slot + */ +void parse_vq_meta_data(FILE *out_fp, unsigned char *buf_itr) { + float num_kws, confidence, temp; + int i; + + if (NULL == buf_itr || NULL == out_fp) { + ALOGE("%s: Buffer or file pointer is NULL", __func__); + return; + } + + kst_float_to_IEEE_float((void *)&num_kws, buf_itr); + buf_itr += 4; + fprintf(out_fp, "Num of Keywords = %f: ", num_kws); + + for (i = 0; i < (int) num_kws; i++) { + kst_float_to_IEEE_float((void *)&confidence, buf_itr); + buf_itr += 4; + + fprintf(out_fp, "CSOUT conf slot %d = %f: ", i, confidence); + confidence = 0.0f; + } + + kst_float_to_IEEE_float((void *)&temp, buf_itr); + buf_itr += 4; + fprintf(out_fp, "Num of events = %f: ", temp); + temp = 0.0f; + + kst_float_to_IEEE_float((void *)&temp, buf_itr); + buf_itr += 4; + fprintf(out_fp, "AECREF KW_DETECT_EVENT0 = %f: ", temp); + temp = 0.0f; + + kst_float_to_IEEE_float((void *)&temp, buf_itr); + buf_itr += 4; + fprintf(out_fp, "AECREF START_FRM_EVENT1 = %f: ", temp); + temp = 0.0f; + + kst_float_to_IEEE_float((void *)&temp, buf_itr); + buf_itr += 4; + fprintf(out_fp, "AECREF END_FRM_EVENT2 = %f: ", temp); + temp = 0.0f; + + kst_float_to_IEEE_float((void *)&temp, buf_itr); + buf_itr += 4; + fprintf(out_fp, "AECREF TRUE_KW_EVENT3 = %f: ", temp); + temp = 0.0f; + + kst_float_to_IEEE_float((void *)&temp, buf_itr); + buf_itr += 4; + fprintf(out_fp, "AECREF FA_KW_EVENT4 = %f: ", temp); + temp = 0.0f; + + kst_float_to_IEEE_float((void *)&temp, buf_itr); + buf_itr += 4; + fprintf(out_fp, "AECREF PEAK_CONF_LEVEL_EVENT5 = %f: ", temp); + temp = 0.0f; + + kst_float_to_IEEE_float((void *)&num_kws, buf_itr); + buf_itr += 4; + fprintf(out_fp, "Num of Keywords = %f: ", num_kws); + + for (i = 0; i < (int) num_kws; i++) { + kst_float_to_IEEE_float((void *)&confidence, buf_itr); + buf_itr += 4; + + fprintf(out_fp, "AECREF conf slot %d = %f: ", i, confidence); + confidence = 0.0f; + } + + fprintf(out_fp, "\n"); +} + +void parse_audio_tunnel_data(FILE *out_fp, unsigned char *buf_itr, int frame_sz_in_bytes) { + char q16_buf[BUF_SIZE]; // This can be smaller but by how much? + int frameSizeInWords = (frame_sz_in_bytes + 3) >> 2; + + if (NULL == buf_itr || NULL == out_fp) { + ALOGE("%s: Buffer or file pointer is NULL", __func__); + return; + } + + kst_float_to_q15_vector(q16_buf, buf_itr, frameSizeInWords); + + fwrite(q16_buf, (frameSizeInWords * 2), 1, out_fp); +} + +/* + * Buffer Index Content + * [0] ParamCount - No of updated parameters in that particular frame + * [1, 3, 5, ...] VP runtime parameter ID's + * [2, 4, 6, ...] VP runtime parameter value's + */ +void parse_param_data(FILE *out_fp, unsigned char *buf_itr) { + float param_id = 0.0f, param_val = 0.0f; + int i = 0; + float num_of_params = 0.0f; + + if (NULL == buf_itr || NULL == out_fp) { + ALOGE("%s: Buffer or file pointer is NULL", __func__); + return; + } + + kst_float_to_IEEE_float((void *)&num_of_params, buf_itr); + buf_itr += 4; + + fprintf(out_fp, "PARAM ID\tPARAM VALUE\n"); + for (i = 0; i < num_of_params; i++) { + kst_float_to_IEEE_float((void *)¶m_id, buf_itr); + buf_itr += 4; + + kst_float_to_IEEE_float((void *)¶m_val, buf_itr); + buf_itr += 4; + + fprintf(out_fp, "0x%X\t\t%f\n", (unsigned int)param_id, param_val); + } +} + +int main(int argc, char *argv[]) { + struct ia_tunneling_hal *thdl = NULL; + int err = 0; + FILE *out_fp[MAX_TUNNELS] = { NULL }; + FILE *unp_out_fp = NULL; + int bytes_avail = 0, bytes_rem = 0; + int bytes_read = 0; + void *buf = NULL; + // The magic number is ROME in ASCII reversed. So we are looking for EMOR in the byte stream + const unsigned char magic_num[4] = {0x45, 0x4D, 0x4F, 0x52}; + int i = 0; + bool valid_frame = true; + int num_of_tunnels = 0; + int sync_tunnels = 0; + int tunnel_src[MAX_TUNNELS] = { 0 }; + int tunnel_mode[MAX_TUNNELS] = { 0 }; + int tunnel_encode[MAX_TUNNELS]; + int lastSeqNum[MAX_TUNNELS] = { 0 }; + int notFirstFrame[MAX_TUNNELS] = { 0 }; + int frameDropCount[MAX_TUNNELS] = { 0 }; + uint64_t tunnel_time_stamps[MAX_TUNNELS] = { 0 }; + bool is_initial_align_reached = true; + unsigned char *frame_start, *buf_itr; + // Minimum bytes required is the magic number + tunnel id + reserved and crc + raf struct + int min_bytes_req = 4 + 2 + 6 + sizeof(struct raf_frame_type); + int instance; + + if (argc < 5) { + ALOGE("USAGE: %s <instance number> <Number of tunnels> <Sync Tunnel req> <Source End pt 1> <tnl mode> <encode fmt> <Source End pt 2> <tnl mode> <encode fmt>...", argv[0]); + return -EINVAL; + } + + instance = strtol(argv[1], NULL, 0); + ALOGD("instance %d", instance); + + num_of_tunnels = strtol(argv[2], NULL, 0); + ALOGD("Number of tunnels %d", num_of_tunnels); + + sync_tunnels= strtol(argv[3], NULL, 0); + ALOGD("Sync tunnels req %s", sync_tunnels?"yes":"no"); + + if (argc != (num_of_tunnels * 3 + 4)) { + ALOGE("USAGE: %s <instance number> <Number of tunnels> <Sync Tunnel req> <Source End pt 1> <tnl mode> <encode fmt> <Source End pt 2> <tnl mode> <encode fmt>...", argv[0]); + return -EINVAL; + } + + for (i = 0; i < num_of_tunnels; i++) { + tunnel_src[i] = strtol(argv[i*3+4], NULL, 0); + tunnel_mode[i] = strtol(argv[i*3+5], NULL, 0); + tunnel_encode[i] = strtol(argv[i*3+6], NULL, 0); + ALOGD("Tunnel source 0x%x Tunnel mode %d Tunnel encode %d", tunnel_src[i], tunnel_mode[i], tunnel_encode[i]); + } + + thdl = ia_start_tunneling(0); + if (NULL == thdl) { + ALOGE("Failed to start tunneling"); + goto exit; + } + + for (i = 0; i < num_of_tunnels; i++) { + err = ia_enable_tunneling_source(thdl, tunnel_src[i], tunnel_mode[i], tunnel_encode[i]); + if (0 != err) { + ALOGE("Failed to enable tunneling for src_id %u mode %u encode %u", tunnel_src[i], tunnel_mode[i], tunnel_encode[i]); + goto exit; + } + } + + if (num_of_tunnels > 1 && sync_tunnels) { + // Mic tunneling is not being done or just one mic + // is enabled so no need of alignment + is_initial_align_reached = false; + } + + buf = malloc(BUF_SIZE * 2); + if (NULL == buf) { + ALOGE("Failed to allocate memory to read buffer"); + goto exit; + } + + unp_out_fp = fopen(UNPARSED_OUTPUT_FILE, "wb"); + if (NULL == unp_out_fp) { + ALOGE("Failed to open the file %s", UNPARSED_OUTPUT_FILE); + goto exit; + } + + signal(SIGINT, sigint_handler); + + unsigned short int tunnel_id; + unsigned short int tunl_src; + while (1) { +read_again: + if (0 == capturing) { + ALOGE("Time to bail from here"); + break; + } + + if (0 != bytes_avail) { + if (bytes_avail < 0) { + bytes_rem = 0; + } else { + bytes_rem = bytes_avail; + ALOGD("bytes_avail is %d", bytes_rem); + memcpy(buf, buf_itr, bytes_rem); + } + } else { + bytes_rem = 0; + } + + // Ensure that we read BUF_SIZE always otherwise the kernel read will hang + bytes_avail = ia_read_tunnel_data (thdl, + (void *)((unsigned char *)buf + bytes_rem), + BUF_SIZE); + if (bytes_avail <= 0) { + ALOGE("Failed to read data from the tunnel"); + break; + } + + fwrite((void *)((unsigned char *)buf + bytes_rem), bytes_avail, 1, unp_out_fp); + fflush(unp_out_fp); + + bytes_avail += bytes_rem; // update the available bytes with the previous reminder if any + ALOGD("bytes_avail is after read %d", bytes_avail); + buf_itr = (unsigned char *)buf; + + do { + // Check for MagicNumber 0x454D4F52 + if (buf_itr[0] != magic_num[0] || buf_itr[1] != magic_num[1] || + buf_itr[2] != magic_num[2] || buf_itr[3] != magic_num[3]) { + ALOGE("Could not find the magic number, reading again"); + ALOGE("buf_itr[0] %x buf_itr[1] %x buf_itr[2] %x buf_itr[3] %x ", + buf_itr[0], buf_itr[1], buf_itr[2], buf_itr[3]); + goto exit; + } + ALOGD("bytes_avail is after magic %d: prev :%d", bytes_avail, bytes_avail + 540); + // Bookmark the start of the frame + frame_start = buf_itr; + + // Skip the magic number + buf_itr += 4; + bytes_avail -= 4; + + // Read the tunnelID + tunnel_id = ((unsigned char) (buf_itr[0]) | + (unsigned char) (buf_itr[1]) << 8); + + // Skip tunnelID + buf_itr += 2; + bytes_avail -= 2; + + tunl_src = ((unsigned char) (buf_itr[0]) | + (unsigned char) (buf_itr[1]) << 8); + + // Skip src id field and CRC - 6 bytes in total + buf_itr += 6; + bytes_avail -= 6; + + valid_frame = true; + if (tunnel_id > MAX_TUNNELS) { + ALOGE("Invalid tunnel id %d", tunnel_id); + valid_frame = false; + } + + struct raf_frame_type rft; + memcpy(&rft, buf_itr, sizeof(struct raf_frame_type)); + if (true == valid_frame) { + if (NULL == out_fp[tunnel_id]) { + char filename[256]; + + if (DOA_TUNNEL_SRC == tunl_src) { + snprintf(filename, 256, "%s_%d.txt", DOA_OUTPUT_FILE, instance); + } else if (VQ_TUNNEL_SRC == tunl_src) { + snprintf(filename, 256, "%s_%d.txt", VQ_CONFIDENCE_OUTPUT_FILE, instance); + } else if (VP_PARAM_TUNNEL_SRC == tunl_src) { + snprintf(filename, 256, "%s_%d.txt", VP_PARAM_DUMP_FILE, instance); + } else { + snprintf(filename, 256, "%sid%d-src0x%x-enc0x%x_client%d.pcm", OUTPUT_FILE, tunnel_id, tunl_src, rft.format.encoding, instance); + } + // Open the file to dump + out_fp[tunnel_id] = fopen(filename, "wb"); + if (NULL == out_fp[tunnel_id]) { + ALOGE("ERROR: Failed to open the file %s", filename); + goto exit; + } + } + } + + ALOGD("Tunnel id %d timestamp %llu", tunnel_id, rft.timeStamp); + tunnel_time_stamps[tunnel_id] = rft.timeStamp; + + if (false == is_initial_align_reached) { + for (i = 0; i < num_of_tunnels; i++) { + if (tunnel_id == 0) { + continue; + } else if (tunnel_time_stamps[tunnel_id] == tunnel_time_stamps[tunnel_id - 1]) { + is_initial_align_reached = true; + } else { + is_initial_align_reached = false; + ALOGE("Tunnel[%d] %llu Tunnel[%d] %llu", tunnel_id - 1, tunnel_time_stamps[tunnel_id - 1], + tunnel_id, tunnel_time_stamps[tunnel_id]); + break; + } + } + } + + // Skip the raf_frame_type + buf_itr += sizeof(struct raf_frame_type); + bytes_avail -= sizeof(struct raf_frame_type); + + if (bytes_avail < rft.format.frameSizeInBytes) { + ALOGD("Incomplete frame received bytes_avail %d framesize %d", bytes_avail, rft.format.frameSizeInBytes); + buf_itr = frame_start; + bytes_avail += min_bytes_req; + goto read_again; + } + + if (true == valid_frame) { + if (DOA_TUNNEL_SRC == tunl_src) { + parse_doa_meta_data(out_fp[tunnel_id], (void*) buf_itr); + } else if (VQ_TUNNEL_SRC == tunl_src) { + parse_vq_meta_data(out_fp[tunnel_id], (void*) buf_itr); + } else if (VP_PARAM_TUNNEL_SRC == tunl_src) { + parse_param_data(out_fp[tunnel_id], (void*) buf_itr); + } else { + if (true == is_initial_align_reached) { + ALOGD("@@@Tunnel id %d encoding %d", tunnel_id, rft.format.encoding); + if (TNL_ENC_AFLOAT == rft.format.encoding) { + parse_audio_tunnel_data(out_fp[tunnel_id], buf_itr, rft.format.frameSizeInBytes); + } else { + fwrite(buf_itr, rft.format.frameSizeInBytes, 1, out_fp[tunnel_id]); + } + } + } + } + + /* Calculate the frame drop count */ + if (notFirstFrame[tunnel_id]) { + frameDropCount[tunnel_id] += (rft.seqNo - lastSeqNum[tunnel_id] - 1); + } + lastSeqNum[tunnel_id] = rft.seqNo; + notFirstFrame[tunnel_id] = 1; + // Skip the data + buf_itr += rft.format.frameSizeInBytes; + bytes_avail -= rft.format.frameSizeInBytes; + /* For debugging the tunnel read errors or wrong magic numbers or bus errors*/ + bytes_read += rft.format.frameSizeInBytes + min_bytes_req; + } while (bytes_avail > min_bytes_req); + } + +exit: + for (i = 0; i < MAX_TUNNELS; i++) { + if (notFirstFrame[i]) { + ALOGE("drop count tunnel id %u: %u", i, frameDropCount[i]); + } + } + ALOGE("bytes_read so far %d", bytes_read); + if (buf) { + free(buf); + buf = NULL; + } + + if (unp_out_fp) { + fflush(unp_out_fp); + fclose(unp_out_fp); + } + + for (i = 0; i < MAX_TUNNELS; i++) { + if (out_fp[i]) + fclose(out_fp[i]); + } + + for (i = 0; i < num_of_tunnels; i++) { + err = ia_disable_tunneling_source(thdl, tunnel_src[i], tunnel_mode[i], tunnel_encode[i]); + if (0 != err) { + ALOGE("Failed to disable tunneling for tunl_id %u src_id %u", i, tunnel_src[i]); + } + } + + err = ia_stop_tunneling(thdl); + if (0 != err) { + ALOGE("Failed to stop tunneling"); + } + + return 0; +} diff --git a/tunnel.c b/tunnel.c new file mode 100644 index 0000000..e191150 --- /dev/null +++ b/tunnel.c @@ -0,0 +1,127 @@ +#define LOG_TAG "ia_tunneling_hal" +#define LOG_NDEBUG 0 + +#include <stdio.h> +#include <stdlib.h> +#include <ctype.h> +#include <errno.h> +#include <string.h> +#include <sys/ioctl.h> + +#include <cutils/log.h> +#include "iaxxx-tunnel-intf.h" +#include "iaxxx-system-identifiers.h" +#include "tunnel.h" + +#define TUNNELING_DEVICE "/dev/tunnel0" +#define FUNCTION_ENTRY_LOG ALOGV("Entering %s", __func__); +#define FUNCTION_EXIT_LOG ALOGV("Exiting %s", __func__); + +struct ia_tunneling_hal { + FILE *tunnel_dev; +}; + +struct ia_tunneling_hal* ia_start_tunneling(int buffering_size) +{ + struct ia_tunneling_hal *thdl; + + FUNCTION_ENTRY_LOG; + + thdl = (struct ia_tunneling_hal*) malloc(sizeof(struct ia_tunneling_hal)); + if (NULL == thdl) { + ALOGE("%s: ERROR Failed to allocate memory of ia_tunneling_hal", __func__); + return NULL; + } + + thdl->tunnel_dev = fopen(TUNNELING_DEVICE, "r"); + if (NULL == thdl->tunnel_dev) { + ALOGE("%s: ERROR Failed to open the tunneling device - %s", __func__, strerror(errno)); + free(thdl); + return NULL; + } + + if (buffering_size) + setvbuf(thdl->tunnel_dev, NULL, _IONBF, 0); + + return thdl; +} + +int ia_stop_tunneling(struct ia_tunneling_hal *thdl) +{ + FUNCTION_ENTRY_LOG; + + if (thdl->tunnel_dev) { + fclose(thdl->tunnel_dev); + thdl->tunnel_dev = NULL; + } + + free(thdl); + + return 0; +} + +int ia_enable_tunneling_source(struct ia_tunneling_hal *thdl, + unsigned int src_id, + unsigned int tnl_mode, + unsigned int tnl_encode) +{ + FUNCTION_ENTRY_LOG; + struct tunlMsg tm; + + if (NULL == thdl->tunnel_dev) { + ALOGE("%s: ERROR Tunneling device is not opened", __func__); + return -EIO; + } + + tm.tunlSrc = src_id; + tm.tunlMode = tnl_mode; + tm.tunlEncode = tnl_encode; + if (-1 == ioctl(fileno(thdl->tunnel_dev), TUNNEL_SETUP, &tm)) { + ALOGE("%s: ERROR Tunnel setup failed %s", __func__, strerror(errno)); + return -1; + } + + return 0; +} + +int ia_disable_tunneling_source(struct ia_tunneling_hal *thdl, + unsigned int src_id, + unsigned int tunl_mode, + unsigned int tunl_encode) +{ + FUNCTION_ENTRY_LOG; + struct tunlMsg tm; + + if (NULL == thdl->tunnel_dev) { + ALOGE("%s: ERROR Tunneling devices is not opened", __func__); + return -EIO; + } + + tm.tunlSrc = src_id; + tm.tunlMode = tunl_mode; + tm.tunlEncode = tunl_encode; + if (-1 == ioctl(fileno(thdl->tunnel_dev), TUNNEL_TERMINATE, &tm)) { + ALOGE("%s: ERROR Tunnel terminate failed %s", __func__, strerror(errno)); + return -1; + } + + return 0; +} + +int ia_read_tunnel_data(struct ia_tunneling_hal *thdl, void *buf, int buf_sz) +{ + FUNCTION_ENTRY_LOG; + int read_bytes; + + if ((NULL == buf) || (buf_sz <= 0)) { + ALOGE("%s: ERROR Invalid buffer or buffer size", __func__); + return -EINVAL; + } + + read_bytes = fread(buf, 1, buf_sz, thdl->tunnel_dev); + if (0 == read_bytes) { + ALOGE("%s: Warning zero bytes read from tunneling device, trying again..", __func__); + } + + return read_bytes; +} diff --git a/tunnel.h b/tunnel.h new file mode 100644 index 0000000..c71c704 --- /dev/null +++ b/tunnel.h @@ -0,0 +1,75 @@ +#ifndef _TUNNEL_H_ +#define _TUNNEL_H_ + +#if __cplusplus +extern "C" +{ +#endif + +struct ia_tunneling_hal; + +/** + * Opens up the tunnel port and sets it up to start the tunneling of data + * + * Input - buffering size + * If buffering size is non-zero, then set Non Buffering Flag + * Output - Handle to Tunneling HAL + * - NULL on failure, non null on success + */ +struct ia_tunneling_hal* ia_start_tunneling(int buffering_size); + +/** + * Enable the tunneling of the data for a particular tunnel id and a source id + * + * Input - tun_hdl - Handle to the Tunneling HAL. + * src_id - Source system ID for this tunnel + * tunl_mode - tunnel out in sync or async mode. + * tunl_encode -tunnel encoding format. + * + * Output - Zero on success, errno on failure. + */ +int ia_enable_tunneling_source(struct ia_tunneling_hal *tun_hdl, + unsigned int src_id, + unsigned int tunl_mode, + unsigned int tunl_encode); + +/** + * Disable the tunneling of the data for a particular tunnel id and a source id + * + * Input - tun_hdl - Handle to the Tunneling HAL. + * src_id - Source system ID for this tunnel + * tunl_mode - tunnel out in sync or async mode. + * tunl_encode -tunnel encoding format. + * + * Output - Zero on success, errno on failure. + */ +int ia_disable_tunneling_source(struct ia_tunneling_hal *tun_hdl, + unsigned int src_id, + unsigned int tunl_mode, + unsigned int tunl_encode); + + +/** + * Get the tunneled data. This data is an interleaved data from all the tunnels that were + * enabled. + * + * Input - tun_hdl - Handle to the Tunneling HAL. + * buf - buffer in which the data will be filled. + * buf_size - Size of the buffer buf + * Output - Number of bytes filled into the buffer + */ +int ia_read_tunnel_data(struct ia_tunneling_hal *tun_hdl, void *buf, int buf_size); + +/** + * Closes tunneling port + * + * Input - tun_hdl - Handle to the Tunneling HAL. + * Output - Zero on success, errno on failure. + */ +int ia_stop_tunneling(struct ia_tunneling_hal *tun_hdl); + +#if __cplusplus +} // extern "C" +#endif + +#endif |