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); }