/**
* Checks if the specified DeviceConfig is available on this platform.
*/
gcc_pure
static bool
DeviceConfigAvailable(const DeviceConfig &config)
{
switch (config.port_type) {
case DeviceConfig::DISABLED:
return false;
case DeviceConfig::SERIAL:
return !is_android();
case DeviceConfig::RFCOMM:
return is_android();
case DeviceConfig::AUTO:
return is_windows_ce();
case DeviceConfig::INTERNAL:
return is_android();
case DeviceConfig::TCP_LISTENER:
return true;
}
/* unreachable */
return false;
}
const TCHAR *
GetHomeDataPath(TCHAR *buffer)
{
if (is_android())
/* hard-coded path for Android */
return NULL;
#ifdef HAVE_POSIX
/* on Unix or WINE, use ~/.xcsoar */
const TCHAR *home = getenv("HOME");
if (home != NULL) {
_tcscpy(buffer, home);
_tcscat(buffer, _T("/.xcsoar"));
return buffer;
} else
return _T("/etc/xcsoar");
#else
if (!SHGetSpecialFolderPath(NULL, buffer, CSIDL_PERSONAL, false))
return NULL;
_tcscat(buffer, _T(DIR_SEPARATOR_S));
_tcscat(buffer, XCSDATADIR);
return buffer;
#endif
}
static void sanremo_ts_timer_handler(unsigned long d)
{
static u16 tem_x = 0xffff;
static u16 tem_y = 0xffff;
int pen_state;
sanremo_tsi_readxy(&tem_x, &tem_y, &pen_state);
if (pen_state) {
tem_x = 4000 - tem_x;
input_report_abs(sanremo_ts_input_dev,
ABS_X, tem_x);
input_report_abs(sanremo_ts_input_dev,
ABS_Y, tem_y);
if (!is_android())
input_report_abs(sanremo_ts_input_dev,
ABS_PRESSURE, 255);
if (is_android()) {
input_report_key(sanremo_ts_input_dev,
BTN_TOUCH, 1);
input_sync(sanremo_ts_input_dev);
}
sanremo_td->ts_timer->expires = jiffies+msecs_to_jiffies(100);
add_timer(sanremo_td->ts_timer);
} else {
/* Report a pen up event */
if (!is_android()) {
input_report_abs(sanremo_ts_input_dev,
ABS_PRESSURE, 0);
input_report_abs(sanremo_ts_input_dev,
ABS_TOOL_WIDTH, 1);
}
if (is_android()) {
input_report_key(sanremo_ts_input_dev,
BTN_TOUCH, 0);
input_sync(sanremo_ts_input_dev);
}
sanremo_enable_pen_down_irq(1);
}
return;
}
static void __init tavorevb_add_onenand(void)
{
if (is_android()) {
tavorevb_onenand_info.parts = android_128m_v75_partitions;
tavorevb_onenand_info.nr_parts = ARRAY_SIZE(android_128m_v75_partitions);
} else {
tavorevb_onenand_info.parts = generic_128m_v75_partitions;
tavorevb_onenand_info.nr_parts = ARRAY_SIZE(generic_128m_v75_partitions);
}
pxa168_add_onenand(&tavorevb_onenand_info);
}
static TCHAR *
FindDataPath()
{
if (is_altair() && is_embedded())
/* hard-coded path for Altair */
return _tcsdup(_T("\\NOR Flash"));
if (is_android()) {
/* XXX use Environment.getExternalStorageDirectory() */
#ifdef ANDROID
/* hack for Samsung Galaxy S and Samsung Galaxy Tab (which has a
build-in and an external SD card) */
struct stat st;
if (stat("/sdcard/external_sd", &st) == 0 &&
(st.st_mode & S_IFDIR) != 0 &&
fgrep("/proc/mounts", "/sdcard/external_sd "))
return strdup("/sdcard/external_sd/XCSoarData");
#endif
/* hard-coded path for Android */
return _tcsdup(_T("/sdcard/XCSoarData"));
}
#ifdef _WIN32_WCE
/* if XCSoar was started from a flash disk, put the XCSoarData onto
it, too */
{
TCHAR buffer[MAX_PATH];
if (ModuleInFlash(NULL, buffer) != NULL) {
_tcscat(buffer, _T(DIR_SEPARATOR_S));
_tcscat(buffer, XCSDATADIR);
if (Directory::Exists(buffer))
return _tcsdup(buffer);
}
/* if a flash disk with XCSoarData exists, use it */
if (ExistingDataOnFlash(buffer) != NULL)
return _tcsdup(buffer);
}
#endif
{
TCHAR buffer[MAX_PATH];
const TCHAR *path = GetHomeDataPath(buffer);
if (path != NULL)
return _tcsdup(path);
}
return NULL;
}
static void __init aspenite_add_nand(void)
{
if (is_android()) {
aspenite_nand_info.parts[0] = android_512m_v75_partitions;
aspenite_nand_info.nr_parts[0] = ARRAY_SIZE(android_512m_v75_partitions);
} else {
aspenite_nand_info.parts[0] = generic_512m_v75_partitions;
aspenite_nand_info.nr_parts[0] = ARRAY_SIZE(generic_512m_v75_partitions);
}
aspenite_nand_info.use_dma = 1;
aspenite_nand_info.enable_arbiter = 1;
pxa168_add_nand((struct flash_platform_data *) &aspenite_nand_info);
}
static void __init tavorevb_add_nand(void)
{
if (is_android()) {
tavorevb_nand_info.parts[0] = android_128m_v75_partitions;
tavorevb_nand_info.nr_parts[0] = ARRAY_SIZE(android_128m_v75_partitions);
} else {
tavorevb_nand_info.parts[0] = generic_128m_v75_partitions;
tavorevb_nand_info.nr_parts[0] = ARRAY_SIZE(generic_128m_v75_partitions);
}
tavorevb_nand_info.use_dma = 0;
tavorevb_nand_info.enable_arbiter = 1;
pxa168_add_nand(&tavorevb_nand_info);
}
static void
UpdateDeviceControlVisibility(WndProperty &port_field,
WndProperty &speed_field,
WndProperty &driver_field)
{
unsigned port = port_field.GetDataField()->GetAsInteger();
enum DeviceConfig::port_type type = port < num_port_types
? port_types[port].type
: (is_android()
? DeviceConfig::RFCOMM
: DeviceConfig::SERIAL);
speed_field.set_visible(DeviceConfig::UsesSpeed(type));
driver_field.set_visible(DeviceConfig::UsesDriver(type));
}
static TCHAR *
FindDataPath()
{
if (is_altair())
/* hard-coded path for Altair */
return _tcsdup(_T("\\NOR Flash"));
if (is_android())
/* hard-coded path for Android */
return _tcsdup(_T("/sdcard/XCSoarData"));
#ifdef _WIN32_WCE
/* if XCSoar was started from a flash disk, put the XCSoarData onto
it, too */
{
TCHAR buffer[MAX_PATH];
if (ModuleInFlash(NULL, buffer) != NULL) {
_tcscat(buffer, _T(DIR_SEPARATOR_S));
_tcscat(buffer, XCSDATADIR);
if (Directory::Exists(buffer))
return _tcsdup(buffer);
}
/* if a flash disk with XCSoarData exists, use it */
if (ExistingDataOnFlash(buffer) != NULL)
return _tcsdup(buffer);
}
#endif
{
TCHAR buffer[MAX_PATH];
const TCHAR *path = GetHomeDataPath(buffer);
if (path != NULL)
return _tcsdup(path);
}
return NULL;
}
static void __init aspenite_init(void)
{
mfp_config(ARRAY_AND_SIZE(aspenite_pin_config));
pxa168_set_vdd_iox(VDD_IO0, VDD_IO_3P3V);
pxa168_set_vdd_iox(VDD_IO1, VDD_IO_3P3V);
pxa168_set_vdd_iox(VDD_IO2, VDD_IO_3P3V);
pxa168_set_vdd_iox(VDD_IO3, VDD_IO_3P3V);
pxa168_set_vdd_iox(VDD_IO4, VDD_IO_3P3V);
pxa168_mfp_set_fastio_drive(MFP_DS02X);
/* on-chip devices */
pxa168_add_uart(1);
#if defined(CONFIG_BT_HCIUART) && defined(CONFIG_WLAN_8688_SDIO)
pxa168_add_uart(3);
#endif
aspenite_add_nand();
pxa168_add_ssp(0);
#if defined(CONFIG_MTD_M25P80) && defined(CONFIG_SPI_PXA2XX)
pxa168_add_ssp(1);
pxa168_add_spi(2, &pxa_ssp_master_info);
spi_flashinit();
#endif
pxa168_add_twsi(0, &pwri2c_info, ARRAY_AND_SIZE(aspenite_i2c_board_info));
pxa168_add_twsi(1, &pwri2c_info, ARRAY_AND_SIZE(pwri2c_board_info));
if (is_android())
pxa168_add_keypad(&aspenite_android_keypad_info);
else
pxa168_add_keypad(&aspenite_keypad_info);
#ifdef CONFIG_USB_GADGET_PXA_U2O
pxa168_add_u2o(&aspenite_u2o_info);
#endif
#ifdef CONFIG_USB_OTG
pxa168_add_u2ootg(&aspenite_u2o_info);
pxa168_add_u2oehci(&aspenite_u2o_info);
#endif
#ifdef CONFIG_USB_EHCI_PXA_U2H
pxa168_add_u2h(&aspenite_u2h_info);
#endif
pxa168_add_mfu(&pxa168_eth_data);
#ifdef CONFIG_PCI
pxa168_add_pcie(&pxa168_pcie_data);
#endif
#if defined(CONFIG_MMC_PXA_SDH)
pxa168_add_sdh(0, &aspenite_sdh_platform_data_MMC1);
#if defined(CONFIG_WLAN_8688_SDIO)
pxa168_add_sdh(1, &aspenite_sdh_platform_data_MMC2);
#if defined(CONFIG_BT_HCIUART)
aspenite_bt_init();
#endif
#endif
#if defined(CONFIG_MMC3)
pxa168_add_sdh(2, &aspenite_sdh_platform_data_MMC3);
#endif
#endif
#if defined(CONFIG_CIR)
pxa168_cir_init(); /*init the gpio */
#endif
#if defined(CONFIG_PXA168_CF)
#if defined(CONFIG_PXA168_CF_USE_GPIO_CARDDETECT)
pxa168_cf_init();
#else
pxa168_add_cf();
#endif
#endif
pxa168_add_freq();
if (machine_is_aspenite()) {
pxa168_add_fb(&aspenite_lcd_info);
pxa168_add_fb_ovly(&aspenite_lcd_ovly_info);
}
/* off-chip devices */
if (machine_is_zylonite2()) {
pxa168_add_fb(&zylonite2_lcd_info);
platform_device_register(&smc91x_device);
}
#if defined(CONFIG_PXA168_CAMERA)
pxa168_add_cam();
#endif
#if defined(CONFIG_PXA_ICR)
pxa168_add_icr();
#endif
#if defined(CONFIG_BATTERY_PXA168)
pxa168_add_battery();
#endif
}
void
TopCanvas::set()
{
unsigned width = 640, height = 480;
#ifndef ANDROID
Uint32 flags = SDL_ANYFORMAT;
#endif
#ifdef ENABLE_OPENGL
#ifndef ANDROID
flags |= SDL_OPENGL;
#endif
#else /* !ENABLE_OPENGL */
/* double buffering temporarily disabled on Android because
Android's SDL port doesn't allow locking it then (which we need
for SDL_gfx) */
if (!is_android())
flags |= SDL_DOUBLEBUF;
/* we need async screen updates as long as we don't have a global
frame rate */
flags |= SDL_ASYNCBLIT;
const SDL_VideoInfo *info = SDL_GetVideoInfo();
assert(info != NULL);
/* hardware surface temporarily disabled on Android because
Android's SDL port doesn't allow locking it then (which we need
for SDL_gfx) */
if (!is_android() && info->hw_available)
flags |= SDL_HWSURFACE;
else
flags |= SDL_SWSURFACE;
#endif /* !ENABLE_OPENGL */
if (is_embedded()) {
#if defined(ANDROID)
width = native_view->get_width();
height = native_view->get_height();
#else
flags |= SDL_FULLSCREEN;
/* select a full-screen video mode */
SDL_Rect **modes = SDL_ListModes(NULL, flags);
if (modes == NULL)
return;
width = modes[0]->w;
height = modes[0]->h;
#endif
}
#ifdef ENABLE_OPENGL
#ifndef ANDROID
::SDL_SetVideoMode(width, height, 0, flags);
#endif
OpenGL::SetupContext(width, height);
Canvas::set(width, height);
#else
Canvas::set(::SDL_SetVideoMode(width, height, 0, flags));
#endif
#ifdef ENABLE_OPENGL
glViewport(0, 0, get_width(), get_height());
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
#ifdef HAVE_GLES
glOrthox(0, get_width()<<16, get_height()<<16, 0, -(1<<16), 1<<16);
#else
glOrtho(0, get_width(), get_height(), 0, -1, 1);
#endif
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glDisable(GL_DEPTH_TEST);
glDisable(GL_DITHER);
glDisable(GL_LIGHTING);
glEnableClientState(GL_VERTEX_ARRAY);
#endif
}
char * select_lv(int disable_android) {
int n;
int *by, pagenum = 1, npages, ret = 0;
char *selected_lv = NULL, str[64];
DECL_LINE(backbtn);
DECL_LINE(prevpage);
DECL_LINE(nextpage);
strcpy(sbstr, "select volume");
update_lv_lists();
n = lv_count();
by = malloc(n * sizeof(int));
npages = 1 + n / PERPAGE;
do {
clear_screen();
START_LIST(8, 32, 352, 0xFF404040, 0xFF808080, 0xFFC0C0C0)
DRAW_LINE(backbtn, "back", "return to previous menu without making a selection");
if (pagenum > 1) {
DRAW_LINE(prevpage, "previous page", "not all volumes are shown");
}
for (int i = PERPAGE * (pagenum - 1); i < n; ++i) {
if (i > pagenum * PERPAGE) break;
if (is_android(lv_name(i)) && disable_android)
continue;
snprintf(str, sizeof(str), "size = %ld MiB", lv_sizes[i]);
USECOLR = !USECOLR;
CURCOLR = USECOLR ? BG1COLR : BG2COLR;
current_y += 48;
by[i] = current_y;
fill_rect(0, by[i], 1024, 44, CURCOLR);
text(lv_name(i), col1_x, by[i] + 8, 2, 2, 0xFFFFFFFF, CURCOLR);
text(str, col2_x, by[i] + 8, 1, 1, 0xFFFFFFFF, CURCOLR);
}
if (pagenum < npages) {
DRAW_LINE(nextpage, "next page", "not all volumes are shown");
}
update_screen();
input_read();
if (BTN_CLICKED(backbtn)) ret = 2;
for (int i = PERPAGE * (pagenum - 1); i < n; ++i)
if (was_clicked(0, by[i], 1024, 44)) {
if (i > pagenum * PERPAGE) break;
selected_lv = strdup(lv_name(i));
ret = 1;
}
if (BTN_CLICKED(prevpage)) --pagenum;
else if (BTN_CLICKED(nextpage)) ++pagenum;
} while (!ret);
free(by);
return selected_lv;
}
