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 / Arch.ycp < prev    next >
Encoding:
Text File  |  2006-11-29  |  9.9 KB  |  466 lines
  1. /**
  2.  * File:    modules/Arch.ycp
  3.  * Module:    yast2
  4.  * Summary:    Architecture, board and bios data
  5.  * Authors:    Klaus Kaempf <kkaempf@suse.de>
  6.  * Flags:    Stable
  7.  *
  8.  * $Id: Arch.ycp 34611 2006-11-28 08:40:08Z jsrain $
  9.  */
  10.  
  11. {
  12.  
  13. module "Arch";
  14.  
  15. // local variables
  16.  
  17. string _architecture = nil;
  18.  
  19. string _board_compatible = nil;
  20.  
  21. string _checkgeneration = "";
  22.  
  23. boolean _has_pcmcia = nil;
  24.  
  25. boolean _is_laptop = nil;
  26.  
  27. boolean _is_uml = nil;
  28.  
  29. boolean _has_smp = nil;
  30.  
  31. // Xen domain (dom0 or domU)
  32. boolean _is_xen = nil;
  33.  
  34. // Xen dom0
  35. boolean _is_xen0 = nil;
  36.  
  37. /* ************************************************************ */
  38. /* system architecture                        */
  39.  
  40. /**
  41.  * General architecture type
  42.  */
  43. global string architecture () {
  44.     if (_architecture == nil)
  45.     _architecture = (string)SCR::Read(.probe.architecture);
  46.     return _architecture;
  47. }
  48.  
  49. /**
  50.  * true for all x86 compatible architectures
  51.  */
  52. global boolean i386 () {
  53.     return architecture () == "i386";
  54. }
  55.  
  56. /**
  57.  * true for all 32bit sparc architectures
  58.  * @see sparc
  59.  * @see sparc64
  60.  */
  61. global boolean sparc32 () {
  62.     return architecture () == "sparc";
  63. }
  64.  
  65. /**
  66.  * true for all 64bit sparc architectures
  67.  * @see sparc
  68.  * @see sparc32
  69.  */
  70. global boolean sparc64 () {
  71.     return architecture () == "sparc64";
  72. }
  73.  
  74. /**
  75.  * true for all sparc architectures (32 or 64 bit)
  76.  * @see sparc32
  77.  * @see sparc64
  78.  */
  79. global boolean sparc () {
  80.     return sparc32 () || sparc64 ();
  81. }
  82.  
  83. /**
  84.  * true for all 32bit mips architectures
  85.  * @see mips
  86.  * @see mips64
  87.  */
  88. global boolean mips32 () {
  89.     return architecture () == "mips";
  90. }
  91.  
  92. /**
  93.  * true for all 64bit mips architectures
  94.  * @see mips
  95.  * @see mips32
  96.  */
  97. global boolean mips64 () {
  98.     return architecture () == "mips64";
  99. }
  100.  
  101. /**
  102.  * true for all mips architectures (32 or 64 bit)
  103.  * @see mips32
  104.  * @see mips64
  105.  */
  106. global boolean mips () {
  107.     return mips32 () || mips64 ();
  108. }
  109.  
  110. /**
  111.  * true for all 32bit ppc architectures
  112.  * @see ppc
  113.  * @see ppc64
  114.  */
  115. global boolean ppc32 () {
  116.     return architecture () == "ppc";
  117. }
  118.  
  119. /**
  120.  * true for all 64bit ppc architectures
  121.  * @see ppc
  122.  * @see ppc32
  123.  */
  124. global boolean ppc64 () {
  125.    return architecture () == "ppc64";
  126. }
  127.  
  128. /**
  129.  * true for all ppc architectures (32 or 64 bit)
  130.  * @see ppc32
  131.  * @see ppc64
  132.  */
  133. global boolean ppc () {
  134.     return ppc32 () || ppc64 ();
  135. }
  136.  
  137. /**
  138.  * true for all alpha architectures
  139.  */
  140. global boolean alpha () {
  141.     return architecture () == "alpha";
  142. }
  143.  
  144. /**
  145.  * true for all 32bit S/390 architectures
  146.  * @see s390
  147.  * @see s390_64
  148.  */
  149. global boolean s390_32 () {
  150.     return architecture () == "s390_32";
  151. }
  152.  
  153. /**
  154.  * true for all 64bit S/390 architectures
  155.  * @see s390
  156.  * @see s390_32
  157.  */
  158. global boolean s390_64 () {
  159.     return architecture () == "s390_64";
  160. }
  161.  
  162. /**
  163.  * true for all S/390 architectures (32 or 64 bit)
  164.  * @see s390_32
  165.  * @see s390_64
  166.  */
  167. global boolean s390 () {
  168.     return s390_32 () || s390_64 ();
  169. }
  170.  
  171. /**
  172.  * true for all IA64 (itanium) architectures
  173.  */
  174. global boolean ia64 () {
  175.     return architecture () == "ia64";
  176. }
  177.  
  178. /**
  179.  * true for all x86-64 (AMD Hammer) architectures
  180.  */
  181. global boolean x86_64 () {
  182.     return architecture () == "x86_64";
  183. }
  184.  
  185. /**
  186.  * General architecture type
  187.  */
  188. global string arch_short () {
  189.     if (sparc ())
  190.     return "sparc";
  191.     else if (mips ())
  192.     return  "mips";
  193.     else if (ppc ())
  194.     return  "ppc";
  195.     else if (s390 ())
  196.     return "s390";
  197.     else
  198.     return architecture ();
  199. }
  200.  
  201. /* ************************************************************ */
  202. /* general system board types (initialized in constructor)    */
  203.  
  204. global string board_compatible () {
  205.     if (_board_compatible == nil)
  206.     {
  207.     _checkgeneration = "";
  208.     list<map> systemProbe = (list<map>) SCR::Read(.probe.system);
  209.     if(systemProbe == nil) systemProbe = [];
  210.  
  211.     foreach (map systemEntry, systemProbe, ``{
  212.         string checksys = systemEntry["system"]:"";
  213.         _checkgeneration = systemEntry["generation"]:"";
  214.         if (checksys != "")
  215.         {
  216.         _board_compatible = checksys;
  217.         }
  218.     });
  219.     y2milestone("_board_compatible '%1' \n", _board_compatible);
  220.     if (i386 () || x86_64 ())
  221.     {
  222.         _board_compatible = "wintel";
  223.     }
  224.     // hwinfo expects CHRP/PReP/iSeries/MacRISC* in /proc/cpuinfo
  225.     // there is no standard for the board identification
  226.     // Cell and Maple based boards have no CHRP in /proc/cpuinfo
  227.     // Pegasos and Cell do have CHRP in /proc/cpuinfo, but Pegasos2 should no be handled as CHRP
  228.     if (ppc () && (_board_compatible == nil || _board_compatible == "CHRP"))
  229.     {
  230.         map device_type = (map) SCR::Execute (.target.bash_output,
  231.         "echo -n `cat /proc/device-tree/device_type`" , $[]);
  232.         map model = (map) SCR::Execute (.target.bash_output,
  233.         "echo -n `cat /proc/device-tree/model`" , $[]);
  234.         string board = model["stdout"]:"";
  235.         y2milestone("model %1 , device_type %2\n", model, device_type);
  236.         // catch remaining IBM boards
  237.         if (device_type["stdout"]:"" == "chrp"
  238.         || device_type["stdout"]:"" == "chrp-cbea")
  239.         {
  240.         _board_compatible = "CHRP";
  241.         }
  242.         // Maple has its own way of pretenting OF1275 compliance
  243.         if (board == "Momentum,Maple-D" || board == "Momentum,Maple-L"
  244.             || board == "Momentum,Maple")
  245.         {
  246.         _board_compatible = "CHRP";
  247.         }
  248.         // Pegasos has CHRP in /proc/cpuinfo and 'chrp' in /proc/device-tree/device_type
  249.         if (board == "Pegasos2")
  250.         {
  251.         _board_compatible = "Pegasos";
  252.         }
  253.     }
  254.     // avoid future re-probing if probing failed
  255.     // also avoid passing nil outside the module
  256.     if (board_compatible == nil)
  257.         _board_compatible = "";
  258.     }
  259.     return _board_compatible;
  260. }
  261. /**
  262.  * true for all PPC "MacRISC" boards
  263.  */
  264. global boolean board_mac () {
  265.     return ppc () && (
  266.     board_compatible () == "MacRISC" ||
  267.     board_compatible () == "MacRISC2" ||
  268.     board_compatible () == "MacRISC3" ||
  269.     board_compatible () == "MacRISC4"
  270.     );
  271. }
  272.  
  273. /**
  274.  * true for all "NewWorld" power macs
  275.  */
  276. global boolean board_mac_new () {
  277.     // board_mac calls board_compatible which initializes _checkgeneration
  278.     return board_mac () && _checkgeneration == "NewWorld";
  279. }
  280.  
  281. /**
  282.  * true for all "OldWorld" power macs
  283.  */
  284. global boolean board_mac_old () {
  285.     // board_mac calls board_compatible which initializes _checkgeneration
  286.     return board_mac () && _checkgeneration == "OldWorld";
  287. }
  288.  
  289. /**
  290.  * true for all "CHRP" ppc boards
  291.  */
  292. global boolean board_chrp () {
  293.     return ppc () && board_compatible () == "CHRP";
  294. }
  295.  
  296. /**
  297.  * true for all "iSeries" ppc boards
  298.  */
  299. global boolean board_iseries () {
  300.     return ppc () && board_compatible () == "iSeries";
  301. }
  302.  
  303. /**
  304.  * true for all "PReP" ppc boards
  305.  */
  306. global boolean board_prep () {
  307.     return ppc () && board_compatible () == "PReP";
  308. }
  309.  
  310. /**
  311.  * true for all "Pegasos" ppc boards
  312.  */
  313. global boolean board_pegasos () {
  314.     return ppc () && board_compatible () == "Pegasos";
  315. }
  316.  
  317. /**
  318.  * true for all "Windows/Intel" compliant boards (x86 based)
  319.  */
  320. global boolean board_wintel () {
  321.     return board_compatible () == "wintel";
  322.  
  323. }
  324.  
  325.  
  326. /* ************************************************************ */
  327. /* BIOS stuff                            */
  328.  
  329. /**
  330.  * true if the system supports PCMCIA
  331.  * But modern notebook computers do not have it. See also Bugzilla #151813#c10
  332.  * @see is_laptop
  333.  * @return true if the system supports PCMCIA
  334.  */
  335. global boolean has_pcmcia () {
  336.     if (_has_pcmcia == nil)
  337.     _has_pcmcia = (boolean)SCR::Read(.probe.has_pcmcia);
  338.     return _has_pcmcia;
  339. }
  340.  
  341. /**
  342.  * true if the system runs on laptop
  343.  *
  344.  * @return if the system is a laptop
  345.  */
  346. global boolean is_laptop () {
  347.     if (_is_laptop == nil) {
  348.     list<map> system = (list<map>) SCR::Read (.probe.system);
  349.     string formfactor = system[0, "formfactor"]:"";
  350.     _is_laptop = formfactor == "laptop";
  351.     }
  352.     return _is_laptop;
  353. }
  354.  
  355. /* ************************************************************ */
  356. /* UML stuff                            */
  357.  
  358. /**
  359.  * true if UML
  360.  * @deprecated
  361.  * @return true if the system is UML
  362.  */
  363. global boolean is_uml () {
  364.     if (_is_uml == nil)
  365.     _is_uml    = (boolean) SCR::Read(.probe.is_uml);
  366.     return _is_uml;
  367. }
  368. /* ************************************************************ */
  369. /* XEN stuff                            */
  370.  
  371. /**
  372.  * true if Xen kernel is running (dom0 or domU)
  373.  * @return true if the Xen kernel is running
  374.  */
  375. global boolean is_xen () {
  376.     if (_is_xen == nil) {
  377.     // XEN kernel has /proc/xen directory
  378.     map stat = (map)SCR::Read(.target.stat, "/proc/xen");
  379.     y2debug("stat /proc/xen: %1", stat);
  380.  
  381.     _is_xen = (size(stat) > 0);
  382.     }
  383.  
  384.     return _is_xen;
  385. }
  386.  
  387. /**
  388.  * true if dom0 Xen kernel is running
  389.  * @see is_xenU
  390.  * @see is_xen
  391.  * @return true if the Xen kernel is running in dom0
  392.  */
  393. global boolean is_xen0 () {
  394.     if (_is_xen0 == nil) {
  395.     // dom0 Xen kernel has /proc/xen/xsd_port file
  396.     map stat = (map)SCR::Read(.target.stat, "/proc/xen/xsd_port");
  397.     y2debug("stat /proc/xen/xsd_port: %1", stat);
  398.  
  399.     _is_xen0 = (size(stat) > 0);
  400.     }
  401.  
  402.     return _is_xen0;
  403. }
  404.  
  405. /**
  406.  * true if domU Xen kernel is running
  407.  *
  408.  * @see is_xen0
  409.  * @see is_xen
  410.  * @return true if the Xen kernel is running in another domain than dom0
  411.  */
  412. global boolean is_xenU () {
  413.     return (is_xen() && !is_xen0());
  414. }
  415.  
  416. /* ************************************************************ */
  417. /* SMP stuff                            */
  418.  
  419. /**
  420.  * Set "Arch::has_smp ()". Since Alpha doesn't reliably probe smp,
  421.  * 'has_smp' must be set later with this function.
  422.  * @param is_smp true if has_smp should be true
  423.  * @example setSMP(true);
  424.  */
  425. global define void setSMP(boolean is_smp) {
  426.     _has_smp = is_smp;
  427. }
  428.  
  429. /**
  430.  * true if running on multiprocessor board. This only reflects the
  431.  * board, not the actual number of CPUs or the running kernel!
  432.  *
  433.  * @return true if running on multiprocessor board
  434.  */
  435. global boolean has_smp () {
  436.     if (_has_smp == nil)
  437.     _has_smp = (boolean)SCR::Read(.probe.has_smp);
  438.     if (alpha ())
  439.     {
  440.         // get smp for alpha from /etc/install.inf
  441.         setSMP (SCR::Read (.etc.install_inf.SMP) == "1");
  442.     }
  443.     return _has_smp;
  444. }
  445.  
  446. /**
  447.  * run X11 configuration after inital boot
  448.  * this is false in case of:
  449.  * installation on iSeries,
  450.  * installation on S390
  451.  *
  452.  * @returns true when the X11 configuration is needed after inital boot
  453.  * @see Installation::x11_setup_needed
  454.  */
  455. global boolean x11_setup_needed    () {
  456.     // disable X11 setup after initial boot
  457.     if (board_iseries () || s390 () || mips ())
  458.     {
  459.     return false;
  460.     }
  461.     return true;
  462. }
  463.  
  464. /* EOF */
  465. }
  466.