g_error gl_init(void) {
const char *s;
g_error e;
/* Load an inlib to handle rendering continuously (or not) */
e = load_inlib(&gl_continuous_regfunc,&gl_global.continuous_inlib);
errorcheck;
s = get_param_str(GL_SECTION,"texture_filtering","linear");
if (!strcmp(s,"linear")) {
gl_global.texture_filtering = GL_LINEAR_MIPMAP_LINEAR;
}
else {
gl_global.texture_filtering = GL_NEAREST;
}
sscanf(get_param_str(GL_SECTION,"fps_interval","0.25"),"%f",&gl_global.fps_interval);
gl_global.continuous = get_param_int(GL_SECTION,"continuous",0);
gl_global.antialias = get_param_int(GL_SECTION,"antialias",0);
if (get_param_int(GL_SECTION,"keys",1)) {
e = infilter_insert(&infilter_list, &gl_global.h_infilter, -1, &infilter_gl);
errorcheck;
}
return success;
}
int get_param_int(const char *section, const char* key, int def) {
const char *strval;
strval = get_param_str(section,key,NULL);
if (strval)
return atoi(strval);
return def;
}
static void
wpa_handle_messages(STATE *state, WPA_INTERFACE *iface)
{
char buffer[BUFFER_SIZE];
char params[512];
int nbytes, idx = -1;
WPA_ACTION handle;
WPA_ACTION handles[TYPES_NUM][NETMAN_NUM_STATES] = {{0}};
handles[CE_CON][NETMAN_STATE_CONNECTING] = netman_exit;
handles[CR_PASS][NETMAN_STATE_CONNECTING] = prompt_password;
wpa_command(iface, "ATTACH");
for (;;) {
nbytes = read(iface->messages.socket, buffer, BUFFER_SIZE);
/* remove trailing newline */
buffer[nbytes] = 0;
DEBUG("> %s\n", buffer);
if (buffer[0] != '<') continue;
idx = get_type(buffer+PLEVEL_LEN);
if (idx < 0) continue;
handle = handles[idx][state->state];
if (handle) {
get_param_str(buffer+PLEVEL_LEN, params, idx);
handle(state, iface, params);
}
}
}
/* Load all input drivers specified in the config database */
g_error input_init(void) {
const char *constinputs;
char *inputs,*str;
char *tok;
g_error e;
struct inputinfo *p;
#ifdef CONFIG_INPUT_AUTOLOAD
/* Automatically try to load all input drivers */
for (p=inputdrivers;p->name;p++)
load_inlib(p->regfunc,NULL);
#else
/* Only load specified drivers */
if ((constinputs = get_param_str("pgserver","input",NULL))) {
str = inputs = strdup(constinputs);
while ((tok = strtok(str," \t"))) {
e = load_inlib(find_inputdriver(tok),NULL);
errorcheck;
str = NULL;
}
free(inputs);
}
#endif
return success;
}
g_error ftgl_create(struct font_descriptor *self, const struct font_style *fs) {
g_error e;
struct ftgl_font *closest, *f;
int r, closeness = -1;
struct font_style s;
if (fs) {
s = *fs;
}
else {
s.name = NULL;
s.size = 0;
s.style = PG_FSTYLE_DEFAULT;
s.representation = 0;
}
/* If they asked for a default font, give it to them */
if (!s.name || !*s.name || (s.style & PG_FSTYLE_DEFAULT)) {
if (s.style & PG_FSTYLE_FIXED)
s.name = get_param_str(CFGSECTION,"default_fixed_face","Bitstream Vera Sans Mono");
else
s.name = get_param_str(CFGSECTION,"default_face","Bitstream Vera Sans");
}
/* If they asked for the default size, give it to them */
if (!s.size)
s.size = ftgl_default_size;
e = g_malloc((void**)&self->data, sizeof(struct ftgl_data));
errorcheck;
DATA->style = s.style;
/* Pick the closest font face */
for (f=ftgl_font_list;f;f=f->next) {
r = ftgl_fontcmp(f,&s);
if (r > closeness) {
closeness = r;
closest = f;
}
}
DATA->font = closest;
/* Scale the font we found to match the requested size */
DATA->scale = ((float)s.size) / ((float)DATA->font->style.size);
return success;
}
void ftgl_load_callback(const char *file, int pathlen) {
const char *sizes = get_param_str(CFGSECTION,"sizes","32");
/* Always load it at the default size */
ftgl_load_font(ftgl_load, file, ftgl_default_size);
/* Also load it at the sizes specified in the list here */
while (*sizes)
ftgl_load_font(ftgl_load, file, strtol(sizes,(char**)&sizes,10));
}
int get_param_ulong(FILE *fp, const char *name, ulong *value, int rewind_seek_type)
{
char str[FILE_LINE_MAX_LEN+1];
if (get_param_str(fp, name, str, rewind_seek_type) < 0) {
return -1;
}
*value = strtoul(str, NULL, 0);
return 0;
}
g_error h3600ts_init(void) {
btnstate=0;
h3600ts_fd = open(get_param_str("input-h3600ts","device","/dev/h3600_ts"),
O_RDONLY | O_NOCTTY | O_NDELAY);
if(h3600ts_fd < 0)
return mkerror(PG_ERRT_IO,43); /* Error opening touchscreen device */
return success;
}
int get_param_file( char *file ) {
static char str[ MAX_STR ];
FILE *f = fopen( file, "rt" );
if ( f == NULL )
return FALSE;
while( fgets( str, MAX_STR - 1, f) != NULL )
get_param_str( str );
fclose( f );
return TRUE;
}
/* Update the title and size of the monolithic window if necessary */
void x11_monolithic_window_update(void) {
char title[256];
if (vid->display) {
x11_internal_window_resize(vid->display, vid->xres, vid->yres);
title[sizeof(title)-1] = 0;
snprintf(title,sizeof(title)-1,get_param_str("video-x11","caption","PicoGUI (X11@%dx%dx%d)"),
vid->xres,vid->yres,vid->bpp);
XStoreName(x11_display, XB(vid->display)->frontbuffer ?
XB(vid->display)->frontbuffer->d : XB(vid->display)->d,
title);
}
}
g_error ftgl_engine_init(void) {
g_error e;
ftgl_default_size = get_param_int(CFGSECTION,"default_size",14);
e = ftgl_fontload_init(&ftgl_load);
errorcheck;
os_dir_scan(get_param_str(CFGSECTION,"path","/usr/share/fonts"), &ftgl_load_callback);
if (!ftgl_font_list)
return mkerror(PG_ERRT_IO, 66); /* Can't find fonts */
ftgl_fontload_finish(ftgl_load);
return success;
}
void get_param( char *exe_name, char *env_var, int argc, char *argv[] ) {
static char _cfg[] = ".CFG";
int i;
char *env;
_splitpath( exe_name, fdisk, fpath, fname, fext );
_makepath( _file, NULL, NULL, fname, _cfg );
if ( ! get_param_file( _file ) ) {
_makepath( _file, fdisk, fpath, fname, _cfg );
get_param_file( _file );
}
if ( (env = getenv( env_var ) ) != NULL )
get_param_str( env );
for ( i = 0; i < argc; i++ )
get_one_param( argv[ i ] );
}
/* If the key exists, append separator and value, if not set it to value */
g_error append_param_str(const char *section, const char *key,
const char *separator, const char *value) {
char *newvalue;
const char *oldvalue;
oldvalue = get_param_str(section,key,NULL);
if (oldvalue) {
/* Append to an existing value */
newvalue = alloca(strlen(oldvalue)+strlen(separator)+strlen(value)+1);
strcpy(newvalue,oldvalue);
strcat(newvalue,separator);
strcat(newvalue,value);
return set_param_str(section,key,newvalue);
}
return set_param_str(section,key,value);
}
int get_param_ushort(FILE *fp, const char *name, ushort *value, int rewind_seek_type)
{
char str[FILE_LINE_MAX_LEN+1];
ulong tmp;
if (get_param_str(fp, name, str, rewind_seek_type) < 0) {
return -1;
}
tmp = strtoul(str, NULL, 0);
if (tmp > USHRT_MAX) {
printf("parameter overflow\n");
*value = USHRT_MAX;
return -1;
}
*value = (ushort)tmp;
return 0;
}
g_error sdlgl_setmode(s16 xres,s16 yres,s16 bpp,u32 flags) {
u32 sdlflags = SDL_RESIZABLE | SDL_OPENGL;
char str[80];
g_error e;
static SDL_Surface *surface = NULL;
/* Interpret flags */
if (get_param_int("video-sdlgl","fullscreen",0))
sdlflags |= SDL_FULLSCREEN;
/* Set the video mode */
if ((!surface) || xres != vid->xres ||
yres !=vid->yres || bpp != vid->bpp) {
surface = SDL_SetVideoMode(xres,yres,bpp,sdlflags);
if (!surface)
return mkerror(PG_ERRT_IO,47);
}
vid->bpp = surface->format->BitsPerPixel;
vid->xres = xres;
vid->yres = yres;
#ifdef CONFIG_SDLSKIN
/* If we've got SDL skinning support, set the relevant vars to good values
* so the input driver won't get wacky on us.
*/
sdlfb_display_x = 0;
sdlfb_display_y = 0;
sdlfb_scale = 1;
#endif
e = gl_setmode(xres,yres,bpp,flags);
errorcheck;
snprintf(str,sizeof(str),get_param_str("video-sdlgl","caption","PicoGUI (sdlgl@%dx%dx%d)"),
vid->xres,vid->yres,bpp);
SDL_WM_SetCaption(str,NULL);
return success;
}
static int
get_param_int(char* reply, int num, int *err)
{
char *rep_str;
char *tptr;
int ret;
rep_str = get_param_str(reply, num, err);
if (rep_str == NULL){
/* err is already set to the error return code, just return */
return 0;
}
ret = strtol(rep_str, &tptr, 10);
if (*tptr != '\0'){
/* this is not a number */
*err = -3;
return 0;
}
xfree(rep_str);
return ret;
}
g_error video_init(void) {
g_error e;
int vidw,vidh,vidd,vidf;
const char *str;
g_error (*viddriver)(struct vidlib *v);
#ifdef CONFIG_PAL8_CUSTOM
/* Load a custom palette if necessary */
e = load_custom_palette(get_param_str("pgserver","palette",NULL));
errorcheck;
#endif
/* Process video driver config options */
vidw = get_param_int("pgserver","width",0);
vidh = get_param_int("pgserver","height",0);
vidd = get_param_int("pgserver","depth",0);
vidf = get_param_int("pgserver","vidflags",0);
sscanf(get_param_str("pgserver","mode",""),"%dx%dx%d",&vidw,&vidh,&vidd);
/* Add rotation flags */
switch (get_param_int("pgserver","rotate",0)) {
case 90:
vidf |= PG_VID_ROTATE90;
break;
case 180:
vidf |= PG_VID_ROTATE180;
break;
case 270:
vidf |= PG_VID_ROTATE270;
break;
}
/* Force an external video driver? */
if (external_regfunc)
{
if (iserror(load_vidlib(external_regfunc,
external_xres, external_yres,
external_bpp, external_flags)))
return mkerror(PG_ERRT_IO,78); /* @@@ Prolly some other error*/
} else
/* Force a specific video driver? */
if ((str = get_param_str("pgserver","video",NULL))) {
if (!(viddriver = find_videodriver(str)))
return mkerror(PG_ERRT_BADPARAM,77);;
e = load_vidlib(viddriver,vidw,vidh,vidd,vidf);
errorcheck;
}
else {
/* Try to detect a driver (see driverinfo.c) */
struct vidinfo *p = videodrivers;
while (p->name) {
if (!iserror(load_vidlib(p->regfunc,vidw,vidh,vidd,vidf)))
/* Yay, found one that works */
break;
p++;
}
if (!p->name) {
/* Oh well... */
return mkerror(PG_ERRT_IO,78);
}
}
return success;
}
g_error sdlinput_init(void) {
g_error e;
if (get_param_int("input-sdlinput","pgcursor",1)) {
e = cursor_new(&sdlinput_cursor,NULL,-1);
errorcheck;
}
sdlinput_foldbuttons = get_param_int("input-sdlinput","foldbuttons",0);
sdlinput_upmove = get_param_int("input-sdlinput","upmove",1);
sdlinput_nomouse = get_param_int("input-sdlinput","nomouse",0);
sdlinput_nokeyboard = get_param_int("input-sdlinput","nokeyboard",0);
sdlinput_scroll_distance = get_param_int("input-sdlinput","scroll_distance",20);
SDL_ShowCursor(get_param_int("input-sdlinput","sdlcursor",0));
#ifdef CONFIG_SDLSKIN
/* Load keyboard map */
if (sdlinput_map)
g_free(sdlinput_map);
sdlinput_mapsize = 0;
{
const char *fname = get_param_str("input-sdlinput","map",NULL);
FILE *f;
char linebuf[80];
int i;
g_error e;
char *p;
int mapscale_n,mapscale_d;
sscanf(get_param_str("input-sdlinput","mapscale","1 1"), "%d %d",
&mapscale_n, &mapscale_d);
if (fname && (f = fopen(fname,"r"))) {
/* Count the number of rectangles */
i = 0;
while (fgets(linebuf,79,f))
if (!strncmp(linebuf,"<AREA",5))
i++;
/* Allocate map */
sdlinput_mapsize = i;
e = g_malloc((void**)&sdlinput_map,i * sizeof(struct sdlinput_rect));
errorcheck;
/* Really stupid parser thingy */
rewind(f);
i = 0;
while (fgets(linebuf,79,f) && i<sdlinput_mapsize)
if (!strncmp(linebuf,"<AREA",5)) {
p = strstr(linebuf,"COORDS=")+8;
sdlinput_map[i].x1 = atoi(p) * mapscale_n / mapscale_d;
p = strchr(p,',')+1;
sdlinput_map[i].y1 = atoi(p) * mapscale_n / mapscale_d;
p = strchr(p,',')+1;
sdlinput_map[i].x2 = atoi(p) * mapscale_n / mapscale_d;
p = strchr(p,',')+1;
sdlinput_map[i].y2 = atoi(p) * mapscale_n / mapscale_d;
p = strstr(p,"HREF=")+6;
sdlinput_map[i].key = atoi(p);
i++;
}
}
}
#endif
SDL_EnableUNICODE(1);
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY,SDL_DEFAULT_REPEAT_INTERVAL);
return success;
}
/*----------------------------------------------------------------------------*/
int main(int argc, char* argv[])
{
ASerialPort_t cPort;
ADeviceNXP_t cDevice;
char filename[FILENAME_LEN];
int loop, test, port=1, go_find=1, override=0;
int do_receive = 0x1, do_command = COMMAND_NONE;
char *pfile = 0x0, *pdev = 0x0, *ptty = 0x0;
my1key_t key;
/* print tool info */
printf("\n%s - NXP Flash Tool (version %s)\n",PROGNAME,PROGVERS);
printf(" => by [email protected]\n\n");
if(argc>1)
{
for(loop=1;loop<argc;loop++)
{
if(!strcmp(argv[loop],"--help")||!strcmp(argv[loop],"-h"))
{
about();
return 0;
}
else if(!strcmp(argv[loop],"--port"))
{
if(get_param_int(argc,argv,&loop,&test)<0)
{
printf("Cannot get port number!\n");
return ERROR_PARAM_PORT;
}
else if(test<1||test>MAX_COM_PORT)
{
printf("Invalid port number! (%d)\n", test);
return ERROR_PARAM_PORT;
}
port = test;
}
else if(!strcmp(argv[loop],"--tty"))
{
if(!(ptty=get_param_str(argc,argv,&loop)))
{
printf("Error getting tty name!\n");
continue;
}
}
else if(!strcmp(argv[loop],"--file"))
{
if(!(pfile=get_param_str(argc,argv,&loop)))
{
printf("Error getting filename!\n");
return ERROR_PARAM_FILE;
}
}
else if(!strcmp(argv[loop],"--device"))
{
if(!(pdev=get_param_str(argc,argv,&loop)))
{
printf("Error getting device name!\n");
continue;
}
}
else if(!strcmp(argv[loop],"--no-device"))
{
go_find = 0;
}
else if(!strcmp(argv[loop],"--force"))
{
override = 1;
}
else if(!strcmp(argv[loop],"scan"))
{
if(do_command!=COMMAND_NONE)
{
printf("Multiple commands '%s'!(%d)\n",
argv[loop],do_command);
return ERROR_MULTI_CMD;
}
do_command = COMMAND_SCAN;
}
else if(!strcmp(argv[loop],"info"))
{
if(do_command!=COMMAND_NONE)
{
printf("Multiple commands '%s'!(%d)\n",
argv[loop],do_command);
return ERROR_MULTI_CMD;
}
do_command = COMMAND_DEVICE;
}
else if(!strcmp(argv[loop],"bcheck"))
{
if(do_command!=COMMAND_NONE)
{
printf("Multiple commands '%s'!(%d)\n",
argv[loop],do_command);
return ERROR_MULTI_CMD;
}
do_command = COMMAND_BCHECK;
}
else if(!strcmp(argv[loop],"erase"))
{
if(do_command!=COMMAND_NONE)
{
printf("Multiple commands '%s'!(%d)\n",
argv[loop],do_command);
return ERROR_MULTI_CMD;
}
do_command = COMMAND_ERASE;
}
else if(!strcmp(argv[loop],"write"))
{
if(do_command!=COMMAND_NONE)
{
printf("Multiple commands '%s'!(%d)\n",
argv[loop],do_command);
return ERROR_MULTI_CMD;
}
do_command = COMMAND_WRITE;
}
else if(!strcmp(argv[loop],"verify"))
{
if(do_command!=COMMAND_NONE)
{
printf("Multiple commands '%s'!(%d)\n",
argv[loop],do_command);
return ERROR_MULTI_CMD;
}
do_command = COMMAND_VERIFY;
}
else
{
printf("Unknown param '%s'!\n",argv[loop]);
}
}
static void*
spd_events_handler(void* conn)
{
char *reply;
int reply_code;
SPDConnection *connection = conn;
while(1){
/* Read the reply/event (block if none is available) */
SPD_DBG("Getting reply in spd_events_handler");
reply = get_reply(connection);
if (reply == NULL){
SPD_DBG("ERROR: BROKEN SOCKET");
reply_code = -1;
}else{
SPD_DBG("<< : |%s|\n", reply);
reply_code = get_err_code(reply);
}
if ((reply_code >= 700) && (reply_code < 800)){
int msg_id;
int client_id;
int err;
SPD_DBG("Callback detected: %s", reply);
/* This is an index mark */
/* Extract message id */
msg_id = get_param_int(reply, 1, &err);
if (err < 0){
SPD_DBG("Bad reply from Speech Dispatcher: %s (code %d)", reply, err);
break;
}
client_id = get_param_int(reply, 2, &err);
if (err < 0){
SPD_DBG("Bad reply from Speech Dispatcher: %s (code %d)", reply, err);
break;
}
/* Decide if we want to call a callback */
if ((reply_code == 701) && (connection->callback_begin))
connection->callback_begin(msg_id, client_id, SPD_EVENT_BEGIN);
if ((reply_code == 702) && (connection->callback_end))
connection->callback_end(msg_id, client_id, SPD_EVENT_END);
if ((reply_code == 703) && (connection->callback_cancel))
connection->callback_cancel(msg_id, client_id, SPD_EVENT_CANCEL);
if ((reply_code == 704) && (connection->callback_pause))
connection->callback_pause(msg_id, client_id, SPD_EVENT_PAUSE);
if ((reply_code == 705) && (connection->callback_resume))
connection->callback_resume(msg_id, client_id, SPD_EVENT_RESUME);
if ((reply_code == 700) && (connection->callback_im)){
char* im;
int err;
im = get_param_str(reply, 3, &err);
if ((err < 0) || (im == NULL)){
SPD_DBG("Broken reply from Speech Dispatcher: %s", reply);
break;
}
/* Call the callback */
connection->callback_im(msg_id, client_id, SPD_EVENT_INDEX_MARK, im);
xfree(im);
}
}else{
/* This is a protocol reply */
pthread_mutex_lock(connection->mutex_reply_ready);
/* Prepare the reply to the reply buffer in connection */
if (reply != NULL){
connection->reply = strdup(reply);
}else{
SPD_DBG("Connection reply is NULL");
connection->reply = NULL;
break;
}
/* Signal the reply is available on the condition variable */
/* this order is correct and necessary */
pthread_cond_signal(connection->cond_reply_ready);
pthread_mutex_lock(connection->mutex_reply_ack);
pthread_mutex_unlock(connection->mutex_reply_ready);
/* Wait until it has bean read */
pthread_cond_wait(connection->cond_reply_ack, connection->mutex_reply_ack);
pthread_mutex_unlock(connection->mutex_reply_ack);
xfree(reply);
/* Continue */
}
}
/* In case of broken socket, we must still signal reply ready */
if (connection->reply == NULL){
SPD_DBG("Signalling reply ready after communication failure");
pthread_mutex_unlock(connection->mutex_reply_ready);
pthread_mutex_unlock(connection->mutex_reply_ack);
if (connection->stream != NULL)
fclose(connection->stream);
connection->stream = NULL;
pthread_cond_signal(connection->cond_reply_ready);
pthread_exit(0);
}
return 0; /* to please gcc */
}
