double GA::evaluate_individual_fitness(Individual* indv)
{
double* cuts = indv->get_cuts();
// if it is already calculated, return significance from histogram
long bin_z = hist_z->GetBin(cuts, false);
if (bin_z >= 0) {
double s = hist_s->GetBinContent(bin_z);
indv->set_signal(s);
double b = hist_b->GetBinContent(bin_z);
indv->set_background(b);
double significance = 0.;
if (s < ZERO || b < ZERO || b < m_opt_background_min || b > m_opt_background_max)
significance = 0.;
else
significance = hist_z->GetBinContent(bin_z);
indv->set_fitness(significance);
return significance;
}
// Calculate significance
TString selection = get_selection(indv);
double s = get_events(m_signal_chain, selection);
double b = get_events(m_background_chain, selection);
if (s < 0)
s = 0.;
if (b < 0)
b = 0.;
indv->set_signal(s);
indv->set_background(b);
double significance = 0.;
if (m_opt_type == 1)
significance = get_s_over_b(s, b);
else if (m_opt_type == 2)
significance = get_s_over_total(s, b);
else if (m_opt_type == 3)
significance = get_significance(s, b, m_opt_background_syst);
if (s < ZERO || b < ZERO || b < m_opt_background_min || b > m_opt_background_max)
significance = 0.;
hist_s->SetBinContent(hist_s->GetBin(cuts), s);
hist_b->SetBinContent(hist_b->GetBin(cuts), b);
hist_z->SetBinContent(hist_z->GetBin(cuts), significance);
indv->set_fitness(significance);
return significance;
}
u32 SPUThread::get_ch_count(u32 ch)
{
if (Ini.HLELogging.GetValue())
{
LOG_NOTICE(SPU, "get_ch_count(ch=%d [%s])", ch, ch < 128 ? spu_ch_name[ch] : "???");
}
switch (ch)
{
//case MFC_Cmd: return 16;
//case SPU_WrSRR0: return 1; break;
//case SPU_RdSRR0: return 1; break;
case SPU_WrOutMbox: return ch_out_mbox.get_count() ^ 1; break;
case SPU_WrOutIntrMbox: return ch_out_intr_mbox.get_count() ^ 1; break;
case SPU_RdInMbox: return ch_in_mbox.get_count(); break;
case MFC_RdTagStat: return ch_tag_stat.get_count(); break;
case MFC_RdListStallStat: return ch_stall_stat.get_count(); break;
case MFC_WrTagUpdate: return ch_tag_stat.get_count(); break; // hack
case SPU_RdSigNotify1: return ch_snr1.get_count(); break;
case SPU_RdSigNotify2: return ch_snr2.get_count(); break;
case MFC_RdAtomicStat: return ch_atomic_stat.get_count(); break;
case SPU_RdEventStat: return get_events() ? 1 : 0; break;
}
throw EXCEPTION("Unknown/illegal channel (ch=%d [%s])", ch, ch < 128 ? spu_ch_name[ch] : "???");
}
void jump::menu::SplashScreen::update(sf::RenderWindow& window)
{
if (!is_running())
return;
auto events = get_events();
while(!events.empty())
{
auto event = events.front();
events.pop();
if (event.type == sf::Event::Resized)
{
sprite_->setScale(static_cast<float>(window.getSize().x) / texture_->getSize().x, static_cast<float>(window.getSize().y) / texture_->getSize().y);
}
if (event.type == sf::Event::KeyPressed || event.type == sf::Event::MouseButtonPressed)
{
if (fade_in_)
{
try
{
system::AnimationHandler::remove_animation(fade_in_);
}
catch (...)
{
}
fade_in_ = nullptr;
}
else
{
try
{
system::AnimationHandler::remove_animation(fade_out_);
}
catch (...)
{
}
fade_out_ = nullptr;
stop();
}
}
}
if (fade_in_)
if (!system::AnimationHandler::contains(fade_in_))
fade_in_ = nullptr;
if (fade_out_)
if (!system::AnimationHandler::contains(fade_out_))
{
fade_out_ = nullptr;
stop();
}
}
int kvdb_input_event_get(unsigned int event[3])
{
event[0]=0 ;
event[1]=0 ;
event[2]=0 ;
get_events(event);
switch(event[1])
{
case IR_KEY_UP :
event[0]=KEY_MESSAGE ;
event[1]=KV_KEY_UP ;
event[2]=0 ;
return 1 ;
case IR_KEY_DOWN :
event[0]=KEY_MESSAGE ;
event[1]=KV_KEY_DOWN ;
event[2]=0 ;
return 1 ;
case IR_KEY_RIGHT :
event[0]=KEY_MESSAGE ;
event[1]=KV_KEY_RIGHT ;
event[2]=0 ;
return 1 ;
case IR_KEY_LEFT :
event[0]=KEY_MESSAGE ;
event[1]=KV_KEY_LEFT ;
event[2]=0 ;
return 1 ;
case IR_KEY_OK :
event[0]=KEY_MESSAGE ;
event[1]=KV_KEY_SELECT ;
event[2]=0 ;
return 1 ;
case IR_KEY_EXIT :
event[0]=KEY_MESSAGE ;
event[1]=KV_KEY_EXIT ;
event[2]=0 ;
return 2 ;
default :
return 0 ;
}
return 0 ;
}
void DsoFinder::populate_event_combo()
{
ui->itemeventcomboBox->clear();
event_data events = get_events();
for(int i=0;i<events.eventcount;i++) {
ui->itemeventcomboBox->addItem(events.events[i].caption);
}
delete [] events.events;
ui->itemeventcomboBox->setCurrentIndex(config.use_event);
}
int EPoll::updateFd(SOCKET_FD fd, uint32_t events)
{
if(fd >= poll_items_.size() || INVALID_FD == poll_items_[fd].fd) {
return KUMA_ERROR_FAILED;
}
struct epoll_event evt = {0};
evt.data.ptr = (void*)(long)fd;
evt.events = get_events(events);
if(epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, fd, &evt) < 0) {
KUMA_INFOTRACE("EPoll::updateFd error, fd="<<fd<<", errno="<<errno);
return KUMA_ERROR_FAILED;
}
return KUMA_ERROR_NOERR;
}
RenderArea::RenderArea(RenderAreaPtr theContext) : AbstractRenderWindow(jslib::JSApp::ShellErrorReporter),
_myContextRefCount(0),
_isFirstFrame(true)
{
GdkGLConfig * myGLConfig = gdk_gl_config_new_by_mode(
GdkGLConfigMode(GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE | GDK_GL_MODE_ALPHA));
if (myGLConfig == 0) {
throw asl::Exception("can't init GL",PLUS_FILE_LINE);
}
// If another render area is supplied as constructor paramter, this render area is uses as
// source for a shared y60-gl-context and gdk-gl-context.
GdkGLContext * myGdkGLContext = 0;
if (theContext) {
myGdkGLContext = theContext->getGdkGlContext();
if (!myGdkGLContext) {
throw asl::Exception("RenderArea: Failed to get gdk GL context from shared render area.", PLUS_FILE_LINE);
}
setGLContext(theContext->getGLContext());
} else {
setGLContext(GLContextPtr(new GLContext()));
}
/* Set OpenGL-capability to the widget. */
DB(cerr << "RenderArea::RenderArea() sharing with " << myGdkGLContext << endl);
if (!gtk_widget_set_gl_capability (GTK_WIDGET(gobj()),
myGLConfig,
myGdkGLContext,
true,
GDK_GL_RGBA_TYPE))
{
throw asl::Exception("RenderArea: could not create GL context!", PLUS_FILE_LINE);
}
// enable mouse events
Gdk::EventMask flags = get_events();
flags |= Gdk::BUTTON_PRESS_MASK;
flags |= Gdk::POINTER_MOTION_MASK;
flags |= Gdk::BUTTON_RELEASE_MASK;
flags |= Gdk::SCROLL_MASK;
flags |= Gdk::ENTER_NOTIFY_MASK;
flags |= Gdk::LEAVE_NOTIFY_MASK;
set_events(flags);
y60::EventDispatcher::get().addSource(&_myEventAdapter);
y60::EventDispatcher::get().addSink(this);
// TODO: createRenderer(theOtherRenderer);
ShaderLibrary::setGLisReadyFlag(true);
}
/**
* Holding registers (empieza en 1):
* LOG_INTERVAL + DATETIME + EVENTS
*/
eMBErrorCode eMBRegHoldingCB(UCHAR * buffer, USHORT address, USHORT regs,
eMBRegisterMode mode) {
// indice para saber por qué grupo de registros voy avanzando
uint16_t idx = address;
// hago operaciones de bit en una variable, para no usar dos
// es para indicar si debo actualizar el grupo de registros
// de eventos y/o datetime.
uint8_t flag = 0;
// grupo de registros correspondiente a datetime
uint16_t* dt = (uint16_t*) &datetime;
// grupo de registros correspondiente a los eventos.
uint16_t* events = (uint16_t*) get_events();
if ((address + regs - 1) > (EVENTS_SIZE + LOGEVENT_SIZE + DATETIME_SIZE)) {
return MB_ENOREG;
}
// si me piden algo que va mas allá de logevent (primer registro)
// avanzo el siguiente grupo, datetime
if (address > LOGEVENT_SIZE) {
dt += address - LOGEVENT_SIZE - 1;
}
// si me piden algo que va mas allá del segundo registro (datetime)
// avanzo el tercer grupo, events hasta donde haga falta.
if (address > (LOGEVENT_SIZE + DATETIME_SIZE)) {
events += address - LOGEVENT_SIZE - DATETIME_SIZE - 1;
}
// operación de lectura
if (mode == MB_REG_READ) {
for (; idx < regs + address; idx++) {
if (idx > 0 && idx <= LOGEVENT_SIZE) {
uint16_t log_interval = get_log_interval();
*buffer++ = (log_interval >> 8);
*buffer++ = (log_interval & 0xFF);
} else if (idx > LOGEVENT_SIZE
&& idx <= (LOGEVENT_SIZE + DATETIME_SIZE)) {
*buffer++ = (*dt >> 8);
*buffer++ = (*dt & 0xFF);
dt++;
} else {
CWRuler::CWRuler(Mode theMode) :
Gtk::DrawingArea(),
_myMode(theMode),
_myState(IDLE),
_myValueRange(0.0, 1.0),
_myWindowCenter(0.0),
_myWindowWidth(0.0),
_myLower(0.0),
_myUpper(0.0)
{
set_size_request(256, 10);
Gdk::EventMask myFlags = get_events();
myFlags |= Gdk::POINTER_MOTION_MASK;
myFlags |= Gdk::BUTTON_PRESS_MASK;
myFlags |= Gdk::BUTTON_RELEASE_MASK;
set_events(myFlags);
}
void main(void){
init();
state_machine_init(&state);
loopdelay_time_ms = 10;
while(1){
loopdelay(state);
get_events();
switch(state){
case :
break;
}
}
}
void MyWidget::on_realize()
{
//Do not call base class Gtk::Widget::on_realize().
//It's intended only for widgets that set_has_window(false).
set_realized();
//Get the themed style from the CSS file:
get_style_property("example_scale", m_scale);
std::cout << "m_scale (example_scale from the theme/css-file) is: "
<< m_scale << std::endl;
if(!m_refGdkWindow)
{
//Create the GdkWindow:
GdkWindowAttr attributes;
memset(&attributes, 0, sizeof(attributes));
Gtk::Allocation allocation = get_allocation();
//Set initial position and size of the Gdk::Window:
attributes.x = allocation.get_x();
attributes.y = allocation.get_y();
attributes.width = allocation.get_width();
attributes.height = allocation.get_height();
attributes.event_mask = get_events () | Gdk::EXPOSURE_MASK;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.wclass = GDK_INPUT_OUTPUT;
m_refGdkWindow = Gdk::Window::create(get_parent_window(), &attributes,
GDK_WA_X | GDK_WA_Y);
set_window(m_refGdkWindow);
//set colors
override_background_color(Gdk::RGBA("red"));
override_color(Gdk::RGBA("blue"));
//make the widget receive expose events
m_refGdkWindow->set_user_data(gobj());
}
}
/* Fill-in the rest of the sDate struct with various nicities */
int
fill_datestruct(sDate *fdate,
int weekday,
int frm_month_num,
int to_month_num,
char *frm_day[],
char *frm_day_short[],
char *frm_month[],
char *frm_month_short[],
char *to_day[],
char *to_day_short[],
char *to_month[],
char *to_month_short[],
sEvent *farr_table,
int farr_size)
{
int error_event;
fdate->frm_dname = (char *) frm_day[weekday];
fdate->frm_dname_sh = (char *) frm_day_short[weekday];
fdate->frm_mname = (char *) frm_month[frm_month_num];
fdate->frm_mname_sh = (char *) frm_month_short[frm_month_num];
fdate->to_dname = (char *) to_day[weekday];
fdate->to_dname_sh = (char *) to_day_short[weekday];
fdate->to_mname = (char *) to_month[to_month_num];
fdate->to_mname_sh = (char *) to_month_short[to_month_num];
if (to_month_num == 12)
fdate->to_mname2 = (char *) to_month[1];
else
fdate->to_mname2 = (char *) to_month[to_month_num+1];
error_event = get_events(&fdate->event,
farr_table,
farr_size,
fdate->day,
fdate->month);
return(error_event);
}
void perfctr_init() {
int i;
if (!initialized) {
char *buf = malloc(64);
printf("Initializing performance counters\n");
printf("Stack address %p, heap %p\n", &buf, buf);
free(buf);
get_events();
/*
* Initialize libpfm library (required before we can use it)
*/
int ret = pfm_initialize();
if (ret != PFM_SUCCESS) errx(1, "cannot initialize library: %s", pfm_strerror(ret));
for (i = 0; i < g_num_events; i++) {
g_event_counts[i] = 0;
}
pthread_mutex_init(&count_lock, NULL);
initialized = 1;
}
}
int EPoll::registerFd(SOCKET_FD fd, uint32_t events, IOCallback&& cb)
{
resizePollItems(fd);
int epoll_op = EPOLL_CTL_ADD;
if (INVALID_FD != poll_items_[fd].fd) {
epoll_op = EPOLL_CTL_MOD;
}
poll_items_[fd].fd = fd;
poll_items_[fd].cb = std::move(cb);
struct epoll_event evt = {0};
evt.data.ptr = (void*)(long)fd;
evt.events = get_events(events);//EPOLLIN | EPOLLOUT | EPOLLERR | EPOLLHUP | EPOLLET;
if(epoll_ctl(epoll_fd_, epoll_op, fd, &evt) < 0) {
KUMA_ERRTRACE("EPoll::registerFd error, fd=" << fd << ", ev=" << evt.events << ", errno=" << errno);
return KUMA_ERROR_FAILED;
}
KUMA_INFOTRACE("EPoll::registerFd, fd=" << fd << ", ev=" << evt.events);
return KUMA_ERROR_NOERR;
}
void oprofile_init() {
const int kBufSize = 512;
int i = 0;
char buf[kBufSize];
char *end = buf;
get_events();
if (!opinitialized) {
//if (system("opcontrol --reset")) err(-1, "reset error");
//if (system("opcontrol --deinit")) err(-1, "deinit error");
//if (system("opcontrol --init"))err(-1, "init error");
//if (system("opcontrol --start-daemon")) err(-1, "start-daemon error");
end = buf + sprintf(buf, "opcontrol ");
for (i = 0; i < g_num_events; i++) {
end += snprintf(end, buf + kBufSize - end, "--event=%s ", g_events[i]);
if (end > buf + kBufSize) err(-1, "opcontrol arg buffer overflow");
}
if(system(buf)) err(-1, "opcontrol events");
opinitialized = 1;
}
}
KMError VPoll::registerFd(SOCKET_FD fd, KMEvent events, IOCallback cb)
{
if (fd < 0) {
return KMError::INVALID_PARAM;
}
resizePollItems(fd);
int idx = -1;
if (INVALID_FD == poll_items_[fd].fd || -1 == poll_items_[fd].idx) { // new
pollfd pfd;
pfd.fd = fd;
pfd.events = get_events(events);
poll_fds_.push_back(pfd);
idx = int(poll_fds_.size() - 1);
poll_items_[fd].idx = idx;
}
poll_items_[fd].fd = fd;
poll_items_[fd].events = events;
poll_items_[fd].cb = std::move(cb);
KUMA_INFOTRACE("VPoll::registerFd, fd="<<fd<<", events="<<events<<", index="<<idx);
return KMError::NOERR;
}
/**
* Does something when the block bar is realized.
*/
void GtkBlockBar::on_realize()
{
//Do not call base class Gtk::Widget::on_realize().
//It's intended only for widgets that set_has_window(false).
set_realized();
if(!m_refGdkWindow)
{
//Create the GdkWindow:
GdkWindowAttr attributes;
memset(&attributes, 0, sizeof(attributes));
Gtk::Allocation allocation = get_allocation();
//Set initial position and size of the Gdk::Window:
attributes.x = allocation.get_x();
attributes.y = allocation.get_y();
attributes.width = allocation.get_width();
attributes.height = allocation.get_height();
attributes.event_mask = get_events () | Gdk::EXPOSURE_MASK;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.wclass = GDK_INPUT_OUTPUT;
m_refGdkWindow = Gdk::Window::create(get_parent_window(), &attributes,
GDK_WA_X | GDK_WA_Y);
set_window(m_refGdkWindow);
//set colors TODO
//override_background_color(Gdk::RGBA("red"));
//override_color(Gdk::RGBA("green"));
//make the widget receive expose events
m_refGdkWindow->set_user_data(gobj());
}
}
KMError VPoll::updateFd(SOCKET_FD fd, KMEvent events)
{
int max_fd = int(poll_items_.size() - 1);
if (fd < 0 || -1 == max_fd || fd > max_fd) {
KUMA_WARNTRACE("VPoll::updateFd, failed, fd="<<fd<<", max_fd="<<max_fd);
return KMError::INVALID_PARAM;
}
if(poll_items_[fd].fd != fd) {
KUMA_WARNTRACE("VPoll::updateFd, failed, fd="<<fd<<", item_fd="<<poll_items_[fd].fd);
return KMError::INVALID_PARAM;
}
int idx = poll_items_[fd].idx;
if (idx < 0 || idx >= poll_fds_.size()) {
KUMA_WARNTRACE("VPoll::updateFd, failed, index="<<idx);
return KMError::INVALID_STATE;
}
if(poll_fds_[idx].fd != fd) {
KUMA_WARNTRACE("VPoll::updateFd, failed, fd="<<fd<<", pfds_fd="<<poll_fds_[idx].fd);
return KMError::INVALID_PARAM;
}
poll_fds_[idx].events = get_events(events);
poll_items_[fd].events = events;
return KMError::NOERR;
}
static void crash_and_debug(HKEY hkey, const char* argv0, const char* dbgtasks)
{
DWORD ret;
HANDLE start_event, done_event;
char* cmd;
char dbglog[MAX_PATH];
char childlog[MAX_PATH];
PROCESS_INFORMATION info;
STARTUPINFOA startup;
DWORD exit_code;
crash_blackbox_t crash_blackbox;
debugger_blackbox_t dbg_blackbox;
ret=RegSetValueExA(hkey, "auto", 0, REG_SZ, (BYTE*)"1", 2);
ok(ret == ERROR_SUCCESS, "unable to set AeDebug/auto: ret=%d\n", ret);
get_file_name(dbglog);
get_events(dbglog, &start_event, &done_event);
cmd=HeapAlloc(GetProcessHeap(), 0, strlen(argv0)+10+strlen(dbgtasks)+1+strlen(dbglog)+34+1);
sprintf(cmd, "%s debugger %s %s %%ld %%ld", argv0, dbgtasks, dbglog);
ret=RegSetValueExA(hkey, "debugger", 0, REG_SZ, (BYTE*)cmd, strlen(cmd)+1);
ok(ret == ERROR_SUCCESS, "unable to set AeDebug/debugger: ret=%d\n", ret);
HeapFree(GetProcessHeap(), 0, cmd);
get_file_name(childlog);
cmd=HeapAlloc(GetProcessHeap(), 0, strlen(argv0)+16+strlen(dbglog)+1);
sprintf(cmd, "%s debugger crash %s", argv0, childlog);
memset(&startup, 0, sizeof(startup));
startup.cb = sizeof(startup);
startup.dwFlags = STARTF_USESHOWWINDOW;
startup.wShowWindow = SW_SHOWNORMAL;
ret=CreateProcessA(NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &info);
ok(ret, "CreateProcess: err=%d\n", GetLastError());
HeapFree(GetProcessHeap(), 0, cmd);
CloseHandle(info.hThread);
/* The process exits... */
trace("waiting for child exit...\n");
ok(WaitForSingleObject(info.hProcess, 60000) == WAIT_OBJECT_0, "Timed out waiting for the child to crash\n");
ok(GetExitCodeProcess(info.hProcess, &exit_code), "GetExitCodeProcess failed: err=%d\n", GetLastError());
if (strstr(dbgtasks, "code2"))
{
/* If, after attaching to the debuggee, the debugger exits without
* detaching, then the debuggee gets a special exit code.
*/
ok(exit_code == 0xffffffff || /* Win 9x */
exit_code == 0x80 || /* NT4 */
exit_code == STATUS_DEBUGGER_INACTIVE, /* Win >= XP */
"wrong exit code : %08x\n", exit_code);
}
else
ok(exit_code == STATUS_ACCESS_VIOLATION ||
exit_code == WAIT_ABANDONED, /* win2k3 */
"exit code = %08x instead of STATUS_ACCESS_VIOLATION or WAIT_ABANDONED\n", exit_code);
CloseHandle(info.hProcess);
/* ...before the debugger */
if (strstr(dbgtasks, "order"))
ok(SetEvent(start_event), "SetEvent(start_event) failed\n");
trace("waiting for the debugger...\n");
ok(WaitForSingleObject(done_event, 60000) == WAIT_OBJECT_0, "Timed out waiting for the debugger\n");
assert(load_blackbox(childlog, &crash_blackbox, sizeof(crash_blackbox)));
assert(load_blackbox(dbglog, &dbg_blackbox, sizeof(dbg_blackbox)));
ok(dbg_blackbox.argc == 6, "wrong debugger argument count: %d\n", dbg_blackbox.argc);
ok(dbg_blackbox.pid == crash_blackbox.pid, "the child and debugged pids don't match: %d != %d\n", crash_blackbox.pid, dbg_blackbox.pid);
ok(dbg_blackbox.debug_rc, "debugger: SetEvent(debug_event) failed err=%d\n", dbg_blackbox.debug_err);
ok(dbg_blackbox.attach_rc, "DebugActiveProcess(%d) failed err=%d\n", dbg_blackbox.pid, dbg_blackbox.attach_err);
ok(dbg_blackbox.nokill_rc, "DebugSetProcessKillOnExit(FALSE) failed err=%d\n", dbg_blackbox.nokill_err);
ok(dbg_blackbox.detach_rc, "DebugActiveProcessStop(%d) failed err=%d\n", dbg_blackbox.pid, dbg_blackbox.detach_err);
assert(DeleteFileA(dbglog) != 0);
assert(DeleteFileA(childlog) != 0);
}
static void doDebugger(int argc, char** argv)
{
const char* logfile;
debugger_blackbox_t blackbox;
HANDLE start_event, done_event, debug_event;
blackbox.argc=argc;
logfile=(argc >= 4 ? argv[3] : NULL);
blackbox.pid=(argc >= 5 ? atol(argv[4]) : 0);
if (strstr(myARGV[2], "attach"))
{
blackbox.attach_rc=DebugActiveProcess(blackbox.pid);
if (!blackbox.attach_rc)
blackbox.attach_err=GetLastError();
}
else
blackbox.attach_rc=TRUE;
debug_event=(argc >= 6 ? (HANDLE)atol(argv[5]) : NULL);
if (debug_event && strstr(myARGV[2], "event"))
{
blackbox.debug_rc=SetEvent(debug_event);
if (!blackbox.debug_rc)
blackbox.debug_err=GetLastError();
}
else
blackbox.debug_rc=TRUE;
get_events(logfile, &start_event, &done_event);
if (strstr(myARGV[2], "order"))
{
trace("debugger: waiting for the start signal...\n");
WaitForSingleObject(start_event, INFINITE);
}
if (strstr(myARGV[2], "nokill"))
{
blackbox.nokill_rc=pDebugSetProcessKillOnExit(FALSE);
if (!blackbox.nokill_rc)
blackbox.nokill_err=GetLastError();
}
else
blackbox.nokill_rc=TRUE;
if (strstr(myARGV[2], "detach"))
{
blackbox.detach_rc=pDebugActiveProcessStop(blackbox.pid);
if (!blackbox.detach_rc)
blackbox.detach_err=GetLastError();
}
else
blackbox.detach_rc=TRUE;
save_blackbox(logfile, &blackbox, sizeof(blackbox));
trace("debugger: done debugging...\n");
SetEvent(done_event);
/* Just exit with a known value */
ExitProcess(0xdeadbeef);
}
u32 SPUThread::get_ch_value(u32 ch)
{
if (Ini.HLELogging.GetValue())
{
LOG_NOTICE(SPU, "get_ch_value(ch=%d [%s])", ch, ch < 128 ? spu_ch_name[ch] : "???");
}
auto read_channel = [this](spu_channel_t& channel) -> u32
{
std::unique_lock<std::mutex> lock(mutex, std::defer_lock);
while (true)
{
bool result;
u32 value;
std::tie(result, value) = channel.try_pop();
if (result)
{
return value;
}
CHECK_EMU_STATUS;
if (is_stopped()) throw CPUThreadStop{};
if (!lock)
{
lock.lock();
continue;
}
cv.wait(lock);
}
};
switch (ch)
{
//case SPU_RdSRR0:
// value = SRR0;
// break;
case SPU_RdInMbox:
{
std::unique_lock<std::mutex> lock(mutex, std::defer_lock);
while (true)
{
bool result;
u32 value;
u32 count;
std::tie(result, value, count) = ch_in_mbox.try_pop();
if (result)
{
if (count + 1 == 4 /* SPU_IN_MBOX_THRESHOLD */) // TODO: check this
{
int_ctrl[2].set(SPU_INT2_STAT_SPU_MAILBOX_THRESHOLD_INT);
}
return value;
}
CHECK_EMU_STATUS;
if (is_stopped()) throw CPUThreadStop{};
if (!lock)
{
lock.lock();
continue;
}
cv.wait(lock);
}
}
case MFC_RdTagStat:
{
return read_channel(ch_tag_stat);
}
case MFC_RdTagMask:
{
return ch_tag_mask;
}
case SPU_RdSigNotify1:
{
return read_channel(ch_snr1);
}
case SPU_RdSigNotify2:
{
return read_channel(ch_snr2);
}
case MFC_RdAtomicStat:
{
return read_channel(ch_atomic_stat);
}
case MFC_RdListStallStat:
{
return read_channel(ch_stall_stat);
}
case SPU_RdDec:
{
return ch_dec_value - (u32)(get_timebased_time() - ch_dec_start_timestamp);
}
case SPU_RdEventMask:
{
return ch_event_mask.load();
}
case SPU_RdEventStat:
{
std::unique_lock<std::mutex> lock(mutex, std::defer_lock);
// start waiting or return immediately
if (u32 res = get_events(true))
{
return res;
}
if (ch_event_mask.load() & SPU_EVENT_LR)
{
// register waiter if polling reservation status is required
vm::wait_op(*this, last_raddr, 128, WRAP_EXPR(get_events(true) || is_stopped()));
}
else
{
lock.lock();
// simple waiting loop otherwise
while (!get_events(true) && !is_stopped())
{
CHECK_EMU_STATUS;
cv.wait(lock);
}
}
ch_event_stat &= ~SPU_EVENT_WAITING;
if (is_stopped()) throw CPUThreadStop{};
return get_events();
}
case SPU_RdMachStat:
{
// HACK: "Not isolated" status
// Return SPU Interrupt status in LSB
return (ch_event_stat.load() & SPU_EVENT_INTR_ENABLED) != 0;
}
}
throw EXCEPTION("Unknown/illegal channel (ch=%d [%s])", ch, ch < 128 ? spu_ch_name[ch] : "???");
}
static long mxc_ipu_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case IPU_INIT_CHANNEL:
{
ipu_channel_parm parm;
if (copy_from_user
(&parm, (ipu_channel_parm *) arg,
sizeof(ipu_channel_parm)))
return -EFAULT;
if (!parm.flag) {
ret =
ipu_init_channel(parm.channel,
&parm.params);
} else {
ret = ipu_init_channel(parm.channel, NULL);
}
}
break;
case IPU_UNINIT_CHANNEL:
{
ipu_channel_t ch;
int __user *argp = (void __user *)arg;
if (get_user(ch, argp))
return -EFAULT;
ipu_uninit_channel(ch);
}
break;
case IPU_INIT_CHANNEL_BUFFER:
{
ipu_channel_buf_parm parm;
if (copy_from_user
(&parm, (ipu_channel_buf_parm *) arg,
sizeof(ipu_channel_buf_parm)))
return -EFAULT;
ret =
ipu_init_channel_buffer(
parm.channel, parm.type,
parm.pixel_fmt,
parm.width, parm.height,
parm.stride,
parm.rot_mode,
parm.phyaddr_0,
parm.phyaddr_1,
parm.u_offset,
parm.v_offset);
}
break;
case IPU_UPDATE_CHANNEL_BUFFER:
{
ipu_channel_buf_parm parm;
if (copy_from_user
(&parm, (ipu_channel_buf_parm *) arg,
sizeof(ipu_channel_buf_parm)))
return -EFAULT;
if ((parm.phyaddr_0 != (dma_addr_t) NULL)
&& (parm.phyaddr_1 == (dma_addr_t) NULL)) {
ret =
ipu_update_channel_buffer(
parm.channel,
parm.type,
parm.bufNum,
parm.phyaddr_0);
} else if ((parm.phyaddr_0 == (dma_addr_t) NULL)
&& (parm.phyaddr_1 != (dma_addr_t) NULL)) {
ret =
ipu_update_channel_buffer(
parm.channel,
parm.type,
parm.bufNum,
parm.phyaddr_1);
} else {
ret = -1;
}
}
break;
case IPU_SELECT_CHANNEL_BUFFER:
{
ipu_channel_buf_parm parm;
if (copy_from_user
(&parm, (ipu_channel_buf_parm *) arg,
sizeof(ipu_channel_buf_parm)))
return -EFAULT;
ret =
ipu_select_buffer(parm.channel,
parm.type, parm.bufNum);
}
break;
case IPU_SELECT_MULTI_VDI_BUFFER:
{
uint32_t parm;
if (copy_from_user
(&parm, (uint32_t *) arg,
sizeof(uint32_t)))
return -EFAULT;
ret = ipu_select_multi_vdi_buffer(parm);
}
break;
case IPU_LINK_CHANNELS:
{
ipu_channel_link link;
if (copy_from_user
(&link, (ipu_channel_link *) arg,
sizeof(ipu_channel_link)))
return -EFAULT;
ret = ipu_link_channels(link.src_ch,
link.dest_ch);
}
break;
case IPU_UNLINK_CHANNELS:
{
ipu_channel_link link;
if (copy_from_user
(&link, (ipu_channel_link *) arg,
sizeof(ipu_channel_link)))
return -EFAULT;
ret = ipu_unlink_channels(link.src_ch,
link.dest_ch);
}
break;
case IPU_ENABLE_CHANNEL:
{
ipu_channel_t ch;
int __user *argp = (void __user *)arg;
if (get_user(ch, argp))
return -EFAULT;
ipu_enable_channel(ch);
}
break;
case IPU_DISABLE_CHANNEL:
{
ipu_channel_info info;
if (copy_from_user
(&info, (ipu_channel_info *) arg,
sizeof(ipu_channel_info)))
return -EFAULT;
ret = ipu_disable_channel(info.channel,
info.stop);
}
break;
case IPU_ENABLE_IRQ:
{
uint32_t irq;
int __user *argp = (void __user *)arg;
if (get_user(irq, argp))
return -EFAULT;
ipu_enable_irq(irq);
}
break;
case IPU_DISABLE_IRQ:
{
uint32_t irq;
int __user *argp = (void __user *)arg;
if (get_user(irq, argp))
return -EFAULT;
ipu_disable_irq(irq);
}
break;
case IPU_CLEAR_IRQ:
{
uint32_t irq;
int __user *argp = (void __user *)arg;
if (get_user(irq, argp))
return -EFAULT;
ipu_clear_irq(irq);
}
break;
case IPU_FREE_IRQ:
{
ipu_irq_info info;
if (copy_from_user
(&info, (ipu_irq_info *) arg,
sizeof(ipu_irq_info)))
return -EFAULT;
ipu_free_irq(info.irq, info.dev_id);
irq_info[info.irq].irq_pending = 0;
}
break;
case IPU_REQUEST_IRQ_STATUS:
{
uint32_t irq;
int __user *argp = (void __user *)arg;
if (get_user(irq, argp))
return -EFAULT;
ret = ipu_get_irq_status(irq);
}
break;
case IPU_REGISTER_GENERIC_ISR:
{
ipu_event_info info;
if (copy_from_user
(&info, (ipu_event_info *) arg,
sizeof(ipu_event_info)))
return -EFAULT;
ret =
ipu_request_irq(info.irq,
mxc_ipu_generic_handler,
0, "video_sink", info.dev);
if (ret == 0)
init_waitqueue_head(&(irq_info[info.irq].waitq));
}
break;
case IPU_GET_EVENT:
/* User will have to allocate event_type
structure and pass the pointer in arg */
{
ipu_event_info info;
int r = -1;
if (copy_from_user
(&info, (ipu_event_info *) arg,
sizeof(ipu_event_info)))
return -EFAULT;
r = get_events(&info);
if (r == -1) {
if ((file->f_flags & O_NONBLOCK) &&
(irq_info[info.irq].irq_pending == 0))
return -EAGAIN;
wait_event_interruptible_timeout(irq_info[info.irq].waitq,
(irq_info[info.irq].irq_pending != 0), 2 * HZ);
r = get_events(&info);
}
ret = -1;
if (r == 0) {
if (!copy_to_user((ipu_event_info *) arg,
&info, sizeof(ipu_event_info)))
ret = 0;
}
}
break;
case IPU_ALOC_MEM:
{
ipu_mem_info info;
if (copy_from_user
(&info, (ipu_mem_info *) arg,
sizeof(ipu_mem_info)))
return -EFAULT;
info.vaddr = dma_alloc_coherent(0,
PAGE_ALIGN(info.size),
&info.paddr,
GFP_DMA | GFP_KERNEL);
if (info.vaddr == 0) {
printk(KERN_ERR "dma alloc failed!\n");
return -ENOBUFS;
}
if (copy_to_user((ipu_mem_info *) arg, &info,
sizeof(ipu_mem_info)) > 0)
return -EFAULT;
}
break;
case IPU_FREE_MEM:
{
ipu_mem_info info;
if (copy_from_user
(&info, (ipu_mem_info *) arg,
sizeof(ipu_mem_info)))
return -EFAULT;
if (info.vaddr)
dma_free_coherent(0, PAGE_ALIGN(info.size),
info.vaddr, info.paddr);
else
return -EFAULT;
}
break;
case IPU_IS_CHAN_BUSY:
{
ipu_channel_t chan;
if (copy_from_user
(&chan, (ipu_channel_t *)arg,
sizeof(ipu_channel_t)))
return -EFAULT;
if (ipu_is_channel_busy(chan))
ret = 1;
else
ret = 0;
}
break;
case IPU_CALC_STRIPES_SIZE:
{
ipu_stripe_parm stripe_parm;
if (copy_from_user (&stripe_parm, (ipu_stripe_parm *)arg,
sizeof(ipu_stripe_parm)))
return -EFAULT;
ipu_calc_stripes_sizes(stripe_parm.input_width,
stripe_parm.output_width,
stripe_parm.maximal_stripe_width,
stripe_parm.cirr,
stripe_parm.equal_stripes,
stripe_parm.input_pixelformat,
stripe_parm.output_pixelformat,
&stripe_parm.left,
&stripe_parm.right);
if (copy_to_user((ipu_stripe_parm *) arg, &stripe_parm,
sizeof(ipu_stripe_parm)) > 0)
return -EFAULT;
}
break;
case IPU_UPDATE_BUF_OFFSET:
{
ipu_buf_offset_parm offset_parm;
if (copy_from_user (&offset_parm, (ipu_buf_offset_parm *)arg,
sizeof(ipu_buf_offset_parm)))
return -EFAULT;
ret = ipu_update_channel_offset(offset_parm.channel,
offset_parm.type,
offset_parm.pixel_fmt,
offset_parm.width,
offset_parm.height,
offset_parm.stride,
offset_parm.u_offset,
offset_parm.v_offset,
offset_parm.vertical_offset,
offset_parm.horizontal_offset);
}
break;
case IPU_CSC_UPDATE:
{
int param[5][3];
ipu_csc_update csc;
if (copy_from_user(&csc, (void *) arg,
sizeof(ipu_csc_update)))
return -EFAULT;
if (copy_from_user(¶m[0][0], (void *) csc.param,
sizeof(param)))
return -EFAULT;
ipu_set_csc_coefficients(csc.channel, param);
}
break;
default:
break;
}
return ret;
}
int
main(int argc, char *argv[], char *env[])
{
char *display_name = NULL;
char *device_name = NULL;
char *output_name = NULL;
XSetWindowAttributes xswa;
int i = 0;
double a, a1, a2, b, b1, b2, xerr, yerr;
int xi_opcode, event, error;
XExtensionVersion *version;
XDeviceInfo *info;
XDevice *device;
long calib_data[4];
unsigned long mask;
unsigned char swap;
int keep_cursor = 0, ch;
/* Crosshair placement */
int cpx[] = { 0, 0, 1, 1, 1 };
int cpy[] = { 0, 1, 0, 0, 1 };
while ((ch = getopt(argc, argv, "cD:d:o:v")) != -1) {
switch (ch) {
case 'c':
keep_cursor++;
break;
case 'D':
display_name = optarg;
break;
case 'd':
device_name = optarg;
break;
case 'o':
output_name = optarg;
break;
case 'v':
verbose = True;
break;
default:
usage();
/* NOTREACHED */
}
}
argc -= optind;
argv += optind;
if (argc != 0)
usage();
/* connect to X server */
if ((display = XOpenDisplay(display_name)) == NULL) {
fprintf(stderr, "%s: cannot connect to X server %s\n",
__progname, XDisplayName(display_name));
exit(1);
}
screen = DefaultScreen(display);
root = RootWindow(display, screen);
/* get screen size from display structure macro */
xpos = 0;
ypos = 0;
width = DisplayWidth(display, screen);
height = DisplayHeight(display, screen);
if (XRRQueryExtension(display, &event, &error)) {
int major, minor;
if (XRRQueryVersion(display, &major, &minor) != True) {
fprintf(stderr, "Error querying XRandR version");
} else {
printf("XRandR extension version %d.%d present\n",
major, minor);
has_xrandr = True;
if (major > 1 || (major == 1 && minor >=2))
has_xrandr_1_2 = True;
if (major > 1 || (major == 1 && minor >=3))
has_xrandr_1_3 = True;
}
}
if (output_name != NULL) {
if (has_xrandr_1_2) {
get_xrandr_config(display, root, output_name,
&xpos, &ypos, &width, &height);
} else {
fprintf(stderr, "%s: can not specify an output "
"whithout XRandr 1.2 or later", __progname);
exit(2);
}
}
if (!XQueryExtension(display, INAME, &xi_opcode,
&event, &error)) {
fprintf(stderr, "%s: X Input extension not available.\n",
__progname);
exit(1);
}
version = XGetExtensionVersion(display, INAME);
if (version == NULL ||
version == (XExtensionVersion *)NoSuchExtension) {
fprintf(stderr, "Cannot query X Input version.\n");
exit(1);
}
XFree(version);
prop_calibration = XInternAtom(display, WS_PROP_CALIBRATION, True);
if (prop_calibration == None) {
fprintf(stderr, "Unable to find the \"%s\" device property.\n"
"There are probably no calibrable devices "
"on this system.\n", WS_PROP_CALIBRATION);
exit(1);
}
prop_swap = XInternAtom(display, WS_PROP_SWAP_AXES, True);
if (prop_swap == None) {
fprintf(stderr, "Unable to find the \"%s\" device property\n",
WS_PROP_SWAP_AXES);
exit(1);
}
info = find_device_info(device_name);
if (info == NULL) {
fprintf(stderr, "Unable to find the %s device\n",
device_name ? device_name : "default");
exit(1);
}
/* setup window attributes */
xswa.override_redirect = True;
xswa.background_pixel = BlackPixel(display, screen);
xswa.event_mask = ExposureMask | KeyPressMask;
mask = CWOverrideRedirect | CWBackPixel | CWEventMask;
if (!keep_cursor) {
xswa.cursor = create_empty_cursor();
mask |= CWCursor;
}
win = XCreateWindow(display, RootWindow(display, screen),
xpos, ypos, width, height, 0,
CopyFromParent, InputOutput, CopyFromParent,
mask, &xswa);
render_init();
XMapWindow(display, win);
XGrabKeyboard(display, win, False, GrabModeAsync, GrabModeAsync,
CurrentTime);
XGrabServer(display);
XClearWindow(display, win);
if (verbose)
printf("Calibrating %s\n", info->name);
device = XOpenDevice(display, info->id);
if (!device) {
fprintf(stderr, "Unable to open the X input device \"%s\"\n",
info->name);
return 0;
}
if (!register_events(info, device, 0))
exit(1);
uncalibrate(device);
calib:
XftDrawRect(draw, &bg, 0, 0, width, height);
for (i = 0; i < 5; i++) {
draw_graphics(cpx[i], cpy[i], i);
XFlush(display);
if (!get_events(i))
break;
XftDrawRect(draw, &bg, 0, 0, width, height);
}
if (interrupted)
cleanup_exit(device);
/* Check if X and Y should be swapped */
if (fabs(x[0] - x[1]) > fabs(y[0] - y[1])) {
calib.swapxy = 1;
for (i = 0; i < 5; i++) {
int t = x[i];
x[i] = y[i];
y[i] = t;
}
}
/* get touch pad resolution to screen resolution ratio */
a1 = (double) (x[4] - x[0]) / (double) (cx[4] - cx[0]);
a2 = (double) (x[3] - x[1]) / (double) (cx[3] - cx[1]);
/* get the minimum pad position on the X-axis */
b1 = x[0] - a1 * cx[0];
b2 = x[1] - a2 * cx[1];
/* use the average ratio and average minimum position */
a = (a1 + a2) / 2.0;
b = (b1 + b2) / 2.0;
xerr = a * width / 2 + b - x[2];
if (fabs(xerr) > fabs(a * width * .01)) {
fprintf(stderr, "Calibration problem: X axis error (%.2f) too high, try again\n",
fabs(xerr));
goto err;
}
calib.minx = (int) (b + 0.5);
calib.maxx = (int) (a * width + b + 0.5);
/* get touch pad resolution to screen resolution ratio */
a1 = (double) (y[4] - y[0]) / (double) (cy[4] - cy[0]);
a2 = (double) (y[3] - y[1]) / (double) (cy[3] - cy[1]);
/* get the minimum pad position on the Y-axis */
b1 = y[0] - a1 * cy[0];
b2 = y[1] - a2 * cy[1];
/* use the average ratio and average minimum position */
a = (a1 + a2) / 2.0;
b = (b1 + b2) / 2.0;
yerr = a * height / 2 + b - y[2];
if (fabs(yerr) > fabs(a * height * 0.01)) {
fprintf(stderr, "Calibration problem: Y axis error (%.2f) too high, try again\n",
fabs(yerr));
goto err;
}
calib.miny = (int) (b + 0.5);
calib.maxy = (int) (a * height + b + 0.5);
XFlush(display);
calib.resx = width;
calib.resy = height;
/* Send new values to the X server */
calib_data[0] = calib.minx;
calib_data[1] = calib.maxx;
calib_data[2] = calib.miny;
calib_data[3] = calib.maxy;
XChangeDeviceProperty(display, device, prop_calibration,
XA_INTEGER, 32, PropModeReplace, (unsigned char *)calib_data, 4);
swap = calib.swapxy;
XChangeDeviceProperty(display, device, prop_swap,
XA_INTEGER, 8, PropModeReplace, (unsigned char *)&swap, 1);
XCloseDevice(display, device);
XCloseDisplay(display);
/* And print them for storage in wsconsctl.conf */
printf("mouse.scale=%d,%d,%d,%d,%d,%d,%d\n",
calib.minx, calib.maxx,
calib.miny, calib.maxy,
calib.swapxy,
calib.resx, calib.resy);
return 0;
err:
draw_text(error_message, &errorColor);
XFlush(display);
sleep(2);
goto calib;
}
/* Event handler for tool 'configuration-manager' */
ATerm configuration_manager_handler(int conn, ATerm term)
{
ATerm in, out;
/* We need some temporary variables during matching */
char *s0;
ATerm t0, t1, t2;
if(ATmatch(term, "rec-eval(get-text-categories)")) {
return get_text_categories(conn);
}
if(ATmatch(term, "rec-do(change-workspace(<str>))", &s0)) {
change_workspace(conn, s0);
return NULL;
}
if(ATmatch(term, "rec-eval(get-language-extension(<str>))", &s0)) {
return get_language_extension(conn, s0);
}
if(ATmatch(term, "rec-eval(get-library-paths)")) {
return get_library_paths(conn);
}
if(ATmatch(term, "rec-eval(get-subtype-action(<term>,<term>,<term>))", &t0, &t1, &t2)) {
return get_subtype_action(conn, t0, t1, t2);
}
if(ATmatch(term, "rec-do(add-system-property(<term>))", &t0)) {
add_system_property(conn, t0);
return NULL;
}
if(ATmatch(term, "rec-eval(get-action(<term>,<term>))", &t0, &t1)) {
return get_action(conn, t0, t1);
}
if(ATmatch(term, "rec-do(add-system-properties(<str>))", &s0)) {
add_system_properties(conn, s0);
return NULL;
}
if(ATmatch(term, "rec-eval(get-module-paths)")) {
return get_module_paths(conn);
}
if(ATmatch(term, "rec-do(remove-system-property(<term>))", &t0)) {
remove_system_property(conn, t0);
return NULL;
}
if(ATmatch(term, "rec-eval(get-subtype-events(<term>,<term>))", &t0, &t1)) {
return get_subtype_events(conn, t0, t1);
}
if(ATmatch(term, "rec-eval(get-extension-editor(<str>))", &s0)) {
return get_extension_editor(conn, s0);
}
if(ATmatch(term, "rec-terminate(<term>)", &t0)) {
rec_terminate(conn, t0);
return NULL;
}
if(ATmatch(term, "rec-eval(get-events(<term>))", &t0)) {
return get_events(conn, t0);
}
if(ATmatch(term, "rec-do(signature(<term>,<term>))", &in, &out)) {
ATerm result = configuration_manager_checker(conn, in);
if(!ATmatch(result, "[]"))
ATfprintf(stderr, "warning: not in input signature:\n\t%\n\tl\n", result);
return NULL;
}
ATerror("tool configuration-manager cannot handle term %t", term);
return NULL; /* Silence the compiler */
}
int main(void) {
/** SDL2 initialized: */
if (sdl_init(SDL_INIT_VIDEO) != 0) {
fprintf(stdout, "SDL initialize failed (%s)\n", SDL_GetError());
exit(EXIT_FAILURE);
}
/** Window creation: */
SDL_Window *pWindow = NULL;
pWindow = sdl_create_window("Balls", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WIDTH, HEIGHT, SDL_WINDOW_SHOWN);
if (pWindow == NULL) {
fprintf(stderr, "Windows creation error: (%s)\n", SDL_GetError());
exit(EXIT_FAILURE);
}
/** Renderer creation. */
SDL_Renderer *pRenderer;
if ((pRenderer = sdl_create_renderer(pWindow, -1, SDL_RENDERER_ACCELERATED)) == NULL) {
fprintf(stderr, "SDL Renderer creating error (%s)\n", SDL_GetError());
exit(EXIT_FAILURE);
}
/** Random seed initialized. **/
struct timeval tv;
gettimeofday(&tv, NULL);
srand((unsigned int) tv.tv_usec);
/** Define the balls and initialized the balls. **/
Ball *red_ball = init_ball('r');
Ball *green_ball = init_ball('g');
Ball *blue_ball = init_ball('b');
Ball *yellow_ball = init_ball('y');
Ball *pink_ball = init_ball('p');
Ball *turquoise_ball = init_ball('t');
const int FPS = 90;
const int FRAME_DELAY = 1000 / FPS;
set_loop(true);
while (loop) {
/** SDL2 mainloop. **/
int frame_start = SDL_GetTicks();
/** Check if a ball collide the border rounded box: **/
check_collide_borders(red_ball);
check_collide_borders(green_ball);
check_collide_borders(blue_ball);
check_collide_borders(yellow_ball);
check_collide_borders(pink_ball);
check_collide_borders(turquoise_ball);
/** Increment the balls positions: **/
translate_ball(red_ball);
translate_ball(green_ball);
translate_ball(blue_ball);
translate_ball(yellow_ball);
translate_ball(pink_ball);
translate_ball(turquoise_ball);
clear(pRenderer, 127, 127, 127, 127);
/** Displaying the interior black boxe using a SDL2_gfx function. **/
boxRGBA(pRenderer, 32, 32, WIDTH - 32, HEIGHT - 32, 0, 0, 0, 255);
/** Display the balls: **/
display_ball(pRenderer, red_ball);
display_ball(pRenderer, green_ball);
display_ball(pRenderer, blue_ball);
display_ball(pRenderer, yellow_ball);
display_ball(pRenderer, pink_ball);
display_ball(pRenderer, turquoise_ball);
display(pRenderer);
update(pWindow);
get_events();
int frame_end = SDL_GetTicks() - frame_start;
if (frame_end < FRAME_DELAY) {
SDL_Delay(FRAME_DELAY - frame_end);
}
}
free_ball(red_ball);
free_ball(green_ball);
free_ball(blue_ball);
free_ball(yellow_ball);
free_ball(pink_ball);
free_ball(turquoise_ball);
clean_up(pRenderer, pWindow);
SDL_Quit();
exit(EXIT_SUCCESS);
}
static int mxc_ipu_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case IPU_INIT_CHANNEL:
{
ipu_channel_parm parm;
if (copy_from_user
(&parm, (ipu_channel_parm *) arg,
sizeof(ipu_channel_parm)))
return -EFAULT;
if (!parm.flag) {
ret =
ipu_init_channel(parm.channel,
&parm.params);
} else {
ret = ipu_init_channel(parm.channel, NULL);
}
}
break;
case IPU_UNINIT_CHANNEL:
{
ipu_channel_t ch;
int __user *argp = (void __user *)arg;
if (get_user(ch, argp))
return -EFAULT;
ipu_uninit_channel(ch);
}
break;
case IPU_INIT_CHANNEL_BUFFER:
{
ipu_channel_buf_parm parm;
if (copy_from_user
(&parm, (ipu_channel_buf_parm *) arg,
sizeof(ipu_channel_buf_parm)))
return -EFAULT;
ret =
ipu_init_channel_buffer(
parm.channel, parm.type,
parm.pixel_fmt,
parm.width, parm.height,
parm.stride,
parm.rot_mode,
parm.phyaddr_0,
parm.phyaddr_1,
parm.u_offset,
parm.v_offset);
}
break;
case IPU_UPDATE_CHANNEL_BUFFER:
{
ipu_channel_buf_parm parm;
if (copy_from_user
(&parm, (ipu_channel_buf_parm *) arg,
sizeof(ipu_channel_buf_parm)))
return -EFAULT;
if ((parm.phyaddr_0 != (dma_addr_t) NULL)
&& (parm.phyaddr_1 == (dma_addr_t) NULL)) {
ret =
ipu_update_channel_buffer(
parm.channel,
parm.type,
parm.bufNum,
parm.phyaddr_0);
} else if ((parm.phyaddr_0 == (dma_addr_t) NULL)
&& (parm.phyaddr_1 != (dma_addr_t) NULL)) {
ret =
ipu_update_channel_buffer(
parm.channel,
parm.type,
parm.bufNum,
parm.phyaddr_1);
} else {
ret = -1;
}
}
break;
case IPU_SELECT_CHANNEL_BUFFER:
{
ipu_channel_buf_parm parm;
if (copy_from_user
(&parm, (ipu_channel_buf_parm *) arg,
sizeof(ipu_channel_buf_parm)))
return -EFAULT;
ret =
ipu_select_buffer(parm.channel,
parm.type, parm.bufNum);
}
break;
case IPU_LINK_CHANNELS:
{
ipu_channel_link link;
if (copy_from_user
(&link, (ipu_channel_link *) arg,
sizeof(ipu_channel_link)))
return -EFAULT;
ret = ipu_link_channels(link.src_ch,
link.dest_ch);
}
break;
case IPU_UNLINK_CHANNELS:
{
ipu_channel_link link;
if (copy_from_user
(&link, (ipu_channel_link *) arg,
sizeof(ipu_channel_link)))
return -EFAULT;
ret = ipu_unlink_channels(link.src_ch,
link.dest_ch);
}
break;
case IPU_ENABLE_CHANNEL:
{
ipu_channel_t ch;
int __user *argp = (void __user *)arg;
if (get_user(ch, argp))
return -EFAULT;
ipu_enable_channel(ch);
}
break;
case IPU_DISABLE_CHANNEL:
{
ipu_channel_info info;
if (copy_from_user
(&info, (ipu_channel_info *) arg,
sizeof(ipu_channel_info)))
return -EFAULT;
ret = ipu_disable_channel(info.channel,
info.stop);
}
break;
case IPU_ENABLE_IRQ:
{
uint32_t irq;
int __user *argp = (void __user *)arg;
if (get_user(irq, argp))
return -EFAULT;
ipu_enable_irq(irq);
}
break;
case IPU_DISABLE_IRQ:
{
uint32_t irq;
int __user *argp = (void __user *)arg;
if (get_user(irq, argp))
return -EFAULT;
ipu_disable_irq(irq);
}
break;
case IPU_CLEAR_IRQ:
{
uint32_t irq;
int __user *argp = (void __user *)arg;
if (get_user(irq, argp))
return -EFAULT;
ipu_clear_irq(irq);
}
break;
case IPU_FREE_IRQ:
{
ipu_irq_info info;
int i;
if (copy_from_user
(&info, (ipu_irq_info *) arg,
sizeof(ipu_irq_info)))
return -EFAULT;
ipu_free_irq(info.irq, info.dev_id);
for (i = 0; i < MAX_Q_SIZE; i++) {
if (events[i].irq == info.irq)
events[i].irq = 0;
}
}
break;
case IPU_REQUEST_IRQ_STATUS:
{
uint32_t irq;
int __user *argp = (void __user *)arg;
if (get_user(irq, argp))
return -EFAULT;
ret = ipu_get_irq_status(irq);
}
break;
case IPU_REGISTER_GENERIC_ISR:
{
ipu_event_info info;
if (copy_from_user
(&info, (ipu_event_info *) arg,
sizeof(ipu_event_info)))
return -EFAULT;
ret =
ipu_request_irq(info.irq,
mxc_ipu_generic_handler,
0, "video_sink", info.dev);
}
break;
case IPU_GET_EVENT:
/* User will have to allocate event_type
structure and pass the pointer in arg */
{
ipu_event_info info;
int r = -1;
if (copy_from_user
(&info, (ipu_event_info *) arg,
sizeof(ipu_event_info)))
return -EFAULT;
r = get_events(&info);
if (r == -1) {
wait_event_interruptible_timeout(waitq,
(pending_events != 0), HZ/10);
r = get_events(&info);
}
ret = -1;
if (r == 0) {
if (!copy_to_user((ipu_event_info *) arg,
&info, sizeof(ipu_event_info)))
ret = 0;
}
}
break;
case IPU_ALOC_MEM:
{
ipu_mem_info info;
if (copy_from_user
(&info, (ipu_mem_info *) arg,
sizeof(ipu_mem_info)))
return -EFAULT;
info.vaddr = dma_alloc_coherent(0,
PAGE_ALIGN(info.size),
&info.paddr,
GFP_DMA | GFP_KERNEL);
if (info.vaddr == 0) {
printk(KERN_ERR "dma alloc failed!\n");
return -ENOBUFS;
}
if (copy_to_user((ipu_mem_info *) arg, &info,
sizeof(ipu_mem_info)) > 0)
return -EFAULT;
}
break;
case IPU_FREE_MEM:
{
ipu_mem_info info;
if (copy_from_user
(&info, (ipu_mem_info *) arg,
sizeof(ipu_mem_info)))
return -EFAULT;
if (info.vaddr)
dma_free_coherent(0, PAGE_ALIGN(info.size),
info.vaddr, info.paddr);
else
return -EFAULT;
}
break;
case IPU_IS_CHAN_BUSY:
{
ipu_channel_t chan;
if (copy_from_user
(&chan, (ipu_channel_t *)arg,
sizeof(ipu_channel_t)))
return -EFAULT;
if (ipu_is_channel_busy(chan))
ret = 1;
else
ret = 0;
}
break;
default:
break;
}
return ret;
}
static inline void update_state(void) {
DHT22_DATA_t sensor_values;
rtc_datetime_24h_t current_dt;
readDHT22(&sensor_values);
rtc_read(rtc, ¤t_dt);
event_t* events = get_events();
long start_secs;
long current_secs;
uint8_t i = 0;
uint8_t flag = 0;
state.temperature = sensor_values.raw_temperature;
state.humidity = sensor_values.raw_humidity;
state.light = adc_read(PHOTORESISTOR);
datetime = (datetime_t ) { .year = current_dt.year, .month =
current_dt.month, .date = current_dt.date, .hour =
current_dt.hour, .minute = current_dt.minute, .second =
current_dt.second };
current_secs = get_seconds((instant_t ) {
datetime.hour,
datetime.minute,
datetime.second });
// recorro eventos para ver si tengo que activar relays
for (i = 0; i < MAX_EVENTS; i++) {
if (events[i].enabled) {
start_secs = get_seconds(events[i].start);
if (start_secs < current_secs
&& (start_secs + events[i].duration) > current_secs) {
flag |= (1 << events[i].target); /* activar el evento */
}
}
}
// si activaron coil, estamos dentro de un evento o presionaron pulsador
for (uint8_t i = 0; i < NUMBER_OF_COILS; i++) {
if (relays & (1 << i) || (flag & (1 << i)) || is_pushed()) {
enable_relay(i);
} else {
disable_relay(i);
}
}
if (ticks >= get_log_interval()) {
update_log_filename(); /* si cambio el dia y hay que hacer roll del archivo */
//yyyyMMddhhmmss light humidity temperature
f_printf(&log_file, "%04d%02d%02d%02d%02d%02d\t%d\t%d\t%d\t%d\t%d\n",
datetime.year, datetime.month, datetime.date, datetime.hour,
datetime.minute, datetime.second, state.light, state.humidity,
state.temperature, is_relay_enabled(0), is_relay_enabled(1));
f_sync(&log_file);
ticks = 0;
}
}
void timer0_callback() {
ticks++;
LED_PORT ^= _BV(LED);
}
/**
* ecryptfs_readdir
* @file: The eCryptfs directory file
* @ctx: The actor to feed the entries to
*/
static int ecryptfs_readdir(struct file *file, struct dir_context *ctx)
{
int rc;
struct file *lower_file;
struct inode *inode = file_inode(file);
struct ecryptfs_getdents_callback buf = {
.ctx.actor = ecryptfs_filldir,
.caller = ctx,
.sb = inode->i_sb,
};
lower_file = ecryptfs_file_to_lower(file);
lower_file->f_pos = ctx->pos;
rc = iterate_dir(lower_file, &buf.ctx);
ctx->pos = buf.ctx.pos;
if (rc < 0)
goto out;
if (buf.filldir_called && !buf.entries_written)
goto out;
if (rc >= 0)
fsstack_copy_attr_atime(inode,
file_inode(lower_file));
out:
return rc;
}
struct kmem_cache *ecryptfs_file_info_cache;
static int read_or_initialize_metadata(struct dentry *dentry)
{
struct inode *inode = dentry->d_inode;
struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
struct ecryptfs_crypt_stat *crypt_stat;
int rc;
crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
mount_crypt_stat = &ecryptfs_superblock_to_private(
inode->i_sb)->mount_crypt_stat;
mutex_lock(&crypt_stat->cs_mutex);
if (crypt_stat->flags & ECRYPTFS_POLICY_APPLIED &&
crypt_stat->flags & ECRYPTFS_KEY_VALID) {
rc = 0;
goto out;
}
rc = ecryptfs_read_metadata(dentry);
if (!rc)
goto out;
if (mount_crypt_stat->flags & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED) {
crypt_stat->flags &= ~(ECRYPTFS_I_SIZE_INITIALIZED
| ECRYPTFS_ENCRYPTED);
rc = 0;
goto out;
}
if (!(mount_crypt_stat->flags & ECRYPTFS_XATTR_METADATA_ENABLED) &&
!i_size_read(ecryptfs_inode_to_lower(inode))) {
rc = ecryptfs_initialize_file(dentry, inode);
if (!rc)
goto out;
}
rc = -EIO;
out:
mutex_unlock(&crypt_stat->cs_mutex);
return rc;
}
/**
* ecryptfs_open
* @inode: inode speciying file to open
* @file: Structure to return filled in
*
* Opens the file specified by inode.
*
* Returns zero on success; non-zero otherwise
*/
static int ecryptfs_open(struct inode *inode, struct file *file)
{
int rc = 0;
struct ecryptfs_crypt_stat *crypt_stat = NULL;
struct dentry *ecryptfs_dentry = file->f_path.dentry;
int ret;
/* Private value of ecryptfs_dentry allocated in
* ecryptfs_lookup() */
struct ecryptfs_file_info *file_info;
/* Released in ecryptfs_release or end of function if failure */
file_info = kmem_cache_zalloc(ecryptfs_file_info_cache, GFP_KERNEL);
ecryptfs_set_file_private(file, file_info);
if (!file_info) {
ecryptfs_printk(KERN_ERR,
"Error attempting to allocate memory\n");
rc = -ENOMEM;
goto out;
}
crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
mutex_lock(&crypt_stat->cs_mutex);
if (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED)) {
ecryptfs_printk(KERN_DEBUG, "Setting flags for stat...\n");
/* Policy code enabled in future release */
crypt_stat->flags |= (ECRYPTFS_POLICY_APPLIED
| ECRYPTFS_ENCRYPTED);
}
mutex_unlock(&crypt_stat->cs_mutex);
rc = ecryptfs_get_lower_file(ecryptfs_dentry, inode);
if (rc) {
printk(KERN_ERR "%s: Error attempting to initialize "
"the lower file for the dentry with name "
"[%pd]; rc = [%d]\n", __func__,
ecryptfs_dentry, rc);
goto out_free;
}
if ((ecryptfs_inode_to_private(inode)->lower_file->f_flags & O_ACCMODE)
== O_RDONLY && (file->f_flags & O_ACCMODE) != O_RDONLY) {
rc = -EPERM;
printk(KERN_WARNING "%s: Lower file is RO; eCryptfs "
"file must hence be opened RO\n", __func__);
goto out_put;
}
ecryptfs_set_file_lower(
file, ecryptfs_inode_to_private(inode)->lower_file);
if (S_ISDIR(ecryptfs_dentry->d_inode->i_mode)) {
ecryptfs_printk(KERN_DEBUG, "This is a directory\n");
mutex_lock(&crypt_stat->cs_mutex);
crypt_stat->flags &= ~(ECRYPTFS_ENCRYPTED);
mutex_unlock(&crypt_stat->cs_mutex);
rc = 0;
goto out;
}
rc = read_or_initialize_metadata(ecryptfs_dentry);
if (rc)
goto out_put;
ecryptfs_printk(KERN_DEBUG, "inode w/ addr = [0x%p], i_ino = "
"[0x%.16lx] size: [0x%.16llx]\n", inode, inode->i_ino,
(unsigned long long)i_size_read(inode));
if (get_events() && get_events()->open_cb) {
ret = vfs_fsync(file, false);
if (ret)
ecryptfs_printk(KERN_ERR,
"failed to sync file ret = %d.\n", ret);
get_events()->open_cb(ecryptfs_inode_to_lower(inode),
crypt_stat);
if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
truncate_inode_pages(inode->i_mapping, 0);
truncate_inode_pages(
ecryptfs_inode_to_lower(inode)->i_mapping, 0);
}
}
goto out;
out_put:
ecryptfs_put_lower_file(inode);
out_free:
kmem_cache_free(ecryptfs_file_info_cache,
ecryptfs_file_to_private(file));
out:
return rc;
}
static int mxc_ipu_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case IPU_INIT_CHANNEL:
{
ipu_channel_parm parm;
if (copy_from_user
(&parm, (ipu_channel_parm *) arg,
sizeof(ipu_channel_parm))) {
return -EFAULT;
}
if (!parm.flag) {
ret =
ipu_init_channel(parm.channel,
&parm.params);
} else {
ret = ipu_init_channel(parm.channel, NULL);
}
}
break;
case IPU_UNINIT_CHANNEL:
{
ipu_channel_t ch;
int __user *argp = (void __user *)arg;
if (get_user(ch, argp))
return -EFAULT;
ipu_uninit_channel(ch);
}
break;
case IPU_INIT_CHANNEL_BUFFER:
{
ipu_channel_buf_parm parm;
if (copy_from_user
(&parm, (ipu_channel_buf_parm *) arg,
sizeof(ipu_channel_buf_parm))) {
return -EFAULT;
}
ret =
ipu_init_channel_buffer(parm.channel, parm.type,
parm.pixel_fmt,
parm.width, parm.height,
parm.stride,
parm.rot_mode,
parm.phyaddr_0,
parm.phyaddr_1,
parm.u_offset,
parm.v_offset);
}
break;
case IPU_UPDATE_CHANNEL_BUFFER:
{
ipu_channel_buf_parm parm;
if (copy_from_user
(&parm, (ipu_channel_buf_parm *) arg,
sizeof(ipu_channel_buf_parm))) {
return -EFAULT;
}
if ((parm.phyaddr_0 != (dma_addr_t) NULL)
&& (parm.phyaddr_1 == (dma_addr_t) NULL)) {
ret =
ipu_update_channel_buffer(parm.channel,
parm.type,
parm.bufNum,
parm.phyaddr_0);
} else if ((parm.phyaddr_0 == (dma_addr_t) NULL)
&& (parm.phyaddr_1 != (dma_addr_t) NULL)) {
ret =
ipu_update_channel_buffer(parm.channel,
parm.type,
parm.bufNum,
parm.phyaddr_1);
} else {
ret = -1;
}
}
break;
case IPU_SELECT_CHANNEL_BUFFER:
{
ipu_channel_buf_parm parm;
if (copy_from_user
(&parm, (ipu_channel_buf_parm *) arg,
sizeof(ipu_channel_buf_parm))) {
return -EFAULT;
}
ret =
ipu_select_buffer(parm.channel, parm.type,
parm.bufNum);
}
break;
case IPU_LINK_CHANNELS:
{
ipu_channel_link link;
if (copy_from_user
(&link, (ipu_channel_link *) arg,
sizeof(ipu_channel_link))) {
return -EFAULT;
}
ret = ipu_link_channels(link.src_ch, link.dest_ch);
}
break;
case IPU_UNLINK_CHANNELS:
{
ipu_channel_link link;
if (copy_from_user
(&link, (ipu_channel_link *) arg,
sizeof(ipu_channel_link))) {
return -EFAULT;
}
ret = ipu_unlink_channels(link.src_ch, link.dest_ch);
}
break;
case IPU_ENABLE_CHANNEL:
{
ipu_channel_t ch;
int __user *argp = (void __user *)arg;
if (get_user(ch, argp))
return -EFAULT;
ipu_enable_channel(ch);
}
break;
case IPU_DISABLE_CHANNEL:
{
ipu_channel_info info;
if (copy_from_user
(&info, (ipu_channel_info *) arg,
sizeof(ipu_channel_info))) {
return -EFAULT;
}
ret = ipu_disable_channel(info.channel, info.stop);
}
break;
case IPU_ENABLE_IRQ:
{
uint32_t irq;
int __user *argp = (void __user *)arg;
if (get_user(irq, argp))
return -EFAULT;
ipu_enable_irq(irq);
}
break;
case IPU_DISABLE_IRQ:
{
uint32_t irq;
int __user *argp = (void __user *)arg;
if (get_user(irq, argp))
return -EFAULT;
ipu_disable_irq(irq);
}
break;
case IPU_CLEAR_IRQ:
{
uint32_t irq;
int __user *argp = (void __user *)arg;
if (get_user(irq, argp))
return -EFAULT;
ipu_clear_irq(irq);
}
break;
case IPU_FREE_IRQ:
{
ipu_irq_info info;
if (copy_from_user
(&info, (ipu_irq_info *) arg,
sizeof(ipu_irq_info))) {
return -EFAULT;
}
ipu_free_irq(info.irq, info.dev_id);
}
break;
case IPU_REQUEST_IRQ_STATUS:
{
uint32_t irq;
int __user *argp = (void __user *)arg;
if (get_user(irq, argp))
return -EFAULT;
ret = ipu_get_irq_status(irq);
}
break;
case IPU_SDC_INIT_PANEL:
{
ipu_sdc_panel_info sinfo;
if (copy_from_user
(&sinfo, (ipu_sdc_panel_info *) arg,
sizeof(ipu_sdc_panel_info))) {
return -EFAULT;
}
ret =
ipu_sdc_init_panel(sinfo.panel, sinfo.pixel_clk,
sinfo.width, sinfo.height,
sinfo.pixel_fmt,
sinfo.hStartWidth,
sinfo.hSyncWidth,
sinfo.hEndWidth,
sinfo.vStartWidth,
sinfo.vSyncWidth,
sinfo.vEndWidth, sinfo.signal);
}
break;
case IPU_SDC_SET_WIN_POS:
{
ipu_sdc_window_pos pos;
if (copy_from_user
(&pos, (ipu_sdc_window_pos *) arg,
sizeof(ipu_sdc_window_pos))) {
return -EFAULT;
}
ret =
ipu_sdc_set_window_pos(pos.channel, pos.x_pos,
pos.y_pos);
}
break;
case IPU_SDC_SET_GLOBAL_ALPHA:
{
ipu_sdc_global_alpha g;
if (copy_from_user
(&g, (ipu_sdc_global_alpha *) arg,
sizeof(ipu_sdc_global_alpha))) {
return -EFAULT;
}
ret = ipu_sdc_set_global_alpha(g.enable, g.alpha);
}
break;
case IPU_SDC_SET_COLOR_KEY:
{
ipu_sdc_color_key c;
if (copy_from_user
(&c, (ipu_sdc_color_key *) arg,
sizeof(ipu_sdc_color_key))) {
return -EFAULT;
}
ret =
ipu_sdc_set_color_key(c.channel, c.enable,
c.colorKey);
}
break;
case IPU_SDC_SET_BRIGHTNESS:
{
uint8_t b;
int __user *argp = (void __user *)arg;
if (get_user(b, argp))
return -EFAULT;
ret = ipu_sdc_set_brightness(b);
}
break;
case IPU_REGISTER_GENERIC_ISR:
{
ipu_event_info info;
if (copy_from_user
(&info, (ipu_event_info *) arg,
sizeof(ipu_event_info))) {
return -EFAULT;
}
ret =
ipu_request_irq(info.irq, mxc_ipu_generic_handler,
0, "video_sink", info.dev);
}
break;
case IPU_GET_EVENT:
/* User will have to allocate event_type structure and pass the pointer in arg */
{
event_type ev;
int r = -1;
r = get_events(&ev);
if (r == -1) {
wait_event_interruptible(waitq,
(pending_events != 0));
r = get_events(&ev);
}
ret = -1;
if (r == 0) {
if (!copy_to_user((event_type *) arg, &ev,
sizeof(event_type))) {
ret = 0;
}
}
}
break;
case IPU_ADC_WRITE_TEMPLATE:
{
ipu_adc_template temp;
if (copy_from_user
(&temp, (ipu_adc_template *) arg, sizeof(temp))) {
return -EFAULT;
}
ret =
ipu_adc_write_template(temp.disp, temp.pCmd,
temp.write);
}
break;
case IPU_ADC_UPDATE:
{
ipu_adc_update update;
if (copy_from_user
(&update, (ipu_adc_update *) arg, sizeof(update))) {
return -EFAULT;
}
ret =
ipu_adc_set_update_mode(update.channel, update.mode,
update.refresh_rate,
update.addr, update.size);
}
break;
case IPU_ADC_SNOOP:
{
ipu_adc_snoop snoop;
if (copy_from_user
(&snoop, (ipu_adc_snoop *) arg, sizeof(snoop))) {
return -EFAULT;
}
ret =
ipu_adc_get_snooping_status(snoop.statl,
snoop.stath);
}
break;
case IPU_ADC_CMD:
{
ipu_adc_cmd cmd;
if (copy_from_user
(&cmd, (ipu_adc_cmd *) arg, sizeof(cmd))) {
return -EFAULT;
}
ret =
ipu_adc_write_cmd(cmd.disp, cmd.type, cmd.cmd,
cmd.params, cmd.numParams);
}
break;
case IPU_ADC_INIT_PANEL:
{
ipu_adc_panel panel;
if (copy_from_user
(&panel, (ipu_adc_panel *) arg, sizeof(panel))) {
return -EFAULT;
}
ret =
ipu_adc_init_panel(panel.disp, panel.width,
panel.height, panel.pixel_fmt,
panel.stride, panel.signal,
panel.addr, panel.vsync_width,
panel.mode);
}
break;
case IPU_ADC_IFC_TIMING:
{
ipu_adc_ifc_timing t;
if (copy_from_user
(&t, (ipu_adc_ifc_timing *) arg, sizeof(t))) {
return -EFAULT;
}
ret =
ipu_adc_init_ifc_timing(t.disp, t.read,
t.cycle_time, t.up_time,
t.down_time,
t.read_latch_time,
t.pixel_clk);
}
break;
case IPU_CSI_INIT_INTERFACE:
{
ipu_csi_interface c;
if (copy_from_user
(&c, (ipu_csi_interface *) arg, sizeof(c)))
return -EFAULT;
ret =
ipu_csi_init_interface(c.width, c.height,
c.pixel_fmt, c.signal);
}
break;
case IPU_CSI_ENABLE_MCLK:
{
ipu_csi_mclk m;
if (copy_from_user(&m, (ipu_csi_mclk *) arg, sizeof(m)))
return -EFAULT;
ret = ipu_csi_enable_mclk(m.src, m.flag, m.wait);
}
break;
case IPU_CSI_READ_MCLK_FLAG:
{
ret = ipu_csi_read_mclk_flag();
}
break;
case IPU_CSI_FLASH_STROBE:
{
bool strobe;
int __user *argp = (void __user *)arg;
if (get_user(strobe, argp))
return -EFAULT;
ipu_csi_flash_strobe(strobe);
}
break;
case IPU_CSI_GET_WIN_SIZE:
{
ipu_csi_window_size w;
ipu_csi_get_window_size(&w.width, &w.height);
if (copy_to_user
((ipu_csi_window_size *) arg, &w, sizeof(w)))
return -EFAULT;
}
break;
case IPU_CSI_SET_WIN_SIZE:
{
ipu_csi_window_size w;
if (copy_from_user
(&w, (ipu_csi_window_size *) arg, sizeof(w)))
return -EFAULT;
ipu_csi_set_window_size(w.width, w.height);
}
break;
case IPU_CSI_SET_WINDOW:
{
ipu_csi_window p;
if (copy_from_user
(&p, (ipu_csi_window *) arg, sizeof(p)))
return -EFAULT;
ipu_csi_set_window_pos(p.left, p.top);
}
break;
case IPU_PF_SET_PAUSE_ROW:
{
uint32_t p;
int __user *argp = (void __user *)arg;
if (get_user(p, argp))
return -EFAULT;
ret = ipu_pf_set_pause_row(p);
}
break;
default:
break;
}
return ret;
}
static void crash_and_debug(HKEY hkey, const char* argv0, const char* dbgtasks)
{
static BOOL skip_crash_and_debug = FALSE;
BOOL bRet;
DWORD ret;
HANDLE start_event, done_event;
char* cmd;
char dbglog[MAX_PATH];
char childlog[MAX_PATH];
PROCESS_INFORMATION info;
STARTUPINFOA startup;
DWORD exit_code;
crash_blackbox_t crash_blackbox;
debugger_blackbox_t dbg_blackbox;
DWORD wait_code;
if (skip_crash_and_debug)
{
win_skip("Skipping crash_and_debug\n");
return;
}
ret=RegSetValueExA(hkey, "auto", 0, REG_SZ, (BYTE*)"1", 2);
if (ret == ERROR_ACCESS_DENIED)
{
skip_crash_and_debug = TRUE;
skip("No write access to change the debugger\n");
return;
}
ok(ret == ERROR_SUCCESS, "unable to set AeDebug/auto: ret=%d\n", ret);
get_file_name(dbglog);
get_events(dbglog, &start_event, &done_event);
cmd=HeapAlloc(GetProcessHeap(), 0, strlen(argv0)+10+strlen(dbgtasks)+1+strlen(dbglog)+2+34+1);
sprintf(cmd, "%s debugger %s \"%s\" %%ld %%ld", argv0, dbgtasks, dbglog);
ret=RegSetValueExA(hkey, "debugger", 0, REG_SZ, (BYTE*)cmd, strlen(cmd)+1);
ok(ret == ERROR_SUCCESS, "unable to set AeDebug/debugger: ret=%d\n", ret);
HeapFree(GetProcessHeap(), 0, cmd);
get_file_name(childlog);
cmd=HeapAlloc(GetProcessHeap(), 0, strlen(argv0)+16+strlen(dbglog)+2+1);
sprintf(cmd, "%s debugger crash \"%s\"", argv0, childlog);
memset(&startup, 0, sizeof(startup));
startup.cb = sizeof(startup);
startup.dwFlags = STARTF_USESHOWWINDOW;
startup.wShowWindow = SW_SHOWNORMAL;
ret=CreateProcessA(NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &info);
ok(ret, "CreateProcess: err=%d\n", GetLastError());
HeapFree(GetProcessHeap(), 0, cmd);
CloseHandle(info.hThread);
/* The process exits... */
trace("waiting for child exit...\n");
wait_code = WaitForSingleObject(info.hProcess, 30000);
#if defined(_WIN64) && defined(__MINGW32__)
/* Mingw x64 doesn't output proper unwind info */
skip_crash_and_debug = broken(wait_code == WAIT_TIMEOUT);
if (skip_crash_and_debug)
{
TerminateProcess(info.hProcess, WAIT_TIMEOUT);
WaitForSingleObject(info.hProcess, 5000);
CloseHandle(info.hProcess);
assert(DeleteFileA(dbglog) != 0);
assert(DeleteFileA(childlog) != 0);
win_skip("Giving up on child process\n");
return;
}
#endif
ok(wait_code == WAIT_OBJECT_0, "Timed out waiting for the child to crash\n");
bRet = GetExitCodeProcess(info.hProcess, &exit_code);
ok(bRet, "GetExitCodeProcess failed: err=%d\n", GetLastError());
if (strstr(dbgtasks, "code2"))
{
/* If, after attaching to the debuggee, the debugger exits without
* detaching, then the debuggee gets a special exit code.
*/
ok(exit_code == STATUS_DEBUGGER_INACTIVE ||
broken(exit_code == STATUS_ACCESS_VIOLATION) || /* Intermittent Vista+ */
broken(exit_code == WAIT_ABANDONED), /* NT4, W2K */
"wrong exit code : %08x\n", exit_code);
}
else
ok(exit_code == STATUS_ACCESS_VIOLATION ||
broken(exit_code == WAIT_ABANDONED), /* NT4, W2K, W2K3 */
"wrong exit code : %08x\n", exit_code);
CloseHandle(info.hProcess);
/* ...before the debugger */
if (strstr(dbgtasks, "order"))
ok(SetEvent(start_event), "SetEvent(start_event) failed\n");
trace("waiting for the debugger...\n");
wait_code = WaitForSingleObject(done_event, 5000);
#if defined(_WIN64) && defined(__MINGW32__)
/* Mingw x64 doesn't output proper unwind info */
skip_crash_and_debug = broken(wait_code == WAIT_TIMEOUT);
if (skip_crash_and_debug)
{
assert(DeleteFileA(dbglog) != 0);
assert(DeleteFileA(childlog) != 0);
win_skip("Giving up on debugger\n");
return;
}
#endif
ok(wait_code == WAIT_OBJECT_0, "Timed out waiting for the debugger\n");
assert(load_blackbox(childlog, &crash_blackbox, sizeof(crash_blackbox)));
assert(load_blackbox(dbglog, &dbg_blackbox, sizeof(dbg_blackbox)));
ok(dbg_blackbox.argc == 6, "wrong debugger argument count: %d\n", dbg_blackbox.argc);
ok(dbg_blackbox.pid == crash_blackbox.pid, "the child and debugged pids don't match: %d != %d\n", crash_blackbox.pid, dbg_blackbox.pid);
ok(dbg_blackbox.debug_rc, "debugger: SetEvent(debug_event) failed err=%d\n", dbg_blackbox.debug_err);
ok(dbg_blackbox.attach_rc, "DebugActiveProcess(%d) failed err=%d\n", dbg_blackbox.pid, dbg_blackbox.attach_err);
ok(dbg_blackbox.nokill_rc, "DebugSetProcessKillOnExit(FALSE) failed err=%d\n", dbg_blackbox.nokill_err);
ok(dbg_blackbox.detach_rc, "DebugActiveProcessStop(%d) failed err=%d\n", dbg_blackbox.pid, dbg_blackbox.detach_err);
assert(DeleteFileA(dbglog) != 0);
assert(DeleteFileA(childlog) != 0);
}