// LCD Display String
void LCDprint(char *sptr){
while( *sptr ){
cprint(*sptr);
++sptr;
}
}
static void bbio_mode_id(t_hydra_console *con)
{
cprint(con, BBIO_SMARTCARD_HEADER, 4);
}
/* Handle one menu */
pt_menuitem getmenuoption( pt_menu menu, char top, char left, char startopt)
// Return item chosen or NULL if ESC was hit.
{
int curr,i;
char asc,scan;
char numitems;
pt_menuitem ci; // Current item
calc_visible(menu);
numitems = menu->numvisible;
// Setup status line
gotoxy(ms->minrow+ms->statline,ms->mincol,ms->menupage);
cprint(ms->spacechar,ms->statusattr[NOHLITE],ms->numcols,ms->menupage);
// Initialise current menu item
curr = next_visible(menu,startopt);
gotoxy(ms->minrow+ms->statline,ms->mincol,ms->menupage);
cprint(ms->spacechar,ms->statusattr[NOHLITE],ms->numcols,1);
gotoxy(ms->minrow+ms->statline,ms->mincol,ms->menupage);
printmenuitem(menu->items[curr]->status,ms->statusattr);
while (1) // Forever
{
printmenu(menu,curr,top,left);
ci = menu->items[curr];
asc = getch(&scan);
switch (scan)
{
case HOMEKEY:
curr = next_visible(menu,0);
break;
case ENDKEY:
curr = prev_visible(menu,numitems-1);
break;
case PAGEDN:
for (i=0; i < 5; i++) curr = next_visible(menu,curr+1);
break;
case PAGEUP:
for (i=0; i < 5; i++) curr = prev_visible(menu,curr-1);
break;
case UPARROW:
curr = prev_visible(menu,curr-1);
break;
case DNARROW:
curr = next_visible(menu,curr+1);
break;
case LTARROW:
case ESCAPE:
return NULL;
break;
case RTARROW:
case ENTERA:
case ENTERB:
if (ci->action == OPT_INACTIVE) break;
if (ci->action == OPT_CHECKBOX) break;
if (ci->action == OPT_SEP) break;
if (ci->action == OPT_EXITMENU) return NULL; // As if we hit Esc
return ci;
break;
case SPACEKEY:
if (ci->action != OPT_CHECKBOX) break;
ci->itemdata.checked = !ci->itemdata.checked;
// Call handler to see it anything needs to be done
if (ci->handler != NULL) ci->handler(ms,ci);
break;
default:
// Check if this is a shortcut key
if (((asc >= 'A') && (asc <= 'Z')) ||
((asc >= 'a') && (asc <= 'z')) ||
((asc >= '0') && (asc <= '9')))
curr = find_shortcut(menu,asc,curr);
break;
}
// Update status line
gotoxy(ms->minrow+ms->statline,ms->mincol,ms->menupage);
cprint(ms->spacechar,ms->statusattr[NOHLITE],ms->numcols,ms->menupage);
printmenuitem(menu->items[curr]->status,ms->statusattr);
}
return NULL; // Should never come here
}
void cls(void)
{
unsigned char dp = getdisppage();
gotoxy(0, 0, dp);
cprint(' ', GETSTRATTR, (1 + getnumrows()) * getnumcols(), dp);
}
static void conf_choice(struct menu *menu)
{
const char *prompt = menu_get_prompt(menu);
struct menu *child;
struct symbol *active;
int stat;
active = sym_get_choice_value(menu->sym);
while (1) {
cprint_init();
cprint("--title");
cprint("%s", prompt ? prompt : _("Main Menu"));
cprint("--radiolist");
cprint(_(radiolist_instructions));
cprint("15");
cprint("70");
cprint("6");
current_menu = menu;
for (child = menu->list; child; child = child->next) {
if (!menu_is_visible(child))
continue;
cprint("%p", child);
cprint("%s", menu_get_prompt(child));
if (child->sym == sym_get_choice_value(menu->sym))
cprint("ON");
else if (child->sym == active)
cprint("SELECTED");
else
cprint("OFF");
}
stat = exec_conf();
switch (stat) {
case 0:
if (sscanf(input_buf, "%p", &child) != 1)
break;
sym_set_tristate_value(child->sym, yes);
return;
case 1:
if (sscanf(input_buf, "%p", &child) == 1) {
show_help(child);
active = child->sym;
} else
show_help(menu);
break;
case 255:
return;
}
}
}
//-----------------------------------------------------------
struct sample{
TString name;
TTree* tree;
double scale;
int color;
int style;
}
//-----------------------------------------------------------
void DYBackground(){
InitgStyle();
gStyle->SetPadRightMargin(0.2);
gStyle->SetTitleYOffset(1.0);
TCanvas * c1=new TCanvas("c1","c1");
// c1->Divide(1,3);
// c1->cd(1);
cout << "Files einlesen:" << endl;
TFile *fileZmumu = new TFile("CheckSelectionSaveFilters_Zmumu.root");
fileZmumu->cd("Analyze");
gDirectory->pwd();
TTree *TreeZmumu=0; gDirectory->GetObject("Event",TreeZmumu);
TFile *fileZee = new TFile("CheckSelectionSaveFilters_Zee.root");
fileZmumu->cd("Analyze");
gDirectory->pwd();
TTree *TreeZee=0; gDirectory->GetObject("Event",TreeZee);
TFile *fileTtbar = new TFile("CheckSelectionSaveFilters_Ttbar.root");
fileTtbar->cd("Analyze");
gDirectory->pwd();
TTree *TreeTtbar=0; gDirectory->GetObject("Event",TreeTtbar);
cout << "Histogramme anlegen:" << endl;
int binNumber = 30;
TH1D * Histo_Zmumu = new TH1D("Histo_Zmumu","Histo_Zmumu",binNumber,50,150);
TH1D * Histo_Zee = new TH1D("Histo_Zee","Histo_Zee",binNumber,50,150);
TH1D * Histo_Signal = new TH1D("Histo_Signal","Histo_Signal",binNumber,50,150);
TH1D * Histo_TtbarBG = new TH1D("Histo_TtbarBG","Histo_TtbarBG",binNumber,50,150);
cout << "Histogramme fuellen:" << endl;
cout << "Zusaetzlicher MET > 35 - Cut auf Different Flavour Events um Kurvenverlaeufe moeglichst gleich zu haben." << endl;
std::string And = " && ";
std::string SelectionString = "p_Objects && p_OppositeCharge && p_Trigger && p_TwoJets && p_TwoLeptons";
std::string SignalString = "p_Dilepton";
std::string TtbarBGString = "!p_Dilepton";
std::string SameFlavString = "abs(sameFlavour) == 2 && Met > 35";
std::string DiffFlavString = "sameFlavour == 0 && Met > 35";
std::string OutString = "(InvM > 106. || InvM < 76.)";
std::string InString = "(InvM < 106. && InvM > 76.)";
TreeZmumu->Draw("InvM>>Histo_Zmumu", (SelectionString + And + SameFlavString).c_str(),"goff");
TreeZee->Draw("InvM>>Histo_Zee", (SelectionString + And + SameFlavString).c_str(),"goff");
TreeTtbar->Draw("InvM>>Histo_Signal", (SignalString + And + SelectionString + And + SameFlavString).c_str(),"goff");
TreeTtbar->Draw("InvM>>Histo_TtbarBG", (TtbarBGString + And + SelectionString + And + SameFlavString).c_str(),"goff");
cout << "Normierung auf 10pb-1:" << endl;
double ScaleZmumu = 1.056e-2;
double ScaleZee = 7.247e-3;
double ScaleTtbar = 7.268e-3;
Histo_Zmumu->Scale(ScaleZmumu);
Histo_Zee->Scale(ScaleZee);
Histo_Signal->Scale(ScaleTtbar);
Histo_TtbarBG->Scale(ScaleTtbar);
cout << "Different Flavour Histogramme anlegen und fuellen:" << endl;
TH1D * Histo_Zmumu_DF = new TH1D("Histo_Zmumu_DF","Histo_Zmumu_DF",binNumber,50,150);
TH1D * Histo_Zee_DF = new TH1D("Histo_Zee_DF","Histo_Zee_DF",binNumber,50,150);
TH1D * Histo_Signal_DF = new TH1D("Histo_Signal_DF","Histo_Signal_DF",binNumber,50,150);
TH1D * Histo_TtbarBG_DF = new TH1D("Histo_TtbarBG_DF","Histo_TtbarBG_DF",binNumber,50,150);
TreeZmumu->Draw("InvM>>Histo_Zmumu_DF", (SelectionString + And + DiffFlavString).c_str(),"goff");
TreeZee->Draw("InvM>>Histo_Zee_DF", (SelectionString + And + DiffFlavString).c_str(),"goff");
TreeTtbar->Draw("InvM>>Histo_Signal_DF", (SignalString + And + SelectionString + And + DiffFlavString).c_str(),"goff");
TreeTtbar->Draw("InvM>>Histo_TtbarBG_DF", (TtbarBGString + And + SelectionString + And + DiffFlavString).c_str(),"goff");
cout << "Histogramme malen:" << endl;
c1->SetLogy(true);
Histo_Zmumu->Add(Histo_Zee);
int LineWidth = 3;
Histo_Zmumu->SetXTitle("Invariante Masse [GeV]"); Histo_Zmumu->SetYTitle("Ereignisse pro 10pb^{-1}");
int upperLimit = 25.;
Histo_Zmumu->GetYaxis()->SetRangeUser(0.01,upperLimit);
Histo_Zmumu->GetXaxis()->SetTitleOffset(1.1);
Histo_Zmumu->GetYaxis()->SetTitleOffset(1.1);
Histo_Zmumu->SetLineWidth(LineWidth);
Histo_Zmumu->SetLineColor(kRed);
Histo_Zmumu->Draw("");
Histo_Signal->SetLineWidth(LineWidth);
Histo_Signal->SetLineColor(kGreen+2);
Histo_Signal->Draw("same");
Histo_TtbarBG->SetLineWidth(LineWidth);
Histo_TtbarBG->SetLineColor(kBlue);
Histo_TtbarBG->Draw("same");
cout << "Different Flavour Histogramme malen:" << endl;
Histo_Zmumu_DF->Scale(ScaleZmumu);
Histo_Zee_DF->Scale(ScaleZee);
Histo_Signal_DF->Scale(ScaleTtbar);
Histo_TtbarBG_DF->Scale(ScaleTtbar);
Histo_Zmumu_DF->Add(Histo_Zee_DF);
Histo_Zmumu_DF->SetLineWidth(LineWidth);
Histo_Zmumu_DF->SetLineColor(kRed);
Histo_Zmumu_DF->SetLineStyle(2);
Histo_Zmumu_DF->Draw("same");
Histo_Signal_DF->SetLineWidth(LineWidth);
Histo_Signal_DF->SetLineColor(kGreen+2);
Histo_Signal_DF->SetLineStyle(2);
Histo_Signal_DF->Draw("same");
Histo_TtbarBG_DF->SetLineWidth(LineWidth);
Histo_TtbarBG_DF->SetLineColor(kBlue);
Histo_TtbarBG_DF->SetLineStyle(2);
Histo_TtbarBG_DF->Draw("same");
left = new TLine(76.,-0.5,76.,upperLimit);
right = new TLine(106.,-0.5,106.,upperLimit);
left->SetLineWidth(LineWidth);
left->SetLineColor(34);
left->SetLineStyle(2);
right->SetLineWidth(LineWidth);
right->SetLineColor(34);
right->SetLineStyle(2);
left->Draw();
right->Draw();
//Legende
TH1D * Histo_Dummy1 = new TH1D("Histo_Dummy1","Histo_Dummy1",binNumber,50,150);
Histo_Dummy1->SetLineWidth(LineWidth);
Histo_Dummy1->SetLineColor(kBlack);
Histo_Dummy1->SetLineStyle(1);
TH1D * Histo_Dummy2 = new TH1D("Histo_Dummy2","Histo_Dummy2",binNumber,50,150);
Histo_Dummy2->SetLineWidth(LineWidth);
Histo_Dummy2->SetLineColor(kBlack);
Histo_Dummy2->SetLineStyle(2);
TLegend *legende1 = new TLegend(0.53,0.76,0.88,0.89);
legende1->AddEntry(Histo_Signal,"Signal","l");
legende1->AddEntry(Histo_Zmumu,"Drell-Yan","l");
legende1->AddEntry(Histo_TtbarBG,"andere t #bar{t}","l");
legende1->SetEntrySeparation(0.1);
legende1->Draw();
TLegend *legende2 = new TLegend(0.53,0.65,0.88,0.75);
legende2->AddEntry(Histo_Dummy1,"ee/#mu#mu-Events","l");
legende2->AddEntry(Histo_Dummy2,"e#mu-Events","l");
legende2->SetEntrySeparation(0.1);
legende2->Draw();
cout << "Berechne die Zahlenwerte:" << endl;
// double Zmumu_out = TreeZmumu->GetEntries((SelectionString + And + SameFlavString + And + OutString).c_str()) * ScaleZmumu;
// double Zee_out = TreeZee->GetEntries((SelectionString + And + SameFlavString + And + OutString).c_str()) * ScaleZee;
// double Zmumu_in = TreeZmumu->GetEntries((SelectionString + And + SameFlavString + And + InString).c_str()) * ScaleZmumu;
// double Zee_in = TreeZee->GetEntries((SelectionString + And + SameFlavString + And + InString).c_str()) * ScaleZee;
// double Routin = (Zmumu_out + Zee_out) / (Zmumu_in + Zee_in);
// cout << "Zmumu: There are " << Zmumu_out << " Events outside and " << Zmumu_in << " Events inside the Z-Peak." << endl;
// cout << "Zee: There are " << Zee_out << " Events outside and " << Zee_in << " Events inside the Z-Peak." << endl;
// cout << "Sum: There are " << Zee_out + Zmumu_out << " Events outside and " << Zee_in + Zmumu_in << " Events inside the Z-Peak." << endl;
// cout << "Routin = " << Routin << endl;
cout << "MonteCarlo:" << endl;
fehlerrechnung Zmumu_out, Zmumu_in, Zee_out, Zee_in, ROutIn;
Zmumu_out = fehlerrechnung(TreeZmumu->GetEntries((SelectionString + And + SameFlavString + And + OutString).c_str()),"poisson") * ScaleZmumu;
Zee_out = fehlerrechnung(TreeZee->GetEntries((SelectionString + And + SameFlavString + And + OutString).c_str()),"poisson") * ScaleZee;
Zmumu_in = fehlerrechnung( TreeZmumu->GetEntries((SelectionString + And + SameFlavString + And + InString).c_str()),"poisson") * ScaleZmumu;
Zee_in = fehlerrechnung( TreeZee->GetEntries((SelectionString + And + SameFlavString + And + InString).c_str()),"poisson") * ScaleZee;
ROutIn = (Zmumu_out + Zee_out) / (Zmumu_in + Zee_in);
//cprint(" DY-Events im Datenbereich: ", (Zmumu_out + Zee_out));
cprint("R_outin = ",ROutIn, 3);
cprint("DY innerhalb unskaliert: ", (Zmumu_in/ScaleZmumu)+(Zee_in/ScaleZee));
cprint("DY ausserhalb unskaliert: ", (Zmumu_out/ScaleZmumu)+(Zee_out/ScaleZee));
fehlerrechnung Ttbar_in, Total_in, Ttbar_in_DF, Zmumu_in_DF, Zee_in_DF, Total_in_DF,DYinPeak, DYinData;
Ttbar_in = fehlerrechnung(TreeTtbar->GetEntries((SelectionString + And + SameFlavString + And + InString).c_str()),"poisson") * ScaleTtbar;
cprint("Ttbar-SameFlavor-Events im Z-Peak unskaliert: ", Ttbar_in /ScaleTtbar);
cprint("Ttbar-SameFlavor-Events im Z-Peak: ", Ttbar_in);
Total_in = Ttbar_in + Zmumu_in + Zee_in;
Ttbar_in_DF = fehlerrechnung(TreeTtbar->GetEntries((SelectionString + And + DiffFlavString + And + InString).c_str()),"poisson") * ScaleTtbar;
cprint("Ttbar-DiffFlavor-Events im Z-Peak unskaliert: ", Ttbar_in_DF /ScaleTtbar);
cprint("Ttbar-DiffFlavor-Events im Z-Peak: ", Ttbar_in_DF);
cprint("Quotient (sollte 1 sein): ", Ttbar_in/Ttbar_in_DF);
Zmumu_in_DF = fehlerrechnung(TreeZmumu->GetEntries((SelectionString + And + DiffFlavString + And + InString).c_str()),"poisson") * ScaleZmumu;
Zee_in_DF = fehlerrechnung(TreeZee->GetEntries((SelectionString + And + DiffFlavString + And + InString).c_str()),"poisson") * ScaleZee;
Total_in_DF = Ttbar_in_DF + Zmumu_in_DF + Zee_in_DF;
DYinPeak = Total_in - Total_in_DF;
cprint("In MC-Daten wirklich vorhandene Events innerhalb des Peaks: ", (Zmumu_in + Zee_in));
cprint("Aus \"Daten\": DY-Ereignisse innerhalb des Peaks: ", DYinPeak);
DYinData = ROutIn * DYinPeak;
cprint("Vorhersage der Methode fuer DY-Events im Datenbereich: ", DYinData);
cprint("In MC-Daten wirklich vorhandene Events im Datenbereich: ", (Zmumu_out + Zee_out));
cprint("Differenz Rekonstruktion - Wahrheit: ", (DYinData - Zmumu_out - Zee_out));
fehlerrechnung Ttbar_out, Ttbar_out_DF;
Ttbar_out = fehlerrechnung(TreeTtbar->GetEntries((SelectionString + And + SameFlavString + And + OutString).c_str()),"poisson") * ScaleTtbar;
cprint("Ttbar-SameFlavor-Events !im Z-Peak unskaliert: ", Ttbar_out /ScaleTtbar);
cprint("Ttbar-SameFlavor-Events !im Z-Peak: ", Ttbar_out);
Ttbar_out_DF = fehlerrechnung(TreeTtbar->GetEntries((SelectionString + And + DiffFlavString + And + OutString).c_str()),"poisson") * ScaleTtbar;
cprint("Ttbar-DiffFlavor-Events !im Z-Peak unskaliert: ", Ttbar_out_DF /ScaleTtbar);
cprint("Ttbar-DiffFlavor-Events !im Z-Peak: ", Ttbar_out_DF);
cprint("Quotient (sollte 1 sein): ", Ttbar_out/Ttbar_out_DF);
// TCanvas *c2 = new TCanvas("c2","c2",100,100,900,900);
// // TH1D * Histo_Diff = new TH1D("Histo_Diff","Histo_Diff",binNumber,50,150);
// Histo_Signal->Add(Histo_TtbarBG);
// Histo_Signal_DF->Add(Histo_TtbarBG_DF);
// // Histo_Signal->Add(Histo_Signal_DF,-1.);
// Histo_Signal->Divide(Histo_Signal_DF);
// Histo_Signal->Draw("");
// // Histo_Diff->(Histo_Signal,Histo_Signal_DF,1,-1);
// // Histo_Diff->Draw("");
// left->Draw();
// right->Draw();
}
void get_config()
{
int flag = 0, sflag = 0, i, j, k, n, m, prt = 0;
int reprint_screen = 0;
char cp[64];
ulong page;
popup();
wait_keyup();
while(!flag) {
cprint(POP_Y+1, POP_X+2, "Settings:");
cprint(POP_Y+3, POP_X+4, "(1) Select wat MEMEZ to test");
cprint(POP_Y+4, POP_X+4, "(2) Address Range");
cprint(POP_Y+5, POP_X+4, "(3) O NOES ERRORZ Mode");
cprint(POP_Y+6, POP_X+4, "(4) Select with COREZ 2 test");
cprint(POP_Y+7, POP_X+4, "(5) Refresh Screen");
cprint(POP_Y+8, POP_X+4, "(6) DISPLYUZ DMI DATUZ");
cprint(POP_Y+9, POP_X+4, "(7) such RAM much SPD");
cprint(POP_Y+11, POP_X+4, "(0) Continue rowHAMMER TIME");
/* Wait for key release */
/* Fooey! This nuts'es up the serial input. */
sflag = 0;
switch(get_key()) {
case 2:
/* 1 - Test Selection */
popclear();
cprint(POP_Y+1, POP_X+2, "Test Selection:");
cprint(POP_Y+3, POP_X+6, "(1) Default Tests");
cprint(POP_Y+4, POP_X+6, "(2) Skip Current Test");
cprint(POP_Y+5, POP_X+6, "(3) Select Test");
cprint(POP_Y+6, POP_X+6, "(4) Enter Test List");
cprint(POP_Y+7, POP_X+6, "(0) Cancel");
if (v->testsel < 0) {
cprint(POP_Y+3, POP_X+5, ">");
} else {
cprint(POP_Y+5, POP_X+5, ">");
}
wait_keyup();
while (!sflag) {
switch(get_key()) {
case 2:
/* Default - All tests */
i = 0;
while (tseq[i].cpu_sel) {
tseq[i].sel = 1;
i++;
}
find_ticks_for_pass();
sflag++;
break;
case 3:
/* Skip test */
bail++;
sflag++;
break;
case 4:
/* Select test */
popclear();
cprint(POP_Y+1, POP_X+3,
"Test Selection:");
cprint(POP_Y+4, POP_X+5,
"Test Number [1-11]: ");
n = getval(POP_Y+4, POP_X+24, 0) - 1;
if (n <= 11)
{
/* Deselect all tests */
i = 0;
while (tseq[i].cpu_sel) {
tseq[i].sel = 0;
i++;
}
/* Now set the selection */
tseq[n].sel = 1;
v->pass = -1;
test = n;
find_ticks_for_pass();
sflag++;
bail++;
}
break;
case 5:
/* Enter a test list */
popclear();
cprint(POP_Y+1, POP_X+3,
"Enter a comma separated list");
cprint(POP_Y+2, POP_X+3,
"of tests to execute:");
cprint(POP_Y+5, POP_X+5, "List: ");
/* Deselect all tests */
k = 0;
while (tseq[k].cpu_sel) {
tseq[k].sel = 0;
k++;
}
/* Get the list */
for (i=0; i<64; i++) cp[i] = 0;
get_list(POP_Y+5, POP_X+10, 64, cp);
/* Now enable all of the tests in the
* list */
i = j = m = 0;
while (1) {
if (isdigit(cp[i])) {
n = cp[i]-'0';
j = j*10 + n;
i++;
if (cp[i] == ',' || cp[i] == 0){
if (j < k) {
tseq[j].sel = 1;
m++;
}
if (cp[i] == 0) break;
j = 0;
i++;
}
}
}
/* If we didn't select at least one
* test turn them all back on */
if (m == 0) {
k = 0;
while (tseq[k].cpu_sel) {
tseq[k].sel = 1;
k++;
}
}
v->pass = -1;
test = n;
find_ticks_for_pass();
sflag++;
bail++;
break;
case 11:
case 57:
sflag++;
break;
}
}
popclear();
break;
case 3:
/* 2 - Address Range */
popclear();
cprint(POP_Y+1, POP_X+2, "rowHAMMER TIME Address Range:");
cprint(POP_Y+3, POP_X+6, "(1) Set Lower Limit");
cprint(POP_Y+4, POP_X+6, "(2) Set Upper Limit");
cprint(POP_Y+5, POP_X+6, "(3) Test All Memory");
cprint(POP_Y+6, POP_X+6, "(0) Cancel");
wait_keyup();
while (!sflag) {
switch(get_key()) {
case 2:
/* Lower Limit */
popclear();
cprint(POP_Y+2, POP_X+4,
"Lower Limit: ");
cprint(POP_Y+4, POP_X+4,
"Current: ");
aprint(POP_Y+4, POP_X+13, v->plim_lower);
cprint(POP_Y+6, POP_X+4,
"New: ");
page = getval(POP_Y+6, POP_X+9, 12);
if (page + 1 <= v->plim_upper) {
v->plim_lower = page;
test--;
bail++;
}
adj_mem();
find_chunks();
find_ticks_for_pass();
sflag++;
break;
case 3:
/* Upper Limit */
popclear();
cprint(POP_Y+2, POP_X+4,
"Upper Limit: ");
cprint(POP_Y+4, POP_X+4,
"Current: ");
aprint(POP_Y+4, POP_X+13, v->plim_upper);
cprint(POP_Y+6, POP_X+4,
"New: ");
page = getval(POP_Y+6, POP_X+9, 12);
if (page - 1 >= v->plim_lower) {
v->plim_upper = page;
bail++;
test--;
}
adj_mem();
find_chunks();
find_ticks_for_pass();
sflag++;
break;
case 4:
/* All of memory */
v->plim_lower = 0;
v->plim_upper =
v->pmap[v->msegs - 1].end;
test--;
bail++;
adj_mem();
find_chunks();
find_ticks_for_pass();
sflag++;
break;
case 11:
case 57:
/* 0/CR - Continue */
sflag++;
break;
}
}
popclear();
break;
case 4:
/* Error Mode */
popclear();
cprint(POP_Y+1, POP_X+2, "Printing Mode:");
cprint(POP_Y+3, POP_X+6, "(1) O NOES ALL ERRORZ");
cprint(POP_Y+4, POP_X+6, "(2) O NOES ONE ERRORZ");
cprint(POP_Y+5, POP_X+6, "(3) BadRAM Patterns. BADRAM");
cprint(POP_Y+6, POP_X+6, "(4) O NOES HOW MANYZ ERRORZ");
cprint(POP_Y+7, POP_X+6, "(5) BEEP BEEP BEEP ERRORZ");
cprint(POP_Y+8, POP_X+6, "(0) GTFO");
cprint(POP_Y+3+v->printmode, POP_X+5, ">");
if (beepmode) { cprint(POP_Y+7, POP_X+5, ">"); }
wait_keyup();
while (!sflag) {
switch(get_key()) {
case 2:
/* Error Summary */
v->printmode=PRINTMODE_SUMMARY;
v->erri.eadr = 0;
v->erri.hdr_flag = 0;
sflag++;
break;
case 3:
/* Separate Addresses */
v->printmode=PRINTMODE_ADDRESSES;
v->erri.eadr = 0;
v->erri.hdr_flag = 0;
v->msg_line = LINE_SCROLL-1;
sflag++;
break;
case 4:
/* BadRAM Patterns */
v->printmode=PRINTMODE_PATTERNS;
v->erri.hdr_flag = 0;
sflag++;
prt++;
break;
case 5:
/* Error Counts Only */
v->printmode=PRINTMODE_NONE;
v->erri.hdr_flag = 0;
sflag++;
break;
case 6:
/* Set Beep On Error mode */
beepmode = !beepmode;
sflag++;
break;
case 11:
case 57:
/* 0/CR - Continue */
sflag++;
break;
}
}
popclear();
break;
case 5:
/* CPU Mode */
reprint_screen = 1;
popclear();
cprint(POP_Y+1, POP_X+2, "BRAINE Selection Mode:");
cprint(POP_Y+3, POP_X+6, "(1) Parallel (All)");
cprint(POP_Y+4, POP_X+6, "(2) Round Robin Hood (RRbH)");
cprint(POP_Y+5, POP_X+6, "(3) Sequential (Seq)");
cprint(POP_Y+6, POP_X+6, "(0) NOPE BYE");
cprint(POP_Y+2+cpu_mode, POP_X+5, ">");
wait_keyup();
while(!sflag) {
switch(get_key()) {
case 2:
if (cpu_mode != CPM_ALL) bail++;
cpu_mode = CPM_ALL;
sflag++;
popdown();
cprint(9,34,"All");
popup();
break;
case 3:
if (cpu_mode != CPM_RROBIN) bail++;
cpu_mode = CPM_RROBIN;
sflag++;
popdown();
cprint(9,34,"RRb");
popup();
break;
case 4:
if (cpu_mode != CPM_SEQ) bail++;
cpu_mode = CPM_SEQ;
sflag++;
popdown();
cprint(9,34,"Seq");
popup();
break;
case 11:
case 57:
/* 0/CR - Continue */
sflag++;
break;
}
}
popclear();
break;
case 6:
reprint_screen = 1;
flag++;
break;
case 7:
/* Display DMI Memory Info */
pop2up();
print_dmi_info();
pop2down();
break;
case 8:
/* Display SPD Data */
popdown();
show_spd();
popup();
sflag++;
break;
case 11:
case 57:
case 28:
/* 0/CR/SP - Continue */
flag++;
break;
}
}
popdown();
if (prt) {
printpatn();
}
if (reprint_screen){
tty_print_screen();
}
}
void get_config()
{
int flag = 0, sflag = 0, i, prt = 0;
int reprint_screen = 0;
ulong page;
popup();
wait_keyup();
while(!flag) {
cprint(POP_Y+1, POP_X+2, "Configuration:");
cprint(POP_Y+3, POP_X+6, "(1) Test Selection");
cprint(POP_Y+4, POP_X+6, "(2) Address Range");
cprint(POP_Y+5, POP_X+6, "(3) Memory Sizing");
cprint(POP_Y+6, POP_X+6, "(4) Error Summary");
cprint(POP_Y+7, POP_X+6, "(5) Error Report Mode");
cprint(POP_Y+8, POP_X+6, "(6) ECC Mode");
cprint(POP_Y+9, POP_X+6, "(7) Restart w/Defaults");
cprint(POP_Y+10, POP_X+6, "(8) Redraw Screen");
cprint(POP_Y+11, POP_X+6, "(9) Adv. Options");
cprint(POP_Y+12,POP_X+6,"(0) Continue");
/* Wait for key release */
/* Fooey! This nuts'es up the serial input. */
sflag = 0;
switch(get_key()) {
case 2:
/* 1 - Test Selection */
popclear();
cprint(POP_Y+1, POP_X+2, "Test Selection:");
cprint(POP_Y+3, POP_X+6, "(1) Default Tests");
cprint(POP_Y+4, POP_X+6, "(2) Skip Current Test");
cprint(POP_Y+5, POP_X+6, "(3) Select Test");
cprint(POP_Y+6, POP_X+6, "(4) Select Bit Fade Test");
cprint(POP_Y+7, POP_X+6, "(0) Cancel");
if (v->testsel < 0) {
cprint(POP_Y+3, POP_X+5, ">");
} else {
cprint(POP_Y+5, POP_X+5, ">");
}
wait_keyup();
while (!sflag) {
switch(get_key()) {
case 2:
/* Default */
if (v->testsel == 9) {
bail++;
}
v->testsel = -1;
find_ticks();
sflag++;
cprint(LINE_INFO, COL_TST, "Std");
break;
case 3:
/* Skip test */
bail++;
sflag++;
break;
case 4:
/* Select test */
popclear();
cprint(POP_Y+1, POP_X+3,
"Test Selection:");
cprint(POP_Y+4, POP_X+5,
"Test Number [0-9]: ");
i = getval(POP_Y+4, POP_X+24, 0);
if (i <= 9) {
if (i != v->testsel) {
v->pass = -1;
v->test = -1;
}
v->testsel = i;
}
find_ticks();
sflag++;
bail++;
cprint(LINE_INFO, COL_TST, "#");
dprint(LINE_INFO, COL_TST+1, i, 2, 1);
break;
case 5:
if (v->testsel != 9) {
v->pass = -1;
v->test = -1;
}
v->testsel = 9;
find_ticks();
sflag++;
bail++;
cprint(LINE_INFO, COL_TST, "#");
dprint(LINE_INFO, COL_TST+1, 9, 2, 1);
break;
case 11:
case 57:
sflag++;
break;
}
}
popclear();
break;
case 3:
/* 2 - Address Range */
popclear();
cprint(POP_Y+1, POP_X+2, "Test Address Range:");
cprint(POP_Y+3, POP_X+6, "(1) Set Lower Limit");
cprint(POP_Y+4, POP_X+6, "(2) Set Upper Limit");
cprint(POP_Y+5, POP_X+6, "(3) Test All Memory");
cprint(POP_Y+6, POP_X+6, "(0) Cancel");
wait_keyup();
while (!sflag) {
switch(get_key()) {
case 2:
/* Lower Limit */
popclear();
cprint(POP_Y+2, POP_X+4,
"Lower Limit: ");
cprint(POP_Y+4, POP_X+4,
"Current: ");
aprint(POP_Y+4, POP_X+13, v->plim_lower);
cprint(POP_Y+6, POP_X+4,
"New: ");
page = getval(POP_Y+6, POP_X+9, 12);
if (page + 1 <= v->plim_upper) {
v->plim_lower = page;
bail++;
}
adj_mem();
find_ticks();
sflag++;
break;
case 3:
/* Upper Limit */
popclear();
cprint(POP_Y+2, POP_X+4,
"Upper Limit: ");
cprint(POP_Y+4, POP_X+4,
"Current: ");
aprint(POP_Y+4, POP_X+13, v->plim_upper);
cprint(POP_Y+6, POP_X+4,
"New: ");
page = getval(POP_Y+6, POP_X+9, 12);
if (page - 1 >= v->plim_lower) {
v->plim_upper = page;
bail++;
}
adj_mem();
find_ticks();
sflag++;
break;
case 4:
/* All of memory */
v->plim_lower = 0;
v->plim_upper = v->pmap[v->msegs - 1].end;
bail++;
adj_mem();
find_ticks();
sflag++;
break;
case 11:
case 57:
/* 0/CR - Continue */
sflag++;
break;
}
}
popclear();
break;
case 4:
/* 3 - Memory Sizing */
popclear();
cprint(POP_Y+1, POP_X+2, "Memory Sizing:");
cprint(POP_Y+3, POP_X+6, "(1) BIOS - Std");
if (e820_nr) {
cprint(POP_Y+4, POP_X+6, "(2) BIOS - All");
cprint(POP_Y+5, POP_X+6, "(3) Probe");
cprint(POP_Y+6, POP_X+6, "(0) Continue");
cprint(POP_Y+2+memsz_mode, POP_X+5, ">");
} else {
cprint(POP_Y+4, POP_X+6, "(3) Probe");
cprint(POP_Y+5, POP_X+6, "(0) Cancel");
if (memsz_mode == SZ_MODE_BIOS) {
cprint(POP_Y+3, POP_X+5, ">");
} else {
cprint(POP_Y+4, POP_X+5, ">");
}
}
wait_keyup();
while (!sflag) {
switch(get_key()) {
case 2:
memsz_mode = SZ_MODE_BIOS;
wait_keyup();
restart();
break;
case 3:
memsz_mode = SZ_MODE_BIOS_RES;
wait_keyup();
restart();
break;
case 4:
memsz_mode = SZ_MODE_PROBE;
wait_keyup();
restart();
break;
case 11:
case 57:
/* 0/CR - Continue */
sflag++;
break;
}
}
popclear();
break;
case 5:
/* 4 - Show error summary */
popclear();
for (i=0; tseq[i].msg != NULL; i++) {
cprint(POP_Y+1+i, POP_X+2, "Test:");
dprint(POP_Y+1+i, POP_X+8, i, 2, 1);
cprint(POP_Y+1+i, POP_X+12, "Errors:");
dprint(POP_Y+1+i, POP_X+20, tseq[i].errors,
5, 1);
}
wait_keyup();
while (get_key() == 0);
popclear();
break;
case 6:
/* 5 - Printing Mode */
popclear();
cprint(POP_Y+1, POP_X+2, "Printing Mode:");
cprint(POP_Y+3, POP_X+6, "(1) Individual Errors");
cprint(POP_Y+4, POP_X+6, "(2) BadRAM Patterns");
cprint(POP_Y+5, POP_X+6, "(3) Error Counts Only");
cprint(POP_Y+6, POP_X+6, "(0) Cancel");
cprint(POP_Y+3+v->printmode, POP_X+5, ">");
wait_keyup();
while (!sflag) {
switch(get_key()) {
case 2:
/* Separate Addresses */
v->printmode=PRINTMODE_ADDRESSES;
v->eadr = 0;
sflag++;
break;
case 3:
/* BadRAM Patterns */
v->printmode=PRINTMODE_PATTERNS;
sflag++;
prt++;
break;
case 4:
/* Error Counts Only */
v->printmode=PRINTMODE_NONE;
sflag++;
break;
case 11:
case 57:
/* 0/CR - Continue */
sflag++;
break;
}
}
popclear();
break;
case 7:
/* 6 - ECC Polling Mode */
popclear();
cprint(POP_Y+1, POP_X+2, "ECC Polling Mode:");
cprint(POP_Y+3, POP_X+6, "(1) Recommended");
cprint(POP_Y+4, POP_X+6, "(2) On");
cprint(POP_Y+5, POP_X+6, "(3) Off");
cprint(POP_Y+6, POP_X+6, "(0) Cancel");
wait_keyup();
while(!sflag) {
switch(get_key()) {
case 2:
set_ecc_polling(-1);
sflag++;
break;
case 3:
set_ecc_polling(1);
sflag++;
break;
case 4:
set_ecc_polling(0);
sflag++;
break;
case 11:
case 57:
/* 0/CR - Continue */
sflag++;
break;
}
}
popclear();
break;
case 8:
wait_keyup();
restart();
break;
case 9:
reprint_screen = 1;
flag++;
break;
case 10:
/* 9 - Advanced Options */
popclear();
cprint(POP_Y+1, POP_X+2, "Advanced Options:");
cprint(POP_Y+3, POP_X+6, "(1) Display SPD Info");
cprint(POP_Y+4, POP_X+6, "(2) Modify Memory Timing");
cprint(POP_Y+5, POP_X+6, "(0) Cancel");
wait_keyup();
while (!sflag) {
switch(get_key()) {
case 2:
popdown();
show_spd();
popup();
sflag++;
break;
case 3:
get_menu();
sflag++;
break;
case 11:
case 57:
/* 0/CR - Continue */
sflag++;
break;
}
}
popclear();
break;
case 11:
case 57:
case 28:
/* 0/CR/SP - Continue */
flag++;
break;
}
}
popdown();
if (prt) {
printpatn();
}
if (reprint_screen) {
tty_print_screen();
}
}
void boot_ap(unsigned cpu_num)
{
unsigned num_sipi, apic_id;
extern uint8_t gdt;
extern uint8_t _ap_trampoline_start;
extern uint8_t _ap_trampoline_protmode;
unsigned len = &_ap_trampoline_protmode - &_ap_trampoline_start;
apic_id = cpu_num_to_apic_id[cpu_num];
memcpy((uint8_t*)BOOTCODESTART, &_ap_trampoline_start, len);
// Fixup the LGDT instruction to point to GDT pointer.
PUT_MEM16(BOOTCODESTART + 3, GDTPOINTERADDR);
// Copy a pointer to the temporary GDT to addr GDTPOINTERADDR.
// The temporary gdt is at addr GDTADDR
PUT_MEM16(GDTPOINTERADDR, 4 * 8);
PUT_MEM32(GDTPOINTERADDR + 2, GDTADDR);
// Copy the first 4 gdt entries from the currently used GDT to the
// temporary GDT.
memcpy((uint8_t *)GDTADDR, &gdt, 32);
// clear the APIC ESR register
APIC_WRITE(APICR_ESR, 0);
APIC_READ(APICR_ESR);
// asserting the INIT IPI
SEND_IPI(apic_id, APIC_TRIGGER_LEVEL, 1, APIC_DELMODE_INIT, 0);
delay(100000 / DELAY_FACTOR);
// de-assert the INIT IPI
SEND_IPI(apic_id, APIC_TRIGGER_LEVEL, 0, APIC_DELMODE_INIT, 0);
for (num_sipi = 0; num_sipi < 2; num_sipi++) {
unsigned timeout;
bool send_pending;
unsigned err;
APIC_WRITE(APICR_ESR, 0);
SEND_IPI(apic_id, 0, 0, APIC_DELMODE_STARTUP, BOOTCODESTART >> 12);
timeout = 0;
do {
delay(10);
timeout++;
send_pending = (APIC_READ(APICR_ICRLO) & APIC_ICRLO_STATUS_MASK) != 0;
} while (send_pending && timeout < 1000);
if (send_pending) {
cprint(LINE_STATUS+3, 0, "SMP: STARTUP IPI was never sent");
}
delay(100000 / DELAY_FACTOR);
err = APIC_READ(APICR_ESR) & 0xef;
if (err) {
cprint(LINE_STATUS+3, 0, "SMP: After STARTUP IPI: err = 0x");
hprint(LINE_STATUS+3, COL_MID, err);
}
}
}
void print_dmi_info(void){
int i,j,page;
char * string=0;
if(!dmi_initialized)
init_dmi();
if (mem_devs_count == 0){
cprint(POP2_Y+1, POP2_X+2, "No valid DMI Memory Devices info found");
while (get_key() == 0);
return;
}
for(page=1; page <= 1 + (mem_devs_count-1)/8; page++){
pop2clear();
cprint(POP2_Y+1, POP2_X+2, "DMI Memory Device Info (page ");
itoa(string,page);
cprint(POP2_Y+1, POP2_X+32, string);
cprint(POP2_Y+1, POP2_X+33, "/");
itoa(string,1 + (mem_devs_count-1)/8);
cprint(POP2_Y+1, POP2_X+34, string);
cprint(POP2_Y+1, POP2_X+35, ")");
cprint(POP2_Y+3, POP2_X+4, "Location Size(MB) Speed(MHz) Type Form");
cprint(POP2_Y+4, POP2_X+4, "--------------------------------------------------------------");
for(i=8*(page-1); i<mem_devs_count && i<8*page; i++){
int size_in_mb;
int yof;
yof=POP2_Y+5+2*(i-8*(page-1));
cprint(yof, POP2_X+4, get_tstruct_string(&(mem_devs[i]->header), mem_devs[i]->dev_locator));
if (mem_devs[i]->size == 0){
cprint(yof, POP2_X+4+18, "Empty");
}else if (mem_devs[i]->size == 0xFFFF){
cprint(yof, POP2_X+4+18, "Unknown");
}else{
size_in_mb = 0xEFFF & mem_devs[i]->size;
if (mem_devs[i]->size & 0x8000)
size_in_mb = size_in_mb<<10;
itoa(string, size_in_mb);
cprint(yof, POP2_X+4+18, string);
}
//this is the only field that needs to be SMBIOS 2.3+
if ( mem_devs[i]->speed &&
mem_devs[i]->header.length > 21){
itoa(string, mem_devs[i]->speed);
cprint(yof, POP2_X+4+27, string);
}else{
cprint(yof, POP2_X+4+27, "Unknown");
}
cprint(yof, POP2_X+4+37, memory_types[mem_devs[i]->type]);
cprint(yof, POP2_X+4+44, form_factors[mem_devs[i]->form]);
//print mappings
int mapped=0,of=0;
cprint(yof+1, POP2_X+6,"mapped to: ");
for(j=0; j<md_maps_count; j++){
if (mem_devs[i]->header.handle != md_maps[j]->md_handle)
continue;
if (mapped++){
cprint(yof+1, POP2_X+17+of, ",");
of++;
}
hprint3(yof+1, POP2_X+17+of, md_maps[j]->start<<10, 12);
of += 12;
cprint(yof+1, POP2_X+17+of, "-");
of++;
hprint3(yof+1, POP2_X+17+of, md_maps[j]->end<<10, 12);
of += 12;
}
if (!mapped)
cprint(yof+1, POP2_X+17, "No mapping (Interleaved Device)");
}
wait_keyup();
while (get_key() == 0);
}
}
title(int up)
{
cprint("C Forth 93 ", up);
// cprint("Version %I%");
cprint(" Copyright (c) 1992 by Bradley Forthware\n", up);
}
void
check(Filsys *fs, long flag)
{
Iobuf *p;
Superb *sb;
Dentry *d;
long raddr;
long nqid;
wlock(&mainlock);
dev = fs->dev;
flags = flag;
fence = fencebase;
sizname = 4000;
name = zalloc(sizname);
sizname -= NAMELEN+10; /* for safety */
sbaddr = superaddr(dev);
raddr = getraddr(dev);
p = xtag(sbaddr, Tsuper, QPSUPER);
if(!p){
cprint("bad superblock\n");
goto out;
}
sb = (Superb*)p->iobuf;
fstart = 1;
fsize = sb->fsize;
sizabits = (fsize-fstart + 7)/8;
abits = zalloc(sizabits);
nqid = sb->qidgen+100; /* not as much of a botch */
if(nqid > 1024*1024*8)
nqid = 1024*1024*8;
if(nqid < 64*1024)
nqid = 64*1024;
sizqbits = (nqid+7)/8;
qbits = zalloc(sizqbits);
mod = 0;
nfree = 0;
nfdup = 0;
nused = 0;
nbad = 0;
ndup = 0;
nqbad = 0;
depth = 0;
maxdepth = 0;
if(flags & Ctouch) {
oldblock = fsize/DSIZE;
oldblock *= DSIZE;
if(oldblock < 0)
oldblock = 0;
cprint("oldblock = %ld\n", oldblock);
}
if(amark(sbaddr))
{}
if(cwflag) {
if(amark(sb->roraddr))
{}
if(amark(sb->next))
{}
}
if(!(flags & Cquiet))
cprint("checking file system: %s\n", fs->name);
nfiles = 0;
maxq = 0;
d = maked(raddr, 0, QPROOT);
if(d) {
if(amark(raddr))
{}
if(fsck(d))
modd(raddr, 0, d);
depth--;
fence -= sizeof(Dentry);
if(depth)
cprint("depth not zero on return\n");
}
if(flags & Cfree) {
mkfreelist(sb);
sb->qidgen = maxq;
settag(p, Tsuper, QPNONE);
}
if(sb->qidgen < maxq)
cprint("qid generator low path=%ld maxq=%ld\n",
sb->qidgen, maxq);
if(!(flags & Cfree))
ckfreelist(sb);
if(mod) {
cprint("file system was modified\n");
settag(p, Tsuper, QPNONE);
}
if(!(flags & Cquiet)){
cprint("%8ld files\n", nfiles);
cprint("%8ld blocks in the file system\n", fsize-fstart);
cprint("%8ld used blocks\n", nused);
cprint("%8ld free blocks\n", sb->tfree);
}
if(!(flags & Cfree)){
if(nfree != sb->tfree)
cprint("%8ld free blocks found\n", nfree);
if(nfdup)
cprint("%8ld blocks duplicated in the free list\n", nfdup);
if(fsize-fstart-nused-nfree)
cprint("%8ld missing blocks\n", fsize-fstart-nused-nfree);
}
if(ndup)
cprint("%8ld address duplications\n", ndup);
if(nbad)
cprint("%8ld bad block addresses\n", nbad);
if(nqbad)
cprint("%8ld bad qids\n", nqbad);
if(!(flags & Cquiet))
cprint("%8ld maximum qid path\n", maxq);
missing();
out:
if(p)
putbuf(p);
free(abits);
free(name);
free(qbits);
wunlock(&mainlock);
}
static
int
fsck(Dentry *d)
{
char *s;
Rune r;
Iobuf *p;
int l, i, ns, dmod;
long a, qpath;
depth++;
if(depth >= maxdepth){
maxdepth = depth;
if(maxdepth >= MAXDEPTH){
cprint("max depth exceeded: %s\n", name);
return 0;
}
}
dmod = 0;
if(!(d->mode & DALLOC))
return 0;
nfiles++;
ns = strlen(name);
i = strlen(d->name);
if(i >= NAMELEN){
d->name[NAMELEN-1] = 0;
cprint("%s->name (%s) not terminated\n", name, d->name);
return 0;
}
ns += i;
if(ns >= sizname){
cprint("%s->name (%s) name too large\n", name, d->name);
return 0;
}
for (s = d->name; *s; s += l){
l = chartorune(&r, s);
if (r == Runeerror)
for (i = 0; i < l; i++){
s[i] = '_';
cprint("%s->name (%s) bad UTF\n", name, d->name);
dmod++;
}
}
strcat(name, d->name);
if(d->mode & DDIR){
if(ns > 1)
strcat(name, "/");
if(flags & Cpdir)
cprint("%s\n", name);
} else
if(flags & Cpfile)
cprint("%s\n", name);
qpath = d->qid.path & ~QPDIR;
qmark(qpath);
if(qpath > maxq)
maxq = qpath;
for(i=0; i<NDBLOCK; i++) {
a = d->dblock[i];
if(!a)
continue;
if(amark(a)) {
d->dblock[i] = 0;
dmod++;
continue;
}
if(d->mode & DDIR)
dmod += checkdir(a, qpath);
else if(flags & Crdall)
xread(a, qpath);
}
a = d->iblock;
if(a && amark(a)) {
d->iblock = 0;
dmod++;
}
else if(a)
dmod += checkindir(a, d, qpath);
a = d->diblock;
if(a && amark(a)) {
d->diblock = 0;
return dmod + 1;
}
dmod += touch(a);
if(p = xtag(a, Tind2, qpath)){
for(i=0; i<INDPERBUF; i++){
a = ((long*)p->iobuf)[i];
if(!a)
continue;
if(amark(a)) {
if(flags & Cbad) {
((long*)p->iobuf)[i] = 0;
p->flags |= Bmod;
}
continue;
}
dmod += checkindir(a, d, qpath);
}
putbuf(p);
}
return dmod;
}
void bbio_mode_smartcard(t_hydra_console *con)
{
uint32_t to_rx, to_tx, i;
uint8_t bbio_subcommand;
uint8_t *tx_data = (uint8_t *)g_sbuf;
uint8_t *rx_data = (uint8_t *)g_sbuf+4096;
uint8_t data;
uint32_t dev_speed=0;
uint32_t final_baudrate;
bsp_status_t status;
mode_config_proto_t* proto = &con->mode->proto;
bbio_smartcard_init_proto_default(con);
bsp_smartcard_init(proto->dev_num, proto);
bbio_mode_id(con);
while (!USER_BUTTON) {
if(chnRead(con->sdu, &bbio_subcommand, 1) == 1) {
switch(bbio_subcommand) {
case BBIO_RESET:
bsp_smartcard_deinit(proto->dev_num);
return;
case BBIO_MODE_ID:
bbio_mode_id(con);
break;
case BBIO_SMARTCARD_RST_LOW:
bsp_smartcard_set_rst(proto->dev_num, 0);
cprint(con, "\x01", 1);
break;
case BBIO_SMARTCARD_RST_HIGH:
bsp_smartcard_set_rst(proto->dev_num, 1);
cprint(con, "\x01", 1);
break;
case BBIO_SMARTCARD_PRESCALER:
/* Not implemented */
chnRead(con->sdu, &data, 1);
proto->config.smartcard.dev_prescaler = data;
status = bsp_smartcard_init(proto->dev_num, proto);
if(status == BSP_OK) {
cprint(con, "\x01", 1);
} else {
cprint(con, "\x00", 1);
}
break;
case BBIO_SMARTCARD_GUARDTIME:
/* Not implemented */
chnRead(con->sdu, &data, 1);
proto->config.smartcard.dev_guardtime = data;
status = bsp_smartcard_init(proto->dev_num, proto);
if(status == BSP_OK) {
cprint(con, "\x01", 1);
} else {
cprint(con, "\x00", 1);
}
break;
case BBIO_SMARTCARD_WRITE_READ:
chnRead(con->sdu, rx_data, 4);
to_tx = (rx_data[0] << 8) + rx_data[1];
to_rx = (rx_data[2] << 8) + rx_data[3];
if ((to_tx > 4096) || (to_rx > 4096)) {
cprint(con, "\x00", 1);
break;
}
if(to_tx > 0) {
chnRead(con->sdu, tx_data, to_tx);
i=0;
while(i<to_tx) {
if((to_tx-i) >= 255) {
bsp_smartcard_write_u8(proto->dev_num,
tx_data+i,
255);
} else {
bsp_smartcard_write_u8(proto->dev_num,
tx_data+i,
to_tx-i);
}
i+=255;
}
}
i=0;
while(i<to_rx) {
if((to_rx-i) >= 255) {
bsp_smartcard_read_u8(proto->dev_num,
rx_data+i,
255);
} else {
bsp_smartcard_read_u8(proto->dev_num,
rx_data+i,
to_rx-i);
}
i+=255;
}
cprint(con, "\x01", 1);
cprint(con, (char *)rx_data, to_rx);
break;
case BBIO_SMARTCARD_SET_SPEED:
chnRead(con->sdu, rx_data, 4);
dev_speed = rx_data[0] << 24;
dev_speed += rx_data[1] << 16;
dev_speed += rx_data[2] << 8;
dev_speed += rx_data[3];
proto->config.smartcard.dev_speed = dev_speed;
status = bsp_smartcard_init(proto->dev_num, proto);
if(status != BSP_OK) {
cprint(con, "\x00", 1);
proto->config.smartcard.dev_speed = SMARTCARD_DEFAULT_SPEED;
bsp_smartcard_init(proto->dev_num, proto);
break;
}
final_baudrate = bsp_smartcard_get_final_baudrate(proto->dev_num);
if(final_baudrate < 1) {
cprintf(con, "\x00", 1);
proto->config.smartcard.dev_speed = SMARTCARD_DEFAULT_SPEED;
bsp_smartcard_init(proto->dev_num, proto);
}
else{
cprint(con, "\x01", 1);
}
break;
default:
if ((bbio_subcommand & BBIO_AUX_MASK) == BBIO_AUX_MASK) {
cprintf(con, "%c", bbio_aux(con, bbio_subcommand));
} else if ((bbio_subcommand & BBIO_SMARTCARD_CONFIG) == BBIO_SMARTCARD_CONFIG) {
proto->config.smartcard.dev_polarity =
(bbio_subcommand & 0b1)?1:0;
proto->config.smartcard.dev_stop_bit =
(bbio_subcommand & 0b10)?1:0;
proto->config.smartcard.dev_parity =
(bbio_subcommand & 0b100)?1:0;
status = bsp_smartcard_init(proto->dev_num, proto);
if(status == BSP_OK) {
cprint(con, "\x01", 1);
} else {
cprint(con, "\x00", 1);
}
}
}
}
}
}
static void compute_segments(int win)
{
unsigned long wstart, wend;
int i;
/* Compute the window I am testing memory in */
wstart = windows[win].start;
wend = windows[win].end;
segs = 0;
/* Now reduce my window to the area of memory I want to test */
if (wstart < v->plim_lower) {
wstart = v->plim_lower;
}
if (wend > v->plim_upper) {
wend = v->plim_upper;
}
if (wstart >= wend) {
return;
}
/* List the segments being tested */
for (i=0; i< v->msegs; i++) {
unsigned long start, end;
start = v->pmap[i].start;
end = v->pmap[i].end;
if (start <= wstart) {
start = wstart;
}
if (end >= wend) {
end = wend;
}
#if 0
cprint(LINE_SCROLL+(2*i), 0, " (");
hprint(LINE_SCROLL+(2*i), 2, start);
cprint(LINE_SCROLL+(2*i), 10, ", ");
hprint(LINE_SCROLL+(2*i), 12, end);
cprint(LINE_SCROLL+(2*i), 20, ") ");
cprint(LINE_SCROLL+(2*i), 22, "r(");
hprint(LINE_SCROLL+(2*i), 24, wstart);
cprint(LINE_SCROLL+(2*i), 32, ", ");
hprint(LINE_SCROLL+(2*i), 34, wend);
cprint(LINE_SCROLL+(2*i), 42, ") ");
cprint(LINE_SCROLL+(2*i), 44, "p(");
hprint(LINE_SCROLL+(2*i), 46, v->plim_lower);
cprint(LINE_SCROLL+(2*i), 54, ", ");
hprint(LINE_SCROLL+(2*i), 56, v->plim_upper);
cprint(LINE_SCROLL+(2*i), 64, ") ");
cprint(LINE_SCROLL+(2*i+1), 0, "w(");
hprint(LINE_SCROLL+(2*i+1), 2, windows[win].start);
cprint(LINE_SCROLL+(2*i+1), 10, ", ");
hprint(LINE_SCROLL+(2*i+1), 12, windows[win].end);
cprint(LINE_SCROLL+(2*i+1), 20, ") ");
cprint(LINE_SCROLL+(2*i+1), 22, "m(");
hprint(LINE_SCROLL+(2*i+1), 24, v->pmap[i].start);
cprint(LINE_SCROLL+(2*i+1), 32, ", ");
hprint(LINE_SCROLL+(2*i+1), 34, v->pmap[i].end);
cprint(LINE_SCROLL+(2*i+1), 42, ") ");
cprint(LINE_SCROLL+(2*i+1), 44, "i=");
hprint(LINE_SCROLL+(2*i+1), 46, i);
cprint(LINE_SCROLL+(2*i+2), 0,
" "
" ");
cprint(LINE_SCROLL+(2*i+3), 0,
" "
" ");
#endif
if ((start < end) && (start < wend) && (end > wstart)) {
v->map[segs].pbase_addr = start;
v->map[segs].start = mapping(start);
v->map[segs].end = emapping(end);
#if 0
cprint(LINE_SCROLL+(2*i+1), 54, " segs: ");
hprint(LINE_SCROLL+(2*i+1), 61, segs);
#endif
segs++;
}
}
}
int cmd_gpio(t_hydra_console *con, t_tokenline_parsed *p)
{
uint16_t gpio[3] = { 0 };
int mode, pull, state, port, pin, read, period, continuous, t, max;
bool mode_changed, pull_changed;
char *str, *s;
mode_changed = false;
pull_changed = false;
t = 1;
mode = MODE_CONFIG_DEV_GPIO_IN;
pull = MODE_CONFIG_DEV_GPIO_NOPULL;
state = 0;
period = 100;
read = FALSE;
continuous = FALSE;
while (p->tokens[t]) {
switch (p->tokens[t]) {
case T_MODE:
switch (p->tokens[++t]) {
case T_IN:
mode = MODE_CONFIG_DEV_GPIO_IN;
break;
case T_OUT:
mode = MODE_CONFIG_DEV_GPIO_OUT_PUSHPULL;
break;
case T_OPEN_DRAIN:
mode = MODE_CONFIG_DEV_GPIO_OUT_OPENDRAIN;
break;
}
mode_changed = true;
break;
case T_PULL:
switch (p->tokens[++t]) {
case T_UP:
pull = MODE_CONFIG_DEV_GPIO_PULLUP;
break;
case T_DOWN:
pull = MODE_CONFIG_DEV_GPIO_PULLDOWN;
break;
case T_FLOATING:
pull = MODE_CONFIG_DEV_GPIO_NOPULL;
break;
}
pull_changed = true;
break;
case T_ON:
case T_OFF:
if (state) {
cprintf(con, "Please choose one of 'on' or 'off'.\r\n");
return FALSE;
}
state = p->tokens[t];
break;
case T_READ:
read = TRUE;
break;
case T_PERIOD:
t += 2;
memcpy(&period, p->buf + p->tokens[t], sizeof(int));
break;
case T_CONTINUOUS:
continuous = TRUE;
break;
case T_ARG_STRING:
str = p->buf + p->tokens[++t];
if (strlen(str) < 3) {
cprintf(con, str_pin_error, str);
return FALSE;
}
/* Allow case-insensitive pin names. */
if (str[0] > 0x60)
str[0] -= 0x20;
if (str[1] > 0x60)
str[1] -= 0x20;
if (str[0] != 'P') {
cprintf(con, str_pin_error, str);
return FALSE;
}
if (str[1] < 'A' || str[1] > 'C') {
cprintf(con, str_pin_error, str);
return FALSE;
}
port = str[1] - 'A';
if (str[2] == '*') {
if (port == 1)
/* 0 to 11 for port B */
gpio[port] = 0x0FFF;
else
/* 0 to 15 */
gpio[port] = 0xFFFF;
} else {
pin = strtoul(str + 2, &s, 10);
if ((*s != 0 && *s != '-') || pin < 0 || pin > 15
|| (port == 1 && pin > 11)) {
cprintf(con, str_pin_error, str);
return FALSE;
}
gpio[port] |= 1 << pin;
if (*s == '-') {
/* Range */
max = strtoul(s + 1, &s, 10);
if (max <= pin || max > 15 ||
(port == 1 && max > 11)) {
cprintf(con, str_pin_error, str);
return FALSE;
}
while (pin <= max)
gpio[port] |= 1 << pin++;
}
}
break;
}
t++;
}
if (!gpio[0] && !gpio[1] && !gpio[2]) {
cprintf(con, "Please select at least one GPIO pin.\r\n");
return FALSE;
}
if (!state && !read) {
cprintf(con, "Please select either 'read' or on/off.\r\n");
return FALSE;
}
if((mode_changed == true) || (pull_changed == true)) {
for (port = 0; port < 3; port++) {
for (pin = 0; pin < 16; pin++) {
if (!(gpio[port] & (1 << pin)))
continue;
bsp_gpio_init(ports[port], pin, mode, pull);
}
}
}
if (!state) {
if (continuous)
read_continuous(con, gpio, period);
else
read_once(con, gpio);
} else {
if (state == T_ON)
cprintf(con, "Setting ");
else
cprintf(con, "Clearing ");
for (port = 0; port < 3; port++) {
if (!gpio[port])
continue;
for (pin = 0; pin < 16; pin++) {
if (!(gpio[port] & (1 << pin)))
continue;
if (state == T_ON)
bsp_gpio_set(ports[port], pin);
else
bsp_gpio_clr(ports[port], pin);
cprintf(con, "P%c%d ", port + 'A', pin);
}
}
cprint(con, "\r\n", 2);
}
return TRUE;
}
static int newmt(void)
{
int i = 0, j = 0;
unsigned long chunks;
unsigned long lo, hi;
#if NMOD_FRAMEBUFFER > 0
video_cls();
#endif
if(setjmp(jmpb_mt)&&(returncode==2)){
ioctl (STDIN, TCSETAF, &sav);
firsttime = 0;
v->test = 0;
v->pass = 0;
v->msg_line = 0;
v->ecount = 0;
v->ecc_ecount = 0;
autotest=0;
firsttime=0;
/* Clear the screen */
#if NMOD_FRAMEBUFFER > 0
video_cls();
#endif
return 0;
}
ioctl (STDIN, CBREAK, &sav);
while(1)
{
window=0;
/* If first time, initialize test */
windows[0].start =LOW_TEST_ADR>>12;
windows[0].end= HIGH_TEST_ADR>>12;
if(!firsttime){init();firsttime++;}
bail = 0;
/* Find the memory areas I am going to test */
compute_segments(window);
if (segs == 0) {
goto skip_window;
}
/* Now map in the window... */
if (map_page(v->map[0].pbase_addr) < 0) {
goto skip_window;
}
/* Update display of memory segments being tested */
lo = page_of(v->map[0].start);
hi = page_of(v->map[segs -1].end);
aprint(LINE_RANGE, COL_MID+9, lo-0x80000);
cprint(LINE_RANGE, COL_MID+14, " - ");
aprint(LINE_RANGE, COL_MID+17, hi-0x80000);
aprint(LINE_RANGE, COL_MID+23, v->selected_pages);
cprint(LINE_RANGE, COL_MID+28,
((ulong)&_start == LOW_TEST_ADR)?" ":" Relocated");
/* Now setup the test parameters based on the current test number */
/* Figure out the next test to run */
if (v->testsel >= 0) {
v->test = v->testsel;
}
dprint(LINE_TST, COL_MID+6, v->test, 2, 1);
cprint(LINE_TST, COL_MID+9, tseq[v->test].msg);
set_cache(tseq[v->test].cache);
/* Compute the number of SPINSZ memory segments */
chunks = 0;
for(i = 0; i < segs; i++) {
unsigned long len;
len = v->map[i].end - v->map[i].start;
chunks += (len + SPINSZ -1)/SPINSZ;
}
test_ticks = find_ticks_for_test(chunks, v->test);
nticks = 0;
v->tptr = 0;
cprint(1, COL_MID+8, " ");
switch(tseq[v->test].pat) {
/* Now do the testing according to the selected pattern */
case 0: /* Moving inversions, all ones and zeros */
p1 = 0;
p2 = ~p1;
movinv1(tseq[v->test].iter,p1,p2);
BAILOUT;
/* Switch patterns */
p2 = p1;
p1 = ~p2;
movinv1(tseq[v->test].iter,p1,p2);
BAILOUT;
break;
case 1: /* Moving inversions, 8 bit wide walking ones and zeros. */
p0 = 0x80;
for (i=0; i<8; i++, p0=p0>>1) {
p1 = p0 | (p0<<8) | (p0<<16) | (p0<<24);
p2 = ~p1;
movinv1(tseq[v->test].iter,p1,p2);
BAILOUT;
/* Switch patterns */
p2 = p1;
p1 = ~p2;
movinv1(tseq[v->test].iter,p1,p2);
BAILOUT
}
break;
case 2: /* Moving inversions, 32 bit shifting pattern, very long */
{
u_int32_t pa = 0;
for (i=0, pa=1; pa; pa=pa<<1, i++) {
movinv32(tseq[v->test].iter,pa, 1, 0x80000000, 0, i);
BAILOUT
movinv32(tseq[v->test].iter,~pa, 0xfffffffe,
0x7fffffff, 1, i);
BAILOUT
}
}
break;
case 3: /* Modulo X check, all ones and zeros */
p1=0;
for (i=0; i<MOD_SZ; i++) {
p2 = ~p1;
modtst(i, tseq[v->test].iter, p1, p2);
BAILOUT
/* Switch patterns */
p2 = p1;
p1 = ~p2;
modtst(i, tseq[v->test].iter, p1,p2);
BAILOUT
}
break;
case 4: /* Modulo X check, 8 bit pattern */
p0 = 0x80;
for (j=0; j<8; j++, p0=p0>>1) {
p1 = p0 | (p0<<8) | (p0<<16) | (p0<<24);
for (i=0; i<MOD_SZ; i++) {
p2 = ~p1;
modtst(i, tseq[v->test].iter, p1, p2);
BAILOUT
/* Switch patterns */
p2 = p1;
p1 = ~p2;
modtst(i, tseq[v->test].iter, p1, p2);
BAILOUT
}
}
break;
case 5: /* Address test, walking ones */
addr_tst1();
BAILOUT;
break;
case 6: /* Address test, own address */
addr_tst2();
BAILOUT;
break;
case 7: /* Block move test */
block_move(tseq[v->test].iter);
BAILOUT;
break;
case 8: /* Bit fade test */
if (window == 0 ) {
bit_fade();
}
BAILOUT;
break;
case 9: /* Random Data Sequence */
for (i=0; i < tseq[v->test].iter; i++) {
movinvr();
BAILOUT;
}
break;
case 10: /* Random Data */
for (i=0; i < tseq[v->test].iter; i++) {
p1 = rand();
p2 = ~p1;
movinv1(2,p1,p2);
BAILOUT;
}
break;
}
skip_window:
if (bail) {
goto bail_test;
}
/* Rever to the default mapping and enable the cache */
paging_off();
set_cache(1);
window++;
if (window >= sizeof(windows)/sizeof(windows[0])) {
window = 0;
}
/* We finished the test so clear the pattern */
cprint(LINE_PAT, COL_PAT, " ");
skip_test:
v->test++;
bail_test:
paging_off();
set_cache(1);
check_input();
window = 0;
cprint(LINE_PAT, COL_PAT-3, " ");
/* If this was the last test then we finished a pass */
if (v->test >= DEFTESTS || v->testsel >= 0) {
v->pass++;
dprint(LINE_INFO, COL_PASS, v->pass, 5, 0);
v->test = 0;
v->total_ticks = 0;
v->pptr = 0;
cprint(0, COL_MID+8,
" ");
}
}
return 0;
}
static void conf(struct menu *menu)
{
struct menu *submenu;
const char *prompt = menu_get_prompt(menu);
struct symbol *sym;
char active_entry[40];
int stat, type, i;
unlink("lxdialog.scrltmp");
active_entry[0] = 0;
while (1) {
cprint_init();
cprint("--title");
cprint("%s", prompt ? prompt : _("Main Menu"));
cprint("--menu");
cprint(_(menu_instructions));
cprint("%d", rows);
cprint("%d", cols);
cprint("%d", rows - 10);
cprint("%s", active_entry);
current_menu = menu;
build_conf(menu);
if (!child_count)
break;
if (menu == &rootmenu) {
cprint(":");
cprint("--- ");
cprint("L");
cprint(_(" Load an Alternate Configuration File"));
cprint("S");
cprint(_(" Save Configuration to an Alternate File"));
}
stat = exec_conf();
if (stat < 0)
continue;
if (stat == 1 || stat == 255)
break;
type = input_buf[0];
if (!type)
continue;
for (i = 0; input_buf[i] && !isspace(input_buf[i]); i++)
;
if (i >= sizeof(active_entry))
i = sizeof(active_entry) - 1;
input_buf[i] = 0;
strcpy(active_entry, input_buf);
sym = NULL;
submenu = NULL;
if (sscanf(input_buf + 1, "%p", &submenu) == 1)
sym = submenu->sym;
switch (stat) {
case 0:
switch (type) {
case 'm':
if (single_menu_mode)
submenu->data = (void *) (long) !submenu->data;
else
conf(submenu);
break;
case 't':
if (sym_is_choice(sym) && sym_get_tristate_value(sym) == yes)
conf_choice(submenu);
else if (submenu->prompt->type == P_MENU)
conf(submenu);
break;
case 's':
conf_string(submenu);
break;
case 'L':
conf_load();
break;
case 'S':
conf_save();
break;
}
break;
case 2:
if (sym)
show_help(submenu);
else
show_helptext("README", _(mconf_readme));
break;
case 3:
if (type == 't') {
if (sym_set_tristate_value(sym, yes))
break;
if (sym_set_tristate_value(sym, mod))
show_textbox(NULL, setmod_text, 6, 74);
}
break;
case 4:
if (type == 't')
sym_set_tristate_value(sym, no);
break;
case 5:
if (type == 't')
sym_set_tristate_value(sym, mod);
break;
case 6:
if (type == 't')
sym_toggle_tristate_value(sym);
else if (type == 'm')
conf(submenu);
break;
case 7:
search_conf();
break;
}
}
}
void
cmd_rename(void)
{
uint32_t perm;
Dentry d;
char stat[DIRREC];
char oelem[NAMELEN], noelem[NAMELEN], nxelem[NAMELEN];
int err;
if(con_clone(FID1, FID2))
return;
if(skipbl(1))
return;
oelem[0] = 0;
while(nextelem()) {
if(oelem[0])
if(con_walk(FID2, oelem)){
cprint("file does not exits");
return;
}
memmove(oelem, elem, NAMELEN);
}
if(skipbl(1))
return;
if(cons.arg[0]=='/'){
if(con_clone(FID1, FID3))
return;
noelem[0] = 0;
while(nextelem()){
if(noelem[0])
if(con_walk(FID3, noelem)){
cprint("target path %s does not exist", noelem);
return;
}
memmove(noelem, elem, NAMELEN);
}
if(!con_walk(FID3, elem)){
cprint("target %s already exists\n", elem);
return;
}
if(con_walk(FID2, oelem)){
cprint("src %s does not exist\n", oelem);
return;
}
/*
* we know the target does not exist,
* the source does exist.
* to do the rename, create the target and then
* copy the directory entry directly. then remove the source.
*/
if(err = con_stat(FID2, stat)){
cprint("can't stat file: %s\n", errstring[err]);
return;
}
convM2D9p1(stat, &d);
perm = (d.mode&0777)|((d.mode&0x7000)<<17);
if(err = con_create(FID3, elem, d.uid, d.gid, perm, (d.mode&DDIR)?OREAD:ORDWR)){
cprint("can't create %s: %s\n", elem, errstring[err]);
return;
}
if(err = con_swap(FID2, FID3)){
cprint("can't swap data: %s\n", errstring[err]);
return;
}
if(err = con_remove(FID2)){
cprint("can't remove file: %s\n", errstring[err]);
return;
}
}else{
cname(nxelem);
if(strchr(nxelem, '/')){
cprint("bad rename target: not full path, but contains slashes\n");
return;
}
if(!con_walk(FID2, nxelem))
cprint("file %s already exists\n", nxelem);
else if(con_walk(FID2, oelem))
cprint("file does not already exist\n");
else if(err = con_stat(FID2, stat))
cprint("can't stat file: %s\n", errstring[err]);
else{
convM2D9p1(stat, &d);
strncpy(d.name, nxelem, NAMELEN);
convD2M9p1(&d, stat);
if(err = con_wstat(FID2, stat))
cprint("can't move file: %s\n", errstring[err]);
}
}
}
void
print_1650(const void *xmd, size_t len)
{
const struct ifmib_iso_8802_3 *md = xmd;
if (len != sizeof *md)
warnx("cannot interpret %lu bytes of MIB data", (u_long)len);
identify_chipset(md->dot3StatsEtherChipSet);
print("Alignment errors", md->dot3StatsAlignmentErrors);
print("FCS errors", md->dot3StatsFCSErrors);
print("Single-collision frames", md->dot3StatsSingleCollisionFrames);
print("Multiple-collision frames", md->dot3StatsMultipleCollisionFrames);
print("SQE (Heartbeat) test errors", md->dot3StatsSQETestErrors);
print("Deferred transmissions", md->dot3StatsDeferredTransmissions);
print("Late collisions", md->dot3StatsLateCollisions);
print("Excessive collisions", md->dot3StatsExcessiveCollisions);
print("Internal transmit errors", md->dot3StatsInternalMacTransmitErrors);
print("Carrier sense errors", md->dot3StatsCarrierSenseErrors);
print("Frame-too-long errors", md->dot3StatsFrameTooLongs);
print("Internal receive errors", md->dot3StatsInternalMacReceiveErrors);
print("Missed frames", md->dot3StatsMissedFrames);
#define cprint(num) print("Packets with " #num " collisions", \
md->dot3StatsCollFrequencies[num - 1])
if (md->dot3Compliance >= DOT3COMPLIANCE_COLLS) {
cprint(1); cprint(2); cprint(3); cprint(4);
cprint(5); cprint(6); cprint(7); cprint(8);
cprint(9); cprint(10); cprint(11); cprint(12);
cprint(13); cprint(14); cprint(15); cprint(16);
}
switch(md->dot3Compliance) {
case DOT3COMPLIANCE_STATS:
printf("\tCompliance: statistics only\n");
break;
case DOT3COMPLIANCE_COLLS:
printf("\tCompliance: statistics and collisions\n");
break;
}
}
int
adduser(char *user, int isgroup)
{
char stat[DIRREC];
char msg[100];
Uid *u;
int i, c, nu;
/*
* check uniq of name
* and get next uid
*/
cmd_exec("cfs");
cmd_exec("user");
if(isgroup)
nu = 9000;
else
nu = 0;
for(i=0, u=uid; i<conf.nuid; i++,u++) {
c = u->uid;
if(c == 0)
break;
if(strcmp(uidspace+u->offset, user) == 0)
return 1;
if(c >= 9000 && !isgroup)
continue;
if(c > nu)
nu = c;
}
nu++;
if(isgroup){
if(nu >= 0x10000) {
cprint("out of group ids\n");
return 0;
}
} else {
if(nu >= 9000) {
cprint("out of user ids\n");
return 0;
}
}
/*
* write onto adm/users
*/
if(con_clone(FID1, FID2)
|| con_path(FID2, "/adm/users")
|| con_open(FID2, 1)) {
cprint("can't open /adm/users\n");
return 0;
}
sprint(msg, "%d:%s:%s:\n", nu, user, user);
cprint("add user %s", msg);
c = strlen(msg);
i = con_stat(FID2, stat);
if(i){
cprint("can't stat /adm/users: %s\n", errstring[i]);
return 0;
}
i = con_write(FID2, msg, statlen(stat), c);
if(i != c){
cprint("short write on /adm/users: %d %d\n", c, i);
return 0;
}
return 1;
}
void printmenu(pt_menu menu, int curr, char top, char left)
{
int x,row; // x = index, row = position from top
int numitems,menuwidth;
char fchar[5],lchar[5]; // The first and last char in for each entry
const char *str; // and inbetween the item or a seperator is printed
char *attr; // attribute attr
char sep[MENULEN];// and inbetween the item or a seperator is printed
pt_menuitem ci;
calc_visible(menu);
numitems = menu->numvisible;
menuwidth = menu->menuwidth+3;
clearwindow(top,left-2, top+numitems+1, left+menuwidth+1,
ms->menupage, ms->fillchar, ms->shadowattr);
drawbox(top-1, left-3, top+numitems, left+menuwidth,
ms->normalattr[NOHLITE], ms->menupage);
memset(sep,HORIZ,menuwidth); // String containing the seperator string
sep[menuwidth-1] = 0;
// Menu title
x = (menuwidth - strlen(menu->title) - 1) >> 1;
gotoxy(top-1,left+x,ms->menupage);
printmenuitem(menu->title,ms->normalattr);
row = -1; // 1 less than inital value of x
for (x=0; x < menu->numitems; x++)
{
ci = menu->items[x];
if (ci->action == OPT_INVISIBLE) continue;
row++;
// Setup the defaults now
lchar[0] = fchar[0] = ' ';
lchar[1] = fchar[1] = '\0'; // fchar and lchar are just spaces
str = ci->item; // Pointer to item string
attr = (x==curr ? ms->reverseattr : ms->normalattr); // Normal attributes
switch (ci->action) // set up attr,str,fchar,lchar for everything
{
case OPT_INACTIVE:
attr = (x==curr? ms->revinactattr : ms->inactattr);
break;
case OPT_SUBMENU:
lchar[0] = SUBMENUCHAR; lchar[1] = 0;
break;
case OPT_RADIOMENU:
lchar[0] = RADIOMENUCHAR; lchar[1] = 0;
break;
case OPT_CHECKBOX:
lchar[0] = (ci->itemdata.checked ? CHECKED : UNCHECKED);
lchar[1] = 0;
break;
case OPT_SEP:
fchar[0] = '\b'; fchar[1] = LTRT; fchar[2] = HORIZ; fchar[3] = HORIZ; fchar[4] = 0;
lchar[0] = HORIZ; lchar[1] = RTLT; lchar[2] = 0;
str = sep;
break;
case OPT_EXITMENU:
fchar[0] = EXITMENUCHAR; fchar[1] = 0;
break;
default: // Just to keep the compiler happy
break;
}
gotoxy(top+row,left-2,ms->menupage);
cprint(ms->spacechar,attr[NOHLITE],menuwidth+2,ms->menupage); // Wipe area with spaces
gotoxy(top+row,left-2,ms->menupage);
csprint(fchar,attr[NOHLITE]); // Print first part
gotoxy(top+row,left,ms->menupage);
printmenuitem(str,attr); // Print main part
gotoxy(top+row,left+menuwidth-1,ms->menupage); // Last char if any
csprint(lchar,attr[NOHLITE]); // Print last part
}
if (ms->handler) ms->handler(ms,menu->items[curr]);
}
void
cmd_newuser(void)
{
char user[NAMELEN], param[NAMELEN], msg[100];
int i, c;
/*
* get uid
*/
cname(user);
cname(param);
for(i=0; i<NAMELEN; i++) {
c = user[i];
if(c == 0)
break;
if(c >= '0' && c <= '9'
|| c >= 'a' && c <= 'z'
|| c >= 'A' && c <= 'Z')
continue;
cprint("bad character in name: 0x%x\n", c);
return;
}
if(i < 2) {
cprint("name too short: %s\n", user);
return;
}
if(i >= NAMELEN) {
cprint("name too long: %s\n", user);
return;
}
switch(param[0]){
case 0:
if(!adduser(user, 0))
return;
cmd_exec("user");
break;
case ':':
adduser(user, 1);
cmd_exec("user");
return;
case '#':
adduser(user, 0);
cmd_exec("user");
return;
}
/*
* create directories
*/
cmd_exec("user");
sprint(msg, "create /usr/%s %s %s 775 d", user, user, user);
cmd_exec(msg);
sprint(msg, "create /usr/%s/tmp %s %s 775 d", user, user, user);
cmd_exec(msg);
sprint(msg, "create /usr/%s/lib %s %s 775 d", user, user, user);
cmd_exec(msg);
sprint(msg, "create /usr/%s/bin %s %s 775 d", user, user, user);
cmd_exec(msg);
sprint(msg, "create /usr/%s/bin/rc %s %s 775 d", user, user, user);
cmd_exec(msg);
sprint(msg, "create /usr/%s/bin/mips %s %s 775 d", user, user, user);
cmd_exec(msg);
sprint(msg, "create /usr/%s/bin/386 %s %s 775 d", user, user, user);
cmd_exec(msg);
sprint(msg, "create /usr/%s/bin/power %s %s 775 d", user, user, user);
cmd_exec(msg);
sprint(msg, "create /usr/%s/bin/alpha %s %s 775 d", user, user, user);
cmd_exec(msg);
}
static void build_conf(struct menu *menu)
{
struct symbol *sym;
struct property *prop;
struct menu *child;
int type, tmp, doint = 2;
tristate val;
char ch;
if (!menu_is_visible(menu))
return;
sym = menu->sym;
prop = menu->prompt;
if (!sym) {
if (prop && menu != current_menu) {
const char *prompt = menu_get_prompt(menu);
switch (prop->type) {
case P_MENU:
child_count++;
cprint("m%p", menu);
if (single_menu_mode) {
cprint1("%s%*c%s",
menu->data ? "-->" : "++>",
indent + 1, ' ', prompt);
} else
cprint1(" %*c%s --->", indent + 1, ' ', prompt);
cprint_done();
if (single_menu_mode && menu->data)
goto conf_childs;
return;
default:
if (prompt) {
child_count++;
cprint(":%p", menu);
cprint("---%*c%s", indent + 1, ' ', prompt);
}
}
} else
doint = 0;
goto conf_childs;
}
type = sym_get_type(sym);
if (sym_is_choice(sym)) {
struct symbol *def_sym = sym_get_choice_value(sym);
struct menu *def_menu = NULL;
child_count++;
for (child = menu->list; child; child = child->next) {
if (menu_is_visible(child) && child->sym == def_sym)
def_menu = child;
}
val = sym_get_tristate_value(sym);
if (sym_is_changable(sym)) {
cprint("t%p", menu);
switch (type) {
case S_BOOLEAN:
cprint1("[%c]", val == no ? ' ' : '*');
break;
case S_TRISTATE:
switch (val) {
case yes: ch = '*'; break;
case mod: ch = 'M'; break;
default: ch = ' '; break;
}
cprint1("<%c>", ch);
break;
}
} else {
cprint("%c%p", def_menu ? 't' : ':', menu);
cprint1(" ");
}
cprint1("%*c%s", indent + 1, ' ', menu_get_prompt(menu));
if (val == yes) {
if (def_menu) {
cprint1(" (%s)", menu_get_prompt(def_menu));
cprint1(" --->");
cprint_done();
if (def_menu->list) {
indent += 2;
build_conf(def_menu);
indent -= 2;
}
} else
cprint_done();
return;
}
cprint_done();
} else {
if (menu == current_menu) {
cprint(":%p", menu);
cprint("---%*c%s", indent + 1, ' ', menu_get_prompt(menu));
goto conf_childs;
}
child_count++;
val = sym_get_tristate_value(sym);
if (sym_is_choice_value(sym) && val == yes) {
cprint(":%p", menu);
cprint1(" ");
} else {
switch (type) {
case S_BOOLEAN:
cprint("t%p", menu);
if (sym_is_changable(sym))
cprint1("[%c]", val == no ? ' ' : '*');
else
cprint1("---");
break;
case S_TRISTATE:
cprint("t%p", menu);
switch (val) {
case yes: ch = '*'; break;
case mod: ch = 'M'; break;
default: ch = ' '; break;
}
if (sym_is_changable(sym))
cprint1("<%c>", ch);
else
cprint1("---");
break;
default:
cprint("s%p", menu);
tmp = cprint1("(%s)", sym_get_string_value(sym));
tmp = indent - tmp + 4;
if (tmp < 0)
tmp = 0;
cprint1("%*c%s%s", tmp, ' ', menu_get_prompt(menu),
(sym_has_value(sym) || !sym_is_changable(sym)) ?
"" : " (NEW)");
cprint_done();
goto conf_childs;
}
}
cprint1("%*c%s%s", indent + 1, ' ', menu_get_prompt(menu),
(sym_has_value(sym) || !sym_is_changable(sym)) ?
"" : " (NEW)");
if (menu->prompt->type == P_MENU) {
cprint1(" --->");
cprint_done();
return;
}
cprint_done();
}
conf_childs:
indent += doint;
for (child = menu->list; child; child = child->next)
build_conf(child);
indent -= doint;
}
// Reads a line of input from stdin. Replace CR with NUL byte
// password <> 0 implies not echoed on screen
// showoldvalue <> 0 implies currentvalue displayed first
// If showoldvalue <> 0 then caller responsibility to ensure that
// str is NULL terminated.
void getuserinput(char *stra, unsigned int size, unsigned int password,
unsigned int showoldvalue)
{
unsigned char c, scan;
char *p, *q; // p = current char of string, q = tmp
char *last; // The current last char of string
char *str; // pointer to string which is going to be allocated
char page;
char row, col;
char start, end; // Cursor shape
char fudge; // How many chars should be removed from output
char insmode; // Are we in insert or overwrite
page = getdisppage();
getpos(&row, &col, page); // Get current position
getcursorshape(&start, &end);
insmode = 1;
str = (char *)malloc(size + 1); // Allocate memory to store user input
memset(str, 0, size + 1); // Zero it out
if (password != 0)
showoldvalue = 0; // Password's never displayed
if (showoldvalue != 0)
strcpy(str, stra); // If show old value copy current value
last = str;
while (*last) {
last++;
} // Find the terminating null byte
p = str + strlen(str);
if (insmode == 0)
setcursorshape(1, 7); // Block cursor
else
setcursorshape(6, 7); // Normal cursor
// Invariants: p is the current char
// col is the corresponding column on the screen
if (password == 0) // Not a password, print initial value
{
gotoxy(row, col, page);
csprint(str, GETSTRATTR);
}
while (1) { // Do forever
c = inputc(&scan);
if (c == '\r')
break; // User hit Enter getout of loop
if (scan == ESCAPE) // User hit escape getout and nullify string
{
*str = 0;
break;
}
fudge = 0;
// if scan code is regognized do something
// else if char code is recognized do something
// else ignore
switch (scan) {
case HOMEKEY:
p = str;
break;
case ENDKEY:
p = last;
break;
case LTARROW:
if (p > str)
p--;
break;
case CTRLLT:
if (p == str)
break;
if (*p == ' ')
while ((p > str) && (*p == ' '))
p--;
else {
if (*(p - 1) == ' ') {
p--;
while ((p > str) && (*p == ' '))
p--;
}
}
while ((p > str) && ((*p == ' ') || (*(p - 1) != ' ')))
p--;
break;
case RTARROW:
if (p < last)
p++;
break;
case CTRLRT:
if (*p == 0)
break; // At end of string
if (*p != ' ')
while ((*p != 0) && (*p != ' '))
p++;
while ((*p != 0) && ((*p == ' ') && (*(p + 1) != ' ')))
p++;
if (*p == ' ')
p++;
break;
case DELETE:
q = p;
while (*(q + 1)) {
*q = *(q + 1);
q++;
}
if (last > str)
last--;
fudge = 1;
break;
case INSERT:
insmode = 1 - insmode; // Switch mode
if (insmode == 0)
setcursorshape(1, 7); // Block cursor
else
setcursorshape(6, 7); // Normal cursor
break;
default: // Unrecognized scan code, look at the ascii value
switch (c) {
case '\b': // Move over by one
q = p;
while (q <= last) {
*(q - 1) = *q;
q++;
}
if (last > str)
last--;
if (p > str)
p--;
fudge = 1;
break;
case '\x15': /* Ctrl-U: kill input */
fudge = last - str;
while (p > str)
*p-- = 0;
p = str;
*p = 0;
last = str;
break;
default: // Handle insert and overwrite mode
if ((c >= ' ') && (c < 128) &&
((unsigned int)(p - str) < size - 1)) {
if (insmode == 0) { // Overwrite mode
if (p == last)
last++;
*last = 0;
*p++ = c;
} else { // Insert mode
if (p == last) { // last char
last++;
*last = 0;
*p++ = c;
} else { // Non-last char
q = last++;
while (q >= p) {
*q = *(q - 1);
q--;
}
*p++ = c;
}
}
} else
beep();
}
break;
}
// Now the string has been modified, print it
if (password == 0) {
gotoxy(row, col, page);
csprint(str, GETSTRATTR);
if (fudge > 0)
cprint(' ', GETSTRATTR, fudge, page);
gotoxy(row, col + (p - str), page);
}
}
*p = '\0';
if (password == 0)
csprint("\r\n", GETSTRATTR);
setcursorshape(start, end); // Block cursor
// If user hit ESCAPE so return without any changes
if (scan != ESCAPE)
strcpy(stra, str);
free(str);
}
