• Pagina non alterabile
  • Informazioni
  • Allegati


Questa guida è stata verificata solo con versioni obsolete di Ubuntu, potrebbe non essere più valida. Vuoi contribuire ad aggiornarla? Clicca qui!

Problemi in questa pagina? Segnalali in questa discussione


Introduzione

Le versioni più recenti del kernel Linux sono in grado di supportare la grafica ibrida. Se la propria macchina dispone di un selettore hardware, attraverso il flag vga_switcheroo è possibile passare da una GPU all'altra.

Questo metodo non è supportato da tutte le macchine e funziona solo se si utilizzano driver open source (Nouveau, Radeon) .

Abilitazione di vga_switcheroo

Per verificare che il kernel sia compilato con l'opzione corretta, è possibile esaminare il file config-* nella directory /boot. Digitare in un terminale:

grep -i switcheroo /boot/config-* 

Il meccanismo vga_switcheroo sarà attivo solo quando il kernel verrà avviato con l'opzione :

"modeset = 1"

e/o con l'opzione:

"nomodeset"

assente.

Per verificare se vga_switcheroo è abilitato, cercare il file switch digitando:

sudo ls -l /sys/kernel/debug/vgaswitcheroo/switch 

se il file viene trovato allora vga_switcheroo è abilitato.

Uso di vga_switcheroo

Una volta accertato che vga_switcheroo sia disponibile, è possibile utilizzare queste opzioni per cambiare GPU:

  • Per attivare la GPU che è scollegata (ma non le uscite di commutazione):

    echo ON > /sys/kernel/debug/vgaswitcheroo/switch 
  • Per connettere la scheda grafica integrata con le uscite:

    echo IGD > /sys/kernel/debug/vgaswitcheroo/switch 
  • Per connettere la scheda grafica dedicata con le uscite:

    echo DIS > /sys/kernel/debug/vgaswitcheroo/switch 
  • Per disattivare la scheda grafica che è attualmente scollegata:

    echo OFF > /sys/kernel/debug/vgaswitcheroo/switch 

Ci sono inoltre ulteriori opzioni utili all'interno di una sessione X-Windows:

  • Per accodare il passaggio alla grafica integrata che si verifica quando il server X è prossimo al riavvio:

    echo DIGD > /sys/kernel/debug/vgaswitcheroo/switch 
  • Per accodare il passaggio alla grafica dedicata che si verifica quando il server X è prossimo al riavvio:

    echo DDIS > /sys/kernel/debug/vgaswitcheroo/switch 

Monitorare le impostazioni

È possibile controllare le impostazioni attualmente in uso attraverso il comando:

cat /sys/kernel/debug/vgaswitcheroo/switch

che può restituire un output di questo tipo:

0:IGD:+:Pwr:0000:01:05.0
1:DIS: :Off:0000:02:00.0

Nella seguente tabella viene mostrato il significato della simbologia utilizzata:

Sigla

Significato

IGD

indica la gpu integrata, generalmente quella meno performante

DIS

indica la gpu discreta, cioè quella dedicata, capace di prestazioni grafiche superiori

+

indica che la gpu è attiva, cioè collegata alle uscite video

Pwr

indica che la gpu è accesa, cioè alimentata (quindi consuma energia)

Off

indica che la gpu è spenta, cioè non più alimentata

Script per l'utilizzo in una sessione di X

È possibile creare uno script utile a creare un'interfaccia grafica per scegliere tra le schede grafiche.

  1. Assicurarsi che siano già installati i pacchetti gxmessage e libnotify-bin.

  2. Scaricare alcuni file nella directory /usr/share/icons digtando in un terminale i comandi:

    sudo wget -P /usr/share/icons/ http://lh4.ggpht.com/_Dw3SC8gD9Jk/S-MGVcEfaiI/AAAAAAAAAIA/Pguy_uSeqSk/s800/hardware_down.png
    
    sudo wget -P /usr/share/icons/ http://lh5.ggpht.com/_Dw3SC8gD9Jk/S-MGVSO0JbI/AAAAAAAAAIE/_mdAnW7UiCQ/s800/hardware_up.png
  3. Creare lo script digitando:

    sudo touch /usr/bin/switch_between_cards.sh
  4. Aprire con i privilegi di amministrazione e con un editor di testo il file /usr/bin/switch_between_cards.sh e inserire al suo interno:

    #!/bin/bash
    # "switch_between_cards.sh" script by RM, with useful changes from LoLL
    # version 20101107
    
    pci_integrated=$(lspci | grep VGA | sed -n '1p' | cut -f 1 -d " ")
    pci_discrete=$(lspci | grep VGA | sed -n '2p' | cut -f 1 -d " ")
    
    integrated=$(cat /sys/kernel/debug/vgaswitcheroo/switch | grep $pci_integrated | grep -o -P ':.:...:')
    discrete=$(cat /sys/kernel/debug/vgaswitcheroo/switch | grep $pci_discrete | grep -o -P ':.:...:')
    
    name_integrated=$(lspci | grep VGA | sed -n '1p' | sed -e "s/.* VGA compatible controller[ :]*//g" | sed -e "s/ Corporation//g" | sed -e "s/ Technologies Inc//g" | sed -e 's/\[[0-9]*\]: //g' | sed -e 's/\[[0-9:a-z]*\]//g' | sed -e 's/(rev [a-z0-9]*)//g' | sed -e "s/ Integrated Graphics Controller//g")
    
    name_discrete=$(lspci | grep VGA | sed -n '2p' | sed -e "s/.* VGA compatible controller[ :]*//g" | sed -e "s/ Corporation//g" | sed -e "s/ Technologies Inc//g" | sed -e 's/\[[0-9]*\]: //g' | sed -e 's/\[[0-9:a-z]*\]//g' | sed -e 's/(rev [a-z0-9]*)//g' | sed -e "s/ Integrated Graphics Controller//g")
    
    if [ "$integrated" = ":+:Pwr:" ]
    then
     integrated_condition="(*) - Power ON"
    elif [ "$integrated" = ": :Pwr:" ]
    then
     integrated_condition="( ) - Power ON"
    elif [ "$integrated" = ": :Off:" ]
    then
     integrated_condition="( ) - Power OFF"
    fi
    
    if [ "$discrete" = ":+:Pwr:" ]
    then
     discrete_condition="(*) - Power ON"
    elif [ "$discrete" = ": :Pwr:" ]
    then
     discrete_condition="( ) - Power ON"
    elif [ "$discrete" = ": :Off:" ]
    then
     discrete_condition="( ) - Power OFF"
    fi
    
    gxmessage -center \
              -buttons "_Cancel":1,"switch to _Integrated":101,"switch to _Discrete":102 \
              -wrap \
              -title "Choose Hybrid Graphic Card" \
    "Choose Hybrid Graphic Card
    =================
    Integrated: $integrated_condition : $name_integrated
    Discrete: $discrete_condition : $name_discrete"
    
    
    whichCard=$?
    
    case "$whichCard" in
    
    1)
     echo "Exit"
    ;;
    101)
     if [ "$integrated" == ":+:Pwr:" ] && [ "$discrete" == ": :Pwr:" ]
     then
      notify-send -t 5000 --icon="/usr/share/icons/hardware_down.png" "switching to $name_integrated"
      echo OFF > /sys/kernel/debug/vgaswitcheroo/switch
     elif [ "$integrated" == ": :Pwr:" ] && [ "$discrete" == ":+:Pwr:" ]
     then
      notify-send -t 5000 --icon="/usr/share/icons/hardware_down.png" "switching to $name_integrated"
      echo DIGD > /sys/kernel/debug/vgaswitcheroo/switch
      if [ "$DESKTOP_SESSION" = "openbox" ]
      then
       killall -u "$USER"
      elif [ "$DESKTOP_SESSION" = "gnome" ]
      then
       gnome-session-save --logout
      fi
     elif [ "$integrated" == ": :Off:" ] && [ "$discrete" == ":+:Pwr:" ]
     then
      notify-send -t 5000 --icon="/usr/share/icons/hardware_down.png" "switching to $name_integrated"
      echo ON > /sys/kernel/debug/vgaswitcheroo/switch
      echo DIGD > /sys/kernel/debug/vgaswitcheroo/switch
      if [ "$DESKTOP_SESSION" = "openbox" ]
      then
       killall -u "$USER"
      elif [ "$DESKTOP_SESSION" = "gnome" ]
      then
       gnome-session-save --logout
      fi
     elif [ "$integrated" == ":+:Pwr:" ] && [ "$discrete" == ": :Off:" ]
     then
      notify-send -t 5000 --icon="/usr/share/icons/hardware_down.png" "already switched to $name_integrated"  
     fi
    ;;
    102)
     if [ "$integrated" == ":+:Pwr:" ] && [ "$discrete" == ": :Pwr:" ]
     then
      notify-send -t 5000 --icon="/usr/share/icons/hardware_up.png" "switching to $name_discrete"
      echo DDIS > /sys/kernel/debug/vgaswitcheroo/switch
      if [ "$DESKTOP_SESSION" = "openbox" ]
      then
       killall -u "$USER"
      elif [ "$DESKTOP_SESSION" = "gnome" ]
      then
       gnome-session-save --logout
      fi
     elif [ "$integrated" == ": :Pwr:" ] && [ "$discrete" == ":+:Pwr:" ]
     then
      notify-send -t 5000 --icon="/usr/share/icons/hardware_up.png" "switching to $name_discrete"
      echo OFF > /sys/kernel/debug/vgaswitcheroo/switch
     elif [ "$integrated" == ":+:Pwr:" ] && [ "$discrete" == ": :Off:" ]
     then
      notify-send -t 5000 --icon="/usr/share/icons/hardware_up.png" "switching to $name_discrete"  
      echo ON > /sys/kernel/debug/vgaswitcheroo/switch
      echo DDIS > /sys/kernel/debug/vgaswitcheroo/switch
      if [ "$DESKTOP_SESSION" = "openbox" ]
      then
       killall -u "$USER"
      elif [ "$DESKTOP_SESSION" = "gnome" ]
      then
       gnome-session-save --logout
      fi
     elif [ "$integrated" == ": :Off:" ] && [ "$discrete" == ":+:Pwr:" ]
     then
      notify-send -t 5000 --icon="/usr/share/icons/hardware_up.png" "already switched to $name_discrete"  
     fi
    ;;
    esac
    Salvare e chiudere il file.

Scorciatoia da tastiera

È possibile assegnare allo script una scorciatoia da tastiera. In tal caso sarà necessario rinominarlo con i privilegi di amministrazione in switch_between_cards senza estensione .sh.

  1. Digitare in una in una finestra di terminale:

    sudo mv /usr/bin/switch_between_cards.sh  /usr/bin/switch_between_cards
  2. Rendere il file eseguibile digitando:

    sudo chmod +x /usr/bin/switch_between_cards
  3. Selezionare il menù Applicazioni → Personalizzazione → Tastiera → Scorciatoie. Fcendo clic sul pulsante + è possibile assegnare una combinazione di tasti a piacere come: Super + G oppure Ctrl + Alt + G ecc.. come comando bisgonerà inserire:

    gksudo switch_between_cards

Verifiche

  1. Per verificare che lo script funzioni, digitare in una finestra di terminale:

    sudo switch_between_cards
  2. Nel caso sia stata scelta una scorciatoia da tastiera, digitare la combinazione di tasti definita per lo script e vedere se si avvia.

Script per l'utilizzo durante l'avvio di sistema

Lo switch delle schede potrebbe essere opportuno durante l'avvio del sistema, ad esempio per abilitare l'uscita per la GPU che Linux utilizza per interrogare le password per decifrare il volume di root (e altri messaggi di avvio) oppure per disattivare una delle schede durante l'avvio per risparmiare la batteria.

Attualmente non ci sono opzioni del kernel per controllare il meccanismo vga_switcheroo, ma è comunque possibile creare uno script initramfs per ottenere il medesimo risultato.

  1. Creare lo script digitando in un terminale:

    sudo touch /etc/initramfs-tools/scripts/local-top/hybrid_boot_options
  2. Aprire con i privilegi di amministrazione e con un editor di testo il file /etc/initramfs-tools/scripts/local-top/hybrid_boot_options e inserire al suo interno:

    #
    # Standard initramfs preamble
    #
    prereqs()
    {
    :
    }
    
    case $1 in
    prereqs)
            prereqs
            exit 0
            ;;
    esac
    
    # source for log_*_msg() functions, see LP: #272301
    . /scripts/functions
    
    #
    # Helper functions
    #
    message()
    {
            if [ -x /bin/plymouth ] && plymouth --ping; then
                    plymouth message --text="$@"
            elif [ -p /dev/.initramfs/usplash_outfifo ] && [ -x /sbin/usplash_write ]; then
                    usplash_write "TEXT-URGENT $@"
            else
                    echo "$@" >&2
            fi
            return 0
    }
    
    run_switcheroo()
    {
            local hybridopts
            hybridopts="$1"
    
            if [ -z "$hybridopts" ]; then
                    return 1
            fi
    
            local IFS=" ,"
            for x in $hybridopts; do
                    message "Switching hybrid graphics to $x"
                    echo $x > /sys/kernel/debug/vgaswitcheroo/switch
            done
            return 0
    }
    
    #
    # Begin real processing
    #
    
    # Do we have any kernel boot arguments?
    for opt in $(cat /proc/cmdline); do
            case $opt in
            hybridopts=*)
                    run_switcheroo "${opt#hybridopts=}"
                    ;;
            esac
    done
    
    exit 0
  3. Rendere lo script eseguibile digitando:

    chmod +x /etc/initramfs-tools/scripts/local-top/hybrid_boot_options
  4. Creare nuovi file initramfs con initramfs-tools digitando:

    initramfs-tools -c -k all
  5. Se il comando initramfs-tools non funziona, digitare:

    update-initramfs -c -k all

Opzioni di avvio

A questo punto è possibile aggiungere le opzioni di avvio del kernel nel file /etc/default/grub. Ad esempio aprendo con i privilegi di amministrazione e con un editor di testo il file /etc/default/grub, inserendo al suo interno la riga:

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash modeset=1 hybridopts=ON,IGD,OFF"

vengono abilitate entrambe le GPU, viene effettuato lo switch sulla GPU integrata e in fine viene spenta la GPU dedicata.

Per rendere effettive le opzioni applicate a Grub sarà necessario il comando:

sudo update-grub 

Per testare le opzioni durante l'avvio, premere il tasto E in Grub e all'opzione "hybridopts= " dopo il simbolo = inserire/rimuovere i comandi separati dalla virgola.

Risoluzione problemi

Ventole che girano alla massima velocità

Come spiegato al seguente indirizzo è possibile allo spegnimento del sistema incorrere nel problema in cui le ventole gireranno alla velocità massima se entrambe le schede non sono accese.

Per ovviare al problema, prima di spegnere il sistema è sufficiente digitare in un terminale:

echo ON > /sys/kernel/debug/vgaswitcheroo/switch

Luminosità

La luminosità dello schermo del portatile all'avvio potrebbe essere molto bassa. Se si dispone di uno schermo quasi nero durante l'avvio, dovrebbe essere sufficiente premere la scorciatoia da tastiera relativa all'aumento della luminosità del proprio portatile.

GPU predefinita

La GPU abilitata dal BIOS durante l'avvio può dipendere dal fatto che il portatile sia collegato o meno alla rete elettrica.

Console FB

Attraverso il parametro fbcon è possibile selezionare quale dispositivo far utilizzare al kernel per la fase di avvio della console. Ad esempio può essere utilizzato:

"fbcon = map: 1"

per /dev/fb1.

In alternativa, se si vuole tenere una GPU disabilitata in ogni momento, è possibile mettere in blacklist i driver pertinenti, aggiornare initramfs e quindi disfarsi di uno dei dispositivi di fb.

Ulteriori risorse


CategoryHardware CategoryDaRevisionare