packages/web/353/test/test_inner_10369.php

Go to the documentation of this file.

#!/usr/local/sbin/php -q
<?php

#
# TODO: work with RAW storage
#
#
#

require 'i2c.inc';

$stage_fn = "/etc/test/board_10369.stage";
$res_fn = "/etc/test/board_10369.res";
$launch_fn = "/etc/launch.conf";
$self_fn="test_inner_10369.php";
//$stage = "0";

// stage:
// 0 - basic check: board presence; temperature sensor; prepare for drivers tests - identification CF0/CF1 and reboot;

//------------------------------------------------------------------------------
// general flow functions

$stage_xml = new SimpleXMLElement("<?xml version='1.0' standalone='yes'?><board_10369_stage/>");
$stage_xml->stage = "finish";

function stage_load() {
        global $stage_xml;
        global $stage_fn;

        if(is_file($stage_fn))
                $stage_xml = simplexml_load_file($stage_fn);
}

function stage_save() {
        global $stage_xml;
        global $stage_fn;

        $file = fopen($stage_fn, "w+");
        if($file) {
                $rslt = $stage_xml->asXML();
                fwrite($file, $rslt);
                fclose($file);
        }
}

function pr($text) {
        echo "<pre>$text</pre>\n";
        flush();
}

function _reboot() {
        exec("sync; reboot");
}

# offline result - stored in a file
function res_update($name, $result, $description) {
        global $res_fn;

        $file = fopen($res_fn, "a+");
        if($result != "")
                fwrite($file, "<${name} result=\"${result}\">".$description."</${name}>\n");
        else
                fwrite($file, "<${name}>".$description."</${name}>\n");
        fclose($file);

        pr("<${name} result=\"${result}\">".$description."</${name}>");
}

function _finish() {
        global $stage_xml;
        global $launch_fn;

        res_update("finish", "OK", "");
        $stage_xml->stage = "finish";
        stage_save();
        if(is_file($launch_fn))
                unlink($launch_fn);
        exit(0);
}

//------------------------------------------------------------------------------
// check the stage
$flag = FALSE;
stage_load();

$file = fopen($launch_fn, 'w+');
if($file) {
        $pwd = exec("pwd");
        fwrite($file, $pwd."/".$self_fn."\n");;
        fclose($file);
}

if($stage_xml->stage == "finish") {
        $stage_xml->stage = "0";
}

if($stage_xml->stage == "0") {
        $flag = TRUE;
        if(is_file($res_fn))
                unlink($res_fn);
        if(test_board_presence() == FALSE)
                _finish();
        $stage_xml->stage = "1";
}

if($stage_xml->stage == "1") {
        // check USB storage presence and prepare CF1 & SATA to test
        // if so - write test file and reboot (stage 2)
        // else - go to "stage 3" for next storage check
        $flag = TRUE;
        test_enable_CF1_SATA();
        if(test_storage("sda", "USB") == TRUE) {
                $stage_xml->stage = "2";
                stage_save();
                _reboot();
        } else {
                $stage_xml->stage = "3";
                stage_save();
                _reboot();
        }
}

if($stage_xml->stage == "2") {
        $flag = TRUE;
        $stage_xml->stage = "3";
        test_storage_md5("sda", "USB");
}

if($stage_xml->stage == "3") {
        // CF1 Slave, SATA Master branch - check hda &&
        $flag = TRUE;
        $CHECK = FALSE;
        if(test_storage("hda", "SATA") === TRUE) {
                $stage_xml->sata = "ok";
                $CHECK = TRUE;
        }
        if(test_storage("hdb", "CF1") === TRUE) {
                $stage_xml->cf1 = "ok";
                $CHECK = TRUE;
        }
        if($CHECK) {
                $stage_xml->stage = "4";
                stage_save();
                _reboot();
        } else {
                test_enable_CF0();
                $stage_xml->stage = "5";
                stage_save();
                _reboot();
        }
}

if($stage_xml->stage == "4") {
        $flag = TRUE;
        if($stage_xml->sata == "ok")
                test_storage_md5("hda", "SATA");
        if($stage_xml->cf1 == "ok")
                test_storage_md5("hdb", "CF1");
//      test_enable_CF1_SATA();
        test_enable_CF0();
        $stage_xml->stage = "5";
        stage_save();
        _reboot();
}

if($stage_xml->stage == "5") {
        // set CF0 as Master and SATA as Slave, reboot and check it
        $flag = TRUE;
        $CHECK = test_storage("hda", "CF0");
        if($CHECK) {
                $stage_xml->stage = "6";
                stage_save();
                _reboot();
        } else {
                $stage_xml->stage = "7";
        }
//      _finish();
}

if($stage_xml->stage == "6") {
        $flag = TRUE;
        $stage_xml->stage = "7";
        test_storage_md5("hda", "CF0");
}

if($stage_xml->stage == "7") {
        $flag = TRUE;
        _finish();
}

if(!$flag) {
        res_update("10369", "FAIL", "wrong test sequence");
        _finish();
}

//------------------------------------------------------------------------------
// tests
function test_board_presence() {
        global $stage_fn;
        // check the board ID
        $_xml = file_get_contents("http://127.0.0.1/i2c.php?cmd=fromEEPROM");
        $xml = simplexml_load_string($_xml);
        // do it in a last time - it's must be merged to two parts...
        if($xml->getName() === "board") {
                // board is found, and ID is written
                res_update("board", "OK", "board present and ID is written");
                res_update("brand", "", $xml->brand);
                res_update("model", "", $xml->model);
                res_update("rev", "", $xml->rev);
                res_update("serial", "", $xml->serial);
                res_update("time", "", $xml->time);
        } else {
                if($xml->getName() === "i2c") {
                        if($xml->error) {
                                // board not found
                                res_update("board", "FAIL", "can't found board");
                                return FALSE;
                        } else {
                                // board is found, and ID is not written
                                res_update("board", "OK", "board present, but ID is not written");
                        }
                }
        }
        // read temperature sensor
        $temp = 0.0;
        $_xml = file_get_contents("http://127.0.0.1/i2c.php?width=8&bus=1&adr=0x4800");
        $xml = simplexml_load_string($_xml);
        if($xml->rdata)
                $temp = (float)$xml->rdata;
        $_xml = file_get_contents("http://127.0.0.1/i2c.php?width=8&bus=1&adr=0x4822");
        $xml = simplexml_load_string($_xml);
        if($xml->rdata)
                $temp += ((float)$xml->rdata) / 256.0;
        $temp=sprintf("%.2f", $temp);
        res_update("temperature", "OK", $temp);
        return TRUE;
}

//------------------------------------------------------------------------------
// storage specific

class storage {}

function st_presence($disk) {
        $res = FALSE;
        $r = exec("dd if=/dev/${disk} of=/dev/null bs=16 count=1 2>&1 | grep 'No such device'");
//      res_update("st_presence", "$disk", "${r}");
        if($r == "")
//      if(exec("dd if=/dev/${disk} of=/dev/null bs=16 count=1 2>&1 | grep 'No such device'") == "")
                $res = TRUE;
        return $res;
}

function st_partition($dev, $part) {
        $res = FALSE;
        $str = exec("fdisk -l /dev/${dev} | grep ${part}");
        if($str != "")
                $res = TRUE;
        return $res;
}

function st_mount($dev, $point) {
        if(!is_dir($point))
                exec("mkdir $point");
        $n = 1;
        for($n = 1; $n < 5; $n++) {
                exec("mount ${dev}1 $point");
//              $r = exec("df | grep '${dev}${n} '");
                $r = exec("df | grep '${dev}${n}'");
                if($r != "")
                        break;
        }
//      $r = exec("df | grep '${dev}${n} '");
        $r = exec("df | grep '${dev}${n}'");
        if($r != "")
                return TRUE;
        return FALSE;
}

function st_umount($point) {
        exec("umount $point");
}

// check the storage device
function what_is_storage($disk) {
//      object $usb;
        $st = new storage;
        $st->presence = FALSE;
        $st->device = "$disk";
        $st->raw = TRUE;
        if(!st_presence("$disk")) {
                return $st;
        } else {
                $st->presence = TRUE;
                $parts = st_partition("$disk", "${disk}1") || st_partition("$disk", "${disk}2") || st_partition("$disk", "${disk}3") || st_partition("$disk", "${disk}4");
                if($parts)
                        $st->raw = FALSE;
        }
        return $st;
}

# use `nanddump` instead of `cat /dev/mtdblock3` for correct BB skipping

function test_storage($disk, $name) {
        $st = what_is_storage("$disk");
        if($st->presence == FALSE) {
                res_update("${name}", "UNKNOWN", "${name} storage device /dev/${disk} not found");
                return FALSE;
        } else {
                if($st->raw == FALSE) {
                        $m = st_mount("/dev/${disk}", "/tmp/z");
                        if($m == TRUE) {
                                $MAC=exec("bootblocktool -x SERNO");
#                               exec("cat /dev/mtdblock3 > /tmp/z/test_353.${MAC}");
                                exec("nanddump -b /dev/mtd3 -f /tmp/z/test_353.${MAC}");
                                st_umount("/tmp/z");
                        } else {
                                res_update("${name}", "FAIL", "${name} storage with partitions, can't mount any partition");
                                return FALSE;
                        }
                } else {
                        res_update("${name}", "UNKNOWN", "${name} storage w/o partitions");
                        return FALSE;
                }
        }
//      res_update("${name}", "OK", "all looks ok");
        return TRUE;
}

function test_storage_md5($disk, $name) {
        $st = what_is_storage("${disk}");
        if($st->presence == FALSE) {
                res_update("${name}", "FAIL", "${name} storage device /dev/${disk} is not the same");
                return;
        } else {
                if($st->raw == FALSE) {
                        $m = st_mount("/dev/${disk}", "/tmp/z");
                        if($m == TRUE) {
                                $MAC=exec("bootblocktool -x SERNO");
#                               $md5_1 = exec("cat /dev/mtdblock3 | md5sum");
                                $md5_1 = exec("nanddump -b /dev/mtd3 2>/dev/null | md5sum");
                                $md5_2 = exec("cat /tmp/z/test_353.${MAC} | md5sum");
                                unlink("/tmp/z/test_353.${MAC}");
                                st_umount("/tmp/z");
                                if($md5_1 === $md5_2) {
                                        res_update("${name}", "OK", "MD5SUM is correct");
                                        return;
                                }
                        }
                        res_update("${name}", "FAIL", "MD5SUM is different");
                } else {
                        res_update("${name}", "FAIL", "{name} storage is not the same");
                }
        }
        res_update("${name}", "OK", "all is ok");
}

function test_enable_CF1_SATA() {
        // hda - SATA; hdb - CF1
        $reg = 0x7B; // 01111011 - disable CF0, CF1 Slave, SATA Master
        $reg_new = sprintf("0x%02X", $reg);
//echo "new REG == ".$reg_new."\n";
        $_xml = file_get_contents("http://127.0.0.1/i2c.php?bus=1&raw=0x2000");
        $xml = simplexml_load_string($_xml);
$file = fopen("php://stderr", "w");
fprintf($file, "\nbefore: %s\n", (string)$xml->hex_data);
fprintf($file, "enable CF1, SATA (0x7B)\n");
        $r1 = file_get_contents("http://127.0.0.1/i2c.php?bus=1&raw=0x2000&data=${reg_new}");
        $_xml = file_get_contents("http://127.0.0.1/i2c.php?bus=1&raw=0x2000");
        $xml = simplexml_load_string($_xml);
        $r2 = file_get_contents("http://127.0.0.1/i2c.php?bus=1&raw=0x2000&data=${reg_new}");
fprintf($file, "after : %s\n\n", (string)$xml->hex_data);
fclose($file);
}

function test_enable_CF0() {
        // hda - CF0; hdb - SATA
        $reg = 0x57; // 01010111 - enable CF0 Master, disable CF1, SATA Slave
        $reg_new = sprintf("0x%02X", $reg);
//echo "new REG == ".$reg_new."\n";
        $_xml = file_get_contents("http://127.0.0.1/i2c.php?bus=1&raw=0x2000");
        $xml = simplexml_load_string($_xml);
$file = fopen("php://stderr", "w");
fprintf($file, "\nbefore: %s\n", (string)$xml->hex_data);
fprintf($file, "enable CF0 (0x57)\n");
        $r1 = file_get_contents("http://127.0.0.1/i2c.php?bus=1&raw=0x2000&data=${reg_new}");
        $_xml = file_get_contents("http://127.0.0.1/i2c.php?bus=1&raw=0x2000");
        $xml = simplexml_load_string($_xml);
        $r2 = file_get_contents("http://127.0.0.1/i2c.php?bus=1&raw=0x2000&data=${reg_new}");
fprintf($file, "after : %s\n\n", (string)$xml->hex_data);
fclose($file);
}

/*
/*
function stage_2() {
        $_xml = file_get_contents("http://127.0.0.1/i2c.php?bus=1&raw=0x2000");
        $xml = simplexml_load_string($_xml);

        $SATA="";
        $CF0="";
        $CF1="";

        // try to mount /dev/hda & /dev/hdb
        $dev_hda_is=0;
        $dev_hdb_is=0;
        if(exec("dd if=/dev/hda of=/dev/null bs=16 count=1 2>&1 | grep 'No such device'") == "")
                $dev_hda_is=1;
        if(exec("dd if=/dev/hdb of=/dev/null bs=16 count=1 2>&1 | grep 'No such device'") == "")
                $dev_hdb_is=1;

        // check the CF0 and CF1 bits; if the CF0 is present:
        //      1. set: CF1 dis., ATA slave, CF0 en.  - reboot; test CF0 as master and ATA as slave;
        //      2. set: CF0 dis., ATA master, CF1 en. - reboot; test CF1 as slave and ATA as master;

        if($xml->rdata) {
                pr("rdata == ".$xml->rdata);
                $reg = (int)$xml->rdata;
                // check the SATA & CF devices
                // SATA is disabled ?
                $reg & 0x10;
                if($reg & 0x10) {
                        // is master?
                        if($reg & 0x20)
                                $SATA="a";
                        else
                                $SATA="b";
                }
        }
}
*/

/*
// check what we have - the drives must be umounted; or check 'df -h' output for this
if(!is_dir("/tmp/z"))
        mkdir("/tmp/z");

$rez = exec("mount /dev/hda1 /tmp/z; df -h | grep /dev/hda");
if($rez != "") {
        $mac=exec("bootblocktool -x SERNO");
        exec("cat /dev/mtdblock3 > /tmp/z/test_10369.".$mac);
        // check MD5SUM here !!!
        exec("umount /tmp/z");
} else {
        // can be just w/o partitions - check it !!!
        pr("ATA drive /dev/hda not found");
}

$rez = exec("mount /dev/hdb1 /tmp/z; df -h | grep /dev/hdb");
if($rez != "") {
        $mac=exec("bootblocktool -x SERNO");
        exec("cat /dev/mtdblock3 > /tmp/z/test_10369.".$mac);
        // check MD5SUM here !!!
        exec("umount /tmp/z");
} else {
        // can be just w/o partitions - check it !!!
        pr("ATA drive /dev/hdb not found");
}
*/

// 

/*
pr($xml->result);
pr($xml->brand);
pr($xml->model);
pr($xml->rev);
pr($xml->serial);
pr($xml->time);
*/

?>

---