Added ebuilds for kogaion desktop

1 files changed, 776 insertions, 0 deletions

diff --git a/sys-apps/gpu-detector/files/gpu-configuration b/sys-apps/gpu-detector/files/gpu-configuration
new file mode 100755
index 00000000..2f816efe
--- /dev/null
+++ b/sys-apps/gpu-detector/files/gpu-configuration
@@ -0,0 +1,776 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import os
+import subprocess
+try:
+    from subprocess import getoutput
+except ImportError:
+    from commands import getoutput
+import shutil
+import sys
+
+# Variables
+xorgfile = "/etc/X11/xorg.conf"
+lspci = '/usr/sbin/lspci'
+nvidia_settings = "/usr/share/applications/nvidia-settings.desktop"
+
+device_id_prefix = "RogentosVga"
+nvidia_option_prefix = "--nvidia-opt--"
+screen_layout_sections = []
+device_sections = []
+xorg_conf_structure = """
+Section "Module"
+    SubSection  "extmod"
+       Option    "omit xfree86-dga"
+    EndSubSection
+    Load    "i2c"
+    Load    "ddc"
+    Load    "vbe"
+    Load    "dri"
+    Load    "glx"
+    Load    "synaptics"
+EndSection
+
+Section "ServerFlags"
+     Option    "AllowMouseOpenFail"    "true"
+EndSection
+
+Section "Monitor"
+    Identifier    "Generic Monitor"
+    VertRefresh    43 - 60
+    HorizSync      28 - 80
+EndSection
+
+__device_section__
+
+__screen_section__
+
+Section "DRI"
+    Mode 0666
+EndSection
+
+Section "ServerLayout"
+    Identifier   "Main Layout"
+    __screen_layout_section__
+EndSection
+
+Section "Extensions"
+   #Option "Composite" "Enable"
+EndSection
+"""
+
+screen_sections = []
+screen_section = """
+Section "Screen"
+
+    Identifier    "Screen __screen_id__"
+    Device        "%s__screen_id__"
+    Monitor       "Generic Monitor"
+    %sOption       "AddARGBGLXVisuals" "true"
+    %sOption       "RegistryDwords" "EnableBrightnessControl=1"
+
+    DefaultDepth 24
+
+    SubSection "Display"
+        Depth		8
+        ViewPort	0 0
+        #Modes		"1024x768" "800x600" "640x480"
+    EndSubsection
+
+    SubSection "Display"
+        Depth           16
+        ViewPort        0 0
+        #Modes		"1024x768" "800x600" "640x480"
+    EndSubsection
+
+    SubSection "Display"
+        Depth           24
+        ViewPort        0 0
+        #Modes		"1024x768" "800x600" "640x480"
+    EndSubsection
+
+EndSection
+""" % (device_id_prefix, nvidia_option_prefix,
+       nvidia_option_prefix,)
+
+# cmdlines
+options = sys.argv[1:]
+dryrun = False
+noproprietary = False
+nvidia_forcefail = False
+nvidia_disablelegacy = False
+legacy = False
+livecd = False
+steps = []
+forced_xdriver = ''
+current_arch = os.uname()[4]
+nomodeset = False
+noefi = False
+
+fglrx_supported = sorted(getoutput(
+        "modinfo fglrx | grep alias | grep pci | "
+        "cut -d':' -f 3 | cut -d'*' -f 1 | "
+        "sed 's/.*1002d//' | sed 's/^0000//' | sed 's/sv$//'"
+        ).lower().split())
+
+nvidia_71xx_supported = ['0020', '0028', '0029', '002c', '002d', '00a0',
+    '0100', '0101', '0103', '0150', '0151', '0152', '0153']
+nvidia_96xx_supported = ['0110', '0111', '0112', '0113', '0170', '0171',
+    '0172', '0173', '0174', '0175', '0176', '0177', '0178', '0179', '017a',
+    '017c', '017d', '0181', '0182', '0183', '0185', '0188', '018a', '018b',
+    '018c', '01a0', '01f0', '0200', '0201', '0202', '0203', '0250', '0251',
+    '0253', '0258', '0259', '025b', '0280', '0281', '0282', '0286', '0288',
+    '0289', '028c']
+nvidia_173xx_supported = ['00fa', '00fb', '00fc', '00fd', '00fe', '0301',
+    '0302', '0308', '0309', '0311', '0312', '0314', '031a', '031b', '031c',
+    '0320', '0321', '0322', '0323', '0324', '0325', '0326', '0327', '0328',
+    '032a', '032b', '032c', '032d', '0330', '0331', '0332', '0333', '0334',
+    '0338', '033f', '0341', '0342', '0343', '0344', '0347', '0348', '034c',
+    '034e']
+# Taken from here:
+# http://www.nvidia.com/object/IO_32667.html
+nvidia_304xx_supported = ['0040', '0041', '0042', '0043', '0044', '0045',
+    '0046', '0047', '0048', '004e', '0090', '0091', '0092', '0093', '0095',
+    '0098', '0099', '009d', '00c0', '00c1', '00c2', '00c3', '00c8', '00c9',
+    '00cc', '00cd', '00ce', '00f1', '00f2', '00f3', '00f4', '00f5', '00f6',
+    '00f8', '00f9', '0140', '0141', '0142', '0143', '0144', '0145', '0146',
+    '0147', '0148', '0149', '014a', '014c', '014d', '014e', '014f', '0160',
+    '0161', '0162', '0163', '0164', '0165', '0166', '0167', '0168', '0169',
+    '016a', '01d0', '01d1', '01d2', '01d3', '01d6', '01d7', '01d8', '01da',
+    '01db', '01dc', '01dd', '01de', '01df', '0211', '0212', '0215', '0218',
+    '0221', '0222', '0240', '0241', '0242', '0244', '0245', '0247', '0290',
+    '0291', '0292', '0293', '0294', '0295', '0297', '0298', '0299', '029a',
+    '029b', '029c', '029d', '029e', '029f', '02e0', '02e1', '02e2', '02e3',
+    '02e4', '038b', '0390', '0391', '0392', '0393', '0394', '0395', '0397',
+    '0398', '0399', '039c', '039e', '03d0', '03d1', '03d2', '03d5', '03d6',
+    '0531', '0533', '053a', '053b', '053e', '07e0', '07e1', '07e2', '07e3',
+    '07e5']
+savage_supported = ['8a20', '8a21', '8a22', '9102', '8c10', '8c11', '8c12',
+    '8c13', '8c22', '8c24', '8c26', '8c2a', '8c2b', '8c2c', '8c2d', '8c2e',
+    '8c2f', '8a25', '8a26', '8d01', '8d02', '8d03', '8d04']
+unichrome_supported = ['3108', '3118', '3157', '3343', '3344', '7205']
+
+lspci_output = ''
+for option in options:
+    if option == "--dry-run":
+        dryrun = True
+    elif option.startswith('--with-lspci=') and len(option.split("=")) >= 2:
+        option = option.split("=")[1:]
+        option = "=".join(option)
+        if option.startswith('"'):
+            option = option[1:]
+        if option.startswith("'"):
+            option = option[1:]
+        if option.endswith("'"):
+            option = option[:len(option)-1]
+        if option.endswith('"'):
+            option = option[:len(option)-1]
+        lspci_output = option
+    elif option.startswith('--forced-xdriver=') and len(option.split("=")) == 2:
+        forced_xdriver = option.split("=")[1]
+
+if not lspci_output:
+    lspci_output = getoutput(lspci+' -mm -n')
+
+# parse cmdline
+with open("/proc/cmdline","r") as f:
+    cmdline = f.readline().split()
+for cmd in cmdline:
+    if cmd == "noproprietary":
+        noproprietary = True
+    elif cmd == "nomodeset":
+        nomodeset = True
+    elif cmd == "nvidia=forcefail":
+        nvidia_forcefail = True
+    elif cmd == "nvidia=disablelegacy":
+        nvidia_disablelegacy = True
+    elif cmd == "legacy":
+        legacy = True
+    elif cmd == "cdroot":
+        livecd = True
+    elif cmd == "noefi":
+        noefi = True
+    elif cmd.startswith("xdriver=") and (len(cmd.split("=")) == 2):
+        if not forced_xdriver:
+            forced_xdriver = cmd.split("=")[1] # --forced-xdriver= owns
+
+def openrc_running():
+    return os.path.isfile("/run/openrc/softlevel")
+
+def systemd_running():
+    return os.path.isdir("/run/systemd/system")
+
+def remove_proprietary_opengl(bumblebee):
+    if not dryrun:
+        if not bumblebee:
+            os.system("""
+            mount -t tmpfs none /usr/lib/opengl/ati &> /dev/null
+            mount -t tmpfs none /usr/lib/opengl/nvidia &> /dev/null
+            sed -i '/LIBGL_DRIVERS_PATH/ s/.*//' /etc/profile.env
+            """)
+            fix_possible_opengl_misconfiguration('xorg-x11')
+        else:
+            print("Bumblebee enabled, not deactivating proprietary drivers")
+    else:
+        print("I was about to remove proprietary OpenGL libraries")
+
+def get_kernel_version():
+    try:
+        return int(os.uname()[2].replace(".", "")[:3])
+    except (ValueError, TypeError) as err:
+        print("get_kernel_version: ouch: %s" % (err,))
+        return None
+
+def setup_radeon_kms():
+    # Starting from kernel 3.6, we have CONFIG_DRM_RADEON_KMS=y
+    kver = get_kernel_version()
+    if kver is None:
+        kver = 360 # assume new kernel
+    if not dryrun and kver < 360:
+        os.system("""
+        modprobe -r radeon &> /dev/null
+        modprobe radeon modeset=1 && touch /tmp/.radeon.kms
+        """)
+    else:
+        print("I was about to modprobe radeon modeset=1")
+
+def remove_tar_members_from_sys(tarpath):
+    import tarfile
+    tar = tarfile.open(tarpath)
+    for el in sorted(tar.getnames(), reverse = True):
+        el = "/%s" % (el,)
+        if os.path.isfile(el):
+            try:
+                os.remove(el)
+            except OSError:
+                pass
+        if os.path.isdir(el):
+            try:
+                os.rmdir(el)
+            except OSError:
+                pass
+    tar.close()
+
+def generate_fglrx_steps(videocard, cardnumber, total_cards, bus_id):
+    print("AMD!")
+    print("total supported AMD cards: %s" % (len(fglrx_supported),))
+    print("supported list:", fglrx_supported)
+    supported = card_id in fglrx_supported
+    if supported:
+        print("fglrx driver supports this card")
+    # check if nomodeset is enabled for >=3.6.0 kernel
+    kver = get_kernel_version()
+    if kver is None:
+        kver = 360 # assume new kernel
+    if not nomodeset and kver >= 360:
+        print("however, nomodeset is not set, though KMS is active,"
+              " defaulting to OSS driver")
+        supported = False
+
+    if supported:
+        if noproprietary:
+            steps.append((drop_kernel_mod, "fglrx",))
+            steps.append((setup_radeon_kms,))
+        else:
+            steps.append((fix_possible_opengl_misconfiguration,
+                          "ati"))
+            steps.append((copy_ati_settings_on_desktop,))
+            steps.append((opengl_activate, "ati"))
+            steps.append((set_xorg_device, "fglrx",
+                          cardnumber, total_cards, bus_id,))
+    else:
+        # video card not supported by fglrx
+        print("using OSS 'ati' drivers")
+        generate_generic_steps()
+        # This works for Mach64, Rage128
+        # Radeon and in future RadeonHD driver
+        steps.append((drop_kernel_mod, "fglrx",))
+        steps.append((setup_radeon_kms,))
+
+def check_if_driver_is_available(xdriver):
+    drv_path = "/usr/lib/xorg/modules/drivers/" + xdriver + "_drv.so"
+    if os.path.isfile(drv_path):
+        print("check_if_driver_is_available for " + xdriver + ": available")
+        return True
+    print("check_if_driver_is_available for " + xdriver + ": not available")
+    return False
+
+def check_if_proprietary_driver_system_is_healthy(kernelmod):
+    rc = subprocess.call(["modprobe", kernelmod])
+    if rc == 0:
+        if kernelmod == "nvidia":
+            if os.path.exists("/usr/lib/opengl/nvidia/lib"):
+                print("check_if_proprietary_driver_system_is_healthy:"
+                      " nvidia healthy")
+                return True
+            print("check_if_proprietary_driver_system_is_healthy:"
+                  " nvidia NOT healthy")
+            return False
+        elif kernelmod == "fglrx":
+            kver = get_kernel_version()
+            if kver is None:
+                kver = 360 # assume new kernel
+            if not nomodeset and kver >= 360:
+                print("check_if_proprietary_driver_system_is_healthy:"
+                      " fglrx (ati) NOT healthy, 'nomodeset' boot argument"
+                      " is mising")
+                return False
+            if os.path.exists("/usr/lib/opengl/ati/lib"):
+                print("check_if_proprietary_driver_system_is_healthy:"
+                      " fglrx (ati) healthy")
+                return True
+            print("check_if_proprietary_driver_system_is_healthy:"
+                  " fglrx (ati) NOT healthy")
+            return False
+    return False
+
+def deploy_nvidia_xxxxxx_drivers(ver):
+    if dryrun:
+        print("I was about to run deploy_nvidia_xxxxxx_drivers"
+              ", ver: %s" % (ver,))
+        return False
+
+    drivers_dir = "/install-data/drivers"
+    # are they available ? we're on livecd...
+    if not os.path.isdir(drivers_dir):
+        print("drivers_dir not available")
+        return False
+
+    packages = os.listdir(drivers_dir)
+    _packages = []
+    for pkg in packages:
+        if not pkg.endswith(".tbz2"):
+            continue
+        if pkg.startswith("x11-drivers:nvidia-drivers-" + ver):
+            _packages.append(pkg)
+        elif pkg.startswith("x11-drivers:nvidia-userspace" + ver):
+            _packages.append(pkg)
+
+    packages = [os.path.join(drivers_dir, x) for x in _packages]
+    package_names = ["x11-drivers/nvidia-drivers",
+                     "x11-drivers/nvidia-userspace"]
+    if not packages:
+        return False
+
+    from entropy.client.interfaces import Client
+    _entropy = Client()
+
+    # prepare system
+    for package_name in package_names:
+        inst_repo = _entropy.installed_repository()
+        package_id, result = inst_repo.atomMatch(package_name)
+        if package_id == -1:
+            continue
+        content = inst_repo.retrieveContentIter(package_id)
+        for myfile, ftype in content:
+            try:
+                os.remove(myfile)
+            except (OSError, IOError):
+                pass
+
+    if hasattr(_entropy,"destroy"):
+        _entropy.destroy()
+
+    for package_file in packages:
+        # remove old garbage - copy over - create module
+        subprocess.call(
+            ["tar", "xjf", package_file, "-C", "/"])
+        # try to check driver status now
+        rc = check_if_proprietary_driver_system_is_healthy("nvidia")
+        if not rc:
+            remove_tar_members_from_sys(package_file)
+        return rc
+
+efivars_loaded = False
+def is_efi():
+    """
+    Return whether the system boots from EFI
+    """
+    global efivars_loaded
+
+    if noefi:
+        return False
+
+    if not efivars_loaded:
+        subprocess.call(["modprobe", "efivars"])
+        efivars_loaded = True
+
+    return os.path.exists("/sys/firmware/efi")
+
+def get_vesa_driver():
+    """
+    Return either "vesa" or "fbdev" as the fallback
+    vesa-like X driver.
+    """
+    if is_efi():
+        # vesa does not work
+        return "fbdev"
+    return "vesa"
+
+def set_xorg_device(xdriver, cardnum, total_cards, bus_id):
+    if (xdriver not in ("nvidia", "fglrx",)) and \
+            (not check_if_driver_is_available(xdriver)):
+        xdriver = get_vesa_driver() # fallback to vesa
+    bus_id_mark = "#"
+    if total_cards > 1:
+        bus_id_mark = ""
+
+    device_sections.append("""
+Section "Device"
+
+    Identifier  "%s%s"
+    Driver      "%s"
+    %sBusID    "%s"
+    #Option "RenderAccel" "on"
+    #Option "XAANoOffscreenPixmaps"
+    #Option "BusType" "PCI"
+    #Option "ColorTiling" "on"
+    #Option "EnablePageFlip" "on"
+    # UseEvents is causing segmentation faults with
+    # NVIDIA 6xxx, 7xxx and >=275.xx.xx drivers
+    #Option "UseEvents" "True"
+    Option "LogoPath" "/usr/share/backgrounds/rogentoslinux-nvidia.png"
+
+EndSection
+    """ % (device_id_prefix, cardnum, xdriver, bus_id_mark, bus_id,))
+
+    my_screen_section = screen_section.replace("__screen_id__", str(cardnum))
+    # setup Option AddARGBVisuals
+    # especially needed for legacy nvidia drivers, but works
+    # on all of them
+    if xdriver == "nvidia":
+        my_screen_section = my_screen_section.replace(nvidia_option_prefix, "")
+    else:
+        my_screen_section = my_screen_section.replace(nvidia_option_prefix, "#")
+    screen_sections.append(my_screen_section)
+    screen_layout_sections.append('Screen %s    "Screen %s"' % (
+            cardnum, cardnum,))
+
+def opengl_activate(profile, force=False):
+    if not dryrun:
+        if not force:
+            current = opengl_show()
+            if current == profile:
+                print("OpenGL profile is already set to: " + profile)
+                return
+        subprocess.call(["eselect", "opengl", "set", profile])
+    else:
+        print("I was about to set opengl subsystem to: " + profile)
+
+def opengl_show():
+    return getoutput("eselect opengl show").split("\n")[0].strip()
+
+def fix_possible_opengl_misconfiguration(profile):
+    # get current subsystem
+    current = opengl_show()
+    if not dryrun:
+        if (profile in ("ati","nvidia","xorg-x11")) and (profile != current):
+            if profile == "ati" or profile == "nvidia":
+                subprocess.call(["umount", "/usr/lib/opengl/" + profile])
+                subprocess.call(["umount", "/usr/lib/opengl/" + profile])
+                opengl_activate(profile)
+    else:
+        print("I was about to fix OpenGL subsystem to: " + \
+                  profile + " while the current implementation is: " + \
+                  current)
+
+def copy_nvidia_settings_on_desktop():
+    homes = []
+    if os.path.isfile(nvidia_settings):
+        _homes = os.listdir("/home")
+        homes += [x for x in os.listdir("/home") \
+                      if os.path.isdir("/home/" + x + "/Desktop")]
+
+    for home in homes:
+        try:
+
+            full_home = os.path.join("/home", home)
+            st = os.stat(full_home)
+            dest_path = "/home/" + home + "/Desktop/" + \
+                os.path.basename(nvidia_settings)
+            shutil.copy2(nvidia_settings, dest_path)
+            os.chmod(dest_path, 0o755)
+            os.chown(dest_path, st.st_uid, st.st_gid)
+
+            if os.path.isdir("/etc/skel/Desktop"):
+                dest_path = os.path.join(
+                    "/etc/skel/Desktop",
+                    os.path.basename(nvidia_settings))
+                shutil.copy2(nvidia_settings, dest_path)
+                os.chmod(dest_path, 0o755)
+
+        except Exception:
+            pass
+
+def copy_ati_settings_on_desktop():
+    desktop_files = getoutput(
+        'equo query files ati-drivers --quiet | grep ".desktop"').split("\n")
+    desktop_files = [x for x in desktop_files if os.path.isfile(x)]
+    print("copy_ati_settings_on_desktop: found files: "+str(desktop_files))
+
+    for ati_settings in desktop_files:
+        homes = os.listdir("/home")
+        homes = [x for x in homes if os.path.isdir("/home/" + x + "/Desktop")]
+        for home in homes:
+            try:
+                full_home = os.path.join("/home", home)
+                st = os.stat(full_home)
+                dest_path = "/home/" + home + "/Desktop/" + \
+                    os.path.basename(ati_settings)
+                shutil.copy2(ati_settings, dest_path)
+                os.chmod(dest_path, 0o755)
+                os.chown(dest_path, st.st_uid, st.st_gid)
+
+                if os.path.isdir("/etc/skel/Desktop"):
+                    dest_path = os.path.join(
+                        "/etc/skel/Desktop",
+                        os.path.basename(ati_settings))
+                    shutil.copy2(ati_settings, dest_path)
+                    os.chmod(dest_path, 0o755)
+            except Exception:
+                pass
+
+def setup_nvidia_drivers(card_id):
+    drv_string = ''
+    done_legacy = False
+
+    drivers_map = (
+        ("304", nvidia_304xx_supported,),
+        ("173", nvidia_173xx_supported,),
+        ("96", nvidia_173xx_supported,),
+        ("71", nvidia_173xx_supported,),
+        )
+    for ver, lst in drivers_map:
+        if card_id not in lst:
+            continue
+        print("NVIDIA %s driver selected" % (ver,))
+        drv_string = ver
+        if livecd:
+            rc = deploy_nvidia_xxxxxx_drivers(ver)
+            if rc:
+                print("NVIDIA %s deployed correctly" % (ver,))
+                done_legacy = True
+                break
+
+    if not done_legacy:
+        drv_string = '[latest]'
+        print("latest and greatest NVIDIA driver selected or unsupported")
+
+    healthy = check_if_proprietary_driver_system_is_healthy("nvidia")
+    if healthy:
+        print("NVIDIA proprietary driver %s is loaded" % (drv_string,))
+
+        if done_legacy:
+            os.makedirs("/lib/nvidia/legacy")
+            with open("/lib/nvidia/legacy/running", "w") as f:
+                f.write("%s" % (drv_string,))
+
+    return done_legacy, healthy
+
+def generate_nvidia_bumblebee_steps(v3dcard, company_id, card_id):
+    done_legacy, healthy = setup_nvidia_drivers(card_id)
+    if not healthy:
+        print("NVIDIA drivers couldn't be loaded, cannot enable bumblebee")
+        return
+
+    if dryrun:
+        print("Was about to start bumblebee")
+        return
+
+    if not livecd:
+        print("LiveCD mode off, not starting bumblebee service")
+        return
+
+    # This is used by our Installer
+    with open("/tmp/.bumblebee.enabled", "w") as f:
+        pass
+
+    if openrc_running():
+        os.system("/etc/init.d/bumblebee start")
+    elif systemd_running():
+        os.system("/usr/bin/systemctl start bumblebeed")
+
+def generate_nvidia_steps(videocard, cardnumber, total_cards, bus_id):
+    comp_id, card_id = extract_pci_ids(videocard)
+    done_legacy, healthy = setup_nvidia_drivers(card_id)
+
+    if healthy:
+        if done_legacy:
+            # then activate nvidia opengl subsystem after resetting it
+            steps.append((opengl_activate, "xorg-x11"))
+            steps.append((opengl_activate, "nvidia"))
+
+            steps.append((set_xorg_device, "nvidia",
+                          cardnumber, total_cards, bus_id,))
+            steps.append((fix_possible_opengl_misconfiguration, "nvidia"))
+            steps.append((copy_nvidia_settings_on_desktop,))
+
+        else:
+
+            steps.append((fix_possible_opengl_misconfiguration, "nvidia"))
+            steps.append((copy_nvidia_settings_on_desktop,))
+            steps.append((opengl_activate, "nvidia"))
+            steps.append((set_xorg_device, "nvidia",
+                          cardnumber, total_cards, bus_id,))
+    else:
+        print("NVIDIA drivers couldn't be loaded, switchting to nv driver")
+        steps.append((opengl_activate, "xorg-x11"))
+
+def generate_generic_steps():
+    steps.append((remove_proprietary_opengl, bb_enabled))
+    steps.append((opengl_activate, "xorg-x11",))
+
+def drop_kernel_mod(kmod):
+    return subprocess.call(["modprobe", "-r", kmod])
+
+def extract_pci_ids(videocard_str):
+    videocard_split = [x.strip() for x in videocard_str.strip().split('"') \
+                           if x.strip()]
+    try:
+        card_id = videocard_split[3].split()[-1].lower().strip("[]")
+    except IndexError:
+        card_id = None
+
+    try:
+        company_id = videocard_split[2].split()[-1].lower().strip("[]")
+    except IndexError:
+        company_id = None
+
+    return company_id, card_id
+
+def extract_vga_cards(lspci_list):
+    cards = []
+    for item in lspci_list:
+        try:
+            class_type = item.split()[1].strip('"')
+            if class_type == "0300":
+                cards.append(item)
+        except IndexError:
+            continue
+    return cards
+
+def extract_3d_cards(lspci_list):
+    # bumblebee support
+    cards = []
+    for item in lspci_list:
+        try:
+            class_type = item.split()[1].strip('"')
+            if class_type == "0302":
+                cards.append(item)
+        except IndexError:
+            continue
+    return cards
+
+
+# Create videocards list
+lspci_out_split = lspci_output.split("\n")
+videocards = extract_vga_cards(lspci_out_split)
+v3dcards = extract_3d_cards(lspci_out_split)
+# Run the program
+cardnumber = -1
+
+total_cards = len(videocards)
+forced_monitor_modes = False
+steps = []
+bb_enabled = False
+write_config = False
+
+for v3dcard in v3dcards:
+
+    company_id, card_id = extract_pci_ids(v3dcard)
+
+    if company_id == "10de":
+        print("NVIDIA Optimus 3D Acceleration detected, enabling bumblebee")
+        generate_nvidia_bumblebee_steps(v3dcard, company_id, card_id)
+        bb_enabled = True
+
+for videocard in videocards:
+
+    # setup card number
+    cardnumber += 1
+    print("Card Number: " + str(cardnumber))
+    try:
+        bus_id = "PCI:%s" % (
+                videocard.split()[0].split(".", 1)[0]
+            )
+    except (IndexError,ValueError,TypeError,):
+        bus_id = None
+
+    if forced_xdriver:
+        print("You have chosen to force the X driver: " + forced_xdriver)
+        if forced_xdriver == "fglrx":
+            if check_if_proprietary_driver_system_is_healthy("fglrx") \
+                    or noproprietary:
+                steps.append((opengl_activate, "xorg-x11"))
+                forced_xdriver = "ati"
+                steps.append((drop_kernel_mod, "fglrx",))
+            else:
+                steps.append((fix_possible_opengl_misconfiguration, "ati"))
+                steps.append((copy_ati_settings_on_desktop,))
+                steps.append((opengl_activate, "ati"))
+
+        elif forced_xdriver == "nvidia" and (not noproprietary):
+            generate_nvidia_steps(videocard, cardnumber, total_cards, bus_id)
+        elif forced_xdriver == "vesa":
+            forced_monitor_modes = True
+        else:
+            generate_generic_steps()
+            steps.append((set_xorg_device, forced_xdriver,
+                          cardnumber, total_cards, bus_id,))
+        write_config = True
+
+    else:
+        company_id, card_id = extract_pci_ids(videocard)
+        print("[%s] company_id: %s | card_id: %s" % (
+                cardnumber, company_id, card_id,))
+
+        if company_id == "10de": # NVIDIA
+            if noproprietary:
+                steps.append((set_xorg_device, "nv",
+                              cardnumber, total_cards, bus_id,))
+            else:
+                generate_nvidia_steps(
+                    videocard, cardnumber, total_cards, bus_id)
+                print("NVIDIA!")
+            write_config = True
+
+        elif company_id == "1002":
+            generate_fglrx_steps(
+                videocard, cardnumber, total_cards, bus_id)
+            write_config = True
+
+        else:
+            generate_generic_steps()
+            print("GPU will be automatically detected by X.Org and udevd")
+
+
+# now create the file
+for args in steps:
+    func, args = args[0], args[1:]
+    func(*args)
+
+if write_config:
+    config = xorg_conf_structure.replace(
+        '__device_section__',
+        '\n\n'.join(device_sections))
+    config = config.replace(
+        '__screen_section__',
+        '\n\n'.join(screen_sections))
+    config = config.replace(
+        '__screen_layout_section__',
+        '\n    '.join(screen_layout_sections))
+    if forced_monitor_modes:
+        config = config.replace('#Modes', 'Modes')
+
+    if not dryrun:
+        with open(xorgfile, "w") as f:
+            f.write(config)
+            f.flush()
+else:
+    try:
+        os.remove(xorgfile)
+    except (OSError, IOError):
+        pass
+
+raise SystemExit(0)