static vpx_codec_err_t vp8_destroy(vpx_codec_alg_priv_t *ctx)
{
int i;
vp8dx_remove_decompressor(ctx->pbi);
for (i = NELEMENTS(ctx->mmaps) - 1; i >= 0; i--)
{
if (ctx->mmaps[i].dtor)
ctx->mmaps[i].dtor(&ctx->mmaps[i]);
}
#if CONFIG_OPENCL
if (cl_initialized == CL_SUCCESS){
cl_destroy(NULL, VP8_CL_NOT_INITIALIZED);
#if HAVE_DLOPEN
close_cl();
#endif
}
#endif
return VPX_CODEC_OK;
}
static void vp8_init_ctx(vpx_codec_ctx_t *ctx, const vpx_codec_mmap_t *mmap)
{
int i;
ctx->priv = mmap->base;
ctx->priv->sz = sizeof(*ctx->priv);
ctx->priv->iface = ctx->iface;
ctx->priv->alg_priv = mmap->base;
for (i = 0; i < NELEMENTS(ctx->priv->alg_priv->mmaps); i++)
ctx->priv->alg_priv->mmaps[i].id = vp8_mem_req_segs[i].id;
ctx->priv->alg_priv->mmaps[0] = *mmap;
ctx->priv->alg_priv->si.sz = sizeof(ctx->priv->alg_priv->si);
ctx->priv->init_flags = ctx->init_flags;
if (ctx->config.dec)
{
/* Update the reference to the config structure to an internal copy. */
ctx->priv->alg_priv->cfg = *ctx->config.dec;
ctx->config.dec = &ctx->priv->alg_priv->cfg;
}
}
TEST_F(I2CVMTest, RegisterIndependence) {
const uint32_t program[] = {
I2C_VM_ASM_SET_IMM(VM_R0, 10),
I2C_VM_ASM_SET_IMM(VM_R1, 11),
I2C_VM_ASM_SET_IMM(VM_R2, 12),
I2C_VM_ASM_SET_IMM(VM_R3, 13),
I2C_VM_ASM_SET_IMM(VM_R4, 14),
I2C_VM_ASM_SET_IMM(VM_R5, 15),
I2C_VM_ASM_SET_IMM(VM_R6, 16),
I2C_VM_ASM_SEND_UAVO(),
};
EXPECT_TRUE(i2c_vm_run (program, NELEMENTS(program), 0));
EXPECT_EQ(7, uavo_data.pc);
EXPECT_EQ(10, uavo_data.r0);
EXPECT_EQ(11, uavo_data.r1);
EXPECT_EQ(12, uavo_data.r2);
EXPECT_EQ(13, uavo_data.r3);
EXPECT_EQ(14, uavo_data.r4);
EXPECT_EQ(15, uavo_data.r5);
EXPECT_EQ(16, uavo_data.r6);
}
static int test16(void)
{
int i, sum = 0;
struct hashtbl *h;
static int keys[] = { 100, 200, 300 };
struct hashtbl_iter iter;
h = hashtbl_create(ht_size,
HASHTBL_MAX_LOAD_FACTOR,
1,
hashtbl_direct_hash, hashtbl_direct_equals,
NULL, NULL,
NULL, NULL);
CUT_ASSERT_NOT_NULL(h);
CUT_ASSERT_EQUAL(0, hashtbl_count(h));
for (i = 0; i < (int)NELEMENTS(keys); i++) {
CUT_ASSERT_EQUAL(0, hashtbl_insert(h, &keys[i], NULL));
}
CUT_ASSERT_EQUAL(3, hashtbl_count(h));
hashtbl_iter_init(h, &iter);
CUT_ASSERT_TRUE(hashtbl_iter_next(h, &iter));
sum += *(int *)iter.key;
CUT_ASSERT_TRUE(hashtbl_iter_next(h, &iter));
sum += *(int *)iter.key;
CUT_ASSERT_TRUE(hashtbl_iter_next(h, &iter));
sum += *(int *)iter.key;
CUT_ASSERT_FALSE(hashtbl_iter_next(h, &iter));
CUT_ASSERT_EQUAL(600, sum);
hashtbl_delete(h);
return 0;
}
int mmuTestInit(
void
)
{
static SYMBOL symTableMmuTest[] =
{
{NULL, "_mmuGlobalMapTest", mmuGlobalMapTest, 0, N_TEXT | N_EXT}
};
int i;
if (mmuInit() != OK)
{
fprintf(stderr, "Error - Unable to initialize mmu.\n");
return ERROR;
}
for (i = 0; i < NELEMENTS(symTableMmuTest); i++)
{
symTableAdd(sysSymTable, &symTableMmuTest[i]);
}
return i;
}
ssize_t write (int fd, const void *buf, size_t n)
{
unsigned retries = 10;
int retcode;
if (!buf || (fd < 0) || (fd >= (int)NELEMENTS(fdarray)) ||
!(fdarray[fd].flags & FD_DATA_IS_INUSE)) {
return (-1);
}
if (fdarray[fd].flags & FD_DATA_IS_RAW) {
do {
retcode = device_io_tx(fdarray[fd].rawdev, (char *)buf, n);
} while (retries-- && (retcode == EAGAIN));
if (retcode < EOK) {
return (-1);
}
} else if (fdarray[fd].flags & FD_DATA_IS_SOCK) {
} else {
return (-1);
}
return (n);
}
UINT8 fontpc88_read(const OEMCHAR *filename, UINT8 loading) {
FILEH fh;
UINT8 *work;
OEMCHAR fname[MAX_PATH];
work = (UINT8 *)_MALLOC(0x20000, "pc88font");
if (work == NULL) {
goto fr88_err1;
}
file_cpyname(fname, filename, NELEMENTS(fname));
// 第２水準以外を読む必要はある？
if (loading & (FONT_ANK8 | FONTLOAD_ANK | FONT_KNJ1)) {
// あったら読み込んでみる
file_cutname(fname);
file_catname(fname, pc88knj1name, NELEMENTS(fname));
fh = file_open_rb(fname);
if (fh != FILEH_INVALID) {
if (file_read(fh, work, 0x20000) == 0x20000) {
// 8dot ANKを読む必要があるか
if (loading & FONT_ANK8) {
loading &= ~FONT_ANK8;
fontdata_ank8store(work + 0x1000, 0, 256);
}
// 16dot ASCIIを読む必要があるか
if (loading & FONT_ANK16a) {
loading &= ~FONT_ANK16a;
CopyMemory(fontrom + 0x80000, work + 0x0000, 16*128);
}
// 16dot ANK(0x80〜)を読む必要があるか
if (loading & FONT_ANK16b) {
loading &= ~FONT_ANK16b;
CopyMemory(fontrom + 0x80800, work + 0x0800, 16*128);
}
// 第一水準漢字を読み込む？
if (loading & FONT_KNJ1) {
loading &= ~FONT_KNJ1;
pc88knjcpy1(fontrom, work, 0x01, 0x30);
fontdata_patchjis();
}
}
// クローズして セクション終わり
file_close(fh);
}
}
// 第２水準を読む必要はある？
if (loading & FONT_KNJ2) {
// あったら読み込んでみる
file_cutname(fname);
file_catname(fname, pc88knj2name, NELEMENTS(fname));
fh = file_open_rb(fname);
if (fh != FILEH_INVALID) {
if (file_read(fh, work, 0x20000) == 0x20000) {
loading &= ~FONT_KNJ2;
pc88knjcpy2(fontrom, work, 0x31, 0x56);
}
// クローズして セクション終わり
file_close(fh);
}
}
// ANKを読み込む必要はある？
if (loading & (FONT_ANK8 | FONTLOAD_ANK)) {
// あったら読み込んでみる
file_cutname(fname);
file_catname(fname, pc88ankname, NELEMENTS(fname));
fh = file_open_rb(fname);
if (fh != FILEH_INVALID) {
// 読み込んでみる
if (file_read(fh, work, 0x1800) == 0x1800) {
// 8dot ANKを読む必要があるか
if (loading & FONT_ANK8) {
loading &= ~FONT_ANK8;
fontdata_ank8store(work + 0x0000, 0, 256);
}
// 16dot ASCIIを読む必要があるか
if (loading & FONT_ANK16a) {
loading &= ~FONT_ANK16a;
CopyMemory(fontrom + 0x80000, work + 0x0800, 16*128);
}
// 16dot ANK(0x80〜)を読む必要があるか
if (loading & FONT_ANK16b) {
loading &= ~FONT_ANK16b;
CopyMemory(fontrom + 0x80800, work + 0x1000, 16*128);
}
}
// クローズして ANKは終わり
file_close(fh);
}
}
_MFREE(work);
fr88_err1:
return(loading);
}
static void
ok_button_clicked(GtkButton *b, gpointer d)
{
const gchar *bufp = gtk_entry_get_text(GTK_ENTRY(buffer_entry));
const gchar *base = gtk_entry_get_text(GTK_ENTRY(baseclock_entry));
const gchar *multp = gtk_entry_get_text(GTK_ENTRY(clockmult_entry));
#if defined(SUPPORT_RESUME)
gint resume = GTK_TOGGLE_BUTTON(resume_checkbutton)->active;
#endif
#if defined(GCC_CPU_ARCH_IA32)
gint disablemmx = GTK_TOGGLE_BUTTON(disablemmx_checkbutton)->active;
#endif
guint bufsize;
guint mult;
UINT renewal = 0;
int i;
if (strcmp(base, "1.9968MHz") == 0) {
if (np2cfg.baseclock != PCBASECLOCK20) {
np2cfg.baseclock = PCBASECLOCK20;
renewal |= SYS_UPDATECFG|SYS_UPDATECLOCK;
}
} else {
if (np2cfg.baseclock != PCBASECLOCK25) {
np2cfg.baseclock = PCBASECLOCK25;
renewal |= SYS_UPDATECFG|SYS_UPDATECLOCK;
}
}
mult = milstr_solveINT(multp);
switch (mult) {
case 1: case 2: case 4: case 5: case 6: case 8: case 10: case 12:
case 16: case 20:
if (mult != np2cfg.multiple) {
np2cfg.multiple = mult;
renewal |= SYS_UPDATECFG|SYS_UPDATECLOCK;
}
break;
}
for (i = 0; i < NELEMENTS(architecture); i++) {
if (strcmp(arch, architecture[i].arch) == 0) {
milstr_ncpy(np2cfg.model, arch, sizeof(np2cfg.model));
renewal |= SYS_UPDATECFG;
break;
}
}
if (i == NELEMENTS(architecture)) {
milstr_ncpy(np2cfg.model, "VX", sizeof(np2cfg.model));
renewal |= SYS_UPDATECFG;
}
switch (rate) {
case 11025:
case 22050:
case 44100:
if (rate != np2cfg.samplingrate) {
np2cfg.samplingrate = rate;
renewal |= SYS_UPDATECFG|SYS_UPDATERATE;
soundrenewal = 1;
}
break;
}
bufsize = milstr_solveINT(bufp);
if (bufsize < 20)
bufsize = 20;
else if (bufsize > 1000)
bufsize = 1000;
if (np2cfg.delayms != bufsize) {
np2cfg.delayms = bufsize;
renewal |= SYS_UPDATECFG|SYS_UPDATESBUF;
soundrenewal = 1;
}
#if defined(GCC_CPU_ARCH_IA32)
if (!(mmxflag & MMXFLAG_NOTSUPPORT)) {
disablemmx = disablemmx ? MMXFLAG_DISABLE : 0;
if (np2oscfg.disablemmx != disablemmx) {
np2oscfg.disablemmx = disablemmx;
mmxflag &= ~MMXFLAG_DISABLE;
mmxflag |= disablemmx;
renewal |= SYS_UPDATEOSCFG;
}
}
#endif
#if defined(SUPPORT_RESUME)
if (np2oscfg.resume != resume) {
np2oscfg.resume = resume;
renewal |= SYS_UPDATEOSCFG;
}
#endif
if (renewal) {
sysmng_update(renewal);
}
gtk_widget_destroy((GtkWidget *)d);
}
void PIOS_Board_Init(void) {
/* Delay system */
PIOS_DELAY_Init();
const struct pios_board_info * bdinfo = &pios_board_info_blob;
#if defined(PIOS_INCLUDE_LED)
const struct pios_led_cfg * led_cfg = PIOS_BOARD_HW_DEFS_GetLedCfg(bdinfo->board_rev);
PIOS_Assert(led_cfg);
PIOS_LED_Init(led_cfg);
#endif /* PIOS_INCLUDE_LED */
/* Set up the SPI interface to the gyro/acelerometer */
if (PIOS_SPI_Init(&pios_spi_gyro_id, &pios_spi_gyro_cfg)) {
PIOS_DEBUG_Assert(0);
}
/* Set up the SPI interface to the flash and rfm22b */
if (PIOS_SPI_Init(&pios_spi_telem_flash_id, &pios_spi_telem_flash_cfg)) {
PIOS_DEBUG_Assert(0);
}
#if defined(PIOS_INCLUDE_FLASH)
/* Connect flash to the approrpiate interface and configure it */
uintptr_t flash_id;
if (PIOS_Flash_Jedec_Init(&flash_id, pios_spi_telem_flash_id, 1, &flash_m25p_cfg) != 0)
panic(1);
uintptr_t fs_id;
if (PIOS_FLASHFS_Logfs_Init(&fs_id, &flashfs_m25p_cfg, &pios_jedec_flash_driver, flash_id) != 0)
panic(1);
#endif
/* Initialize UAVObject libraries */
EventDispatcherInitialize();
UAVObjInitialize();
HwFreedomInitialize();
ModuleSettingsInitialize();
#if defined(PIOS_INCLUDE_RTC)
PIOS_RTC_Init(&pios_rtc_main_cfg);
#endif
/* Initialize the alarms library */
AlarmsInitialize();
/* Initialize the task monitor library */
TaskMonitorInitialize();
// /* Set up pulse timers */
PIOS_TIM_InitClock(&tim_1_cfg);
PIOS_TIM_InitClock(&tim_2_cfg);
PIOS_TIM_InitClock(&tim_3_cfg);
/* IAP System Setup */
PIOS_IAP_Init();
uint16_t boot_count = PIOS_IAP_ReadBootCount();
if (boot_count < 3) {
PIOS_IAP_WriteBootCount(++boot_count);
AlarmsClear(SYSTEMALARMS_ALARM_BOOTFAULT);
} else {
/* Too many failed boot attempts, force hw config to defaults */
HwFreedomSetDefaults(HwFreedomHandle(), 0);
ModuleSettingsSetDefaults(ModuleSettingsHandle(),0);
AlarmsSet(SYSTEMALARMS_ALARM_BOOTFAULT, SYSTEMALARMS_ALARM_CRITICAL);
}
PIOS_IAP_Init();
#if defined(PIOS_INCLUDE_USB)
/* Initialize board specific USB data */
PIOS_USB_BOARD_DATA_Init();
/* Flags to determine if various USB interfaces are advertised */
bool usb_hid_present = false;
bool usb_cdc_present = false;
#if defined(PIOS_INCLUDE_USB_CDC)
if (PIOS_USB_DESC_HID_CDC_Init()) {
PIOS_Assert(0);
}
usb_hid_present = true;
usb_cdc_present = true;
#else
if (PIOS_USB_DESC_HID_ONLY_Init()) {
PIOS_Assert(0);
}
usb_hid_present = true;
#endif
uint32_t pios_usb_id;
PIOS_USB_Init(&pios_usb_id, PIOS_BOARD_HW_DEFS_GetUsbCfg(bdinfo->board_rev));
#if defined(PIOS_INCLUDE_USB_CDC)
uint8_t hw_usb_vcpport;
/* Configure the USB VCP port */
HwFreedomUSB_VCPPortGet(&hw_usb_vcpport);
if (!usb_cdc_present) {
/* Force VCP port function to disabled if we haven't advertised VCP in our USB descriptor */
hw_usb_vcpport = HWFREEDOM_USB_VCPPORT_DISABLED;
}
switch (hw_usb_vcpport) {
case HWFREEDOM_USB_VCPPORT_DISABLED:
break;
case HWFREEDOM_USB_VCPPORT_USBTELEMETRY:
#if defined(PIOS_INCLUDE_COM)
PIOS_Board_configure_com(&pios_usb_cdc_cfg, PIOS_COM_TELEM_USB_RX_BUF_LEN, PIOS_COM_TELEM_USB_TX_BUF_LEN, &pios_usb_cdc_com_driver, &pios_com_telem_usb_id);
#endif /* PIOS_INCLUDE_COM */
break;
case HWFREEDOM_USB_VCPPORT_COMBRIDGE:
#if defined(PIOS_INCLUDE_COM)
PIOS_Board_configure_com(&pios_usb_cdc_cfg, PIOS_COM_BRIDGE_RX_BUF_LEN, PIOS_COM_BRIDGE_TX_BUF_LEN, &pios_usb_cdc_com_driver, &pios_com_vcp_id);
#endif /* PIOS_INCLUDE_COM */
break;
case HWFREEDOM_USB_VCPPORT_DEBUGCONSOLE:
#if defined(PIOS_INCLUDE_COM)
#if defined(PIOS_INCLUDE_DEBUG_CONSOLE)
{
uint32_t pios_usb_cdc_id;
if (PIOS_USB_CDC_Init(&pios_usb_cdc_id, &pios_usb_cdc_cfg, pios_usb_id)) {
PIOS_Assert(0);
}
uint8_t * tx_buffer = (uint8_t *) pvPortMalloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_debug_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
NULL, 0,
tx_buffer, PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN)) {
PIOS_Assert(0);
}
}
#endif /* PIOS_INCLUDE_DEBUG_CONSOLE */
#endif /* PIOS_INCLUDE_COM */
break;
}
#endif /* PIOS_INCLUDE_USB_CDC */
#if defined(PIOS_INCLUDE_USB_HID)
/* Configure the usb HID port */
uint8_t hw_usb_hidport;
HwFreedomUSB_HIDPortGet(&hw_usb_hidport);
if (!usb_hid_present) {
/* Force HID port function to disabled if we haven't advertised HID in our USB descriptor */
hw_usb_hidport = HWFREEDOM_USB_HIDPORT_DISABLED;
}
switch (hw_usb_hidport) {
case HWFREEDOM_USB_HIDPORT_DISABLED:
break;
case HWFREEDOM_USB_HIDPORT_USBTELEMETRY:
#if defined(PIOS_INCLUDE_COM)
{
uint32_t pios_usb_hid_id;
if (PIOS_USB_HID_Init(&pios_usb_hid_id, &pios_usb_hid_cfg, pios_usb_id)) {
PIOS_Assert(0);
}
uint8_t * rx_buffer = (uint8_t *) pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
uint8_t * tx_buffer = (uint8_t *) pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_hid_com_driver, pios_usb_hid_id,
rx_buffer, PIOS_COM_TELEM_USB_RX_BUF_LEN,
tx_buffer, PIOS_COM_TELEM_USB_TX_BUF_LEN)) {
PIOS_Assert(0);
}
}
#endif /* PIOS_INCLUDE_COM */
break;
}
#endif /* PIOS_INCLUDE_USB_HID */
if (usb_hid_present || usb_cdc_present) {
PIOS_USBHOOK_Activate();
}
#endif /* PIOS_INCLUDE_USB */
/* Configure IO ports */
uint8_t hw_DSMxBind;
HwFreedomDSMxBindGet(&hw_DSMxBind);
/* Configure FlexiPort */
uint8_t hw_mainport;
HwFreedomMainPortGet(&hw_mainport);
switch (hw_mainport) {
case HWFREEDOM_MAINPORT_DISABLED:
break;
case HWFREEDOM_MAINPORT_TELEMETRY:
PIOS_Board_configure_com(&pios_usart_main_cfg, PIOS_COM_TELEM_RF_RX_BUF_LEN, PIOS_COM_TELEM_RF_TX_BUF_LEN, &pios_usart_com_driver, &pios_com_telem_rf_id);
break;
break;
case HWFREEDOM_MAINPORT_GPS:
PIOS_Board_configure_com(&pios_usart_main_cfg, PIOS_COM_GPS_RX_BUF_LEN, -1, &pios_usart_com_driver, &pios_com_gps_id);
break;
case HWFREEDOM_MAINPORT_DSM2:
case HWFREEDOM_MAINPORT_DSMX10BIT:
case HWFREEDOM_MAINPORT_DSMX11BIT:
{
enum pios_dsm_proto proto;
switch (hw_mainport) {
case HWFREEDOM_MAINPORT_DSM2:
proto = PIOS_DSM_PROTO_DSM2;
break;
case HWFREEDOM_MAINPORT_DSMX10BIT:
proto = PIOS_DSM_PROTO_DSMX10BIT;
break;
case HWFREEDOM_MAINPORT_DSMX11BIT:
proto = PIOS_DSM_PROTO_DSMX11BIT;
break;
default:
PIOS_Assert(0);
break;
}
PIOS_Board_configure_dsm(&pios_usart_dsm_main_cfg, &pios_dsm_main_cfg,
&pios_usart_com_driver, &proto, MANUALCONTROLSETTINGS_CHANNELGROUPS_DSMMAINPORT,&hw_DSMxBind);
}
break;
case HWFREEDOM_MAINPORT_DEBUGCONSOLE:
#if defined(PIOS_INCLUDE_DEBUG_CONSOLE)
{
PIOS_Board_configure_com(&pios_usart_main_cfg, 0, PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN, &pios_usart_com_driver, &pios_com_aux_id);
}
#endif /* PIOS_INCLUDE_DEBUG_CONSOLE */
break;
case HWFREEDOM_MAINPORT_COMBRIDGE:
PIOS_Board_configure_com(&pios_usart_main_cfg, PIOS_COM_BRIDGE_RX_BUF_LEN, PIOS_COM_BRIDGE_TX_BUF_LEN, &pios_usart_com_driver, &pios_com_bridge_id);
break;
} /* hw_freedom_mainport */
/* Configure flexi USART port */
uint8_t hw_flexiport;
HwFreedomFlexiPortGet(&hw_flexiport);
switch (hw_flexiport) {
case HWFREEDOM_FLEXIPORT_DISABLED:
break;
case HWFREEDOM_FLEXIPORT_TELEMETRY:
PIOS_Board_configure_com(&pios_usart_flexi_cfg, PIOS_COM_TELEM_RF_RX_BUF_LEN, PIOS_COM_TELEM_RF_TX_BUF_LEN, &pios_usart_com_driver, &pios_com_telem_rf_id);
break;
case HWFREEDOM_FLEXIPORT_GPS:
PIOS_Board_configure_com(&pios_usart_flexi_cfg, PIOS_COM_GPS_RX_BUF_LEN, -1, &pios_usart_com_driver, &pios_com_gps_id);
break;
case HWFREEDOM_FLEXIPORT_DSM2:
case HWFREEDOM_FLEXIPORT_DSMX10BIT:
case HWFREEDOM_FLEXIPORT_DSMX11BIT:
{
enum pios_dsm_proto proto;
switch (hw_flexiport) {
case HWFREEDOM_FLEXIPORT_DSM2:
proto = PIOS_DSM_PROTO_DSM2;
break;
case HWFREEDOM_FLEXIPORT_DSMX10BIT:
proto = PIOS_DSM_PROTO_DSMX10BIT;
break;
case HWFREEDOM_FLEXIPORT_DSMX11BIT:
proto = PIOS_DSM_PROTO_DSMX11BIT;
break;
default:
PIOS_Assert(0);
break;
}
//TODO: Define the various Channelgroup for Revo dsm inputs and handle here
PIOS_Board_configure_dsm(&pios_usart_dsm_flexi_cfg, &pios_dsm_flexi_cfg,
&pios_usart_com_driver, &proto, MANUALCONTROLSETTINGS_CHANNELGROUPS_DSMFLEXIPORT,&hw_DSMxBind);
}
break;
case HWFREEDOM_FLEXIPORT_I2C:
#if defined(PIOS_INCLUDE_I2C)
{
if (PIOS_I2C_Init(&pios_i2c_flexiport_adapter_id, &pios_i2c_flexiport_adapter_cfg)) {
PIOS_Assert(0);
}
}
#endif /* PIOS_INCLUDE_I2C */
case HWFREEDOM_FLEXIPORT_DEBUGCONSOLE:
#if defined(PIOS_INCLUDE_DEBUG_CONSOLE)
{
PIOS_Board_configure_com(&pios_usart_flexi_cfg, 0, PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN, &pios_usart_com_driver, &pios_com_aux_id);
}
#endif /* PIOS_INCLUDE_DEBUG_CONSOLE */
break;
case HWFREEDOM_FLEXIPORT_COMBRIDGE:
PIOS_Board_configure_com(&pios_usart_flexi_cfg, PIOS_COM_BRIDGE_RX_BUF_LEN, PIOS_COM_BRIDGE_TX_BUF_LEN, &pios_usart_com_driver, &pios_com_bridge_id);
break;
} /* hw_freedom_flexiport */
/* Initalize the RFM22B radio COM device. */
#if defined(PIOS_INCLUDE_RFM22B)
uint8_t hwsettings_radioport;
HwFreedomRadioPortGet(&hwsettings_radioport);
switch (hwsettings_radioport) {
case HWFREEDOM_RADIOPORT_DISABLED:
break;
case HWFREEDOM_RADIOPORT_TELEMETRY:
{
const struct pios_board_info * bdinfo = &pios_board_info_blob;
const struct pios_rfm22b_cfg *pios_rfm22b_cfg = PIOS_BOARD_HW_DEFS_GetRfm22Cfg(bdinfo->board_rev);
if (PIOS_RFM22B_Init(&pios_rfm22b_id, PIOS_RFM22_SPI_PORT, pios_rfm22b_cfg->slave_num, pios_rfm22b_cfg)) {
PIOS_Assert(0);
}
uint8_t *rx_buffer = (uint8_t *) pvPortMalloc(PIOS_COM_RFM22B_RF_RX_BUF_LEN);
uint8_t *tx_buffer = (uint8_t *) pvPortMalloc(PIOS_COM_RFM22B_RF_TX_BUF_LEN);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_telem_rf_id, &pios_rfm22b_com_driver, pios_rfm22b_id,
rx_buffer, PIOS_COM_RFM22B_RF_RX_BUF_LEN,
tx_buffer, PIOS_COM_RFM22B_RF_TX_BUF_LEN)) {
PIOS_Assert(0);
}
break;
}
}
#endif /* PIOS_INCLUDE_RFM22B */
/* Configure input receiver USART port */
uint8_t hw_rcvrport;
HwFreedomRcvrPortGet(&hw_rcvrport);
switch (hw_rcvrport) {
case HWFREEDOM_RCVRPORT_DISABLED:
break;
case HWFREEDOM_RCVRPORT_PPM:
{
uint32_t pios_ppm_id;
PIOS_PPM_Init(&pios_ppm_id, &pios_ppm_cfg);
uint32_t pios_ppm_rcvr_id;
if (PIOS_RCVR_Init(&pios_ppm_rcvr_id, &pios_ppm_rcvr_driver, pios_ppm_id)) {
PIOS_Assert(0);
}
pios_rcvr_group_map[MANUALCONTROLSETTINGS_CHANNELGROUPS_PPM] = pios_ppm_rcvr_id;
}
break;
case HWFREEDOM_RCVRPORT_DSM2:
case HWFREEDOM_RCVRPORT_DSMX10BIT:
case HWFREEDOM_RCVRPORT_DSMX11BIT:
{
enum pios_dsm_proto proto;
switch (hw_rcvrport) {
case HWFREEDOM_RCVRPORT_DSM2:
proto = PIOS_DSM_PROTO_DSM2;
break;
case HWFREEDOM_RCVRPORT_DSMX10BIT:
proto = PIOS_DSM_PROTO_DSMX10BIT;
break;
case HWFREEDOM_RCVRPORT_DSMX11BIT:
proto = PIOS_DSM_PROTO_DSMX11BIT;
break;
default:
PIOS_Assert(0);
break;
}
//TODO: Define the various Channelgroup for Revo dsm inputs and handle here
PIOS_Board_configure_dsm(&pios_usart_dsm_rcvr_cfg, &pios_dsm_rcvr_cfg,
&pios_usart_com_driver, &proto, MANUALCONTROLSETTINGS_CHANNELGROUPS_DSMFLEXIPORT,&hw_DSMxBind);
}
break;
case HWFREEDOM_RCVRPORT_SBUS:
#if defined(PIOS_INCLUDE_SBUS)
{
uint32_t pios_usart_sbus_id;
if (PIOS_USART_Init(&pios_usart_sbus_id, &pios_usart_sbus_rcvr_cfg)) {
PIOS_Assert(0);
}
uint32_t pios_sbus_id;
if (PIOS_SBus_Init(&pios_sbus_id, &pios_sbus_cfg, &pios_usart_com_driver, pios_usart_sbus_id)) {
PIOS_Assert(0);
}
uint32_t pios_sbus_rcvr_id;
if (PIOS_RCVR_Init(&pios_sbus_rcvr_id, &pios_sbus_rcvr_driver, pios_sbus_id)) {
PIOS_Assert(0);
}
pios_rcvr_group_map[MANUALCONTROLSETTINGS_CHANNELGROUPS_SBUS] = pios_sbus_rcvr_id;
}
#endif
break;
}
if (hw_rcvrport != HWFREEDOM_RCVRPORT_SBUS) {
GPIO_Init(pios_sbus_cfg.inv.gpio, (GPIO_InitTypeDef*)&pios_sbus_cfg.inv.init);
GPIO_WriteBit(pios_sbus_cfg.inv.gpio, pios_sbus_cfg.inv.init.GPIO_Pin, pios_sbus_cfg.gpio_inv_disable);
}
#if defined(PIOS_OVERO_SPI)
/* Set up the SPI based PIOS_COM interface to the overo */
{
bool overo_enabled = false;
#ifdef MODULE_OveroSync_BUILTIN
overo_enabled = true;
#else
uint8_t module_state[MODULESETTINGS_ADMINSTATE_NUMELEM];
ModuleSettingsAdminStateGet(module_state);
if (module_state[MODULESETTINGS_ADMINSTATE_OVEROSYNC] == MODULESETTINGS_ADMINSTATE_ENABLED) {
overo_enabled = true;
} else {
overo_enabled = false;
}
#endif
if (overo_enabled) {
if (PIOS_OVERO_Init(&pios_overo_id, &pios_overo_cfg)) {
PIOS_DEBUG_Assert(0);
}
const uint32_t PACKET_SIZE = 1024;
uint8_t * rx_buffer = (uint8_t *) pvPortMalloc(PACKET_SIZE);
uint8_t * tx_buffer = (uint8_t *) pvPortMalloc(PACKET_SIZE);
PIOS_Assert(rx_buffer);
PIOS_Assert(tx_buffer);
if (PIOS_COM_Init(&pios_com_overo_id, &pios_overo_com_driver, pios_overo_id,
rx_buffer, PACKET_SIZE,
tx_buffer, PACKET_SIZE)) {
PIOS_Assert(0);
}
}
}
#endif
#if defined(PIOS_INCLUDE_GCSRCVR)
GCSReceiverInitialize();
uint32_t pios_gcsrcvr_id;
PIOS_GCSRCVR_Init(&pios_gcsrcvr_id);
uint32_t pios_gcsrcvr_rcvr_id;
if (PIOS_RCVR_Init(&pios_gcsrcvr_rcvr_id, &pios_gcsrcvr_rcvr_driver, pios_gcsrcvr_id)) {
PIOS_Assert(0);
}
pios_rcvr_group_map[MANUALCONTROLSETTINGS_CHANNELGROUPS_GCS] = pios_gcsrcvr_rcvr_id;
#endif /* PIOS_INCLUDE_GCSRCVR */
#ifndef PIOS_DEBUG_ENABLE_DEBUG_PINS
uint8_t hw_output_port;
HwFreedomOutputGet(&hw_output_port);
switch (hw_output_port) {
case HWFREEDOM_OUTPUT_DISABLED:
break;
case HWFREEDOM_OUTPUT_PWM:
/* Set up the servo outputs */
PIOS_Servo_Init(&pios_servo_cfg);
break;
default:
break;
}
#else
PIOS_DEBUG_Init(&pios_tim_servo_all_channels, NELEMENTS(pios_tim_servo_all_channels));
#endif
PIOS_DELAY_WaitmS(200);
PIOS_SENSORS_Init();
#if defined(PIOS_INCLUDE_MPU6000)
if (PIOS_MPU6000_Init(pios_spi_gyro_id,0, &pios_mpu6000_cfg) != 0)
panic(2);
if (PIOS_MPU6000_Test() != 0)
panic(2);
// To be safe map from UAVO enum to driver enum
uint8_t hw_gyro_range;
HwFreedomGyroRangeGet(&hw_gyro_range);
switch(hw_gyro_range) {
case HWFREEDOM_GYRORANGE_250:
PIOS_MPU6000_SetGyroRange(PIOS_MPU60X0_SCALE_250_DEG);
break;
case HWFREEDOM_GYRORANGE_500:
PIOS_MPU6000_SetGyroRange(PIOS_MPU60X0_SCALE_500_DEG);
break;
case HWFREEDOM_GYRORANGE_1000:
PIOS_MPU6000_SetGyroRange(PIOS_MPU60X0_SCALE_1000_DEG);
break;
case HWFREEDOM_GYRORANGE_2000:
PIOS_MPU6000_SetGyroRange(PIOS_MPU60X0_SCALE_2000_DEG);
break;
}
uint8_t hw_accel_range;
HwFreedomAccelRangeGet(&hw_accel_range);
switch(hw_accel_range) {
case HWFREEDOM_ACCELRANGE_2G:
PIOS_MPU6000_SetAccelRange(PIOS_MPU60X0_ACCEL_2G);
break;
case HWFREEDOM_ACCELRANGE_4G:
PIOS_MPU6000_SetAccelRange(PIOS_MPU60X0_ACCEL_4G);
break;
case HWFREEDOM_ACCELRANGE_8G:
PIOS_MPU6000_SetAccelRange(PIOS_MPU60X0_ACCEL_8G);
break;
case HWFREEDOM_ACCELRANGE_16G:
PIOS_MPU6000_SetAccelRange(PIOS_MPU60X0_ACCEL_16G);
break;
}
uint8_t hw_mpu6000_rate;
HwFreedomMPU6000RateGet(&hw_mpu6000_rate);
uint16_t hw_mpu6000_divisor = \
(hw_mpu6000_rate == HWFREEDOM_MPU6000RATE_500) ? 15 : \
(hw_mpu6000_rate == HWFREEDOM_MPU6000RATE_666) ? 11 : \
(hw_mpu6000_rate == HWFREEDOM_MPU6000RATE_1000) ? 7 : \
(hw_mpu6000_rate == HWFREEDOM_MPU6000RATE_2000) ? 3 : \
(hw_mpu6000_rate == HWFREEDOM_MPU6000RATE_4000) ? 1 : \
(hw_mpu6000_rate == HWFREEDOM_MPU6000RATE_8000) ? 0 : \
15;
PIOS_MPU6000_SetDivisor(hw_mpu6000_divisor);
uint8_t hw_dlpf;
HwFreedomMPU6000DLPFGet(&hw_dlpf);
uint16_t hw_mpu6000_dlpf = \
(hw_dlpf == HWFREEDOM_MPU6000DLPF_256) ? PIOS_MPU60X0_LOWPASS_256_HZ : \
(hw_dlpf == HWFREEDOM_MPU6000DLPF_188) ? PIOS_MPU60X0_LOWPASS_188_HZ : \
(hw_dlpf == HWFREEDOM_MPU6000DLPF_98) ? PIOS_MPU60X0_LOWPASS_98_HZ : \
(hw_dlpf == HWFREEDOM_MPU6000DLPF_42) ? PIOS_MPU60X0_LOWPASS_42_HZ : \
(hw_dlpf == HWFREEDOM_MPU6000DLPF_20) ? PIOS_MPU60X0_LOWPASS_20_HZ : \
(hw_dlpf == HWFREEDOM_MPU6000DLPF_10) ? PIOS_MPU60X0_LOWPASS_10_HZ : \
(hw_dlpf == HWFREEDOM_MPU6000DLPF_5) ? PIOS_MPU60X0_LOWPASS_5_HZ : \
PIOS_MPU60X0_LOWPASS_256_HZ;
PIOS_MPU6000_SetLPF(hw_mpu6000_dlpf);
#endif
if (PIOS_I2C_Init(&pios_i2c_mag_pressure_adapter_id, &pios_i2c_mag_pressure_adapter_cfg)) {
PIOS_DEBUG_Assert(0);
}
if (PIOS_I2C_CheckClear(pios_i2c_mag_pressure_adapter_id) != 0)
panic(5);
PIOS_DELAY_WaitmS(50);
#if defined(PIOS_INCLUDE_ADC)
PIOS_ADC_Init(&pios_adc_cfg);
#endif
PIOS_LED_On(0);
#if defined(PIOS_INCLUDE_HMC5883)
if (PIOS_HMC5883_Init(pios_i2c_mag_pressure_adapter_id, &pios_hmc5883_cfg) != 0)
panic(3);
#endif
PIOS_LED_On(1);
#if defined(PIOS_INCLUDE_MS5611)
if (PIOS_MS5611_Init(&pios_ms5611_cfg, pios_i2c_mag_pressure_adapter_id) != 0)
panic(4);
#endif
PIOS_LED_On(2);
}
/**
* カレント パス設定
* @param[in] lpPathName カレント ファイル名
*/
void DOSIOCALL file_setcd(const OEMCHAR* lpPathName)
{
file_cpyname(curpath, lpPathName, NELEMENTS(curpath));
curfilep = file_getname(curpath);
*curfilep = '\0';
}
int statsave_load(const OEMCHAR *filename) {
SFFILEH sffh;
int ret;
BOOL done;
const SFENTRY *tbl;
const SFENTRY *tblterm;
sffh = statflag_open(filename, NULL, 0);
if (sffh == NULL) {
return(STATFLAG_FAILURE);
}
// PCCORE read!
ret = statflag_readsection(sffh);
if ((ret != STATFLAG_SUCCESS) ||
(memcmp(sffh->sfh.hdr.index, np2tbl[0].index, sizeof(sffh->sfh.hdr.index)))) {
statflag_close(sffh);
return(STATFLAG_FAILURE);
}
soundmng_stop();
rs232c_midipanic();
mpu98ii_midipanic();
pc9861k_midipanic();
sxsi_alltrash();
ret |= flagload_common(&sffh->sfh, np2tbl);
CPU_RESET();
CPU_SETEXTSIZE((UINT32)pccore.extmem);
nevent_allreset();
sound_changeclock();
beep_changeclock();
sound_reset();
fddmtrsnd_bind();
iocore_reset(&np2cfg); // サウンドでpicを呼ぶので…
cbuscore_reset(&np2cfg);
fmboard_reset(&np2cfg, pccore.sound);
done = FALSE;
while((!done) && (ret != STATFLAG_FAILURE)) {
ret |= statflag_readsection(sffh);
tbl = np2tbl + 1;
tblterm = np2tbl + NELEMENTS(np2tbl);
while(tbl < tblterm) {
if (!memcmp(sffh->sfh.hdr.index, tbl->index, sizeof(sffh->sfh.hdr.index))) {
break;
}
tbl++;
}
if (tbl < tblterm) {
switch(tbl->type) {
case STATFLAG_BIN:
ret |= flagload_common(&sffh->sfh, tbl);
break;
case STATFLAG_TERM:
done = TRUE;
break;
case STATFLAG_COM:
ret |= flagload_com(&sffh->sfh, tbl);
break;
case STATFLAG_DMA:
ret |= flagload_dma(&sffh->sfh, tbl);
break;
case STATFLAG_EGC:
ret |= flagload_egc(&sffh->sfh, tbl);
break;
case STATFLAG_EPSON:
ret |= flagload_epson(&sffh->sfh, tbl);
break;
case STATFLAG_EVT:
ret |= flagload_evt(&sffh->sfh, tbl);
break;
case STATFLAG_EXT:
ret |= flagload_ext(&sffh->sfh, tbl);
break;
case STATFLAG_FDD:
ret |= flagload_fdd(&sffh->sfh, tbl);
break;
#if !defined(DISABLE_SOUND)
case STATFLAG_FM:
ret |= flagload_fm(&sffh->sfh, tbl);
break;
#endif
case STATFLAG_GIJ:
ret |= flagload_gij(&sffh->sfh, tbl);
break;
#if defined(SUPPORT_HOSTDRV)
case STATFLAG_HDRV:
ret |= hostdrv_sfload(&sffh->sfh, tbl);
break;
#endif
case STATFLAG_MEM:
ret |= flagload_mem(&sffh->sfh, tbl);
break;
case STATFLAG_SXSI:
ret |= flagload_sxsi(&sffh->sfh, tbl);
break;
default:
ret |= STATFLAG_WARNING;
break;
}
}
else {
ret |= STATFLAG_WARNING;
}
}
statflag_close(sffh);
// I/O作り直し
MEMM_ARCH((pccore.model & PCMODEL_EPSON)?1:0);
iocore_build();
iocore_bind();
cbuscore_bind();
fmboard_bind();
gdcs.textdisp |= GDCSCRN_EXT;
gdcs.textdisp |= GDCSCRN_ALLDRAW2;
gdcs.grphdisp |= GDCSCRN_EXT;
gdcs.grphdisp |= GDCSCRN_ALLDRAW2;
gdcs.palchange = GDCSCRN_REDRAW;
tramflag.renewal = 1;
cgwindow.writable |= 0x80;
#if defined(CPUSTRUC_FONTPTR)
FONTPTR_LOW = fontrom + cgwindow.low;
FONTPTR_HIGH = fontrom + cgwindow.high;
#endif
MEMM_VRAM(vramop.operate);
fddmtr_reset();
soundmng_play();
return(ret);
}
int statsave_save(const OEMCHAR *filename) {
SFFILEH sffh;
int ret;
const SFENTRY *tbl;
const SFENTRY *tblterm;
sffh = statflag_create(filename);
if (sffh == NULL) {
return(STATFLAG_FAILURE);
}
ret = STATFLAG_SUCCESS;
tbl = np2tbl;
tblterm = tbl + NELEMENTS(np2tbl);
while(tbl < tblterm) {
ret |= statflag_createsection(sffh, tbl);
switch(tbl->type) {
case STATFLAG_BIN:
case STATFLAG_TERM:
ret |= flagsave_common(&sffh->sfh, tbl);
break;
case STATFLAG_COM:
ret |= flagsave_com(&sffh->sfh, tbl);
break;
case STATFLAG_DMA:
ret |= flagsave_dma(&sffh->sfh, tbl);
break;
case STATFLAG_EGC:
ret |= flagsave_egc(&sffh->sfh, tbl);
break;
case STATFLAG_EPSON:
ret |= flagsave_epson(&sffh->sfh, tbl);
break;
case STATFLAG_EVT:
ret |= flagsave_evt(&sffh->sfh, tbl);
break;
case STATFLAG_EXT:
ret |= flagsave_ext(&sffh->sfh, tbl);
break;
case STATFLAG_FDD:
ret |= flagsave_fdd(&sffh->sfh, tbl);
break;
#if !defined(DISABLE_SOUND)
case STATFLAG_FM:
ret |= flagsave_fm(&sffh->sfh, tbl);
break;
#endif
case STATFLAG_GIJ:
ret |= flagsave_gij(&sffh->sfh, tbl);
break;
#if defined(SUPPORT_HOSTDRV)
case STATFLAG_HDRV:
ret |= hostdrv_sfsave(&sffh->sfh, tbl);
break;
#endif
case STATFLAG_MEM:
ret |= flagsave_mem(&sffh->sfh, tbl);
break;
case STATFLAG_SXSI:
ret |= flagsave_sxsi(&sffh->sfh, tbl);
break;
}
tbl++;
}
statflag_close(sffh);
return(ret);
}
char* get_move_name(uint8 move_id)
{
return get_name_from_id(move_id, moves, NELEMENTS(moves));
}
uint8 get_turn_id(char* turn_name)
{
return get_id_from_name(turn_name, turns, NELEMENTS(turns));
}
char* get_turn_name(uint8 turn_id)
{
return get_name_from_id(turn_id, turns, NELEMENTS(turns));
}
static vpx_codec_err_t vp8_decode(vpx_codec_alg_priv_t *ctx,
const uint8_t *data,
unsigned int data_sz,
void *user_priv,
long deadline)
{
vpx_codec_err_t res = VPX_CODEC_OK;
unsigned int resolution_change = 0;
unsigned int w, h;
/* Determine the stream parameters. Note that we rely on peek_si to
* validate that we have a buffer that does not wrap around the top
* of the heap.
*/
w = ctx->si.w;
h = ctx->si.h;
res = ctx->base.iface->dec.peek_si(data, data_sz, &ctx->si);
if((res == VPX_CODEC_UNSUP_BITSTREAM) && !ctx->si.is_kf)
{
/* the peek function returns an error for non keyframes, however for
* this case, it is not an error */
res = VPX_CODEC_OK;
}
if(!ctx->decoder_init && !ctx->si.is_kf)
res = VPX_CODEC_UNSUP_BITSTREAM;
if ((ctx->si.h != h) || (ctx->si.w != w))
resolution_change = 1;
/* Perform deferred allocations, if required */
if (!res && ctx->defer_alloc)
{
int i;
for (i = 1; !res && i < NELEMENTS(ctx->mmaps); i++)
{
vpx_codec_dec_cfg_t cfg;
cfg.w = ctx->si.w;
cfg.h = ctx->si.h;
ctx->mmaps[i].id = vp8_mem_req_segs[i].id;
ctx->mmaps[i].sz = vp8_mem_req_segs[i].sz;
ctx->mmaps[i].align = vp8_mem_req_segs[i].align;
ctx->mmaps[i].flags = vp8_mem_req_segs[i].flags;
if (!ctx->mmaps[i].sz)
ctx->mmaps[i].sz = vp8_mem_req_segs[i].calc_sz(&cfg,
ctx->base.init_flags);
res = vp8_mmap_alloc(&ctx->mmaps[i]);
}
if (!res)
vp8_finalize_mmaps(ctx);
ctx->defer_alloc = 0;
}
/* Initialize the decoder instance on the first frame*/
if (!res && !ctx->decoder_init)
{
res = vp8_validate_mmaps(&ctx->si, ctx->mmaps, ctx->base.init_flags);
if (!res)
{
VP8D_CONFIG oxcf;
struct VP8D_COMP* optr;
oxcf.Width = ctx->si.w;
oxcf.Height = ctx->si.h;
oxcf.Version = 9;
oxcf.postprocess = 0;
oxcf.max_threads = ctx->cfg.threads;
oxcf.error_concealment =
(ctx->base.init_flags & VPX_CODEC_USE_ERROR_CONCEALMENT);
oxcf.input_fragments =
(ctx->base.init_flags & VPX_CODEC_USE_INPUT_FRAGMENTS);
optr = vp8dx_create_decompressor(&oxcf);
/* If postprocessing was enabled by the application and a
* configuration has not been provided, default it.
*/
if (!ctx->postproc_cfg_set
&& (ctx->base.init_flags & VPX_CODEC_USE_POSTPROC))
{
ctx->postproc_cfg.post_proc_flag =
VP8_DEBLOCK | VP8_DEMACROBLOCK | VP8_MFQE;
ctx->postproc_cfg.deblocking_level = 4;
ctx->postproc_cfg.noise_level = 0;
}
if (!optr)
res = VPX_CODEC_ERROR;
else
ctx->pbi = optr;
}
ctx->decoder_init = 1;
}
if (!res && ctx->pbi)
{
if(resolution_change)
{
VP8D_COMP *pbi = ctx->pbi;
VP8_COMMON *const pc = & pbi->common;
MACROBLOCKD *const xd = & pbi->mb;
#if CONFIG_MULTITHREAD
int i;
#endif
pc->Width = ctx->si.w;
pc->Height = ctx->si.h;
{
int prev_mb_rows = pc->mb_rows;
if (setjmp(pbi->common.error.jmp))
{
pbi->common.error.setjmp = 0;
/* same return value as used in vp8dx_receive_compressed_data */
return -1;
}
pbi->common.error.setjmp = 1;
if (pc->Width <= 0)
{
pc->Width = w;
vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
"Invalid frame width");
}
if (pc->Height <= 0)
{
pc->Height = h;
vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
"Invalid frame height");
}
if (vp8_alloc_frame_buffers(pc, pc->Width, pc->Height))
vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
"Failed to allocate frame buffers");
xd->pre = pc->yv12_fb[pc->lst_fb_idx];
xd->dst = pc->yv12_fb[pc->new_fb_idx];
#if CONFIG_MULTITHREAD
for (i = 0; i < pbi->allocated_decoding_thread_count; i++)
{
pbi->mb_row_di[i].mbd.dst = pc->yv12_fb[pc->new_fb_idx];
vp8_build_block_doffsets(&pbi->mb_row_di[i].mbd);
}
#endif
vp8_build_block_doffsets(&pbi->mb);
/* allocate memory for last frame MODE_INFO array */
#if CONFIG_ERROR_CONCEALMENT
if (pbi->ec_enabled)
{
/* old prev_mip was released by vp8_de_alloc_frame_buffers()
* called in vp8_alloc_frame_buffers() */
pc->prev_mip = vpx_calloc(
(pc->mb_cols + 1) * (pc->mb_rows + 1),
sizeof(MODE_INFO));
if (!pc->prev_mip)
{
vp8_de_alloc_frame_buffers(pc);
vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
"Failed to allocate"
"last frame MODE_INFO array");
}
pc->prev_mi = pc->prev_mip + pc->mode_info_stride + 1;
if (vp8_alloc_overlap_lists(pbi))
vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
"Failed to allocate overlap lists "
"for error concealment");
}
#endif
#if CONFIG_MULTITHREAD
if (pbi->b_multithreaded_rd)
vp8mt_alloc_temp_buffers(pbi, pc->Width, prev_mb_rows);
#else
(void)prev_mb_rows;
#endif
}
pbi->common.error.setjmp = 0;
/* required to get past the first get_free_fb() call */
ctx->pbi->common.fb_idx_ref_cnt[0] = 0;
}
ctx->user_priv = user_priv;
if (vp8dx_receive_compressed_data(ctx->pbi, data_sz, data, deadline))
{
VP8D_COMP *pbi = (VP8D_COMP *)ctx->pbi;
res = update_error_state(ctx, &pbi->common.error);
}
}
return res;
}
/**
* @brief This function fill the txpd for tx packet
*
* @param priv A pointer to mlan_private structure
* @param pmbuf A pointer to the mlan_buffer for process
*
* @return headptr or MNULL
*/
t_void *
wlan_ops_uap_process_txpd(IN t_void *priv, IN pmlan_buffer pmbuf)
{
pmlan_private pmpriv = (pmlan_private)priv;
UapTxPD *plocal_tx_pd;
t_u8 *head_ptr = MNULL;
t_u32 pkt_type;
t_u32 tx_control;
ENTER();
if (!pmbuf->data_len) {
PRINTM(MERROR, "uAP Tx Error: Invalid packet length: %d\n",
pmbuf->data_len);
pmbuf->status_code = MLAN_ERROR_PKT_SIZE_INVALID;
goto done;
}
if (pmbuf->buf_type == MLAN_BUF_TYPE_RAW_DATA) {
memcpy(pmpriv->adapter, &pkt_type,
pmbuf->pbuf + pmbuf->data_offset, sizeof(pkt_type));
memcpy(pmpriv->adapter, &tx_control,
pmbuf->pbuf + pmbuf->data_offset + sizeof(pkt_type),
sizeof(tx_control));
pmbuf->data_offset += sizeof(pkt_type) + sizeof(tx_control);
pmbuf->data_len -= sizeof(pkt_type) + sizeof(tx_control);
}
if (pmbuf->data_offset < (sizeof(UapTxPD) + INTF_HEADER_LEN +
DMA_ALIGNMENT)) {
PRINTM(MERROR,
"not enough space for UapTxPD: headroom=%d pkt_len=%d, required=%d\n",
pmbuf->data_offset, pmbuf->data_len,
sizeof(UapTxPD) + INTF_HEADER_LEN + DMA_ALIGNMENT);
DBG_HEXDUMP(MDAT_D, "drop pkt",
pmbuf->pbuf + pmbuf->data_offset, pmbuf->data_len);
pmbuf->status_code = MLAN_ERROR_PKT_SIZE_INVALID;
goto done;
}
/* head_ptr should be aligned */
head_ptr =
pmbuf->pbuf + pmbuf->data_offset - sizeof(UapTxPD) -
INTF_HEADER_LEN;
head_ptr = (t_u8 *)((t_ptr)head_ptr & ~((t_ptr)(DMA_ALIGNMENT - 1)));
plocal_tx_pd = (UapTxPD *)(head_ptr + INTF_HEADER_LEN);
memset(pmpriv->adapter, plocal_tx_pd, 0, sizeof(UapTxPD));
/* Set the BSS number to TxPD */
plocal_tx_pd->bss_num = GET_BSS_NUM(pmpriv);
plocal_tx_pd->bss_type = pmpriv->bss_type;
plocal_tx_pd->tx_pkt_length = (t_u16)pmbuf->data_len;
plocal_tx_pd->priority = (t_u8)pmbuf->priority;
plocal_tx_pd->pkt_delay_2ms =
wlan_wmm_compute_driver_packet_delay(pmpriv, pmbuf);
if (plocal_tx_pd->priority <
NELEMENTS(pmpriv->wmm.user_pri_pkt_tx_ctrl))
/*
* Set the priority specific tx_control field, setting of 0 will
* cause the default value to be used later in this function
*/
plocal_tx_pd->tx_control
=
pmpriv->wmm.user_pri_pkt_tx_ctrl[plocal_tx_pd->
priority];
if (pmbuf->flags & MLAN_BUF_FLAG_TX_STATUS) {
plocal_tx_pd->tx_token_id = (t_u8)pmbuf->tx_seq_num;
plocal_tx_pd->flags |= MRVDRV_TxPD_FLAGS_TX_PACKET_STATUS;
}
/* Offset of actual data */
plocal_tx_pd->tx_pkt_offset =
(t_u16)((t_ptr)pmbuf->pbuf + pmbuf->data_offset -
(t_ptr)plocal_tx_pd);
if (!plocal_tx_pd->tx_control) {
/* TxCtrl set by user or default */
plocal_tx_pd->tx_control = pmpriv->pkt_tx_ctrl;
}
if (pmbuf->buf_type == MLAN_BUF_TYPE_RAW_DATA) {
plocal_tx_pd->tx_pkt_type = (t_u16)pkt_type;
plocal_tx_pd->tx_control = tx_control;
}
uap_endian_convert_TxPD(plocal_tx_pd);
/* Adjust the data offset and length to include TxPD in pmbuf */
pmbuf->data_len += pmbuf->data_offset;
pmbuf->data_offset = (t_u32)((t_ptr)head_ptr - (t_ptr)pmbuf->pbuf);
pmbuf->data_len -= pmbuf->data_offset;
done:
LEAVE();
return head_ptr;
}
uint8 get_move_id(char* move_name)
{
return get_id_from_name(move_name, moves, NELEMENTS(moves));
}
int statsave_check(const OEMCHAR *filename, OEMCHAR *buf, int size) {
SFFILEH sffh;
int ret;
BOOL done;
const SFENTRY *tbl;
const SFENTRY *tblterm;
sffh = statflag_open(filename, buf, size);
if (sffh == NULL) {
return(STATFLAG_FAILURE);
}
done = FALSE;
ret = STATFLAG_SUCCESS;
while((!done) && (ret != STATFLAG_FAILURE)) {
ret |= statflag_readsection(sffh);
tbl = np2tbl;
tblterm = tbl + NELEMENTS(np2tbl);
while(tbl < tblterm) {
if (!memcmp(sffh->sfh.hdr.index, tbl->index, sizeof(sffh->sfh.hdr.index))) {
break;
}
tbl++;
}
if (tbl < tblterm) {
switch(tbl->type) {
case STATFLAG_BIN:
case STATFLAG_MEM:
ret |= flagcheck_versize(&sffh->sfh, tbl);
break;
case STATFLAG_TERM:
done = TRUE;
break;
case STATFLAG_COM:
case STATFLAG_DMA:
case STATFLAG_EGC:
case STATFLAG_EPSON:
case STATFLAG_EVT:
case STATFLAG_EXT:
case STATFLAG_GIJ:
#if !defined(DISABLE_SOUND)
case STATFLAG_FM:
#endif
#if defined(SUPPORT_HOSTDRV)
case STATFLAG_HDRV:
#endif
ret |= flagcheck_veronly(&sffh->sfh, tbl);
break;
case STATFLAG_FDD:
ret |= flagcheck_fdd(&sffh->sfh, tbl);
break;
case STATFLAG_SXSI:
ret |= flagcheck_sxsi(&sffh->sfh, tbl);
break;
default:
ret |= STATFLAG_WARNING;
break;
}
}
else {
ret |= STATFLAG_WARNING;
}
}
statflag_close(sffh);
return(ret);
}
char* get_state_name(uint8 state_id)
{
return get_name_from_id(state_id, states, NELEMENTS(states));
}
static void viewasm_paint(NP2VIEW_T *view, RECT *rc, HDC hdc) {
LONG x, y, i;
UINT32 seg4;
UINT16 off, prevoff;
UINT32 pos;
UINT8 *p;
UINT8 buf[16];
TCHAR str[16];
_UNASM una;
int step;
#if defined(UNICODE)
TCHAR cnv[64];
#endif
COLORREF bkcol;
if (view->lock) {
if ((view->buf1.type != ALLOCTYPE_SEG) ||
(view->buf1.arg != view->seg)) {
if (viewcmn_alloc(&view->buf1, view->memsize)) {
view->lock = FALSE;
viewmenu_lock(view);
}
else {
view->buf1.type = ALLOCTYPE_SEG;
view->buf1.arg = view->seg;
viewmem_read(&view->dmem, seg_to_real(view->buf1.arg), (BYTE *)view->buf1.ptr, view->memsize);
view->buf2.type = ALLOCTYPE_NONE;
}
viewcmn_putcaption(view);
}
}
seg4 = seg_to_real(view->seg);
pos = view->pos;
if ((view->buf2.type != ALLOCTYPE_ASM) ||
(view->buf2.arg != (seg4 + view->off))) {
if (viewcmn_alloc(&view->buf2, view->maxline*2)) {
pos = 0;
}
else {
DWORD i;
UINT16 *r;
r = (UINT16 *)view->buf2.ptr;
view->buf2.type = ALLOCTYPE_ASM;
view->buf2.arg = seg4 + view->off;
off = view->off;
for (i=0; i<(view->maxline - 1); i++) {
*r++ = off;
step = viewasm_unasm_next(NULL, buf, view, off);
off += (UINT16)step;
}
*r = off;
}
}
prevoff = off = viewasm_line_to_off(view, view->pos);
for (y=0; y<rc->bottom; y+=viewcfg.font_height) {
x = 0;
// Emphasize wrapping
if(prevoff > off) {
viewpaint_line_fill(rc, hdc, y, 2, viewcfg.color_hilite);
}
bkcol = viewpaint_line_set_colors(view, rc, hdc, y, off, CPU_CS, CPU_IP);
viewpaint_print_addr(hdc, x, y, view->seg, off, TRUE);
SetBkColor(hdc, bkcol);
step = viewasm_unasm_next(&una, buf, view, off);
p = buf;
if (!step) {
break;
}
x += 11 * np2viewfontwidth;
for(i = 0; i < step; i++) {
wsprintf(str + (i*2), _T("%02x"), *p);
p++;
}
TextOut(hdc, x, y, str, i * 2);
x += 15 * np2viewfontwidth;
#if defined(UNICODE)
TextOut(hdc, x, y, cnv, MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED, una.mnemonic, -1, cnv, NELEMENTS(cnv)));
#else
TextOut(hdc,x, y, una.mnemonic, lstrlen(una.mnemonic));
#endif
x += 7 * np2viewfontwidth;
if (una.operand[0]) {
#if defined(UNICODE)
TextOut(hdc, x, y, cnv, MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED, una.operand, -1, cnv, NELEMENTS(cnv)));
#else
TextOut(hdc, x, y, una.operand, lstrlen(una.operand));
#endif
}
prevoff = off;
off += (UINT16)step;
}
}
uint8 get_state_id(char* state_name)
{
return get_id_from_name(state_name, states, NELEMENTS(states));
}
/**
* カレント パス取得
* @param[in] lpFilename ファイル名
* @return パス
*/
OEMCHAR* DOSIOCALL file_getcd(const OEMCHAR* lpFilename)
{
file_cpyname(curfilep, lpFilename, NELEMENTS(curpath) - (int)(curfilep - curpath));
return curpath;
}
char* get_command_name(uint8 cmd_id)
{
return get_name_from_id(cmd_id, commands, NELEMENTS(commands));
}
void
create_configure_dialog(void)
{
GtkWidget *config_dialog;
GtkWidget *main_widget;
GtkWidget *cpu_hbox;
GtkWidget *cpu_frame;
GtkWidget *cpuframe_vbox;
GtkWidget *cpuclock_hbox;
GtkWidget *baseclock_combo;
GtkWidget *rate_combo;
GtkWidget *times_label;
GtkWidget *realclock_label;
GtkWidget *confirm_widget;
GtkWidget *ok_button;
GtkWidget *cancel_button;
GtkWidget *arch_frame;
GtkWidget *arch_hbox;
GtkWidget *arch_radiobutton[NELEMENTS(architecture)];
GtkWidget *sound_frame;
GtkWidget *soundframe_vbox;
GtkWidget *soundrate_hbox;
GtkWidget *rate_label;
GtkWidget *rate_radiobutton[NELEMENTS(samplingrate)];
GtkWidget *soundbuffer_hbox;
GtkWidget *buffer_label;
GtkWidget *ms_label;
gchar buf[8];
int i;
uninstall_idle_process();
config_dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(config_dialog), "Configure");
gtk_window_set_position(GTK_WINDOW(config_dialog), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(config_dialog), TRUE);
gtk_window_set_resizable(GTK_WINDOW(config_dialog), FALSE);
gtk_container_set_border_width(GTK_CONTAINER(config_dialog), 5);
g_signal_connect(GTK_OBJECT(config_dialog), "destroy",
G_CALLBACK(dialog_destroy), NULL);
main_widget = gtk_vbox_new(FALSE, 0);
gtk_widget_show(main_widget);
gtk_container_add(GTK_CONTAINER(config_dialog), main_widget);
/* CPU column */
cpu_hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(cpu_hbox);
gtk_box_pack_start(GTK_BOX(main_widget), cpu_hbox, TRUE, TRUE, 0);
/*
* CPU frame
*/
cpu_frame = gtk_frame_new("CPU");
gtk_widget_show(cpu_frame);
gtk_box_pack_start(GTK_BOX(cpu_hbox), cpu_frame, TRUE, TRUE, 0);
cpuframe_vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(cpuframe_vbox), 5);
gtk_widget_show(cpuframe_vbox);
gtk_container_add(GTK_CONTAINER(cpu_frame), cpuframe_vbox);
/* cpu clock */
cpuclock_hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(cpuclock_hbox);
gtk_box_pack_start(GTK_BOX(cpuframe_vbox),cpuclock_hbox, TRUE, TRUE, 2);
baseclock_combo = gtk_combo_box_entry_new_text();
gtk_widget_show(baseclock_combo);
gtk_box_pack_start(GTK_BOX(cpuclock_hbox), baseclock_combo, TRUE, FALSE, 0);
gtk_widget_set_size_request(baseclock_combo, 96, -1);
for (i = 0; i < NELEMENTS(baseclock_str); i++) {
gtk_combo_box_append_text(GTK_COMBO_BOX(baseclock_combo), baseclock_str[i]);
}
baseclock_entry = GTK_BIN(baseclock_combo)->child;
gtk_widget_show(baseclock_entry);
gtk_editable_set_editable(GTK_EDITABLE(baseclock_entry), FALSE);
switch (np2cfg.baseclock) {
default:
np2cfg.baseclock = PCBASECLOCK25;
sysmng_update(SYS_UPDATECFG|SYS_UPDATECLOCK);
/*FALLTHROUGH*/
case PCBASECLOCK25:
gtk_entry_set_text(GTK_ENTRY(baseclock_entry),baseclock_str[1]);
break;
case PCBASECLOCK20:
gtk_entry_set_text(GTK_ENTRY(baseclock_entry),baseclock_str[0]);
break;
}
times_label = gtk_label_new("x");
gtk_widget_show(times_label);
gtk_box_pack_start(GTK_BOX(cpuclock_hbox), times_label, TRUE, FALSE, 0);
gtk_misc_set_padding(GTK_MISC(times_label), 5, 0);
rate_combo = gtk_combo_box_entry_new_text();
gtk_widget_show(rate_combo);
gtk_box_pack_start(GTK_BOX(cpuclock_hbox), rate_combo, TRUE, FALSE, 0);
gtk_widget_set_size_request(rate_combo, 48, -1);
for (i = 0; i < NELEMENTS(clockmult_str); i++) {
gtk_combo_box_append_text(GTK_COMBO_BOX(rate_combo), clockmult_str[i]);
}
clockmult_entry = GTK_BIN(rate_combo)->child;
gtk_widget_show(clockmult_entry);
gtk_editable_set_editable(GTK_EDITABLE(clockmult_entry), FALSE);
switch (np2cfg.multiple) {
case 1: case 2: case 4: case 5: case 6: case 8: case 10: case 12:
case 16: case 20:
g_snprintf(buf, sizeof(buf), "%d", np2cfg.multiple);
gtk_entry_set_text(GTK_ENTRY(clockmult_entry), buf);
break;
default:
gtk_entry_set_text(GTK_ENTRY(clockmult_entry), "4");
break;
}
/* calculated cpu clock */
realclock_label = gtk_label_new("MHz");
gtk_widget_show(realclock_label);
gtk_box_pack_start(GTK_BOX(cpuframe_vbox), realclock_label, FALSE, FALSE, 2);
gtk_misc_set_alignment(GTK_MISC(realclock_label), 1.0, 0.5);
g_signal_connect(GTK_OBJECT(baseclock_entry), "changed",
G_CALLBACK(clock_changed), (gpointer)realclock_label);
g_signal_connect(GTK_OBJECT(clockmult_entry), "changed",
G_CALLBACK(clock_changed), (gpointer)realclock_label);
clock_changed(NULL, realclock_label);
/* OK, Cancel button base widget */
confirm_widget = gtk_vbutton_box_new();
gtk_widget_show(confirm_widget);
gtk_box_pack_start(GTK_BOX(cpu_hbox), confirm_widget, TRUE, TRUE, 0);
gtk_button_box_set_layout(GTK_BUTTON_BOX(confirm_widget), GTK_BUTTONBOX_END);
//gtk_button_box_set_spacing(GTK_BUTTON_BOX(confirm_widget), 0);
/*
* Architecture frame
*/
arch_frame = gtk_frame_new("Architecture");
gtk_widget_show(arch_frame);
gtk_box_pack_start(GTK_BOX(main_widget), arch_frame, TRUE, TRUE, 0);
/* architecture */
arch_hbox = gtk_hbox_new(TRUE, 0);
gtk_widget_show(arch_hbox);
gtk_container_add(GTK_CONTAINER(arch_frame), arch_hbox);
for (i = 0; i < NELEMENTS(architecture); i++) {
arch_radiobutton[i] = gtk_radio_button_new_with_label_from_widget(i > 0 ? GTK_RADIO_BUTTON(arch_radiobutton[i-1]) : NULL, architecture[i].label);
gtk_widget_show(arch_radiobutton[i]);
gtk_box_pack_start(GTK_BOX(arch_hbox), arch_radiobutton[i], FALSE, FALSE, 0);
#if GTK_MAJOR_VERSION > 2 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18)
gtk_widget_set_can_focus(arch_radiobutton[i], FALSE);
#else
GTK_WIDGET_UNSET_FLAGS(rate_radiobutton[i], GTK_CAN_FOCUS);
#endif
g_signal_connect(GTK_OBJECT(arch_radiobutton[i]), "clicked",
G_CALLBACK(arch_radiobutton_clicked), (gpointer)architecture[i].arch);
}
for (i = 0; i < NELEMENTS(architecture); i++) {
if (strcmp(np2cfg.model, architecture[i].arch) == 0) {
break;
}
}
if (i == NELEMENTS(architecture)) {
i = 1;
milstr_ncpy(np2cfg.model, "VX", sizeof(np2cfg.model));
sysmng_update(SYS_UPDATECFG);
}
g_signal_emit_by_name(GTK_OBJECT(arch_radiobutton[i]), "clicked");
/*
* Sound frame
*/
sound_frame = gtk_frame_new("Sound");
gtk_widget_show(sound_frame);
gtk_box_pack_start(GTK_BOX(main_widget), sound_frame, TRUE, TRUE, 0);
soundframe_vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(soundframe_vbox), 5);
gtk_widget_show(soundframe_vbox);
gtk_container_add(GTK_CONTAINER(sound_frame), soundframe_vbox);
/* sampling rate */
soundrate_hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(soundrate_hbox);
gtk_box_pack_start(GTK_BOX(soundframe_vbox), soundrate_hbox, TRUE, TRUE, 2);
rate_label = gtk_label_new("Sampling Rate");
gtk_widget_show(rate_label);
gtk_box_pack_start(GTK_BOX(soundrate_hbox), rate_label, FALSE, TRUE, 3);
gtk_widget_set_size_request(rate_label, 96, -1);
for (i = 0; i < NELEMENTS(samplingrate); i++) {
rate_radiobutton[i] = gtk_radio_button_new_with_label_from_widget((i > 0) ? GTK_RADIO_BUTTON(rate_radiobutton[i-1]) : NULL, samplingrate[i].label);
gtk_widget_show(rate_radiobutton[i]);
gtk_box_pack_start(GTK_BOX(soundrate_hbox), rate_radiobutton[i], FALSE, FALSE, 0);
#if GTK_MAJOR_VERSION > 2 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18)
gtk_widget_set_can_focus(rate_radiobutton[i], FALSE);
#else
GTK_WIDGET_UNSET_FLAGS(rate_radiobutton[i], GTK_CAN_FOCUS);
#endif
g_signal_connect(GTK_OBJECT(rate_radiobutton[i]), "clicked",
G_CALLBACK(rate_radiobutton_clicked), GINT_TO_POINTER(samplingrate[i].rate));
}
if (np2cfg.samplingrate == 11025) {
i = 0;
} else if (np2cfg.samplingrate == 22050) {
i = 1;
} else if (np2cfg.samplingrate == 44100) {
i = 2;
} else {
i = 1;
np2cfg.samplingrate = 22050;
sysmng_update(SYS_UPDATECFG|SYS_UPDATERATE);
}
g_signal_emit_by_name(GTK_OBJECT(rate_radiobutton[i]), "clicked");
soundbuffer_hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(soundbuffer_hbox);
gtk_box_pack_start(GTK_BOX(soundframe_vbox), soundbuffer_hbox, TRUE, TRUE, 2);
/* buffer size */
buffer_label = gtk_label_new("Buffer");
gtk_widget_show(buffer_label);
gtk_box_pack_start(GTK_BOX(soundbuffer_hbox), buffer_label, FALSE, FALSE, 0);
gtk_widget_set_size_request(buffer_label, 96, -1);
buffer_entry = gtk_entry_new();
gtk_widget_show(buffer_entry);
gtk_box_pack_start(GTK_BOX(soundbuffer_hbox), buffer_entry, FALSE, FALSE, 0);
gtk_widget_set_size_request(buffer_entry, 48, -1);
if (np2cfg.delayms >= 20 && np2cfg.delayms <= 1000) {
g_snprintf(buf, sizeof(buf), "%d", np2cfg.delayms);
gtk_entry_set_text(GTK_ENTRY(buffer_entry), buf);
} else {
gtk_entry_set_text(GTK_ENTRY(buffer_entry), "500");
np2cfg.delayms = 500;
sysmng_update(SYS_UPDATECFG|SYS_UPDATESBUF);
soundrenewal = 1;
}
ms_label = gtk_label_new(" ms");
gtk_widget_show(ms_label);
gtk_box_pack_start(GTK_BOX(soundbuffer_hbox),ms_label, FALSE, FALSE, 0);
#if defined(SUPPORT_RESUME)
/* resume */
resume_checkbutton = gtk_check_button_new_with_label("Resume");
gtk_widget_show(resume_checkbutton);
gtk_box_pack_start(GTK_BOX(main_widget), resume_checkbutton, FALSE, FALSE, 1);
if (np2oscfg.resume) {
g_signal_emit_by_name(GTK_OBJECT(resume_checkbutton), "clicked");
}
#endif
#if defined(GCC_CPU_ARCH_IA32)
/* Disable MMX */
disablemmx_checkbutton = gtk_check_button_new_with_label("Disable MMX");
gtk_widget_show(disablemmx_checkbutton);
gtk_box_pack_start(GTK_BOX(main_widget), disablemmx_checkbutton, FALSE, FALSE, 1);
if (mmxflag & MMXFLAG_NOTSUPPORT) {
gtk_widget_set_sensitive(disablemmx_checkbutton, FALSE);
} else if (mmxflag & MMXFLAG_DISABLE) {
g_signal_emit_by_name(GTK_OBJECT(disablemmx_checkbutton), "clicked");
}
#endif
/*
* OK, Cancel button
*/
ok_button = gtk_button_new_from_stock(GTK_STOCK_OK);
gtk_widget_show(ok_button);
gtk_container_add(GTK_CONTAINER(confirm_widget), ok_button);
#if GTK_MAJOR_VERSION > 2 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18)
gtk_widget_set_can_default(ok_button, TRUE);
gtk_widget_has_default(ok_button);
#else
GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT);
GTK_WIDGET_SET_FLAGS(ok_button, GTK_HAS_DEFAULT);
#endif
g_signal_connect(GTK_OBJECT(ok_button), "clicked",
G_CALLBACK(ok_button_clicked), (gpointer)config_dialog);
gtk_widget_grab_default(ok_button);
cancel_button = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
gtk_widget_show(cancel_button);
gtk_container_add(GTK_CONTAINER(confirm_widget), cancel_button);
#if GTK_MAJOR_VERSION > 2 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18)
gtk_widget_set_can_default(cancel_button, TRUE);
#else
GTK_WIDGET_SET_FLAGS(cancel_button, GTK_CAN_DEFAULT);
#endif
g_signal_connect_swapped(GTK_OBJECT(cancel_button), "clicked",
G_CALLBACK(gtk_widget_destroy), GTK_OBJECT(config_dialog));
gtk_widget_show_all(config_dialog);
}
uint8 get_command_id(char* cmd_name)
{
return get_id_from_name(cmd_name, commands, NELEMENTS(commands));
}
.pin = {
.gpio = GPIOC,
.init = {
.GPIO_Pin = GPIO_Pin_5,
.GPIO_Speed = GPIO_Speed_50MHz,
.GPIO_Mode = GPIO_Mode_OUT,
.GPIO_OType = GPIO_OType_PP,
.GPIO_PuPd = GPIO_PuPd_UP
},
},
},
};
static const struct pios_led_cfg pios_led_cfg = {
.leds = pios_leds,
.num_leds = NELEMENTS(pios_leds),
};
const struct pios_led_cfg *PIOS_BOARD_HW_DEFS_GetLedCfg(__attribute__((unused)) uint32_t board_revision)
{
return &pios_led_cfg;
}
#endif /* PIOS_INCLUDE_LED */
#if defined(PIOS_INCLUDE_FLASH)
#include "pios_flashfs_logfs_priv.h"
#include "pios_flash_internal_priv.h"
static const struct pios_flash_internal_cfg flash_internal_cfg = {};
#define DSET_SO devSoSkeletonGpib
#define DSET_EV devEvSkeletonGpib
#include <devGpib.h> /* must be included after DSET defines */
#define TIMEOUT 1.0
#define TIMEWINDOW 2.0
/******************************************************************************
* Strings used by the init routines to fill in the znam,onam,...
* fields in BI and BO record types.
******************************************************************************/
static char *offOnList[] = { "Off","On" };
static struct devGpibNames offOn = { NELEMENTS(offOnList),offOnList,0,1 };
static char *initNamesList[] = { "Init","Init" };
static struct devGpibNames initNames = { NELEMENTS(initNamesList),initNamesList,0,1 };
static char *disableEnableList[] = { "Disable","Enable" };
static struct devGpibNames disableEnable = { NELEMENTS(disableEnableList),disableEnableList,0,1 };
static char *resetList[] = { "Reset","Reset" };
static struct devGpibNames reset = { NELEMENTS(resetList),resetList,0,1 };
static char *lozHizList[] = { "50 OHM","IB_Q_HIGH Z" };
static struct devGpibNames lozHiz = {NELEMENTS(lozHizList),lozHizList,0,1};
static char *invertNormList[] = { "INVERT","NORM" };
static struct devGpibNames invertNorm = { NELEMENTS(intvertNormList),invertNormList,0,1 };
no. mBlks no. clBlks memArea memSize
----------- ---------- ------- -------
*/
0, 0, NULL, 0
};
CL_DESC NetdrvClDescTbl [] = /* network cluster pool configuration table */
{
/*
clusterSize num memArea memSize
----------- ---- ------- -------
*/
{NETDRV_CL_LEN, 0, NULL, 0}
};
int NetdrvClDescTblNumEnt = (NELEMENTS(NetdrvClDescTbl));
NET_POOL NetdrvCmpNetPool;
/* static int g_RxPort; */
#define g_RxMinUnit 0
#define g_RxMaxUnit MAX_DEVICES
/* Definitions for the flags field */
/* Status register bits, returned by NetdrvStatusRead() */
#define NETDRV_RINT 0x1 /* Rx interrupt pending */
#define NETDRV_TINT 0x2 /* Tx interrupt pending */
#define NETDRV_RXON 0x4 /* Rx on (enabled) */
I2C_VM_ASM_STORE(0xF4, 0), /* Store ctrl register address */ I2C_VM_ASM_STORE(0x2E, 1), /* Store temp conv address */ I2C_VM_ASM_WRITE_I2C(0, 2), /* Write two bytes */ I2C_VM_ASM_DELAY(5), /* Wait for temperature conversion to complete */ I2C_VM_ASM_STORE(0xF6, 0), /* Store ADC MSB address */ I2C_VM_ASM_WRITE_I2C(0, 1), /* Write one byte */ I2C_VM_ASM_READ_I2C(0, 2), /* Read 2 byte ADC value */ I2C_VM_ASM_LOAD_BE(0, 2, VM_R3), /* Load 16-bit formatted bytes into first output reg */ /* Pressure conversion */ I2C_VM_ASM_STORE(0xF4, 0), /* Store ctrl register address */ I2C_VM_ASM_STORE(0x34 + (0x3 << 6), 1), /* Store pressure conv address */ I2C_VM_ASM_WRITE_I2C(0, 2), /* Write two bytes */ I2C_VM_ASM_DELAY(26), /* Wait for pressure conversion to complete */ I2C_VM_ASM_STORE(0xF6, 0), /* Store ADC MSB address */ I2C_VM_ASM_WRITE_I2C(0, 1), /* Write one byte */ I2C_VM_ASM_READ_I2C(0, 3), /* Read 3 byte ADC value */ I2C_VM_ASM_LOAD_BE(0, 3, VM_R4), /* Load 24-bit formatted bytes into first output reg */ /* Scale the pressure conversion by the oversampling factor (set when conversion started) */ I2C_VM_ASM_LSR_IMM(VM_R4, 8 - 3), I2C_VM_ASM_SEND_UAVO(), /* Set the UAVObject */ I2C_VM_ASM_JUMP(-38), /* Jump back 38 instructions */ }; const uint32_t vmprog_op_mag_baro_len = NELEMENTS(vmprog_op_mag_baro);
