/**
* Updates the last value read from hardware.
*/
u32 nvhost_syncpt_update_min(struct nvhost_syncpt *sp, u32 id)
{
struct nvhost_dev *dev = syncpt_to_dev(sp);
void __iomem *sync_regs = dev->sync_aperture;
u32 old, live, maxsp;
do {
smp_rmb();
old = (u32)atomic_read(&sp->min_val[id]);
live = readl(sync_regs + (HOST1X_SYNC_SYNCPT_0 + id * 4));
} while ((u32)atomic_cmpxchg(&sp->min_val[id], old, live) != old);
if(!check_max(sp, id, live))
{
smp_rmb();
maxsp = (u32)atomic_read(&sp->max_val[id]);
nvhost_sync_reg_dump(dev);
printk("%s check_max failed: id=%lu max=%lu real=%lu \n",__func__,
(unsigned long)id,
(unsigned long)maxsp,
(unsigned long)live);
BUG();
}
return live;
}
bool num_limits(void)
{ bool ok = true;
ok &= check_epsilon();
ok &= check_min();
ok &= check_max();
ok &= check_nan();
return ok;
}
void
Main_GUI::set_defaults()
{
min_box->setValue(hinting_range_min);
max_box->setValue(hinting_range_max);
fallback_box->setCurrentIndex(latin_fallback);
limit_box->setValue(hinting_limit ? hinting_limit : hinting_range_max);
// handle command line option `--hinting-limit=0'
if (!hinting_limit)
{
hinting_limit = max_box->value();
no_limit_box->setChecked(true);
}
increase_box->setValue(increase_x_height ? increase_x_height
: TA_INCREASE_X_HEIGHT);
// handle command line option `--increase-x-height=0'
if (!increase_x_height)
{
increase_x_height = TA_INCREASE_X_HEIGHT;
no_increase_box->setChecked(true);
}
snapping_line->setText(x_height_snapping_exceptions_string);
if (windows_compatibility)
wincomp_box->setChecked(true);
if (pre_hinting)
pre_box->setChecked(true);
if (hint_with_components)
hint_box->setChecked(true);
if (symbol)
symbol_box->setChecked(true);
if (!no_info)
info_box->setChecked(true);
if (gray_strong_stem_width)
gray_box->setChecked(true);
if (gdi_cleartype_strong_stem_width)
gdi_box->setChecked(true);
if (dw_cleartype_strong_stem_width)
dw_box->setChecked(true);
run_button->setEnabled(false);
check_min();
check_max();
check_limit();
check_no_limit();
check_no_increase();
check_number_set();
}
int
main (void)
{
tests_start ();
check_data ();
check_max ();
tests_end ();
exit (0);
}
/*
* update the percpu scd from the raw @now value
*
* - filter out backward motion
* - use jiffies to generate a min,max window to clip the raw values
*/
static void __update_sched_clock(struct sched_clock_data *scd, u64 now, u64 *time)
{
unsigned long now_jiffies = jiffies;
long delta_jiffies = now_jiffies - scd->tick_jiffies;
u64 clock = scd->clock;
u64 min_clock, max_clock;
s64 delta = now - scd->prev_raw;
WARN_ON_ONCE(!irqs_disabled());
/*
* At schedule tick the clock can be just under the gtod. We don't
* want to push it too prematurely.
*/
min_clock = scd->tick_gtod + (delta_jiffies * TICK_NSEC);
if (min_clock > TICK_NSEC)
min_clock -= TICK_NSEC / 2;
if (unlikely(delta < 0)) {
clock++;
goto out;
}
/*
* The clock must stay within a jiffie of the gtod.
* But since we may be at the start of a jiffy or the end of one
* we add another jiffy buffer.
*/
max_clock = scd->tick_gtod + (2 + delta_jiffies) * TICK_NSEC;
delta *= scd->multi;
delta >>= MULTI_SHIFT;
if (unlikely(clock + delta > max_clock) && check_max(scd)) {
if (clock < max_clock)
clock = max_clock;
else
clock++;
} else {
clock += delta;
}
out:
if (unlikely(clock < min_clock))
clock = min_clock;
if (time)
*time = clock;
else {
scd->prev_raw = now;
scd->clock = clock;
}
}
int
main (int argc, char *argv[])
{
tests_start_mpfr ();
check_nans ();
check_exact ();
check_float ();
check53("6.9314718055994530941514e-1", "0.0", MPFR_RNDZ, "0.0");
check53("0.0", "6.9314718055994530941514e-1", MPFR_RNDZ, "0.0");
check_sign();
check53("-4.165000000e4", "-0.00004801920768307322868063274915", MPFR_RNDN,
"2.0");
check53("2.71331408349172961467e-08", "-6.72658901114033715233e-165",
MPFR_RNDZ, "-1.8251348697787782844e-172");
check53("2.71331408349172961467e-08", "-6.72658901114033715233e-165",
MPFR_RNDA, "-1.8251348697787786e-172");
check53("0.31869277231188065", "0.88642843322303122", MPFR_RNDZ,
"2.8249833483992453642e-1");
check("8.47622108205396074254e-01", "3.24039313247872939883e-01", MPFR_RNDU,
28, 45, 2, "0.375");
check("8.47622108205396074254e-01", "3.24039313247872939883e-01", MPFR_RNDA,
28, 45, 2, "0.375");
check("2.63978122803639081440e-01", "6.8378615379333496093e-1", MPFR_RNDN,
34, 23, 31, "0.180504585267044603");
check("1.0", "0.11835170935876249132", MPFR_RNDU, 6, 41, 36,
"0.1183517093595583");
check53("67108865.0", "134217729.0", MPFR_RNDN, "9.007199456067584e15");
check("1.37399642157394197284e-01", "2.28877275604219221350e-01", MPFR_RNDN,
49, 15, 32, "0.0314472340833162888");
check("4.03160720978664954828e-01", "5.854828e-1"
/*"5.85483042917246621073e-01"*/, MPFR_RNDZ,
51, 22, 32, "0.2360436821472831");
check("3.90798504668055102229e-14", "9.85394674650308388664e-04", MPFR_RNDN,
46, 22, 12, "0.385027296503914762e-16");
check("4.58687081072827851358e-01", "2.20543551472118792844e-01", MPFR_RNDN,
49, 3, 2, "0.09375");
check_max();
check_min();
check_regression ();
test_generic (2, 500, 100);
data_check ("data/mulpi", mpfr_mulpi, "mpfr_mulpi");
valgrind20110503 ();
tests_end_mpfr ();
return 0;
}
/**
* Updates the last value read from hardware.
*/
u32 nvhost_syncpt_update_min(struct nvhost_syncpt *sp, u32 id)
{
struct nvhost_master *dev = syncpt_to_dev(sp);
void __iomem *sync_regs = dev->sync_aperture;
u32 old, live;
do {
smp_rmb();
old = (u32)atomic_read(&sp->min_val[id]);
live = readl(sync_regs + (HOST1X_SYNC_SYNCPT_0 + id * 4));
} while ((u32)atomic_cmpxchg(&sp->min_val[id], old, live) != old);
BUG_ON(!check_max(sp, id, live));
return live;
}
int
main (void)
{
tests_start_mpfr ();
mpfr_test_init ();
#ifndef MPFR_DOUBLE_SPEC
printf ("Warning! The MPFR_DOUBLE_SPEC macro is not defined. This means\n"
"that you do not have a conforming C implementation and problems\n"
"may occur with conversions between MPFR numbers and standard\n"
"floating-point types. Please contact the MPFR team.\n");
#elif MPFR_DOUBLE_SPEC == 0
/*
printf ("The type 'double' of your C implementation does not seem to\n"
"correspond to the IEEE-754 double precision. Though code has\n"
"been written to support such implementations, tests have been\n"
"done only on IEEE-754 double-precision implementations and\n"
"conversions between MPFR numbers and standard floating-point\n"
"types may be inaccurate. You may wish to contact the MPFR team\n"
"for further testing.\n");
*/
printf ("The type 'double' of your C implementation does not seem to\n"
"correspond to the IEEE-754 double precision. Such particular\n"
"implementations are not supported yet, and conversions between\n"
"MPFR numbers and standard floating-point types may be very\n"
"inaccurate.\n");
printf ("FLT_RADIX = %ld\n", (long) FLT_RADIX);
printf ("DBL_MANT_DIG = %ld\n", (long) DBL_MANT_DIG);
printf ("DBL_MIN_EXP = %ld\n", (long) DBL_MIN_EXP);
printf ("DBL_MAX_EXP = %ld\n", (long) DBL_MAX_EXP);
#endif
if (check_denorms ())
exit (1);
check_inf_nan ();
check_min();
check_max();
check_get_d_2exp_inf_nan ();
tests_end_mpfr ();
return 0;
}
/**
* Main entrypoint for syncpoint value waits.
*/
int nvhost_syncpt_wait_timeout(struct nvhost_syncpt *sp, u32 id,
u32 thresh, u32 timeout, u32 *value)
{
DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
void *ref;
int err = 0;
if (value)
*value = 0;
BUG_ON(!check_max(sp, id, thresh));
/* first check cache */
if (nvhost_syncpt_min_cmp(sp, id, thresh)) {
if (value)
*value = nvhost_syncpt_read_min(sp, id);
return 0;
}
/* keep host alive */
nvhost_module_busy(&syncpt_to_dev(sp)->mod);
if (client_managed(id) || !nvhost_syncpt_min_eq_max(sp, id)) {
/* try to read from register */
u32 val = nvhost_syncpt_update_min(sp, id);
if ((s32)(val - thresh) >= 0) {
if (value)
*value = val;
goto done;
}
}
if (!timeout) {
err = -EAGAIN;
goto done;
}
/* schedule a wakeup when the syncpoint value is reached */
err = nvhost_intr_add_action(&(syncpt_to_dev(sp)->intr), id, thresh,
NVHOST_INTR_ACTION_WAKEUP_INTERRUPTIBLE, &wq, &ref);
if (err)
goto done;
err = -EAGAIN;
/* wait for the syncpoint, or timeout, or signal */
while (timeout) {
u32 check = min_t(u32, SYNCPT_CHECK_PERIOD, timeout);
int remain = wait_event_interruptible_timeout(wq,
nvhost_syncpt_min_cmp(sp, id, thresh),
check);
if (remain > 0 || nvhost_syncpt_min_cmp(sp, id, thresh)) {
if (value)
*value = nvhost_syncpt_read_min(sp, id);
err = 0;
break;
}
if (remain < 0) {
err = remain;
break;
}
if (timeout != NVHOST_NO_TIMEOUT)
timeout -= check;
if (timeout) {
dev_warn(&syncpt_to_dev(sp)->pdev->dev,
"syncpoint id %d (%s) stuck waiting %d\n",
id, nvhost_syncpt_name(id), thresh);
nvhost_syncpt_debug(sp);
}
};
nvhost_intr_put_ref(&(syncpt_to_dev(sp)->intr), ref);
done:
nvhost_module_idle(&syncpt_to_dev(sp)->mod);
return err;
}
PAM_EXTERN int pam_sm_chauthtok(pam_handle_t *pamh, int flags,
int argc, const char **argv)
{
params_t params;
struct pam_response *resp;
struct passwd *pw, fake_pw;
#ifdef HAVE_SHADOW
struct spwd *spw;
#endif
char *user, *oldpass, *newpass, *randompass;
const char *reason;
int ask_oldauthtok;
int randomonly, enforce, retries_left, retry_wanted;
int status;
params = defaults;
status = parse(¶ms, pamh, argc, argv);
if (status != PAM_SUCCESS)
return status;
ask_oldauthtok = 0;
if (flags & PAM_PRELIM_CHECK) {
if (params.flags & F_ASK_OLDAUTHTOK_PRELIM)
ask_oldauthtok = 1;
} else
if (flags & PAM_UPDATE_AUTHTOK) {
if (params.flags & F_ASK_OLDAUTHTOK_UPDATE)
ask_oldauthtok = 1;
} else
return PAM_SERVICE_ERR;
if (ask_oldauthtok && getuid() != 0) {
status = converse(pamh, PAM_PROMPT_ECHO_OFF,
PROMPT_OLDPASS, &resp);
if (status == PAM_SUCCESS) {
if (resp && resp->resp) {
status = pam_set_item(pamh,
PAM_OLDAUTHTOK, resp->resp);
_pam_drop_reply(resp, 1);
} else
status = PAM_AUTHTOK_RECOVERY_ERR;
}
if (status != PAM_SUCCESS)
return status;
}
if (flags & PAM_PRELIM_CHECK)
return status;
status = pam_get_item(pamh, PAM_USER, (pam_item_t *)&user);
if (status != PAM_SUCCESS)
return status;
status = pam_get_item(pamh, PAM_OLDAUTHTOK, (pam_item_t *)&oldpass);
if (status != PAM_SUCCESS)
return status;
if (params.flags & F_NON_UNIX) {
pw = &fake_pw;
pw->pw_name = user;
pw->pw_gecos = "";
} else {
pw = getpwnam(user);
endpwent();
if (!pw)
return PAM_USER_UNKNOWN;
if ((params.flags & F_CHECK_OLDAUTHTOK) && getuid() != 0) {
if (!oldpass)
status = PAM_AUTH_ERR;
else
#ifdef HAVE_SHADOW
if (!strcmp(pw->pw_passwd, "x")) {
spw = getspnam(user);
endspent();
if (spw) {
if (strcmp(crypt(oldpass, spw->sp_pwdp),
spw->sp_pwdp))
status = PAM_AUTH_ERR;
memset(spw->sp_pwdp, 0,
strlen(spw->sp_pwdp));
} else
status = PAM_AUTH_ERR;
} else
#endif
if (strcmp(crypt(oldpass, pw->pw_passwd),
pw->pw_passwd))
status = PAM_AUTH_ERR;
}
memset(pw->pw_passwd, 0, strlen(pw->pw_passwd));
if (status != PAM_SUCCESS)
return status;
}
randomonly = params.qc.min[4] > params.qc.max;
if (getuid() != 0)
enforce = params.flags & F_ENFORCE_USERS;
else
enforce = params.flags & F_ENFORCE_ROOT;
if (params.flags & F_USE_AUTHTOK) {
status = pam_get_item(pamh, PAM_AUTHTOK,
(pam_item_t *)&newpass);
if (status != PAM_SUCCESS)
return status;
if (!newpass || (check_max(¶ms, pamh, newpass) && enforce))
return PAM_AUTHTOK_ERR;
reason = _passwdqc_check(¶ms.qc, newpass, oldpass, pw);
if (reason) {
say(pamh, PAM_ERROR_MSG, MESSAGE_WEAKPASS, reason);
if (enforce)
status = PAM_AUTHTOK_ERR;
}
return status;
}
retries_left = params.retry;
retry:
retry_wanted = 0;
if (!randomonly &&
params.qc.passphrase_words && params.qc.min[2] <= params.qc.max)
status = say(pamh, PAM_TEXT_INFO, MESSAGE_INTRO_BOTH);
else
status = say(pamh, PAM_TEXT_INFO, MESSAGE_INTRO_PASSWORD);
if (status != PAM_SUCCESS)
return status;
if (!randomonly && params.qc.min[3] <= params.qc.min[4])
status = say(pamh, PAM_TEXT_INFO, MESSAGE_EXPLAIN_PASSWORD_1,
params.qc.min[3] == 8 || params.qc.min[3] == 11 ? "n" : "",
params.qc.min[3]);
else
if (!randomonly)
status = say(pamh, PAM_TEXT_INFO, MESSAGE_EXPLAIN_PASSWORD_2,
params.qc.min[3] == 8 || params.qc.min[3] == 11 ? "n" : "",
params.qc.min[3],
params.qc.min[4] == 8 || params.qc.min[4] == 11 ? "n" : "",
params.qc.min[4]);
if (status != PAM_SUCCESS)
return status;
if (!randomonly &&
params.qc.passphrase_words &&
params.qc.min[2] <= params.qc.max) {
status = say(pamh, PAM_TEXT_INFO, MESSAGE_EXPLAIN_PASSPHRASE,
params.qc.passphrase_words,
params.qc.min[2], params.qc.max);
if (status != PAM_SUCCESS)
return status;
}
randompass = _passwdqc_random(¶ms.qc);
if (randompass) {
status = say(pamh, PAM_TEXT_INFO, randomonly ?
MESSAGE_RANDOMONLY : MESSAGE_RANDOM, randompass);
if (status != PAM_SUCCESS) {
_pam_overwrite(randompass);
randompass = NULL;
}
} else
if (randomonly) {
say(pamh, PAM_ERROR_MSG, getuid() != 0 ?
MESSAGE_MISCONFIGURED : MESSAGE_RANDOMFAILED);
return PAM_AUTHTOK_ERR;
}
status = converse(pamh, PAM_PROMPT_ECHO_OFF, PROMPT_NEWPASS1, &resp);
if (status == PAM_SUCCESS && (!resp || !resp->resp))
status = PAM_AUTHTOK_ERR;
if (status != PAM_SUCCESS) {
if (randompass) _pam_overwrite(randompass);
return status;
}
newpass = strdup(resp->resp);
_pam_drop_reply(resp, 1);
if (!newpass) {
if (randompass) _pam_overwrite(randompass);
return PAM_AUTHTOK_ERR;
}
if (check_max(¶ms, pamh, newpass) && enforce) {
status = PAM_AUTHTOK_ERR;
retry_wanted = 1;
}
reason = NULL;
if (status == PAM_SUCCESS &&
(!randompass || !strstr(newpass, randompass)) &&
(randomonly ||
(reason = _passwdqc_check(¶ms.qc, newpass, oldpass, pw)))) {
if (randomonly)
say(pamh, PAM_ERROR_MSG, MESSAGE_NOTRANDOM);
else
say(pamh, PAM_ERROR_MSG, MESSAGE_WEAKPASS, reason);
if (enforce) {
status = PAM_AUTHTOK_ERR;
retry_wanted = 1;
}
}
if (status == PAM_SUCCESS)
status = converse(pamh, PAM_PROMPT_ECHO_OFF,
PROMPT_NEWPASS2, &resp);
if (status == PAM_SUCCESS) {
if (resp && resp->resp) {
if (strcmp(newpass, resp->resp)) {
status = say(pamh,
PAM_ERROR_MSG, MESSAGE_MISTYPED);
if (status == PAM_SUCCESS) {
status = PAM_AUTHTOK_ERR;
retry_wanted = 1;
}
}
_pam_drop_reply(resp, 1);
} else
status = PAM_AUTHTOK_ERR;
}
if (status == PAM_SUCCESS)
status = pam_set_item(pamh, PAM_AUTHTOK, newpass);
if (randompass) _pam_overwrite(randompass);
_pam_overwrite(newpass);
free(newpass);
if (retry_wanted && --retries_left > 0) {
status = say(pamh, PAM_TEXT_INFO, MESSAGE_RETRY);
if (status == PAM_SUCCESS)
goto retry;
}
return status;
}
/** \brief Find the maximum around the pixel.
\param img The pointer to gradient image.
\param yx The pixel coordinate (yx = y*w + x)
\param w The image width.
\param in1 The previous maximum direction.
\retval The direction of of local max.
*/
static inline int dir(uint8 *con, int16 *grad, int *dr, int yx, int in1, int w)
{
uint8 max = 0, i;
int in = 0, tmp[3];
/*
if(yx == 812-1 + (542+1)*w) {
printf("befor dir3: x = %d y = %d in1 = %d\n", yx%w, yx/w, in1);
print_around(con, yx, w);
print_around(grad, yx, w);
print_con_grad(grad, con, yx, w);
}*/
//x = 1077 y = 1174
if(in1 == 0){
if(grad[yx+dr[0]] > max) { max = grad[yx+dr[0]]; in = dr[0]; }
if(grad[yx+dr[1]] > max) { max = grad[yx+dr[1]]; in = dr[1]; }
if(grad[yx+dr[2]] > max) { max = grad[yx+dr[2]]; in = dr[2]; }
if(grad[yx+dr[3]] > max) { max = grad[yx+dr[3]]; in = dr[3]; }
if(grad[yx+dr[4]] > max) { max = grad[yx+dr[4]]; in = dr[4]; }
if(grad[yx+dr[5]] > max) { max = grad[yx+dr[5]]; in = dr[5]; }
if(grad[yx+dr[6]] > max) { max = grad[yx+dr[6]]; in = dr[6]; }
if(grad[yx+dr[7]] > max) { max = grad[yx+dr[7]]; in = dr[7]; }
return in;
}
if (in1 == dr[0]){ tmp[0] = dr[3]; tmp[1] = dr[4]; tmp[2] = dr[5]; }
else if (in1 == dr[1]){ tmp[0] = dr[4]; tmp[1] = dr[5]; tmp[2] = dr[6]; }
else if (in1 == dr[2]){ tmp[0] = dr[5]; tmp[1] = dr[6]; tmp[2] = dr[7]; }
else if (in1 == dr[3]){ tmp[0] = dr[6]; tmp[1] = dr[7]; tmp[2] = dr[0]; }
else if (in1 == dr[4]){ tmp[0] = dr[7]; tmp[1] = dr[0]; tmp[2] = dr[1]; }
else if (in1 == dr[5]){ tmp[0] = dr[0]; tmp[1] = dr[1]; tmp[2] = dr[2]; }
else if (in1 == dr[6]){ tmp[0] = dr[1]; tmp[1] = dr[2]; tmp[2] = dr[3]; }
else if (in1 == dr[7]){ tmp[0] = dr[2]; tmp[1] = dr[3]; tmp[2] = dr[4]; }
//printf("tmp0 = %d tmp1 = %d tmp2 = %d\n", tmp[0], tmp[1], tmp[2]);
max = 0;
if(grad[yx+tmp[0]] > max) { max = grad[yx+tmp[0]]; in = tmp[0]; }
if(grad[yx+tmp[1]] > max) { max = grad[yx+tmp[1]]; in = tmp[1]; }
if(grad[yx+tmp[2]] > max) { max = grad[yx+tmp[2]]; in = tmp[2]; }
//printf("max = %d in = %d\n", max, in);
if(con[yx+in]){
if(check_diagonal(con, dr, yx, find_dir(dr, in)) ){
if(in == tmp[0]) tmp[0] = tmp[2];
else if(in == tmp[1]) tmp[1] = tmp[2];
//printf("Remove diagonal 1 \n ");
//print_con_grad(grad, con, yx, w);
//printf("First ");
} else if(check_max(grad, dr, yx+in, 255) ){
if(in == tmp[0]) tmp[0] = tmp[2];
else if(in == tmp[1]) tmp[1] = tmp[2];
} else return in;
} else {
return in;
}
if(grad[yx+tmp[0]] > grad[yx+tmp[1]]) in = tmp[0];
else in = tmp[1];
if(!check_diagonal(con, dr, yx, find_dir(dr, in))) {
if(con[yx+in]){
//if(max == 255) return in;
if(check_max(grad, dr, yx+in, 255)){
if(in == tmp[0]) in = tmp[1];
else in = tmp[0];
//printf("Second ");
} else return in;
} else {
return in;
}
} else {
if(in == tmp[0]) in = tmp[1];
else in = tmp[0];
}
if(!check_diagonal(con, dr, yx, find_dir(dr, in))) {
if(con[yx+in]){
//if(max == 255) return in;
if(check_max(grad, dr, yx+in, 255)){
return 0;
//printf("Second ");
} else return in;
} else {
return in;
}
} else return 0;
}
/**
* Main entrypoint for syncpoint value waits.
*/
int nvhost_syncpt_wait_timeout(struct nvhost_syncpt *sp, u32 id,
u32 thresh, u32 timeout)
{
DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
void *ref;
int err = 0;
//struct nvhost_dev *dev = syncpt_to_dev(sp);
BUG_ON(!check_max(sp, id, thresh));
/* first check cache */
if (nvhost_syncpt_min_cmp(sp, id, thresh))
return 0;
/* keep host alive */
nvhost_module_busy(&syncpt_to_dev(sp)->mod);
if (client_managed(id) || !nvhost_syncpt_min_eq_max(sp, id)) {
/* try to read from register */
u32 val = nvhost_syncpt_update_min(sp, id);
if ((s32)(val - thresh) >= 0)
goto done;
}
if (!timeout) {
err = -EAGAIN;
goto done;
}
/* schedule a wakeup when the syncpoint value is reached */
err = nvhost_intr_add_action(&(syncpt_to_dev(sp)->intr), id, thresh,
NVHOST_INTR_ACTION_WAKEUP_INTERRUPTIBLE, &wq, &ref);
if (err)
goto done;
/* wait for the syncpoint, or timeout, or signal */
while (timeout) {
u32 check = min_t(u32, SYNCPT_CHECK_PERIOD, timeout);
err = wait_event_interruptible_timeout(wq,
nvhost_syncpt_min_cmp(sp, id, thresh),
check);
if (err != 0)
break;
if (timeout != NVHOST_NO_TIMEOUT)
timeout -= SYNCPT_CHECK_PERIOD;
if (timeout) {
dev_warn(&syncpt_to_dev(sp)->pdev->dev,
"syncpoint id %d (%s) stuck waiting %d timeout=%d\n",
id, nvhost_syncpt_name(id), thresh, timeout);
/* A wait queue in nvhost driver maybe run frequently
when early suspend/late resume. These log will be
printed,then the early suspend/late resume
maybe blocked,then it will triger early suspend/late
resume watchdog. Now we cancel these log. */
/*
nvhost_syncpt_debug(sp);
nvhost_channel_fifo_debug(dev);
nvhost_sync_reg_dump(dev);
*/
}
};
if (err > 0)
err = 0;
else if (err == 0)
err = -EAGAIN;
nvhost_intr_put_ref(&(syncpt_to_dev(sp)->intr), ref);
done:
nvhost_module_idle(&syncpt_to_dev(sp)->mod);
return err;
}
/******************************************************************************
Trace the scalar variables located in cell center
******************************************************************************/
int trace_scalar(PARA_DATA *para, REAL **var, int var_type, REAL *d, REAL *d0,
int **BINDEX)
{
int i, j, k;
int it;
int itmax = 20000; // Max number of iterations for backward tracing
int imax = para->geom->imax, jmax = para->geom->jmax;
int kmax = para->geom->kmax;
int IMAX = imax+2, IJMAX = (imax+2)*(jmax+2);
REAL x_1, y_1, z_1;
REAL dt = para->mytime->dt;
REAL u0, v0, w0;
REAL *x = var[X], *y = var[Y], *z = var[Z];
REAL *gx = var[GX], *gy = var[GY], *gz = var[GZ];
REAL *u = var[VX], *v = var[VY], *w = var[VZ];
REAL *flagp = var[FLAGP];
REAL Lx = para->geom->Lx, Ly = para->geom->Ly, Lz = para->geom->Lz;
int COOD[3], LOC[3];
REAL OL[3];
int OC[3];
FOR_EACH_CELL
// Do not trace for boundary cells
if(flagp[IX(i,j,k)]>=0) continue;
/*-------------------------------------------------------------------------
| Step 1: Tracing Back
-------------------------------------------------------------------------*/
// Get velocities at the location of scalar variable
u0 = 0.5 * (u[IX(i,j,k)]+u[IX(i-1,j,k )]);
v0 = 0.5 * (v[IX(i,j,k)]+v[IX(i,j-1,k )]);
w0 = 0.5 * (w[IX(i,j,k)]+w[IX(i,j ,k-1)]);
// Find the location at previous time step
OL[X] = x[IX(i,j,k)] - u0*dt;
OL[Y] = y[IX(i,j,k)] - v0*dt;
OL[Z] = z[IX(i,j,k)] - w0*dt;
// Initialize the coordinates of previous step
OC[X] = i;
OC[Y] = j;
OC[Z] = k;
// Initialize the signs for tracing process
// Completed: 0; In process: 1
COOD[X] = 1;
COOD[Y] = 1;
COOD[Z] = 1;
// Initialize the signs for recording if the tracing back hits the boundary
// Hit the boundary: 0; Not hit the boundary: 1
LOC[X] = 1;
LOC[Y] = 1;
LOC[Z] = 1;
//Initialize the number of iterations
it=1;
// Trace back more if the any of the trace is still in process
while(COOD[X]==1 || COOD[Y] ==1 || COOD[Z] == 1)
{
it++;
// If trace in X is in process and donot hit the boundary
if(COOD[X]==1 && LOC[X]==1)
set_x_location(para, var, flagp, x, u0, i, j, k, OL, OC, LOC, COOD);
// If trace in Y is in process and donot hit the boundary
if(COOD[Y]==1 && LOC[Y]==1)
set_y_location(para, var, flagp, y, v0, i, j, k, OL, OC, LOC, COOD);
// If trace in Z is in process and donot hit the boundary
if(COOD[Z]==1 && LOC[Z]==1)
set_z_location(para, var, flagp, z, w0, i, j, k, OL, OC, LOC, COOD);
if(it>itmax)
{
printf("Error: advection.c, can not track the location for Temperature(%d, %d,%d)",
i, j, k);
printf("after %d iterations.\n", it);
return 1;
}
} // End of while() for backward tracing
// Set the coordinates of previous location if it is as boundary
if(u0>=0 && LOC[X]==0) OC[X] -=1;
if(v0>=0 && LOC[Y]==0) OC[Y] -=1;
if(w0>=0 && LOC[Z]==0) OC[Z] -=1;
// Fixme: Do not understand here. Should it be
// if(u0<0 && LOC[X] = 0) OC[X] += 1;
if(u0<0 && LOC[X]==1) OC[X] -=1;
if(v0<0 && LOC[Y]==1) OC[Y] -=1;
if(w0<0 && LOC[Z]==1) OC[Z] -=1;
//Store the local minium and maximum values
var[LOCMIN][IX(i,j,k)]=check_min(para, d0, OC[X], OC[Y], OC[Z]);
var[LOCMAX][IX(i,j,k)]=check_max(para, d0, OC[X], OC[Y], OC[Z]);
/*-------------------------------------------------------------------------
| Interpolate
-------------------------------------------------------------------------*/
x_1 = (OL[X]- x[IX(OC[X],OC[Y],OC[Z])])
/ ( x[IX(OC[X]+1,OC[Y], OC[Z] )] - x[IX(OC[X],OC[Y],OC[Z])]);
y_1 = (OL[Y]- y[IX(OC[X],OC[Y],OC[Z])])
/ ( y[IX(OC[X], OC[Y]+1, OC[Z] )] - y[IX(OC[X],OC[Y],OC[Z])]);
z_1 = (OL[Z]- z[IX(OC[X],OC[Y],OC[Z])])
/ ( z[IX(OC[X], OC[Y], OC[Z]+1)] - z[IX(OC[X],OC[Y],OC[Z])]);
d[IX(i,j,k)] = interpolation(para, d0, x_1, y_1, z_1, OC[X], OC[Y], OC[Z]);
END_FOR // End of loop for all cells
/*---------------------------------------------------------------------------
| Define the b.c.
---------------------------------------------------------------------------*/
set_bnd(para, var, var_type, d, BINDEX);
return 0;
} // End of trace_scalar()
