void user_loop(void) { char xdata str[32]; static unsigned char xdata adc_chn = 0; static char xdata turbo_on_last = -1; static unsigned long xdata last_read = 0; /* read one ADC channel */ adc_read(adc_chn, &user_data.adc[adc_chn]); /* convert voltage to pressure, see data sheets */ if (adc_chn == 0) user_data.hv_mbar = pow(10, 1.667 * user_data.adc[0] - 11.33); // PKR 251 if (adc_chn == 1) user_data.vv_mbar = pow(10, user_data.adc[1] - 5.5); // TPR 280 if (adc_chn == 5) user_data.hv_close = user_data.adc[5] > 5; // ADC as digital input if (adc_chn == 6) user_data.bv_open = user_data.adc[6] > 5; // ADC as digital input if (adc_chn == 7) user_data.bv_close = user_data.adc[7] > 5; // ADC as digital input adc_chn = (adc_chn + 1) % 8; /* read buttons and digital input */ sr_read(); /* read turbo pump parameters once each second */ if (time() > last_read + 100) { if (user_data.turbo_on != turbo_on_last) { tc600_write(10, 6, user_data.turbo_on ? 111111 : 0); turbo_on_last = user_data.turbo_on; } if (tc600_read(309, str)) { user_data.error &= ~ERR_TURBO_COMM; user_data.rot_speed = atoi(str); if (tc600_read(310, str)) user_data.tmp_current = atoi(str) / 100.0; if (tc600_read(303, str)) { if (atoi(str) != 0) { user_data.error |= ERR_TURBO; strcpy(turbo_err, str); } else { user_data.error &= ~ERR_TURBO; turbo_err[0] = 0; } } } else user_data.error |= ERR_TURBO_COMM; last_read = time(); } /* mangae menu on LCD display */ lcd_menu(); }
uint8 NECDSP::read(unsigned addr) { if(!debugger_access()) cpu.synchronize_coprocessor(); if((addr & srmask) == srtest) return sr_read(); if((addr & drmask) == drtest) return dr_read(); if((addr & dpmask) == dptest) return dp_read(addr); return 0x00; }
/* sr9700_android read one word from phy or eeprom */ static int sr_share_read_word(struct usbnet *dev, int phy, u8 reg, __le16 *value) { int ret, i; mutex_lock(&dev->phy_mutex); sr_write_reg(dev, EPAR, phy ? (reg | 0x40) : reg); sr_write_reg(dev, EPCR, phy ? 0xc : 0x4); for (i = 0; i < SR_SHARE_TIMEOUT; i++) { u8 tmp; udelay(1); ret = sr_read_reg(dev, EPCR, &tmp); if (ret < 0) goto out; /* ready */ if ((tmp & 1) == 0) break; } if (i >= SR_SHARE_TIMEOUT) { netdev_err(dev->net, "%s read timed out!", phy ? "phy" : "eeprom"); ret = -EIO; goto out; } sr_write_reg(dev, EPCR, 0x0); ret = sr_read(dev, EPDR, 2, value); netdev_dbg(dev->net, "read shared %d 0x%02x returned 0x%04x, %d", phy, reg, *value, ret); out: mutex_unlock(&dev->phy_mutex); return ret; }
static int sr_share_read_word(struct usbnet *dev, int phy, u8 reg, __le16 *value) { int ret; mutex_lock(&dev->phy_mutex); sr_write_reg(dev, SR_EPAR, phy ? (reg | EPAR_PHY_ADR) : reg); sr_write_reg(dev, SR_EPCR, phy ? (EPCR_EPOS | EPCR_ERPRR) : EPCR_ERPRR); ret = wait_phy_eeprom_ready(dev, phy); if (ret < 0) goto out_unlock; sr_write_reg(dev, SR_EPCR, 0x0); ret = sr_read(dev, SR_EPDR, 2, value); netdev_dbg(dev->net, "read shared %d 0x%02x returned 0x%04x, %d\n", phy, reg, *value, ret); out_unlock: mutex_unlock(&dev->phy_mutex); return ret; }
/* sr9700_android read one register from MAC */ static int sr_read_reg(struct usbnet *dev, u8 reg, u8 *value) { return sr_read(dev, reg, 1, value); }
unsigned char application_display(bit init) { static bit b0_old = 0, b1_old = 0, b2_old = 0, b3_old = 0, station_on_old = 0, valve_locked_old = 0; if (init) lcd_clear(); /* display pressures */ lcd_goto(0, 0); if (user_data.relais[0] && user_data.relais[1]) printf("P1*: %9.2E mbar", user_data.vv_mbar); else printf("P1: %10.2E mbar", user_data.vv_mbar); lcd_goto(0, 1); if (user_data.turbo_on && (user_data.relais[2] || user_data.relais[3])) printf("P2*: %9.2E mbar", user_data.hv_mbar); else printf("P2: %10.2E mbar", user_data.hv_mbar); lcd_goto(0, 2); if (user_data.error & ERR_TURBO_COMM) printf("ERROR: turbo comm. "); else if (user_data.error & ERR_FOREVAC) printf("ERROR: fore vaccuum "); else if (user_data.error & ERR_MAINVAC) printf("ERROR: main vaccuum "); else if (user_data.error & ERR_TURBO) printf("TMP ERROR: %s ", turbo_err); else { if (user_data.man_mode) { printf("TMP: %4d Hz, %4.2f A", user_data.rot_speed, user_data.tmp_current); } else { if (pump_state == ST_OFF) { if (user_data.rot_speed > 10) printf("Rmp down TMP:%4d Hz", user_data.rot_speed); else printf("Pump station off "); } else if (pump_state == ST_START_FORE) printf("Starting fore pump "); else if (pump_state == ST_EVAC_FORE) printf("Pumping buffer tank "); else if (pump_state == ST_EVAC_MAIN) printf("Pumping recipient "); else printf("TMP: %4d Hz, %4.2f A", user_data.rot_speed, user_data.tmp_current); } } if (user_data.man_mode) { lcd_goto(0, 3); printf(user_data.relais[0] ? "FP0" : "FP1"); lcd_goto(5, 3); printf(user_data.relais[1] ? "VV0" : "VV1"); lcd_goto(11, 3); printf(user_data.relais[2] ? "HV0" : "HV1"); lcd_goto(16, 3); printf(user_data.relais[3] ? "BV0" : "BV1"); if (b0 && !b0_old) user_data.relais[0] = !user_data.relais[0]; if (b1 && !b1_old) user_data.relais[1] = !user_data.relais[1]; if (b2 && !b2_old) user_data.relais[2] = !user_data.relais[2]; if (b3 && !b3_old) user_data.relais[3] = !user_data.relais[3]; user_write(4); user_write(5); user_write(6); user_write(7); /* enter menu on buttons 2 & 3 */ if (b2 && b3) { /* wait for buttons to be released */ do { sr_read(); } while (b2 || b3); return 1; } } else { lcd_goto(0, 3); printf(user_data.station_on ? "OFF" : "ON "); lcd_goto(4, 3); printf(user_data.valve_locked ? "UNLOCK" : " LOCK "); /* toggle main switch with button 0 */ if (b0 && !b0_old) user_data.station_on = !user_data.station_on; /* toggle locking with button 1 */ if (b1 && !b1_old) user_data.valve_locked = !user_data.valve_locked; /* enter menu on release of button 3 */ if (!init) if (!b3 && b3_old) return 1; } b0_old = b0; b1_old = b1; b2_old = b2; b3_old = b3; /*---- Pump station turn on logic ----*/ if (user_data.station_on && !station_on_old) { /* start station */ /* vent enable off */ tc600_write(12, 6, 0); set_mainvalve(0); set_bypassvalve(0); set_forepump(1); pump_state = ST_START_FORE; start_time = time(); // remember start time } /* wait 5s for forepump to start (turbo could be still rotating!) */ if (pump_state == ST_START_FORE && time() > start_time + 5*100) { set_forevalve(1); start_time = time(); // remember start time pump_state = ST_EVAC_FORE; } /* check if buffer tank gets evacuated in less than 15 min */ if (pump_state == ST_EVAC_FORE && time() > start_time + 15*60*100) { pump_state = ST_ERROR; user_data.error = ERR_FOREVAC; set_forevalve(0); set_forepump(0); } /* check if evacuation of forepump and buffer tank is ready */ if (pump_state == ST_EVAC_FORE && user_data.vv_mbar < 1) { if (user_data.hv_mbar < 1) { /* recipient is already evacuated, go to running mode */ start_time = time(); // remember start time pump_state = ST_EVAC_MAIN ; } else { if (user_data.valve_locked) { /* go immediately to running mode */ user_data.turbo_on = 1; set_forevalve(1); start_time = time(); // remember start time pump_state = ST_RAMP_TURBO; } else { /* evacuate recipient through bypass valve */ set_forevalve(0); delay_ms(2000); // wait 2s set_bypassvalve(1); start_time = time(); // remember start time pump_state = ST_EVAC_MAIN; } } } /* check if recipient gets evacuated in less than evac_timeout minutes */ if (pump_state == ST_EVAC_MAIN && user_data.evac_timeout > 0 && time() > start_time + (unsigned long)user_data.evac_timeout*60*100) { pump_state = ST_ERROR; user_data.error = ERR_MAINVAC; set_forevalve(0); set_forepump(0); } /* check if evacuation of main recipient is ready, may take very long time */ if (pump_state == ST_EVAC_MAIN && user_data.hv_mbar < 1) { set_forevalve(1); // now evacuate both recipient and buffer tank } /* check if vacuum on both sides of main valve is ok */ if (pump_state == ST_EVAC_MAIN && user_data.hv_mbar < 1 && user_data.vv_mbar < 1) { /* turn on turbo pump */ user_data.turbo_on = 1; start_time = time(); // remember start time pump_state = ST_RAMP_TURBO; } /* check if vacuum leak after ramping */ if (pump_state == ST_RAMP_TURBO || pump_state == ST_RUN_FPON || pump_state == ST_RUN_FPOFF || pump_state == ST_RUN_FPUP || pump_state == ST_RUN_FPDOWN) { if (user_data.hv_mbar > 4 && user_data.valve_locked == 0) { /* protect turbo pump */ set_mainvalve(0); set_forevalve(0); user_data.turbo_on = 0; /* force restart of pump station */ if (user_data.station_on) { station_on_old = 0; pump_state = ST_OFF; return 0; } } } /* check if turbo pump started successfully in unlocked mode */ if (user_data.valve_locked == 0 && pump_state == ST_RAMP_TURBO && user_data.rot_speed > user_data.final_speed*0.8 && user_data.hv_mbar < 1 && user_data.vv_mbar < 1) { set_bypassvalve(0); /* now open main (gate) valve */ set_mainvalve(1); start_time = time(); // remember start time pump_state = ST_RUN_FPON; } /* check if turbo pump started successfully in locked mode */ if (user_data.valve_locked == 1 && pump_state == ST_RAMP_TURBO && user_data.rot_speed > user_data.final_speed*0.8 && user_data.vv_mbar < 1) { start_time = time(); // remember start time pump_state = ST_RUN_FPON; } /* check for fore pump off */ if (pump_state == ST_RUN_FPON) { if (time() > start_time + user_data.fp_cycle*100 && user_data.vv_mbar < user_data.vv_min) { set_forevalve(0); pump_state = ST_RUN_FPDOWN; start_time = time(); } } /* turn fore pump off */ if (pump_state == ST_RUN_FPDOWN) { if (time() > start_time + 3*100) { // wait 3s set_forepump(0); // turn fore pump off pump_state = ST_RUN_FPOFF; } } /* check for fore pump on */ if (pump_state == ST_RUN_FPOFF) { if (user_data.vv_mbar > user_data.vv_max) { set_forepump(1); pump_state = ST_RUN_FPUP; start_time = time(); } } /* turn fore pump on */ if (pump_state == ST_RUN_FPUP) { if (time() > start_time + 10*100) { // wait 10s set_forevalve(1); pump_state = ST_RUN_FPON; } } /* set vacuum status */ user_data.vacuum_ok = (user_data.hv_mbar <= user_data.hv_thresh); user_write(3); /*---- Pump station turn off logic ----*/ if (!user_data.station_on && station_on_old) { /* close all valves */ set_forevalve(0); set_mainvalve(0); set_bypassvalve(0); set_forepump(0); /* stop turbo pump */ user_data.turbo_on = 0; /* vent enable on */ tc600_write(12, 6, 111111); /* vent mode auto */ tc600_write(30, 3, 0); pump_state = ST_OFF; user_data.error = 0; } /*---- Lock logic ----*/ if (user_data.valve_locked && !valve_locked_old) { set_mainvalve(0); set_bypassvalve(0); } if (!user_data.valve_locked && valve_locked_old) { if (user_data.station_on) { start_time = time(); // remember start time pump_state = ST_EVAC_FORE; // start with buffer tank evacuation set_forepump(1); delay_ms(1000); set_forevalve(1); } } station_on_old = user_data.station_on; valve_locked_old = user_data.valve_locked; return 0; }
int main(void (*sr_read)(unsigned int start_sector, char *buffer, int num_sectors), void (*ser_puts)(const char *buffer)) { char *dst = (char *)LINUX_LOADADDR; const struct mbr_part *part; unsigned found = 0; unsigned int i; BUILD_BUG_ON(sizeof(struct mbr_part) != 16); BUILD_BUG_ON(sizeof(struct mbr) != SECT_SIZE); if (mbr->sig != MBR_SIG) { ser_puts("S"); die(); } for (i = 0; i < NUM_PE; i++) { part = &mbr->pe[i]; /* First partition is Linux */ if (part->type != PART_TYPE_OTHER_DATA) { ser_puts("P"); continue; } ser_puts("L"); sr_read(part->lba, dst, part->num_sects); ser_puts(".\r\n"); found = 1; break; } if (!found) { dbg_str("N"); die(); } /* Prepare ATAGS */ atags->hdr.tag = ATAG_CORE; atags->hdr.size = atag_size(atag_core); atags->u.core.flags = 1; atags->u.core.pagesize = 4096; atags->u.core.rootdev = 0; atags = atag_next(atags); #if (SDRAM_SIZE_MB > 32) #error "Need to add additional ATAG_MEM for second bank!" #endif atags->hdr.tag = ATAG_MEM; atags->hdr.size = atag_size(atag_mem); atags->u.mem.start = 0; atags->u.mem.size = 8 << 20; atags = atag_next(atags); atags->hdr.tag = ATAG_MEM; atags->hdr.size = atag_size(atag_mem); atags->u.mem.start = 0x1000000; atags->u.mem.size = 8 << 20; atags = atag_next(atags); atags->hdr.tag = ATAG_MEM; atags->hdr.size = atag_size(atag_mem); atags->u.mem.start = 0x4000000; atags->u.mem.size = 8 << 20; atags = atag_next(atags); atags->hdr.tag = ATAG_MEM; atags->hdr.size = atag_size(atag_mem); atags->u.mem.start = 0x5000000; atags->u.mem.size = 8 << 20; atags = atag_next(atags); atags->hdr.tag = ATAG_NONE; atags->hdr.size = 0; /* Start kernel, bye! */ ser_puts("G\r\n"); void (*kernel_start)(int, int, uint32_t) = (void *)LINUX_LOADADDR; kernel_start(0, TS72XX_MACH_NUM, ATAGS_OFFSET); return 0; }