gboolean refresh(PROC_T *p){
if(!p->entry_iseed) create_entry(p);
switch(p->status.info){
case 0:
break;
case S_RUNNING:
break;
case S_WAIT:
/*waiting to start */
gtk_entry_set_text(GTK_ENTRY(p->entry_timing),"Waiting");
break;
case S_START:
/*just started. */
gtk_entry_set_text(GTK_ENTRY(p->entry_timing),"Started");
{
char lb[12];
char stime[80];
snprintf(lb,12," %5d",p->pid);
struct tm *tim=localtime(&(p->status.timstart));
strftime(stime,80,"[%F %k:%M:%S]",tim);
strcat(stime,lb);
gtk_label_set_text(GTK_LABEL(p->entry_pid), stime);
}
notify_user(p);
break;
case S_QUEUED:
/*queued in scheduler */
gtk_entry_set_text(GTK_ENTRY(p->entry_timing),"Queued");
break;
case S_FINISH:/*Finished */
p->frac=1;
change_button(p,GTK_STOCK_APPLY,(GCallback)delete_hbox_event);
/*progress bar color. */
gtk_widget_modify_bg(p->entry_timing,GTK_STATE_SELECTED,&green);
notify_user(p);
break;
case S_CRASH:/*Error */
gtk_entry_set_text(GTK_ENTRY(p->entry_timing),"Error");
change_button(p,GTK_STOCK_CLOSE,(GCallback)delete_hbox_event);
gtk_widget_modify_base(p->entry_timing,GTK_STATE_NORMAL,&red);
notify_user(p);
break;
case S_TOKILL:/*kill command sent */
gtk_entry_set_text(GTK_ENTRY(p->entry_timing),"Kill command sent");
change_button(p,GTK_STOCK_CLOSE,(GCallback)delete_hbox_event);
gtk_widget_modify_base(p->entry_timing,GTK_STATE_NORMAL,&yellow);
break;
case S_KILLED:
gtk_entry_set_text(GTK_ENTRY(p->entry_timing),"Killed");
change_button(p,GTK_STOCK_CLOSE,(GCallback)delete_hbox_event);
gtk_widget_modify_base(p->entry_timing,GTK_STATE_NORMAL,&red);
notify_user(p);
break;
default:
warning("Unknown info\n");
}
update_prog(p);
return 0;
}
int caps_loadimage (struct zfile *zf, int drv, int *num_tracks)
{
static int notified;
struct CapsImageInfo ci;
int len, ret;
uae_u8 *buf;
TCHAR s1[100];
struct CapsDateTimeExt *cdt;
if (!caps_init ())
return 0;
caps_unloadimage (drv);
zfile_fseek (zf, 0, SEEK_END);
len = zfile_ftell (zf);
zfile_fseek (zf, 0, SEEK_SET);
buf = xmalloc (uae_u8, len);
if (!buf)
return 0;
if (zfile_fread (buf, len, 1, zf) == 0)
return 0;
ret = pCAPSLockImageMemory (caps_cont[drv], buf, len, 0);
xfree (buf);
if (ret != imgeOk) {
if (ret == imgeIncompatible || ret == imgeUnsupported) {
if (!notified)
notify_user (NUMSG_OLDCAPS);
notified = 1;
}
write_log (L"caps: CAPSLockImageMemory() returned %d\n", ret);
return 0;
}
caps_locked[drv] = 1;
ret = pCAPSGetImageInfo(&ci, caps_cont[drv]);
*num_tracks = (ci.maxcylinder - ci.mincylinder + 1) * (ci.maxhead - ci.minhead + 1);
if (cvi.release < 4) { // pre-4.x bug workaround
struct CapsTrackInfoT1 cit;
cit.type = 1;
if (pCAPSLockTrack ((PCAPSTRACKINFO)&cit, caps_cont[drv], 0, 0, caps_flags) == imgeIncompatible) {
if (!notified)
notify_user (NUMSG_OLDCAPS);
notified = 1;
caps_unloadimage (drv);
return 0;
}
pCAPSUnlockAllTracks (caps_cont[drv]);
}
ret = pCAPSLoadImage(caps_cont[drv], caps_flags);
cdt = &ci.crdt;
_stprintf (s1, L"%d.%d.%d %d:%d:%d", cdt->day, cdt->month, cdt->year, cdt->hour, cdt->min, cdt->sec);
write_log (L"caps: type:%d date:%s rel:%d rev:%d\n",
ci.type, s1, ci.release, ci.revision);
return 1;
}
int caps_init (void)
{
static int init, noticed;
int i;
HMODULE h;
TCHAR *dllname = L"CAPSImg.dll";
if (init)
return 1;
h = WIN32_LoadLibrary (dllname);
if (!h) {
TCHAR tmp[MAX_DPATH];
if (SUCCEEDED (SHGetFolderPath (NULL, CSIDL_PROGRAM_FILES_COMMON, NULL, 0, tmp))) {
_tcscat (tmp, L"\\Software Preservation Society\\");
_tcscat (tmp, dllname);
h = LoadLibrary (tmp);
if (!h) {
if (noticed)
return 0;
notify_user (NUMSG_NOCAPS);
noticed = 1;
return 0;
}
}
}
if (GetProcAddress (h, "CAPSLockImageMemory") == 0 || GetProcAddress (h, "CAPSGetVersionInfo") == 0) {
if (noticed)
return 0;
notify_user (NUMSG_OLDCAPS);
noticed = 1;
return 0;
}
pCAPSInit = (CAPSINIT)GetProcAddress (h, "CAPSInit");
pCAPSAddImage = (CAPSADDIMAGE)GetProcAddress (h, "CAPSAddImage");
pCAPSLockImageMemory = (CAPSLOCKIMAGEMEMORY)GetProcAddress (h, "CAPSLockImageMemory");
pCAPSUnlockImage = (CAPSUNLOCKIMAGE)GetProcAddress (h, "CAPSUnlockImage");
pCAPSLoadImage = (CAPSLOADIMAGE)GetProcAddress (h, "CAPSLoadImage");
pCAPSGetImageInfo = (CAPSGETIMAGEINFO)GetProcAddress (h, "CAPSGetImageInfo");
pCAPSLockTrack = (CAPSLOCKTRACK)GetProcAddress (h, "CAPSLockTrack");
pCAPSUnlockTrack = (CAPSUNLOCKTRACK)GetProcAddress (h, "CAPSUnlockTrack");
pCAPSUnlockAllTracks = (CAPSUNLOCKALLTRACKS)GetProcAddress (h, "CAPSUnlockAllTracks");
pCAPSGetVersionInfo = (CAPSGETVERSIONINFO)GetProcAddress (h, "CAPSGetVersionInfo");
init = 1;
cvi.type = 1;
pCAPSGetVersionInfo (&cvi, 0);
write_log (L"CAPS: library version %d.%d (flags=%08X)\n", cvi.release, cvi.revision, cvi.flag);
oldlib = (cvi.flag & (DI_LOCK_TRKBIT | DI_LOCK_OVLBIT)) != (DI_LOCK_TRKBIT | DI_LOCK_OVLBIT);
if (!oldlib)
caps_flags |= DI_LOCK_TRKBIT | DI_LOCK_OVLBIT;
canseed = (cvi.flag & DI_LOCK_SETWSEED) != 0;
for (i = 0; i < 4; i++)
caps_cont[i] = pCAPSAddImage ();
return 1;
}
void moduleripper (void)
{
int size;
uae_u8 *buf, *p;
size = currprefs.chipmem_size;
for (int i = 0; i < MAX_RAM_BOARDS; i++) {
size += currprefs.fastmem[i].size;
size += currprefs.z3fastmem[i].size;
}
size += currprefs.bogomem_size;
size += currprefs.mbresmem_low_size;
size += currprefs.mbresmem_high_size;
buf = p = xmalloc (uae_u8, size);
if (!buf)
return;
memcpy (p, chipmem_bank.baseaddr, currprefs.chipmem_size);
p += currprefs.chipmem_size;
for (int i = 0; i < MAX_RAM_BOARDS; i++) {
mc (p, fastmem_bank[i].start, currprefs.fastmem[i].size);
p += currprefs.fastmem[i].size;
}
mc (p, bogomem_bank.start, currprefs.bogomem_size);
p += currprefs.bogomem_size;
mc (p, a3000lmem_bank.start, currprefs.mbresmem_low_size);
p += currprefs.mbresmem_low_size;
mc (p, a3000hmem_bank.start, currprefs.mbresmem_high_size);
p += currprefs.mbresmem_high_size;
for (int i = 0; i < MAX_RAM_BOARDS; i++) {
mc (p, z3fastmem_bank[i].start, currprefs.z3fastmem[i].size);
p += currprefs.z3fastmem[i].size;
}
got = 0;
canceled = 0;
#ifdef _WIN32
__try {
#endif
prowizard_search (buf, size);
#ifdef _WIN32
} __except(ExceptionFilter (GetExceptionInformation (), GetExceptionCode ())) {
write_log (_T("prowizard scan crashed\n"));
}
#endif
if (!got)
notify_user (NUMSG_MODRIP_NOTFOUND);
else if (!canceled)
notify_user (NUMSG_MODRIP_FINISHED);
xfree (buf);
}
static void state_incompatible_warn (void)
{
static int warned;
int dowarn = 0;
int i;
#ifdef BSDSOCKET
if (currprefs.socket_emu)
dowarn = 1;
#endif
#ifdef UAESERIAL
if (currprefs.uaeserial)
dowarn = 1;
#endif
#ifdef SCSIEMU
if (currprefs.scsi)
dowarn = 1;
#endif
#ifdef CATWEASEL
if (currprefs.catweasel)
dowarn = 1;
#endif
#ifdef FILESYS
for(i = 0; i < currprefs.mountitems; i++) {
struct mountedinfo mi;
int type = get_filesys_unitconfig (&currprefs, i, &mi);
if (mi.ismounted && type != FILESYS_VIRTUAL && type != FILESYS_HARDFILE && type != FILESYS_HARDFILE_RDB)
dowarn = 1;
}
#endif
if (!warned && dowarn) {
warned = 1;
notify_user (NUMSG_STATEHD);
}
}
static void ersatz_failed (void)
{
if (already_failed)
return;
already_failed = 1;
notify_user (NUMSG_KICKREPNO);
uae_restart (-1, NULL);
}
int kickstart_checksum (uae_u8 *mem, int size)
{
if (!kickstart_checksum_do (mem, size)) {
#ifndef SINGLEFILE
notify_user (NUMSG_KSROMCRCERROR);
#endif
return 0;
}
return 1;
}
/* Returns true if the configuration value changed */
static int
set_configuration()
{
notify_user(USB_EVENT_CONFIG);
if (usb_configuration_value != LOW_BYTE(usb_setup_buffer.wValue)) {
usb_configuration_value = LOW_BYTE(usb_setup_buffer.wValue);
usb_arch_set_configuration(usb_configuration_value);
usb_send_ctrl_status();
return 1;
} else {
usb_send_ctrl_status();
return 0;
}
}
int decode_rom (uae_u8 *mem, int size, int mode, int real_size)
{
if (mode == 1) {
if (!decode_cloanto_rom_do (mem, size, real_size)) {
#ifndef SINGLEFILE
notify_user (NUMSG_NOROMKEY);
#endif
return 0;
}
return 1;
} else if (mode == 2) {
decode_rekick_rom_do (mem, size, real_size);
return 1;
}
return 0;
}
void notify_all_users(char* caption, char* message, char* icon) {
printf("NOTIFY: %s - %s\n", caption, message);
FILE* ufp = PCHECKED(fopen(_PATH_UTMP, "r"));
struct utmp utmp_entry;
while(fread((char*) &utmp_entry, sizeof(utmp_entry), 1, ufp) == 1) {
// we want to have a login name, we want to be a user session and we want our line to start with ':', indicating a x11 session
if (*utmp_entry.ut_name && *utmp_entry.ut_line && utmp_entry.ut_type == USER_PROCESS && *utmp_entry.ut_line == ':') {
struct passwd *user_passwd = PCHECKED(getpwnam(utmp_entry.ut_name));
notify_user(user_passwd->pw_uid, caption, message, icon);
}
}
fclose(ufp);
}
static int process_job(struct job *job, int cid)
{
int err = 0;
job->state = STATE_PROCESSING;
INFO("%s", job->infile);
err = __process_job(job);
if (err)
INFO("__process_job return %d", err);
job->state = err ? STATE_FAILED : STATE_SUCCESS;
notify_user(job, err, cid);
destroy_job(job);
return 0;
}
static bool load_qemu_implementation(void)
{
#ifdef WITH_QEMU_CPU
write_log(_T("PPC: Loading QEmu implementation\n"));
memset(&impl, 0, sizeof(impl));
UAE_DLHANDLE handle = uae_qemu_uae_init();
if (!handle) {
#ifdef FSUAE
gui_message(_T("PPC: Error loading qemu-uae plugin\n"));
#else
notify_user (NUMSG_NO_PPC);
#endif
return false;
}
write_log(_T("PPC: Loaded qemu-uae library at %p\n"), handle);
/* Retrieve function pointers from library */
impl.init = (ppc_cpu_init_function) uae_dlsym(handle, "ppc_cpu_init");
//impl.free = (ppc_cpu_free_function) uae_dlsym(handle, "ppc_cpu_free");
//impl.stop = (ppc_cpu_stop_function) uae_dlsym(handle, "ppc_cpu_stop");
impl.external_interrupt = (qemu_uae_ppc_external_interrupt_function) uae_dlsym(handle, "qemu_uae_ppc_external_interrupt");
impl.map_memory = (ppc_cpu_map_memory_function) uae_dlsym(handle, "ppc_cpu_map_memory");
impl.run_continuous = (ppc_cpu_run_continuous_function) uae_dlsym(handle, "ppc_cpu_run_continuous");
impl.check_state = (ppc_cpu_check_state_function) uae_dlsym(handle, "ppc_cpu_check_state");
impl.set_state = (ppc_cpu_set_state_function) uae_dlsym(handle, "ppc_cpu_set_state");
impl.reset = (ppc_cpu_reset_function) uae_dlsym(handle, "ppc_cpu_reset");
impl.in_cpu_thread = (qemu_uae_ppc_in_cpu_thread_function) uae_dlsym(handle, "qemu_uae_ppc_in_cpu_thread");
impl.lock = (qemu_uae_lock_function) uae_dlsym(handle, "qemu_uae_lock");
// FIXME: not needed, handled internally by uae_dlopen_plugin
// uae_dlopen_patch_common(handle);
uae_patch_library_ppc(handle);
return true;
#else
return false;
#endif
}
int caps_init (void)
{
static int init, noticed;
int i;
if (init)
return 1;
#ifdef FSUAE
UAE_DLHANDLE h = uae_dlopen_plugin(_T("capsimg"));
// compatibility lookup for older plugin
if (!h) {
h = uae_dlopen_plugin(_T("libcapsimage"));
}
#else
UAE_DLHANDLE h = uae_dlopen_plugin(_T("CAPSImg"));
if (!h) {
TCHAR tmp[MAX_DPATH];
if (SUCCEEDED (SHGetFolderPath (NULL, CSIDL_PROGRAM_FILES_COMMON, NULL, 0, tmp))) {
_tcscat (tmp, _T("\\Software Preservation Society\\"));
_tcscat (tmp, _T("CAPSImg.dll"));
h = uae_dlopen(tmp);
}
}
#endif
if (!h) {
if (noticed)
return 0;
notify_user (NUMSG_NOCAPS);
noticed = 1;
return 0;
}
if (uae_dlsym(h, "CAPSLockImageMemory") == 0 || uae_dlsym(h, "CAPSGetVersionInfo") == 0) {
if (noticed)
return 0;
notify_user (NUMSG_OLDCAPS);
noticed = 1;
return 0;
}
pCAPSInit = (CAPSINIT) uae_dlsym(h, "CAPSInit");
pCAPSAddImage = (CAPSADDIMAGE) uae_dlsym(h, "CAPSAddImage");
pCAPSLockImageMemory = (CAPSLOCKIMAGEMEMORY) uae_dlsym(h, "CAPSLockImageMemory");
pCAPSUnlockImage = (CAPSUNLOCKIMAGE) uae_dlsym(h, "CAPSUnlockImage");
pCAPSLoadImage = (CAPSLOADIMAGE) uae_dlsym(h, "CAPSLoadImage");
pCAPSGetImageInfo = (CAPSGETIMAGEINFO) uae_dlsym(h, "CAPSGetImageInfo");
pCAPSLockTrack = (CAPSLOCKTRACK) uae_dlsym(h, "CAPSLockTrack");
pCAPSUnlockTrack = (CAPSUNLOCKTRACK) uae_dlsym(h, "CAPSUnlockTrack");
pCAPSUnlockAllTracks = (CAPSUNLOCKALLTRACKS) uae_dlsym(h, "CAPSUnlockAllTracks");
pCAPSGetVersionInfo = (CAPSGETVERSIONINFO) uae_dlsym(h, "CAPSGetVersionInfo");
pCAPSGetInfo = (CAPSGETINFO) uae_dlsym(h, "CAPSGetInfo");
pCAPSSetRevolution = (CAPSSETREVOLUTION) uae_dlsym(h, "CAPSSetRevolution");
pCAPSGetImageTypeMemory = (CAPSGETIMAGETYPEMEMORY) uae_dlsym(h, "CAPSGetImageTypeMemory");
init = 1;
cvi.type = 1;
pCAPSGetVersionInfo (&cvi, 0);
write_log (_T("CAPS: library version %d.%d (flags=%08X)\n"), cvi.release, cvi.revision, cvi.flag);
oldlib = (cvi.flag & (DI_LOCK_TRKBIT | DI_LOCK_OVLBIT)) != (DI_LOCK_TRKBIT | DI_LOCK_OVLBIT);
if (!oldlib)
caps_flags |= DI_LOCK_TRKBIT | DI_LOCK_OVLBIT;
canseed = (cvi.flag & DI_LOCK_SETWSEED) != 0;
for (i = 0; i < 4; i++)
caps_cont[i] = pCAPSAddImage ();
return 1;
}
gboolean refresh(PROC_T *p){
if(!p->row){
char sdate[80];
char spid[12];
snprintf(spid,12," %d ",p->pid);
struct tm *tim=localtime(&p->status.timstart);
strftime(sdate,80,"%m-%d %k:%M:%S",tim);
char *spath=p->path;
char *sstart=NULL, *sout=NULL, *sargs=NULL;
if(spath){
const char *pos=NULL;
pos=strstr(spath, "/maos ");
if(!pos){
pos=strstr(spath, "/skyc ");
}
if(pos){
sstart=(char*)malloc(pos-spath+1);
memcpy(sstart, spath, pos-spath);
sstart[pos-spath]='\0';
sargs=strdup(pos+1);
char *pos2=NULL;
for(char *tmp=sargs; (tmp=strstr(tmp, " -o ")); tmp+=4){
pos2=tmp;
}
if(pos2){
pos2+=4;
char *pos3=strchr(pos2, ' ');
if(!pos3) pos3=strchr(pos2, '\0');
if(pos3){
sout=(char*)malloc(pos3-pos2+1);
memcpy(sout, pos2, pos3-pos2);
sout[pos3-pos2]='\0';
memmove(pos2-4, pos3, strlen(pos3)+1);
}
}
}
}
GtkListStore *list=lists[p->hid];
GtkTreeIter iter;
gtk_list_store_append(list, &iter);
gtk_list_store_set(list,&iter,
COL_DATE, sdate,
COL_PID, spid,
COL_FULL, spath?spath:"Unknown",
COL_START, sstart?sstart:" ",
COL_ARGS, sargs?sargs:" ",
COL_OUT, sout?sout:" ",
COL_ERRHI, " ",
COL_ERRLO, " ",
COL_SEED, " ",
COL_SEEDP, 0,
COL_STEP, " ",
COL_STEPP, 0,
-1);
free(sstart); free(sout); free(sargs);
GtkTreePath *tpath=gtk_tree_model_get_path(GTK_TREE_MODEL(list), &iter);
p->row=gtk_tree_row_reference_new(GTK_TREE_MODEL(list),tpath);
list_update_progress(p);
gtk_tree_path_free(tpath);
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(views[p->hid]));
}
switch(p->status.info){
case 0:
break;
case S_RUNNING:
list_update_progress(p);
list_modify_icon(p,icon_running);
break;
case S_WAIT: /*waiting to start */
//list_modify_status(p, "Waiting");
list_modify_reset(p);
list_modify_icon(p,icon_waiting);
break;
case S_START: /*just started. */
//list_modify_status(p, "Started");
list_modify_reset(p);
list_modify_icon(p,icon_running);
notify_user(p);
break;
case S_QUEUED:
//list_modify_status(p, "Queued");
list_modify_reset(p);
list_modify_icon(p,icon_waiting);
break;
case S_FINISH:/*Finished */
list_update_progress(p);
list_modify_icon(p, icon_finished);
//list_modify_color(p,"#00DD00");
notify_user(p);
break;
case S_CRASH:/*Error */
//list_modify_status(p, "Error");
list_modify_icon(p,icon_failed);
//list_modify_color(p,"#CC0000");
notify_user(p);
break;
case S_TOKILL:/*kill command sent */
//list_modify_status(p, "Kill command sent");
list_modify_icon(p,icon_failed);
//list_modify_color(p,"#CCCC00");
break;
case S_KILLED:
//list_modify_status(p, "Killed");
list_modify_icon(p,icon_failed);
//list_modify_color(p,"#CC0000");
notify_user(p);
break;
case S_REMOVE:
break;
default:
warning("Unknown info: %d\n",p->status.info);
}
if(p->status.warning){
list_modify_color(p, "#FF0000");
}
return 0;
}
static void ersatz_init (void)
{
int f;
uaecptr request;
uaecptr a;
already_failed = 0;
write_log ("initializing kickstart replacement\n");
if (disk_empty (0)) {
already_failed = 1;
notify_user (NUMSG_KICKREP);
uae_restart (-1, NULL);
return;
}
regs.s = 0;
/* Set some interrupt vectors */
for (a = 8; a < 0xC0; a += 4) {
put_long (a, 0xF8001A);
}
regs.isp = regs.msp = regs.usp = 0x800;
m68k_areg(®s, 7) = 0x80000;
regs.intmask = 0;
/* Build a dummy execbase */
put_long (4, m68k_areg(®s, 6) = 0x676);
put_byte (0x676 + 0x129, 0);
for (f = 1; f < 105; f++) {
put_word (0x676 - 6*f, 0x4EF9);
put_long (0x676 - 6*f + 2, 0xF8000C);
}
/* Some "supported" functions */
put_long (0x676 - 456 + 2, 0xF80014);
put_long (0x676 - 216 + 2, 0xF80020);
put_long (0x676 - 198 + 2, 0xF80026);
put_long (0x676 - 204 + 2, 0xF8002c);
put_long (0x676 - 210 + 2, 0xF8002a);
/* Build an IORequest */
request = 0x800;
put_word (request + 0x1C, 2);
put_long (request + 0x28, 0x4000);
put_long (request + 0x2C, 0);
put_long (request + 0x24, 0x200 * 4);
m68k_areg(®s, 1) = request;
ersatz_doio ();
/* kickstart disk loader */
if (get_long(0x4000) == 0x4b49434b) {
/* a kickstart disk was found in drive 0! */
write_log ("Loading Kickstart rom image from Kickstart disk\n");
/* print some notes... */
write_log ("NOTE: if UAE crashes set CPU to 68000 and/or chipmem size to 512KB!\n");
/* read rom image from kickstart disk */
put_word (request + 0x1C, 2);
put_long (request + 0x28, 0xF80000);
put_long (request + 0x2C, 0x200);
put_long (request + 0x24, 0x200 * 512);
m68k_areg(®s, 1) = request;
ersatz_doio ();
/* read rom image once again to mirror address space.
not elegant, but it works... */
put_word (request + 0x1C, 2);
put_long (request + 0x28, 0xFC0000);
put_long (request + 0x2C, 0x200);
put_long (request + 0x24, 0x200 * 512);
m68k_areg(®s, 1) = request;
ersatz_doio ();
disk_eject (0);
m68k_setpc (®s, 0xFC0002);
fill_prefetch_slow (®s);
uae_reset (0);
ersatzkickfile = 0;
return;
}
m68k_setpc (®s, 0x400C);
fill_prefetch_slow (®s);
/* Init the hardware */
put_long (0x3000, 0xFFFFFFFEul);
put_long (0xDFF080, 0x3000);
put_word (0xDFF088, 0);
put_word (0xDFF096, 0xE390);
put_word (0xDFF09A, 0xE02C);
put_word (0xDFF09E, 0x0000);
put_word (0xDFF092, 0x0038);
put_word (0xDFF094, 0x00D0);
put_word (0xDFF08E, 0x2C81);
put_word (0xDFF090, 0xF4C1);
put_word (0xDFF02A, 0x8000);
put_byte (0xBFD100, 0xF7);
put_byte (0xBFEE01, 0);
put_byte (0xBFEF01, 0x08);
put_byte (0xBFDE00, 0x04);
put_byte (0xBFDF00, 0x84);
put_byte (0xBFDD00, 0x9F);
put_byte (0xBFED01, 0x9F);
}
PROCESS_THREAD(usb_process, ev , data)
{
PROCESS_BEGIN();
PRINTF("USB process started\r\n");
while(1) {
PROCESS_WAIT_EVENT();
if (ev == PROCESS_EVENT_EXIT) break;
if (ev == PROCESS_EVENT_POLL) {
unsigned int events = usb_arch_get_global_events();
if (events) {
if (events & USB_EVENT_RESET) {
submit_setup();
usb_configuration_value = 0;
notify_user(USB_EVENT_RESET);
}
if (events & USB_EVENT_SUSPEND) {
notify_user(USB_EVENT_SUSPEND);
}
if (events & USB_EVENT_RESUME) {
notify_user(USB_EVENT_RESUME);
}
}
events = usb_get_ep_events(0);
if (events) {
if ((events & USB_EP_EVENT_NOTIFICATION)
&& !(ctrl_buffer.flags & USB_BUFFER_SUBMITTED)) {
/* PRINTF("Endpoint 0\r\n"); */
if (ctrl_buffer.flags & USB_BUFFER_FAILED) {
/* Something went wrong with the buffer, just wait for a
new SETUP packet */
PRINTF("Discarded\r\n");
submit_setup();
} else if (ctrl_buffer.flags & USB_BUFFER_SETUP) {
struct USBRequestHandlerHook *hook = usb_request_handler_hooks;
PRINTF("Setup\r\n");
#if 0
{
unsigned int i;
for (i = 0; i< 8; i++) PRINTF(" %02x", ((unsigned char*)&usb_setup_buffer)[i]);
PRINTF("\r\n");
}
#endif
while(hook) {
const struct USBRequestHandler *handler = hook->handler;
/* Check if the handler matches the request */
if (((handler->request_type ^ usb_setup_buffer.bmRequestType)
& handler->request_type_mask) == 0
&& ((handler->request ^ usb_setup_buffer.bRequest)
& handler->request_mask) == 0) {
if (handler->handler_func()) break;
}
hook = hook->next;
}
if (!hook) {
/* No handler found */
usb_error_stall();
PRINTF("Unhandled setup: %02x %02x %04x %04x %04x\r\n",
usb_setup_buffer.bmRequestType, usb_setup_buffer.bRequest,
usb_setup_buffer.wValue, usb_setup_buffer.wIndex,
usb_setup_buffer.wLength);
}
/* Check if any handler stalled the pipe, if so prepare for
next setup */
if (error_stall) {
error_stall = 0;
submit_setup();
}
} else {
if (ctrl_buffer.id == IN_ID) {
/* Receive status stage */
PRINTF("Status OUT\r\n");
ctrl_buffer.flags = USB_BUFFER_NOTIFY;
ctrl_buffer.next = NULL;
ctrl_buffer.data = NULL;
ctrl_buffer.left = 0;
ctrl_buffer.id = STATUS_OUT_ID;
usb_submit_recv_buffer(0,&ctrl_buffer);
} else if (ctrl_buffer.id == STATUS_OUT_ID) {
PRINTF("Status OUT done\r\n");
submit_setup();
} else if (ctrl_buffer.id == STATUS_IN_ID) {
PRINTF("Status IN done\r\n");
if (usb_flags & USB_FLAG_ADDRESS_PENDING) {
while(usb_send_pending(0));
usb_arch_set_address(LOW_BYTE(usb_setup_buffer.wValue));
usb_flags &= ~USB_FLAG_ADDRESS_PENDING;
}
submit_setup();
} else if (ctrl_buffer.id == OUT_ID) {
PRINTF("OUT\r\n");
if (data_callback) {
data_callback(ctrl_data, ctrl_data_len- ctrl_buffer.left);
} else {
usb_send_ctrl_status();
}
}
}
}
}
}
}
PROCESS_END();
}
static unsigned int
handle_standard_requests()
{
switch(usb_setup_buffer.bmRequestType) {
case 0x80: /* standard device IN requests */
switch(usb_setup_buffer.bRequest) {
case GET_DESCRIPTOR:
switch (HIGH_BYTE(usb_setup_buffer.wValue)) {
case DEVICE:
get_device_descriptor();
break;
case CONFIGURATION:
get_configuration_descriptor();
break;
case STRING:
get_string_descriptor();
break;
default:
/* Unknown descriptor */
return 0;
}
break;
case GET_CONFIGURATION:
get_configuration();
break;
case GET_STATUS:
get_device_status();
break;
case GET_INTERFACE:
get_interface();
break;
default:
return 0;
}
break;
case 0x81: /* standard interface IN requests */
switch(usb_setup_buffer.bRequest) {
case GET_STATUS:
get_interface_status();
break;
#ifdef HID_ENABLED
case GET_DESCRIPTOR:
switch (USB_setup_buffer.wValue.byte.high) {
case REPORT:
get_report_descriptor();
break;
}
break;
#endif
default:
return 0;
}
break;
case 0x82: /* standard endpoint IN requests */
switch(usb_setup_buffer.bRequest) {
case GET_STATUS:
get_endpoint_status();
break;
default:
return 0;
}
break;
case 0x00: /* standard device OUT requests */
switch(usb_setup_buffer.bRequest) {
case SET_ADDRESS:
PRINTF("Address: %d\r\n", LOW_BYTE(usb_setup_buffer.wValue));
usb_flags |= USB_FLAG_ADDRESS_PENDING;
/* The actual setting of the address is done when the status packet
is sent. */
usb_send_ctrl_status();
break;
#if SETABLE_STRING_DESCRIPTORS > 0
case SET_DESCRIPTOR:
if (usb_setup_buffer.wValue.byte.high == STRING) {
set_string_descriptor();
} else {
return 0;
}
break;
#endif
case SET_CONFIGURATION:
if (set_configuration()) {
#if 0
config_msg.data.config = LOW_BYTE(usb_setup_buffer.wValue);
notify_user(&config_msg);
#endif
}
break;
default:
return 0;
}
break;
case 0x01: /* standard interface OUT requests */
switch(usb_setup_buffer.bRequest) {
case SET_INTERFACE:
/* Change interface here if we support more than one */
usb_send_ctrl_status();
break;
default:
return 0;
}
break;
case 0x02: /* standard endpoint OUT requests */
switch(usb_setup_buffer.bRequest) {
case SET_FEATURE:
case CLEAR_FEATURE:
if (usb_setup_buffer.wValue == ENDPOINT_HALT_FEATURE) {
usb_arch_halt_endpoint(usb_setup_buffer.wIndex, usb_setup_buffer.bRequest== SET_FEATURE);
usb_send_ctrl_status();
} else {
usb_error_stall();
}
break;
default:
return 0;
}
break;
#ifdef HID_ENABLED
case 0xa1: /* class specific interface IN request*/
switch(USB_setup_buffer.bRequest) {
case GET_HID_REPORT:
PRINTF("Get report\r\n");
send_ctrl_response((code u_int8_t*)&zero_byte,
sizeof(zero_byte));
break;
case GET_HID_IDLE:
PRINTF("Get idle\r\n");
send_ctrl_response((code u_int8_t*)&zero_byte,
sizeof(zero_byte));
break;
default:
return 0;
}
break;
case 0x21: /* class specific interface OUT request*/
switch(USB_setup_buffer.bRequest) {
case SET_HID_IDLE:
PRINTF("Set idle\r\n");
send_ctrl_status();
break;
default:
return 0;
}
break;
#endif
default:
return 0;
}
return 1;
}
