home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / boot / i386 / root / usr / share / YaST2 / modules / InitHWinfo.ycp < prev    next >
Encoding:
Text File  |  2006-11-29  |  8.1 KB  |  346 lines
  1. /**
  2.  *
  3.  * Module:    Initial HW info module
  4.  *
  5.  * Author:    Ladislav Slezak <lslezak@suse.cz>
  6.  *
  7.  * $Id: InitHWinfo.ycp 33530 2006-10-20 11:08:26Z lslezak $
  8.  *
  9.  * Collect and store hardware information.
  10.  */
  11.  
  12. {
  13.  
  14. module "InitHWinfo";
  15.  
  16. import "String";
  17. import "Confirm";
  18. import "Progress";
  19. import "Arch";
  20. import "SystemSettings";
  21.  
  22. include "hwinfo/routines.ycp";
  23.  
  24. textdomain "tune";
  25.  
  26. boolean initialized = false;
  27.  
  28. // CPU summary string
  29. string cpu_string = "";
  30. // memory size
  31. integer memory_size = 0;
  32. // system summary string
  33. string system_string= "";
  34.  
  35. // list of detected devices
  36. list<map> detectedHW = nil;
  37.  
  38. // default is "/dev/fd0" floppy device (used when floppy detection is skipped as a fallback)
  39. global map<string,string> floppy = $["/dev/fd0" : _("Floppy disk")];
  40.  
  41. /**
  42.  * Start hardware detection (only CPU and main memory)
  43.  * @param force If true then start detection again (discard cached values)
  44.  * @return boolean True on success
  45.  */
  46. global define boolean Initialize(boolean force) ``{
  47.     if (initialized == true && force == false)
  48.     {
  49.     return true;
  50.     }
  51.  
  52.     // initialize procesor string
  53.     list<map> cpu_result = (list<map>) SCR::Read(.probe.cpu);
  54.     map<string,integer> cpus = $[];
  55.  
  56.     foreach(map info, cpu_result, ``{
  57.         string str = info["name"]:_("Unknown processor");
  58.         integer counter = cpus[str]:0;
  59.         cpus[str] = counter + 1;
  60.     }
  61.     );
  62.  
  63.     boolean first = true;
  64.     cpu_string = "";
  65.  
  66.     foreach(string cpu, integer count, cpus, ``{
  67.  
  68.         if (!first)
  69.         {
  70.         cpu_string = cpu_string + ", ";
  71.         }
  72.         else
  73.         {
  74.         first = false;
  75.         }
  76.  
  77.         if (count > 1)
  78.         {
  79.         // create processor count string
  80.         // %1 is integer number (greater than 1)
  81.         // %2 is processor model name
  82.         cpu_string = cpu_string + sformat(_("%1x %2"), count, cpu);
  83.         }
  84.         else
  85.         {
  86.         cpu_string = cpu_string + cpu;
  87.         }
  88.     }
  89.     );
  90.  
  91.     list<map> memory = (list<map>) SCR::Read(.probe.memory);
  92.  
  93.     y2milestone("memory: %1", memory);
  94.     memory_size = 0;
  95.  
  96.     foreach(map info, memory, ``{
  97.         // internal class, main memory
  98.         if (info["class_id"]:0 == 257 && info["sub_class_id"]:0 == 2)
  99.         {
  100.         list<map> minf = info["resource", "phys_mem"]:[];
  101.         foreach(map i, minf, ``{
  102.             memory_size = memory_size + i["range"]:0;
  103.             }
  104.         );
  105.         }
  106.     }
  107.     );
  108.  
  109.     // initialize system string
  110.     list bios = (list) SCR::Read(.probe.bios);
  111.  
  112.     if (size(bios) != 1)
  113.     {
  114.     y2warning("Warning: BIOS list size is %1", size(bios));
  115.     }
  116.  
  117.     map biosinfo = (map)(bios[0]:$[]);
  118.     list<map> smbios = (list<map>)(biosinfo["smbios"]:[]);
  119.  
  120.     map sysinfo = $[];
  121.  
  122.     foreach(map inf, smbios, ``{
  123.         if (inf["type"]:"" == "sysinfo")
  124.         {
  125.         sysinfo = inf;
  126.         }
  127.     }
  128.     );
  129.  
  130.     system_string = "";
  131.  
  132.     if (size(sysinfo) > 0)
  133.     {
  134.     // system manufacturer is unknown
  135.     string manufacturer = (string)(sysinfo["manufacturer"]:_("Unknown"));
  136.     // system product name is unknown
  137.     string product = (string)(sysinfo["product"]:_("Unknown"));
  138.     string version = (string)(sysinfo["version"]:"");
  139.  
  140.     system_string = sformat("%1 - %2", manufacturer, product);
  141.  
  142.     if (size(version) > 0)
  143.     {
  144.         system_string = system_string + sformat(" (%1)", version);
  145.     }
  146.     }
  147.     // PPC architecture - use board and generation information
  148.     else if (Arch::ppc ())
  149.     {
  150.     string board = "";
  151.     string generation = "";
  152.  
  153.     list<map> systemProbe = (list<map>) SCR::Read(.probe.system);
  154.     if (systemProbe == nil)
  155.     {
  156.         systemProbe = [];
  157.     }
  158.  
  159.     foreach (map systemEntry, systemProbe, ``{
  160.         string board_tmp = systemEntry["system"]:"";
  161.         if (board_tmp != nil && board_tmp != "")
  162.         {
  163.         board = board_tmp;
  164.         }
  165.  
  166.         string generation_tmp = systemEntry["generation"]:"";
  167.         if (generation_tmp != nil && generation_tmp != "")
  168.         {
  169.         generation = generation_tmp;
  170.         }
  171.     });
  172.  
  173.     system_string = board;
  174.  
  175.     if (system_string != "" && generation != "")
  176.     {
  177.         system_string = system_string + sformat(" (%1)", generation);
  178.     }
  179.     }
  180.  
  181.     y2milestone("System string: %1", system_string);
  182.  
  183.     initialized = true;
  184.  
  185.     return true;
  186. }
  187.  
  188. /**
  189.  * Return short system description
  190.  * @param reset If reset is true then always do hardware detection
  191.  * @return list(string) list of hardware desciptions
  192.  */
  193. global define list<string> MakeProposal(boolean reset) ``{
  194.     Initialize(reset);
  195.  
  196.     // the installation proposal item
  197.     // %1 is processor name
  198.     list<string> ret = [ sformat(_("Processor: %1"), cpu_string),
  199.     // the installation proposal item
  200.     // %1 is memory size string
  201.     sformat(_("Main Memory: %1"), String::FormatSizeWithPrecision(memory_size, 2, true))
  202.     ];
  203.  
  204.     // add system string
  205.     if (size(system_string) > 0)
  206.     {
  207.     // the installation proposal item
  208.     // %1 is system name
  209.     ret = prepend(ret, sformat(_("System: %1"), system_string));
  210.     }
  211.  
  212.     // add SysRq status line
  213.     if (SystemSettings::GetSysRqKeysEnabled())
  214.     {
  215.     // item in the installation proposal (displayed only when SysRq key is enabled
  216.     ret = add(ret, _("SysRq Key: Enabled"));
  217.     }
  218.  
  219.     y2milestone("proposal: %1", ret);
  220.  
  221.     return ret;
  222. }
  223.  
  224. /**
  225.  * Detect all hardware present in the system
  226.  * @param force If force is true then detection is always started (cached value is discarded)
  227.  * @return list list of maps - detected hardware items ()
  228.  */
  229. global define list<map> DetectedHardware(boolean force, block<boolean> abort) ``{
  230.  
  231.     // return cached values if possible
  232.     if (detectedHW != nil && force != true)
  233.     {
  234.     return detectedHW;
  235.     }
  236.  
  237.     detectedHW = [];
  238.  
  239.     // probe devices, store model, class, uniq. ID for each device
  240.  
  241.     // probe by bus
  242.     // list(string) paths = [ "cpu", "memory", "ide", "pci", "scsi", "isapnp", "floppy", "usb", "monitor" ];
  243.  
  244.     // probe by device class
  245.     list<string> paths = [ "cpu", "memory", "disk", "display", "mouse", "keyboard", "storage", "netcard", "monitor", "braille", "bios" ];
  246.  
  247.     if (!Arch::is_uml())
  248.     {
  249.     paths = (list<string>)union(paths, [ "cdrom", "floppy", "sound", "isdn", "modem", "printer", "tv", "dvb", "scanner", "camera", "chipcard", "usbctrl", "ieee1394ctrl", "hub", "joystick", "pppoe" ]);
  250.     }
  251.  
  252.     Progress::New(_("Hardware Detection"), "", size(paths), [_("Detect hardware")], [_("Detecting hardware...")], _("Hardware detection is in progress. Please wait."));
  253.  
  254.     Progress::NextStage();
  255.  
  256.     boolean aborted = false;
  257.  
  258.     foreach(string subpath, paths, ``{
  259.  
  260.         if (abort != nil && aborted != true)
  261.         {
  262.         aborted = eval(abort);
  263.         }
  264.  
  265.         y2debug("aborted: %1", aborted);
  266.  
  267.         if (!aborted)
  268.         {
  269.         path p = add(.probe, subpath);
  270.  
  271.         // translate path name
  272.         string pathname = trans_str(subpath);
  273.  
  274.         // use untranslated string if translation failed
  275.         if (pathname == nil)
  276.         {
  277.             pathname = subpath;
  278.         }
  279.  
  280.         // set progress bar label
  281.         Progress::Title(sformat(_("%1..."), pathname));
  282.  
  283.         // don't ask for probing CPU and memory, they were already probed and detection should be harmless
  284.         boolean detect = (subpath == "cpu" || subpath == "memory") ? true : Confirm::Detection(pathname);
  285.  
  286.         // confirm hardware detection in the manual mode
  287.         if (detect == true)
  288.         {
  289.             y2milestone("Probing: %1", p);
  290.             list<map<string, any> > result = (list<map<string, any> >) SCR::Read(p);
  291.  
  292.             // store floppy devices, used in hwinfo output saving
  293.             if (subpath == "floppy")
  294.             {
  295.             // reset list of floppies
  296.             floppy = $[];
  297.  
  298.             if (result != nil && size(result) > 0)
  299.             {
  300.                 foreach(map<string,any> f, result, ``{
  301.                     string device = (string)(f["dev_name"]:nil);
  302.                     string model = (string)(f["model"]:nil);
  303.  
  304.                     if (device != nil && model != nil)
  305.                     {
  306.                     floppy[device] = model;
  307.                     }
  308.                 }
  309.                 );
  310.             }
  311.  
  312.             y2milestone("Detected floppy devices: %1", floppy);
  313.             }
  314.  
  315.             if (size(result) > 0)
  316.             {
  317.             foreach(map info, result, ``{
  318.                 // device name (CPU model name string has key "name" instead of "model")
  319.                 string model = (subpath == "cpu") ? info["name"]:_("Unknown device") : info["model"]:_("Unknown device");
  320.                 y2debug("Model: %1", model);
  321.  
  322.                 detectedHW = add(detectedHW, $[ "model" : model, "info" : info ]);
  323.                 }
  324.             );
  325.             }
  326.         }
  327.  
  328.         // update progress bar
  329.         Progress::NextStep();
  330.         }
  331.     }
  332.     );
  333.  
  334.     if (aborted == true)
  335.     {
  336.     // set to non-initialized state when detection is aborted
  337.     detectedHW = nil;
  338.     }
  339.  
  340.     y2milestone("Detected HW: %1", detectedHW);
  341.  
  342.     return detectedHW;
  343. }
  344.  
  345. }
  346.