static void ds1302_sendbits(unsigned int val)
{
int i;
for (i = 8; (i); i--, val >>= 1) {
set_dp((get_dp() & ~RTC_IODATA) | ((val & 0x1) ? RTC_IODATA : 0));
set_dp(get_dp() | RTC_SCLK); // clock high
set_dp(get_dp() & ~RTC_SCLK); // clock low
}
}
static unsigned int ds1302_recvbits(void)
{
unsigned int val;
int i;
for (i = 0, val = 0; (i < 8); i++) {
val |= (((get_dp() & RTC_IODATA) ? 1 : 0) << i);
set_dp(get_dp() | RTC_SCLK); // clock high
set_dp(get_dp() & ~RTC_SCLK); // clock low
}
return(val);
}
static void ds1302_writebyte(unsigned int addr, unsigned int val)
{
unsigned long flags;
local_irq_save(flags);
set_dirp(get_dirp() | RTC_RESET | RTC_IODATA | RTC_SCLK);
set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
set_dp(get_dp() | RTC_RESET);
ds1302_sendbits(((addr & 0x3f) << 1) | RTC_CMD_WRITE);
ds1302_sendbits(val);
set_dp(get_dp() & ~RTC_RESET);
local_irq_restore(flags);
}
static unsigned int ds1302_readbyte(unsigned int addr)
{
unsigned int val;
set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
set_dp(get_dp() | RTC_RESET);
ds1302_sendbits(((addr & 0x3f) << 1) | RTC_CMD_READ);
val = ds1302_recvbits();
set_dp(get_dp() & ~RTC_RESET);
return val;
}
static void PNGCBAPI
display_error(png_structp pp, png_const_charp error)
{
struct display *dp = get_dp(pp);
display_log(dp, LIBPNG_ERROR, "%s", error);
}
static struct mic_device_desc *get_device_desc(struct mic_info *mic, int type)
{
struct mic_device_desc *d;
int i;
void *dp = get_dp(mic, type);
for (i = sizeof(struct mic_bootparam); i < PAGE_SIZE;
i += mic_total_desc_size(d)) {
d = dp + i;
/* End of list */
if (d->type == 0)
break;
if (d->type == -1)
continue;
mpsslog("%s %s d-> type %d d %p\n",
mic->name, __func__, d->type, d);
if (d->type == (__u8)type)
return d;
}
mpsslog("%s %s %d not found\n", mic->name, __func__, type);
assert(0);
return NULL;
}
static void ds1302_writebyte(unsigned int addr, unsigned int val)
{
unsigned long flags;
#if 0
printk("SnapGear RTC: ds1302_writebyte(addr=%x)\n", addr);
#endif
save_flags(flags);
cli();
set_dirp(get_dirp() | RTC_RESET | RTC_IODATA | RTC_SCLK);
set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
set_dp(get_dp() | RTC_RESET);
ds1302_sendbits(((addr & 0x3f) << 1) | RTC_CMD_WRITE);
ds1302_sendbits(val);
set_dp(get_dp() & ~RTC_RESET);
restore_flags(flags);
}
static unsigned int ds1302_readbyte(unsigned int addr)
{
unsigned int val;
unsigned long flags;
local_irq_save(flags);
set_dirp(get_dirp() | RTC_RESET | RTC_IODATA | RTC_SCLK);
set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
set_dp(get_dp() | RTC_RESET);
ds1302_sendbits(((addr & 0x3f) << 1) | RTC_CMD_READ);
set_dirp(get_dirp() & ~RTC_IODATA);
val = ds1302_recvbits();
set_dp(get_dp() & ~RTC_RESET);
local_irq_restore(flags);
return(val);
}
static void ds1302_reset(void)
{
unsigned long flags;
/* Hardware dependent reset/init */
local_irq_save(flags);
set_dirp(get_dirp() | RTC_RESET | RTC_IODATA | RTC_SCLK);
set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
local_irq_restore(flags);
}
static void ds1302_reset(void)
{
unsigned long flags;
/* Hardware dependant reset/init */
save_flags(flags);
cli();
set_dirp(get_dirp() | RTC_RESET | RTC_IODATA | RTC_SCLK);
set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
restore_flags(flags);
}
static unsigned int ds1302_readbyte(unsigned int addr)
{
unsigned int val;
unsigned long flags;
#if 0
printk("SnapGear RTC: ds1302_readbyte(addr=%x)\n", addr);
#endif
save_flags(flags);
cli();
set_dirp(get_dirp() | RTC_RESET | RTC_IODATA | RTC_SCLK);
set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
set_dp(get_dp() | RTC_RESET);
ds1302_sendbits(((addr & 0x3f) << 1) | RTC_CMD_READ);
set_dirp(get_dirp() & ~RTC_IODATA);
val = ds1302_recvbits();
set_dp(get_dp() & ~RTC_RESET);
restore_flags(flags);
return(val);
}
void calc_dp( struct domain * theDomain ){
struct cell ** theCells = theDomain->theCells;
int Nr = theDomain->Nr;
int Nz = theDomain->Nz;
int * Np = theDomain->Np;
int i,jk;
for( jk=0 ; jk<Nr*Nz ; ++jk ){
for( i=0 ; i<Np[jk] ; ++i ){
int im = i-1;
if( i == 0 ) im = Np[jk]-1;
double phim = theCells[jk][im].piph;
double phip = theCells[jk][i ].piph;
double dphi = get_dp(phip,phim);
theCells[jk][i].dphi = dphi;
}
}
}
/* Called with genl_mutex. */
static int flush_flows(int dp_ifindex)
{
struct flow_table *old_table;
struct flow_table *new_table;
struct datapath *dp;
dp = get_dp(dp_ifindex);
if (!dp)
return -ENODEV;
old_table = genl_dereference(dp->table);
new_table = ovs_flow_tbl_alloc(TBL_MIN_BUCKETS);
if (!new_table)
return -ENOMEM;
rcu_assign_pointer(dp->table, new_table);
ovs_flow_tbl_deferred_destroy(old_table);
return 0;
}
static int __init ds1302_rtc_probe(struct platform_device *pdev)
{
struct rtc_device *rtc;
/* Reset */
set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
/* Write a magic value to the DS1302 RAM, and see if it sticks. */
ds1302_writebyte(RTC_ADDR_RAM0, 0x42);
if (ds1302_readbyte(RTC_ADDR_RAM0) != 0x42)
return -ENODEV;
rtc = rtc_device_register("ds1302", &pdev->dev,
&ds1302_rtc_ops, THIS_MODULE);
if (IS_ERR(rtc))
return PTR_ERR(rtc);
platform_set_drvdata(pdev, rtc);
return 0;
}
void source( double * prim , double * cons , double * xp , double * xm , double dVdt ){
double rp = xp[0];
double rm = xm[0];
double dphi = get_dp(xp[1],xm[1]);
double rho = prim[RHO];
double Pp = prim[PPP];
double r_1 = .5*(rp+rm);
double r2_3 = (rp*rp + rp*rm + rm*rm)/3.;
double vr = prim[URR];
double omega = prim[UPP];
double Br = prim[BRR];
double Bp = prim[BPP];
double Bz = prim[BZZ];
double B2 = Br*Br+Bp*Bp+Bz*Bz;
//double centrifugal = ( rho*omega*omega*r2_3 - Bp*Bp )/r_1*sin(.5*dphi)/(.5*dphi);
double centrifugal = ( rho*omega*omega*r2_3 )/r_1*sin(.5*dphi)/(.5*dphi);
centrifugal -= Bp*Bp/r_1;
double press_bal = (Pp+.5*B2)/r_1;
cons[SRR] += dVdt*( centrifugal + press_bal );
double om = get_om( r_1 );
double om1 = get_om1( r_1 );
cons[TAU] += dVdt*rho*vr*( om*om*r2_3/r_1 - om1*(omega-om)*r2_3 );
if( include_viscosity ){
double nu = explicit_viscosity;
cons[SRR] += -dVdt*nu*rho*vr/(r_1*r_1);
}
}
static inline void ds1302_stop(void)
{
set_dp(get_dp() & ~RTC_RESET);
}
static inline void ds1302_clock(void)
{
set_dp(get_dp() | RTC_SCLK); /* clock high */
set_dp(get_dp() & ~RTC_SCLK); /* clock low */
}
static inline void ds1302_reset(void)
{
set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
}
/*
* Set up the initial state of a MACH thread so that it will invoke
* routine(child) when it is resumed.
*/
void
rthread_setup(rthread_t child, thread_port_t thread, rthread_fn_t routine)
{
struct hp700_thread_state state;
kern_return_t r;
unsigned size;
/*
* Set up hp700 call frame and registers.
*/
size = HP700_THREAD_STATE_COUNT;
MACH_CALL(thread_get_state(thread, HP700_THREAD_STATE,
(thread_state_t) &state, &size), r);
/*
* set the PC queue to point to routine.
*/
state.iioq_head = (unsigned)routine;
state.iioq_tail = (unsigned)routine + 4;
/*
* setup the first argument to routine to be the address of child.
*/
state.arg0 = (unsigned) child;
state.dp = get_dp();
/*
* establish a user stack for this thread. There is no guarantee
* that the stack is aligned correctly. We have to align it to
* a double word boundary. (In fact, if RTHREAD_STACK_OFFSET
* is aligned, then so is the stack. But little things can go
* wrong.)
*/
state.sp = rthread_stack_base(child, RTHREAD_STACK_OFFSET)
+ 7 & 0xfffffff8;
/*
* clear off the first 48 bytes of the stack, this is going to be
* our fake stack marker, we don't want any routine to think there
* is a stack frame below us.
*/
bzero((char*)state.sp, 48);
/*
* now set the stack pointer 48 bytes deeper, 32 for a frame marker
* and 16 for the standard 4 arguments.
*/
state.sp += 48;
/*
* Now we have to initialize the floating point status registers
* since they will be in a random state and could cause a trap.
state.fr0 = 0.0;
state.fr1 = 0.0;
state.fr2 = 0.0;
state.fr3 = 0.0;
*/
/*
* the psw is fine it is set up as CQPDI by the kernel. Set the
* registers into the saved state of the thread.
*/
MACH_CALL(thread_set_state(thread, HP700_THREAD_STATE,
(thread_state_t) &state,
HP700_THREAD_STATE_COUNT),r);
}
static inline void ds1302_start(void)
{
set_dp(get_dp() | RTC_RESET);
}
static inline void ds1302_txbit(int bit)
{
set_dp((get_dp() & ~RTC_IODATA) | (bit ? RTC_IODATA : 0));
}
static inline int ds1302_rxbit(void)
{
return !!(get_dp() & RTC_IODATA);
}
static void PNGCBAPI
read_function(png_structp pp, png_bytep data, png_size_t size)
{
buffer_read(get_dp(pp), get_buffer(pp), data, size);
}
void avg_Efields( struct domain * theDomain ){
int i,j,k;
struct cell ** theCells = theDomain->theCells;
int Nr = theDomain->Nr;
int Nz = theDomain->Nz;
int * Np = theDomain->Np;
for( j=0 ; j<Nr ; ++j ){
for( k=0 ; k<Nz ; ++k ){
int jk = j+Nr*k;
for( i=0 ; i<Np[jk] ; ++i ){
struct cell * c = theCells[jk]+i;
int ip = (i+1)%Np[jk];
struct cell * cp = theCells[jk]+ip;
double El_avg = .5*( c->E[0] + cp->E[2] );
double Er_avg = .5*( c->E[1] + cp->E[3] );
c->E[0] = El_avg;
c->E[1] = Er_avg;
cp->E[2] = El_avg;
cp->E[3] = Er_avg;
double Bl_avg = .5*( c->B[0] + cp->B[2] );
double Br_avg = .5*( c->B[1] + cp->B[3] );
c->B[0] = Bl_avg;
c->B[1] = Br_avg;
cp->B[2] = Bl_avg;
cp->B[3] = Br_avg;
if( NUM_EDGES == 8 ){
double El_avg = .5*( c->E[4] + cp->E[6] );
double Er_avg = .5*( c->E[5] + cp->E[7] );
c->E[4] = El_avg;
c->E[5] = Er_avg;
cp->E[6] = El_avg;
cp->E[7] = Er_avg;
double Bl_avg = .5*( c->B[4] + cp->B[6] );
double Br_avg = .5*( c->B[5] + cp->B[7] );
c->B[4] = Bl_avg;
c->B[5] = Br_avg;
cp->B[6] = Bl_avg;
cp->B[7] = Br_avg;
}
}
}
}
int Nf = theDomain->fIndex_r[theDomain->N_ftracks_r];
struct face * theFaces = theDomain->theFaces_1;
int n;
for( n=0 ; n<Nf ; ++n ){
struct face * f = theFaces+n;
struct cell * c1;
struct cell * c2;
if( f->LRtype == 0 ){
c1 = f->L;
c2 = f->R;
}else{
c1 = f->R;
c2 = f->L;
}
double p1 = c1->piph;
double p2 = c2->piph;
double dp1 = get_dp(p2,p1);
double dp2 = c2->dphi - dp1;
if( f->LRtype == 0 ){
double Eavg = ( dp2*c2->E[0] + dp1*c2->E[2] )/(dp1+dp2);
double Bavg = ( dp2*c2->B[0] + dp1*c2->B[2] )/(dp1+dp2);
f->E = .5*(f->L->E[1] + Eavg);
f->B = .5*(f->L->B[1] + Bavg);
}else{
double Eavg = ( dp2*c2->E[1] + dp1*c2->E[3] )/(dp1+dp2);
double Bavg = ( dp2*c2->B[1] + dp1*c2->B[3] )/(dp1+dp2);
f->E = .5*(f->R->E[0] + Eavg);
f->B = .5*(f->R->B[0] + Bavg);
}
}
for( n=0 ; n<Nf ; ++n ){
struct face * f = theFaces+n;
if( f->LRtype==0 ){
f->L->E[1] = f->E;
f->L->B[1] = f->B;
}else{
f->R->E[0] = f->E;
f->R->B[0] = f->B;
}
f->E = 0.0;
f->B = 0.0;
}
if( NUM_EDGES == 8 ){
//REPEAT THE ABOVE FOR VERTICALLY-ORIENTED FACES & RADIAL EDGES
Nf = theDomain->fIndex_z[theDomain->N_ftracks_z];
theFaces = theDomain->theFaces_2;
int n;
for( n=0 ; n<Nf ; ++n ){
struct face * f = theFaces+n;
struct cell * c1;
struct cell * c2;
if( f->LRtype == 0 ){
c1 = f->L;
c2 = f->R;
}else{
c1 = f->R;
c2 = f->L;
}
double p1 = c1->piph;
double p2 = c2->piph;
double dp1 = get_dp(p2,p1);
double dp2 = c2->dphi - dp1;
if( f->LRtype == 0 ){
double Eavg = ( dp2*c2->E[4] + dp1*c2->E[6] )/(dp1+dp2);
double Bavg = ( dp2*c2->B[4] + dp1*c2->B[6] )/(dp1+dp2);
f->E = .5*(f->L->E[5] + Eavg);
f->B = .5*(f->L->B[5] + Bavg);
}else{
double Eavg = ( dp2*c2->E[5] + dp1*c2->E[7] )/(dp1+dp2);
double Bavg = ( dp2*c2->B[5] + dp1*c2->B[7] )/(dp1+dp2);
f->E = .5*(f->R->E[4] + Eavg);
f->B = .5*(f->R->B[4] + Bavg);
}
}
for( n=0 ; n<Nf ; ++n ){
struct face * f = theFaces+n;
if( f->LRtype==0 ){
f->L->E[5] = f->E;
f->L->B[5] = f->B;
}else{
f->R->E[4] = f->E;
f->R->B[4] = f->B;
}
f->E = 0.0;
f->B = 0.0;
}
}
//E_Z ALONG THE POLE...
j=0;
for( k=0 ; k<Nz ; ++k ){
int jk = j+Nr*k;
double E = 0.0;
double B = 0.0;
for( i=0 ; i<Np[jk] ; ++i ){
struct cell * c = theCells[jk]+i;
E += c->E[1]/(double)Np[jk];
// B += c->B[0]/(double)Np[jk];
}
for( i=0 ; i<Np[jk] ; ++i ){
struct cell * c = theCells[jk]+i;
c->E[0] = E;
c->B[0] = B;
}
}
for( j=0 ; j<Nr ; ++j ){
for( k=0 ; k<Nz ; ++k ){
int jk = j+Nr*k;
for( i=0 ; i<Np[jk] ; ++i ){
struct cell * c = theCells[jk]+i;
int ip = (i+1)%Np[jk];
struct cell * cp = theCells[jk]+ip;
cp->E[2] = c->E[0];
cp->E[3] = c->E[1];
cp->B[2] = c->B[0];
cp->B[3] = c->B[1];
if( NUM_EDGES == 8 ){
cp->E[6] = c->E[4];
cp->E[7] = c->E[5];
cp->B[6] = c->B[4];
cp->B[7] = c->B[5];
}
}
}
}
}
/* error handler callbacks for libpng */
static void PNGCBAPI
display_warning(png_structp pp, png_const_charp warning)
{
display_log(get_dp(pp), LIBPNG_WARNING, "%s", warning);
}
