Article: ATI driver with atiupgrade (new version)

atiupgrade is a script which downloads, builds and installs the latest available ATI proprietary driver. This article describes all the steps performed by atiupgrade. It intends to serve as a reference and answer questions often asked in the atiupgrade thread in the Programming/Scripting forum. Don’t worry if you don’t understand some of the details. Using atiupgrade is quite simple and straighforward: you just type “atiupgrade” and reboot (or exit and restart X).

Why atiupgrade?

I started atiupgrade a while ago to apply a patch to the kernel source (that was bad), then to the driver source (that was better), since the fglrx module didn’t compile after a kernel update. That only lasted a short time.

Later I started developing a script to automate the driver installation following the method commonly known as “the hard way”. There wasn’t an unofficial repo with the latest driver at that time. If there had been, I wouldn’t have spent time writing a script and would just have used that repo. The reason why I didn’t use the “official” ATI repo is that the drivers in this repo were not up to date and - although they mostly worked - often printed an awkward watermark entitled " AMD - UNSUPPORTED HARDWARE " on the desktop. We later found how to remove this watermark and put it in a short script. (ATI RadeonHD 6310M - OpenSuse 11.4 ( Asus K43U Seris Laptop )) Today the ATI official repo is not used anymore. AFAIK there isn’t any for 12.1.

I was asked why I would keep maintaining atiupgrade since a repo providing the latest drivers had been created. Well … the answer is that atiupgrade is easier, faster, performs some additionnal checks before, can fix installation bugs afterwards, provides more features (can be used to upgrade as well as downgrade the driver), is not bound to a specific release of openSUSE, and is able to package the driver on tumbleweed or beta versions*, and before a package will be available in any repo.

  • Notice that it doesn’t work on openSUSE 12.2 Milestone 3 yet. But it is not because of atiupgrade. The script would work, but the ATI installer fails to build the package. Do not try to install the ATI proprietary driver on openSUSE 12.2 M3 today (April 2012) , using atiupgrade or another method.

Installation.

atiupgrade is available as a rpm package in my repo for openSUSE 11.4 and 12.1. It will be available for future releases as well. Tumbleweed users may install it from any repo. The package has no dependencies and contains only a single script, which is identical for all versions.

To install atiupgrade from repo, open a terminal and type the following commands:


su -l
zypper ar [noparse]http://download.opensuse.org/repositories/home:/please_try_again/openSUSE_12.2/[/noparse]  PTA
zypper --gpg-auto-import-keys refresh -r PTA
zypper -n in atiupgrade

view screenshot

Installing from repo is convenient because it ensures that you get the latest version and receive further updates. But you can also download the scipt from this page - or copy/paste the code from this article -, save it in /usr/bin or /usr/local/bin as the file “atiupgrade” and make it executable:


su -l
cd /usr/bin
wget [noparse]http://www.unixversal.com/linux/openSUSE/atiupgrade[/noparse]
chmod 755 atiupgrade

view screenshot

If you don’t know which method is better, install from repo.

code

Here’s version 5.3 (from November 6 2012):


#! /bin/bash
#: Title       : atiupgrade
#: Date Created: Fri Oct 29 20:02:40 PST 2010
#: Last Edit   : Tue Nov  6 14:11:45 PST 2012
#: Author      : Agnelo de la Crotche (please_try_again)
#: Version     : 5.3
#: Description : install or upgrade the latest ATI proprietary driver
#
# --------------------------------------------------------------
# What This script does the following :
#  (1) checks the model of your ATI card
#  (2) gets latest Catalyst version number
#  (3) installs required packages
#  (4) creates /usr/share/atiupgrade
#  (5) downloads latest ATI Catalyst installer
#  (6) looks for existing fglrx package 
#  (7) builds rpm
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#  (!) exit if X is fglrx is running in case we need to uninstall (not update) 
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#  (8) unloads fglrx module if needed
#  (9) uninstalls any previously installed fglrx driver:
#      . from earlier rpm package ( fglrx-xxxx.rpm)
#      . from repo (x11-video-fglrxG02 )
#      . from the ATI run file (with /usr/share/ati/fglrx-unistall.sh)
#
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# (10) installs the fglrx package (compiling the kernel module)
# (11) runs aticonfig --initial if needed
#
# --------------------------------------------------------------
# as always ... you're using it at your own risk.
# ChangeLog
# * Tue Nov  6 14:11:45 PST 2012
# - fixed ati installer name for Catalyst 12.10 
# * Wed Sep 19 15:41:17 PDT 2012
# - fixed rpm build under 12.2
# * Mon Sep 10 13:11:55 PDT 2012
# - fixed legaycy driver download url
# * Sat Sep  8 12:00:34 PDT 2012
# - install driver directly under 12.2 (workaround)
# * Sun Jul 22 14:55:18 PDT 2012
# - print currently installed Catalyst version
# * Fri Jul  6 21:08:37 PDT 2012
# - added support for new Radeon HD 2000/3000/4000 legacy driver
# * Thu Apr 26 21:19:25 PDT 2012
# - set defaut to Catalyst 12.4
# * Sun Apr 22 17:30:02 PDT 2012
# - version 4.1 - added option -d to install the driver
# * Thu Apr 12 08:59:11 PDT 2012
# - version 4.0 - first build
# --------------------------------------------------------------

# check if we are root
 $UID -eq 0 ] || exec echo "You have to run this script as root"

catalystDef="12-10"
catalystLegacyDef="12-6"
catalystLegacy="9-3"
ext='run'
LastSupportedSUSE=122
LegacyRadeonLastSupportedSUSE=121
LegacyLastSupportedSUSE=111
#atiBaseUrl="https://a248.e.akamai.net/f/674/9206/0/www2.ati.com/drivers/linux"
atiBaseUrl="http://www2.ati.com/drivers/linux"
atiLegacyBaseUrl="http://www2.ati.com/drivers/legacy"
atiDownloadUrl="http://support.amd.com/us/gpudownload/linux/Pages/radeon_linux.aspx?type"
atiLegacyDownloadUrl="http://support.amd.com/us/gpudownload/linux/legacy/Pages/legacy-radeon_linux.aspx?type"
#atiLegacyDownloadUrl="http://support.amd.com/us/kbarticles/Pages/catalyst${catalystLegacyDef/-/}legacyproducts.aspx?type"
atiUninstall=/usr/share/ati/fglrx-uninstall.sh
atiupgradeDir=/usr/share/atiupgrade
FGLRX=$atiupgradeDir/FGLRXRPM
mach=`uname -m`
arch=${mach/i[34567]86/i586}
kernel=`uname -r`
rel=${kernel%-*}
krn=${kernel##*-}
i686=IA32
x86_64=AMD64
BUILDPKG=yes
UPDATE=yes
RPMBUILD_PKG="rpm-build"
FORCE=""
RED=$(tput bold)$(tput setaf 1)
BLD=$(tput bold)$(tput setaf 2)
BLU=$(tput bold)$(tput setaf 4)
SGR=$(tput sgr0) 
PRG=$(basename $0)
declare -l yesno

# use lsb_release to get openSUSE version
which lsb_release >/dev/null 2>&1 || zypper -n in lsb-release

function msgExit {
if  -f "$fglrxrpm" ] ; then
cat << EOF_SUCCESS_MSG

  _____________________________________________________________
  | The driver has be successfully compiled and the  package  |
  | $(tput bold)$(basename $fglrxrpm)$(tput sgr0) has been created  |
  | in the directory $atiupgradeDir.                   |
  |                                                           | 
  | Please exit X or reboot in runlevel 3 and run atiupgrade  |
  | again.                                                    | 
  _____________________________________________________________

EOF_SUCCESS_MSG
else
cat << EOF_FAIL_MSG

         $BLD$(tput setaf 1)The fglrx package failed to build.$SGR :-(

EOF_FAIL_MSG
fi
exit
}

function matchkernel {
linux="linux-$rel"
Kernel="kernel-$krn"
ksrc=$(rpm -qa kernel-source)
srel=${ksrc#kernel-source-*} ; srel=${srel%*.noarch}

if  "$ksrc" ] ; then
# kernel-source is installed and ...
	slinux=$(readlink /usr/src/linux)
	if  "$slinux" ==  "$linux" ] ; then
		# kernel-source matches kernel (nothing to do)
		printf "     * Kernel source matches installed kernel (%s%s%s)
" $BLU "$rel" $SGR 
	else
		# kernel-source doesn't matche kernel and ...
		printf "     * %sKernel source (%s%s%s) doesn't match installed kernel(%s%s%s)%s
" $RED $BLU "${slinux##linux-}" $RED $BLU "$rel" $RED $SGR 
		eval $(zypper lu | awk -F "|" '/'$Kernel'/ { gsub(/ /,"", $4) ; gsub(/ /, "", $5) ; printf "crel=%s ; urel=%s ;",  $4, $5 }')
		if  "$urel" ] ; then
			# a kernel update is available or
			printf "     * %sand a new kernel (%s%s%s) is available.%s
" $RED $BLU "$urel" $RED $SGR 
			UPDKERNEL=yes
		elif ( zypper lu | grep -q 'kernel-source'); then
			# a kernel source update is available or
			printf "     * %sand a kernel source update is available.%s
" $RED $SGR 
		else
			# no update is available but /usr/src/linux doesn't point to the source of the installed kernel (re-symlinking)			
 			for slinux in $(find /usr/src . -maxdepth 1 -type d ! -type l -name "linux*" ! -name "*-obj" -exec basename "{}" ";") ; do
				if  "$slinux" ==  "$linux" ] ; then
					printf "     * symlinking /usr/src/linux to %s%s%s
" $BLU $slinux $SGR 
					ln -sfn $slinux /usr/src/linux
					break
				fi
			done
		fi
	fi 
else
# kernel-source is not installed and ...
	eval $(zypper lu | awk -F "|" '/'$Kernel'/ { gsub(/ /,"", $4) ; gsub(/ /, "", $5) ; printf "crel=%s ; urel=%s ;",  $4, $5 }')
	# a kernel update is available
	if  "$urel" ] ; then
		printf "     * %sKernel source is not installed and a new kernel (%s%s%s) is available.%s
" $RED $BLU "$urel" $RED $SGR 
		UPDKERNEL=yes
	# no kernel update is available (nothing to do. We can install the kernel-source later in the script.)	
	else
		printf "     * Kernel source will be installed...
" 
	fi
fi

if  "$UPDKERNEL" ] ; then
		printf "     * %sYou should update the kernel an reboot, then run %s again.%s
" $RED $PRG $SGR 
		yesno=""
		while  "true" ] ; do
			printf "       Do you want to update the kernel now? [yn] "  
			read -n1 yesno
			printf "
"
			 "$yesno" == "y" -o "$yesno" == "n" ] && break
		done
		if  "$yesno" == "y" ] ; then
			zypper refresh
			zypper -n update $Kernel && exec printf  "     * %sThe kernel has been updated. Please reboot now and run %s again.%s
" $RED $PRG $SGR 
		fi
fi

}

function enableKMS {
grep -q '^NO_KMS_IN_INITRD=\"yes\"' /etc/sysconfig/kernel && SETKMS=yes
grep -q '^KMS_IN_INITRD=\"no\"' /etc/sysconfig/kernel && SETKMS=yes
 "x$SETKMS" == "xyes" ] || return
printf "     * Enabling KMS in /etc/sysconfig/kernel...
"
sed -i 's/^NO_KMS_IN_INITRD.*/NO_KMS_IN_INITRD="no"/g;s/^KMS_IN_INITRD.*/KMS_IN_INITRD="no"/g' /etc/sysconfig/kernel
printf "     * Rebuilding initrd...
"
mkinitrd
}


if  "$1" == "-d" -o "$1" == "--deinstall" ] ; then
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# Deinstalling fglrx
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# 1) Deinstalling fglrx package
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
printf "%s (1) - Deinstalling fglrx package ...%s
" $BLD $SGR
printf "     * Querying rpm database... Please wait...
"
fglrxrpm=$(rpm -qa | grep "fglrx.*SUSE")

if  "$fglrxrpm" ] ; then
	fglrx=${fglrxrpm%%-*}
	zypper rm $fglrx
	rpm -qa | grep -q "$fglrx" && exit
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# 2) Re-enabling Kernel Mode Setting
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
	printf "%s (2) - Re-enabling Kernel Mode Setting ...%s
" $BLD $SGR
	yesno=""
	while  "true" ] ; do
		printf "     Do you want to enable KMS in initrd? [yn] "  
		read -n1 yesno
		printf "
"
		 "$yesno" == "y" -o "$yesno" == "n" ] && break
	done
	 "$yesno" == "y" ] && enableKMS

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# 3) Restoring original Xorg configuration
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
	printf "%s (3) - Restoring original Xorg configuration ...%s
" $BLD $SGR
	if  -f /etc/X11/xorg.conf ] ; then
		grep -q fglrx /etc/X11/xorg.conf && mv /etc/X11/xorg.conf{,.fglrx}	
	fi
	echo $RED ; zypper ps ; echo $SGR
else
	exec printf "%s     No fglrx package installed.%s
" $RED $SGR
fi


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
else
	
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# 1) get OS release and ATI model
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
printf "%s (1) - Analyzing system...%s
" $BLD $SGR

Ver=$(lsb_release -s -r | tr -d ".")
 $Ver -le 121 ] && RPMBUILD_PKG=rpm

# ~~~~ 12.2 workaround - BEGIN ~ hope we can't remove that soo ~~~~~~~~~~
# ! packaging the driver doesn't work under 12.2. SO we won't do it
# !! fixed after installing rpmbuild - which wasn't installed under 12.2 !!
#  $Ver -ge 122 ] && BUILDPKG=no
# ~~~~ 12.2 workaround - END ~ hope we can't remove that soo ~~~~~~~~~~~~

 $Ver -gt $LastSupportedSUSE ] && UPDATE=no
rpm -qa | grep -q x11-video-fglrxG02 && UPDATE=no
 -x "$atiUninstall" ] && UPDATE=no
catalystInstalledVer=0
if  -f "/etc/ati/amdpcsdb.default" ] ; then
	catalystInstalledVer=$(sed -n 's/Catalyst_Version=^0-9]*//p' /etc/ati/amdpcsdb.default) 
	 "$catalystInstalledVer" ] || ReleaseVersion=$(sed -n 's/ReleaseVersion=^0-9]*//p' /etc/ati/amdpcsdb.default) 
	isATI=yes
fi

rpm -qa | grep -q fglrx && isATI=yes
lsmod | grep -q fglrx && isATI=yes
 "x$NOSYSCHECK" == "xyes" ] && isATI=yes

ati_legacy="9500 9550 9600 9700 9800 X300 X550 X600 X700 X800 X850 X1050 X1300 X1550 X1600 X1650 X1800 X1900 Xpress X1200 X1250 X2100"
ati_model="$(lspci | sed -n '/VGA/s/.*Radeon *//ip' | sed 's/Mobility *//i;s/ *Series//i;s/]//g' )"
which aticonfig &>/dev/null && ati_radeon=$(aticonfig --query-monitor | sed -n 's/Default Adapter - *//p')
ati_model=${ati_model:-$ati_radeon}
which fglrxinfo &>/dev/null && ati_radeon=$(fglrxinfo 2>/dev/null | awk -F ":" '/renderer string/ { sub(/^ /,"", $2) ;  print $2 }')
ati_model=${ati_model:-$ati_radeon}


if  "x$isATI" == "xyes" ] ; then
	 $Ver -gt $LastSupportedSUSE ] && Ver=$LastSupportedSUSE
	printf "     * Found ATI graphics card: %s%s%s
" $BLU "$ati_model" $SGR
else
	if  "x$ati_model" == "x" ] ; then
		yesno=""
		while  "true" ] ; do
			printf "       ATI graphic card detection failed. Is your ATI card a HD Radeon >= 5000 [yn] "
			read -n1 yesno
			printf "
"
			 "$yesno" == "y" -o "$yesno" == "n" ] && break
		done
		if  "$yesno" == "y" ] ; then
			ati_oldradeon="no"
			ati_model="HD > 5000x"
		else
			yesno=""
			while  "true" ] ; do
				printf "       Is your ATI card a HD Radeon 2000x, 3000x or 4000x? [yn] "
				read -n1 yesno
				printf "
"
				 "$yesno" == "y" -o "$yesno" == "n" ] && break
			done
			if  "$yesno" == "y" ] ; then
				ati_oldradeon="yes"
				ati_model="HD > 2000x"
			else
				while  "true" ] ; do
					printf "       No ATI graphic card detected. Do you want to continue? [yn] "  
					read -n1 yesno
					printf "
"
					 "$yesno" == "y" -o "$yesno" == "n" ] && break
				done
				 "$yesno" == "n" ] && exit
				NOATI="yes"
				while  "true" ] ; do
					printf "       Which ATI driver do you wamt to build? Legacy (1) or current (2) ? [12] "  
					read -n1 yesno
					printf "
"
					 "$yesno" == "1" -o "$yesno" == "2" ] && break
					printf "       Please type %s1%s for legacy or %s2%s for current.%s
" $(tput bold) $SGR $(tput bold) $SGR 
				done	
				case  $yesno in
					1) ati_model="HD > 2000x" ;;
					2) ati_model="HD > 5000x" ;;
				esac

			fi
		fi
	fi

	ati_model=${ati_model#Radeon *}
	model=${ati_model%% *}

	if  "${ati_legacy#*$model}" == "${ati_legacy}" ] ; then
		 $Ver -gt $LastSupportedSUSE ] && Ver=$LastSupportedSUSE
		 "$NOATI" ] || printf "     * Found ATI graphics card: %s%s%s
" $BLU "$ati_model" $SGR
	else
		catalystDef="$catalystLegacy"
		 $Ver -gt $LegacyLastSupportedSUSE ] && exec printf "
ATI Legacy card (%s) detected.
Thes legacy fglrx driver (%s) is incompatible with this openSUSE version. Script aborted.
" "$ati_model" $catalystLegacy 
		Ver=$LegacyLastSupportedSUSE
	fi
fi

ati_serie=$(( $(echo $ati_model | sed 's|HD >]*\([1-9]\).*|\1|') * 1))
 $ati_serie -lt 5 ] && ati_oldradeon="yes" || ati_oldradeon="no"

cver="${1:-$catalystDef}" ; cver=${cver/.} ; cver=${cver/-} ; cver=$(($cver * 1))
 $cver -le 124 ] && ati_oldradeon="no" 

if  "x$ati_oldradeon" == "xyes" ]; then
	catalystDef="$catalystLegacyDef"
	Ver=$LegacyRadeonLastSupportedSUSE
fi

catalystVer="${1:-$catalystDef}"
catalystVer=${catalystVer/./-}

if  "x$ati_oldradeon" == "xyes" ] ; then
	atiDownloadUrl="$atiLegacyDownloadUrl"
	atiBaseUrl="$atiLegacyBaseUrl/${catalystVer/./-}"
fi

SUSEVer=SUSE$Ver
buildOption="SuSE/$SUSEVer-${!mach}"

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# 2) getting latest Catalyst version number
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  

# find out latest Catalyst version
which curl &>/dev/null && catalystLast=$(curl -s $atiDownloadUrl | sed -n 's/^.*\(a[tm][id]-*driver-installer^"]*\)">.*/\1/p' | grep -v beta)

 "$catalystLast" ] && catalystLastVer=$(echo $catalystLast | sed 's/a[tm][id]-*driver-installer-[a-z-]*\([0-9]*\)\.-]\([0-9]*\)-.*/\1-\2/') || catalystLastVer=$catalystDef

# take version given as argument 
if  "$1" ]; then
	catalystLastVer=${catalystVer}
	latest="This"
else
	latest=" Latest "
	atiDownloadFile=$catalystLast
fi

Cdef=${catalystDef/-/}     ;  ${#Cdef} -eq 3 ] && Cdef=${Cdef:0:2}0${Cdef:2}
Clst=${catalystLastVer/-/} ;  ${#Clst} -eq 3 ] && Clst=${Clst:0:2}0${Clst:2}
Clst=$(($Clst * 1))
 $Clst -eq 0 ] && exec printf "\033[31;1m     ! Catalyst version nummer is zero. Most likely the installer has changed name again :-(%s
" $SGR
[ "$latest" == " Latest" ] &&  $Cdef -gt $Clst ] && catalystLastVer=$catalystDef 

if  "x$ati_oldradeon" == "xyes" ] ; then
	ext='zip'
	catalystLastVer=${catalystLastVer/-/.}
	atiBaseFile=amd-driver-installer-$catalystLastVer-legacy-x86.x86_64.run
	FORCE="--force"
else
	if  "$latest" == "This" ]; then
		atiDownloadFile=ati-driver-installer-$catalystLastVer-x86.x86_64.run
		 $Clst -ge 1208 ] && atiDownloadFile="amd-driver-installer-$catalystLastVer-x86.x86_64.zip"
		 $Clst -ge 1210 ] && atiDownloadFile="amd-driver-installer-catalyst-${catalystLastVer/-/.}-x86.x86_64.zip"
	fi
fi

atiBaseFile=${atiDownloadFile/.zip/.run}
catalystInstalledVer=${catalystInstalledVer:-0}
catalystLastVer=${catalystLastVer/-/.}

if  "$catalystInstalledVer" ] ; then
	if  "$catalystInstalledVer" == "0" ] ; then
		 "$ReleaseVersion" ] && printf "     * Found fglrx: %s%s%s
" $BLU "${ReleaseVersion%%-*}" $SGR
	else
		printf "     * Found: Catalyst %s%s%s
" $BLU "$catalystInstalledVer" $SGR
	fi
fi

printf "%s (2) - Getting latest (or specified) Catalyst version: " $BLD
printf "%s%s%s" $BLU $catalystLastVer $SGR

if  "x$catalystLastVer" == "x$catalystInstalledVer" ] ; then
	yesno=""
	while  "true" ] ; do
		printf "
     *%sCatalyst version (%s%s%s) already installed. Do you want to continue? [yn] " "$latest" $BLU $catalystInstalledVer $SGR
		read -n1 yesno
		printf "
"
		 "$yesno" == "y" -o "$yesno" == "n" ] && break
	done
	 "$yesno" == "n" ] && echo && exit
elif  $((${catalystInstalledVer/./}*1)) -gt $((${catalystLastVer/./}*1)) ] ; then
	printf "
" 
	FORCE="--force"	
elif  "$ReleaseVersion" ] ; then
	# had to do that in order to be able to downgrade. Could be more precise but ...
	printf "
" 
	FORCE="--force"
else
	printf "
" 
fi

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# 3) installing required packages
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
printf "%s (3) - Installing required packages...%s
" $BLD $SGR

matchkernel

# install kernel headers and sources if not present
PKG2INSTALL=""
for pkg in kernel-source kernel-$krn-devel kernel-syms gcc make ${RPMBUILD_PKG} ; do
	zypper se --match-exact -i $pkg | grep -q $pkg && echo "     * $pkg is already installed" || PKG2INSTALL="$PKG2INSTALL $pkg"
done
 "$PKG2INSTALL" ] && zypper -n in $PKG2INSTALL


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# 4) creating /usr/share/atiupgrade
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
if  -d "$atiupgradeDir" ] ; then
	printf "%s (4) - %s directory exists...%s
" $BLD $atiupgradeDir $SGR
else
	printf "%s (4) - Creating %s directory...%s
" $BLD $atiupgradeDir $SGR
	mkdir $atiupgradeDir
fi

cd $atiupgradeDir
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# 5) getting the ATI installer 
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# if installer found, skip downloading

AtiInstall=$atiupgradeDir/$atiDownloadFile

if  -f $AtiInstall ] ; then
	printf "%s (5) - ATI installer %s%s%s found...%s
" $BLD $BLU $atiDownloadFile $BLD $SGR

else
	printf "%s (5) - Downloading the ATI installer %s%s%s ...%s
" $BLD $BLU $atiDownloadFile $BLD $SGR

	# make sure wget is installed
	which wget > /dev/null 2>&1 || zypper in wget

	# get the ATI installer for your architecture (i686 or x86_64)
	printf "     * Connecting... Please wait...
"
	
	wget $atiBaseUrl/$atiDownloadFile
	
	if  "x$ati_oldradeon" == "xyes" ] ; then
		# force installation for now because the package has lower version number than the one from previous Catalyst.
		FORCE="--force"	
	fi
fi

if ( file $AtiInstall | grep -q Zip ) ; then
	which unzip > /dev/null 2>&1 || zypper in unzip
	AtiInstall=$atiupgradeDir/$(unzip -l $atiDownloadFile | awk '/.run/ { print $NF}')
	 -f $AtiInstall ] || unzip $atiDownloadFile 
fi

if  -f "$AtiInstall" ] ; then
	fglrxver=$(strings $AtiInstall | sed -n 's|.*Driver-\([0-9.]*\)"|\1-1|p' | sed 's|\([0-9]\{1,\}\.[0-9]\{2\}\)-1$|\10-1|')
else
	exec printf "     %s* ATI installer %s%s%s not found. Script aborted.%s
" $RED $BLU $atiBaseFile $RED $SGR
fi

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# 6) Looking for existing rpm package 
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  

# ~~~~ 12.2 workaround - BEGIN ~ hope we can't remove that soo ~~~~~~~~~~
if  "$BUILDPKG" == "no" ] ; then
	if  -f $AtiInstall ] ; then

		cat << EOFWA
$RED
  !! The AMD installer was unable to create the fglrx package.  This is not !! 
  !! a bug in atiupgrade.  However the AMD installer for your graphics card !! 
  !! has been succesfully downloaded, and atiupgrade can run it if you wish !!
  !! to install Catalyst  $BLU$catalystLastVer$RED.  This will be the same procedure as running !!
  !! the installer manually ('the hard way'). This is not optimal, and this !!
  !! bug will also break  other atiupgrade functionalities.  But there is a !! 
  !! good chance that the driver will work for you.  Please select "Install !!
  !! Driver..."  in AMD Catalyst(TM) setup and  NOT  "Generate Distribution !!
  !! Specific Driver Package".                                              !!$SGR
EOFWA
	declare -l yesno
	while  "$yesno" != "y" -a "$yesno" != "n" ] ; do
		printf "
    Do you want to run %s%s? [y,n]%s " $BLU $(basename $AtiInstall) $SGR  
		read -N 1 yesno
		 "$yesno" == "n" ] && echo && exit
		 "$yesno" == "y" ] && exec sh $AtiInstall
		printf "
    Please answer with n or y." 
	done
	fi
exit
fi
# ~~~~ 12.2 workaround - END ~ hope we can't remove that soo ~~~~~~~~~~~~

# if fglrx package found, skip bulding

if  -f "$FGLRX" ] ; then 
	fglrxrpm=$(cat $FGLRX)
elif   "$fglrxver" ] ; then
	fglrxrpm=$(find $atiupgradeDir -type f -name "fglrx*rpm" | grep "$fglrxver")
	if  "$fglrxrpm" == "${fglrxrpm%%$arch*}" ] ; then
		unset fglrxrpm 
	else
		echo $fglrxrpm > $FGLRX
	fi
fi
	
printf "%s (6) - Looking for rpm package of fglrx %s%s%s...%s" $BLD $BLU "$fglrxver" $BLD $SGR

if  "$fglrxrpm" ] ; then
	if  -f "$fglrxrpm" ] ; then
		FGLRXRPM=$(basename $fglrxrpm)
		BUILDPKG=no
		printf "
     * found %s%s%s
" $BLU "$FGLRXRPM" $SGR
	else
		printf "
"	
	fi
else
	printf "%s not found.%s
" $BLD $SGR
fi


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# 7) Building rpm package 
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
if  "$BUILDPKG" == "yes" ] ; then
	printf "%s (7) - creating fglrx rpm...%s
" $BLD $SGR
	sh $AtiInstall --buildpkg $buildOption  
	fglrxrpm=$(find $atiupgradeDir -type f -name "fglrx*rpm" | grep $fglrxver)
	 -f "$fglrxrpm" ] && echo $fglrxrpm > $FGLRX || exec  printf "     %s* package %s%s%s not found. Script aborted.%s
" $RED $BLUE $fglrxrpm $RED $SGR
else
	printf "%s (7) - skipping package building...%s
" $BLD $SGR
fi

NR=8

#**************************************************************************
# deinstalling a previous 
#**************************************************************************
if  "$UPDATE" == "no" ] ; then
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# Abort script here if run in X
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# don't run in X if fglrx is loaded (but run in SSH sessions) 

ps ax | grep -v grep | grep -q 'X ' && XRUN=1
ps ax | grep -v grep | grep -q -i 'xorg ' && XRUN=1

 "$XRUN" ] && lsmod | grep -q fglrx && msgExit

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# 8) Aborting script if the fglrx module cannot be unloaded
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
printf "%s (8) - unloading kernel module...%s
" $BLD $SGR
# unload fglrx 
lsmod | grep -q fglrx && modprobe -r fglrx

# exit if fglrx is still loaded 
lsmod | grep -q fglrx && exec printf "     %s* fglrx is still loaded.%s
" $RED $SGR

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# 9) Uninstalling previoulsy installed fglrx 
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
printf "%s (9) - uninstalling previously installed fglrx...%s
" $BLD $SGR

# save /etc/X11/xorg.conf 
 -f "/etc/X11/xorg.conf" ] && cp /etc/X11/xorg.conf{,.pta}

# uninstall x11-video-fglrxG02 (installed from the ATI repo)
rpm -qa | grep -q x11-video-fglrxG02 && { 
	zypper rm x11-video-fglrxG02
	sed -i 's/^DISPLAYMANAGER_XSERVER=.*/DISPLAYMANAGER_XSERVER="Xorg"/' /etc/sysconfig/displaymanager
	ln -snf /usr/bin/Xorg /var/lib/X11/X
}

# uninstall ATI driver directly installed from the ati .run file
 -x "$atiUninstall" ] && $atiUninstall

# uninstall older fglrx packages
atirpm=$(rpm -qa | grep -i -E '^fglrx.*suse')

if  "$atirpm" ] ; then
	zypper rm $atirpm
	# restore previously saved xorg.conf since we're updating and not deinstalling
	 -f "/etc/X11/xorg.conf.pta" ] && cp /etc/X11/xorg.conf{.pta,}
fi
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  

NR=10
fi
#**************************************************************************



# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# 10) Installing fglrx 
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
printf "%s (%s) - installing fglrx...%s
" $BLD $NR $SGR

 -d /etc/ld.so.conf.d ] || mkdir /etc/ld.so.conf.d
function ldconfpath {
lib="lib$(uname -m | sed 's/.*86_*//')"
grep -q -R "/usr/X11R6/$lib" /etc/ld.so.conf.d/* && return
libpath="/usr/X11R6/lib"
 "$lib" == "lib64" ] && libpath="/usr/X11R6/lib64
$libpath"
printf "# created by atiupgrade - %s
# Remove this file when it's not needed anymmore
$libpath
" "$(date)" > /etc/ld.so.conf.d/ati-fglrx.conf
}

function lnglx {
lib="lib$(uname -m | sed 's/.*86_*//')"
if  ! -L "/usr/$lib/xorg/modules/updates/extensions/libglx.so" ]; then
    echo "     * Create symlink to fglrx-libglx.so"
    /usr/$lib/fglrx/switchlibglx amd 2>/dev/null
fi
if  ! -L "/usr/X11R6/$lib/libGL.so.1.2" ]; then
    echo "     * Create symlink to fglrx-libGL.so.1.2"
    /usr/$lib/fglrx/switchlibGL amd 2>/dev/null
fi
}

# install/update fglrx package 
if  -f "$fglrxrpm" ]; then
	yesno=""
	while  "true" ] ; do
		printf "       Do you want to install %s now? [yn] " $(basename $fglrxrpm)  
		read -n1 yesno
		printf "
"
		 "$yesno" == "y" -o "$yesno" == "n" ] && break
	done
	if  "$yesno" == "y" ] ; then
		# ldconfpath
		zypper in $FORCE $fglrxrpm && rm -f $FGLRX && lnglx
		echo $RED
		zypper ps
		let NR++
	else
		exit
	fi
fi

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
# 11) Running aticonfig 
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
printf "%s (%s) - Running aticonfig...%s
" $BLD $NR $SGR
 
# exit if aticonfig not found
 -x "/usr/bin/aticonfig" ] || exec echo "aticonfig not found. /etc/X11/xorg.conf not updated".

# exit if fglrx sextion found in /etc/X11/xorg.conf
/usr/bin/aticonfig --initial=check && exit

# if /etc/X11/xorg.conf exists and doesn't contain a fglrx section, rewrite it with sed
# (aticonfig changes too much thing, IMO)
if  -f "/etc/X11/xorg.conf" ] ; then
	cp /etc/X11/xorg.conf{,.radeon.pta}
	sed '/Driver/s/[Dd]river.*radeon.*/Driver    "fglrx"/' /etc/X11/xorg.conf.radeon.pta > /etc/X11/xorg.conf
	grep -q fglrx /etc/X11/xorg.conf || /usr/bin/aticonfig --initial	
	exec echo "/etc/X11/xorg.conf updated."
fi

# generate a basic dual head /etc/X11/xorg.conf if more than 1 monitor found
HWINFO=`which hwinfo 2&gt;/dev/null`
 "$HWINFO" ] &&  $($HWINFO --monitor | grep "Unique ID" | wc -l) -gt 1 ] && exec /usr/bin/aticonfig --initial=dual-head	

# otherwise generate a basic /etc/X11/xorg.conf
/usr/bin/aticonfig --initial	
exit

fi

Usage

Open a terminal and type:


su -l
atiupgrade

That’s all you have to do. Thus you don’t have to:

  • download anything
  • install or uninstall anything

atiupgrade will download the driver installation script (AMD or ATI run file) from ATI’s website and install all packages required to compile the kernel module, such as kernel source, make and gcc compiler.

kernel update

A common mistake while installing a package which needs to compile a kernel module is to install the kernel source without upgrading the kernel itself. VirtualBox users might have experienced this issue already. Since version 4.0, atiupgrade makes sure that kernel and kernel source are of the same version and also checks for available kernel and kernel source updates.
If the kernel source is not installed and a kernel update is available, atiupgrade will ask for your confirmation to update the kernel (see picture below). You should proceed and reboot once the new kernel has been installed, then run atiupgrade again. When kernel source is installed later in the script - together with other required packages - it will match the running kernel.
If the kernel source is already installed for your kernel version, it won’t be upgraded, even if an update is availalble, because it is not necessary to compile the module, and it is not the job of atiupgrade to decide if you should upgrade the kernel or not. If you later update kernel and kernel source, the fglrx kernel module will be automatically recompiled at next boot - thanks to a sysinit service installed with the package (/etc/init.d/boot.fglrxrebuild). Thus it is NOT necessary to use modautocompile for this module any longer.

view screenshot

The different steps of installing or upgrading the driver

atiupgrade performs several tasks, before downloading the installer, building the package and after installing the driver, which can be divided into 9 steps - 11 if a previous version of the driver has to be uninstalled first. It prints the number of each step to standard output and a short description of the task. Thus, if it fails to complete the whole process, it will tell you at which step it hung and you may report the problem or look for solutions in the atiupgrade thread.

(1) - analysing system

atiupgrade tries to detects your graphics card. It can only obtain the information that the graphics card gives about itself. Thus it might fail in some cases. This system check can produce different results:

  • Non-ATI graphic card detected.
    In this case, the script will ask if you want to continue. You may proceed if you know that you have a supported ATI graphics card. You may also proceed if you don’t have an ATI card but just want to build the fglrx package (for example to install it later on an ATI system). Otherwise or if you are unsure, say “no” to abort the script.

  • ATI Legacy card detected.
    Legacy cards are older models which are not supported by ATI any more. If you happen to have one of those, you should not try to install nor use the fglrx driver: it won’t work. atiupgrade will abort if it detects a legacy card. Again the test is as reliable as the info given by the card. If you are sure that your graphics card is supported, you may skip the system check by running atiupgrade with this command:

env NOSYSCHECK=yes atiupgrade

It is assumed that you know what you are doing!
If atiupgrade sees your graphics card as a legacy one when it is not, please post the output of this command in the atiupgrade thread, so that I can fix it or make a workaround:

lspci | grep -i vga
  • Found ATI graphics card.
    This is the expected result in the most common case. The script will print the model of the graphics card.

**(2) - get latest (or specified) catalyst version: **

atiupgrade queries the ATI website to find out the latest available Catalyst version. It it fails (for example if the website is offline or the script is unable to parse this information), it will default to the value defined in the script (in the variable catalysDef). This is the main reason why I update atiupgrade whenever a new Catalyst version is released, so that it will default to the latest version if it fails to read it from the website. You can also specify a version as argument if you know it is the latest one and the script didn’t get it or if you want to downgrade the driver. As of the this writing, these two commands are equivalent and install Catalyst 12.3:

atiupgrade
atiupgrade 12-3

To downgrade the driver to version 12.2, you would type:

atiupgrade 12-2

(3) - Installing required packages.

atiupgrade installs everything it needs to build the kernel module. This include the packages kernel-source, kernel-devel, kernel-syms, gcc and make. Packages that are already installed will be skipped - meaning atiupgrade won’t try to reinstall or update them.

At this point, if the kernel-source is not installed, before installing it, the script will offer to update the kernel if a newer version is available. Otherwise the version of the kernel-source will not match the version of the installed kernel. Upgrading to the latest kernel ensures that the kernel-source will have the correct version. After the kernel has been updated, you should reboot and run atiupgrade again to proceed.

(4) - creating /usr/share/atiupgrade directory.

atiupgrade creates the directory /usr/share/atiupgrade to store the ATI run file and fglrx package if this directory doesn’t already exist.

(5) - Downloading the ATI installer.

atiupgrade downloads the ATI installer and saves it in the directory /usr/share/atiupgrade. If the installer is already there, it won’t be downloaded again. If it fails to download the installer, the script will abort with an error message. It is advisable to keep older versions of the installer in /usr/share/atiupgrade in order to be able to rebuild an older package in case you need it. If you can’t download the installer from ATI’s site but get it from somewhere else, copy the file in /usr/share/atiupgrade and run atiupgrade again.

(6) - Looking for existing rpm package

atiupgrade checks whether a rpm package of the driver to be installed already exists in /usr/share/atiupgrade. If this package is found, it won’t build it again.

(7) - creating fglrx rpm

atiupgrade executes the ati/amd installer, which builds the fglrx rpm package for the openSUSE version on which it is run or for the last supported openSUSE version (specified in the variable LastSupportedSUSE in the script). Both the installer (the ati/amd .run file) and the resulting package are stored in the directory /usr/share/atiupgrade. You may keep this package for further installing/reinstalling on the same or another ATI based machine (see next step).

**(8) - installing fglrx. **

atiupgrade asks if you want install the fglrx package. If you were just building the package but don’t intend to install it on this system, you may say no here.

Notice that compiling the kernel module occures at installation time, not at package build time! Thus, if you want to install the fglrx package using zypper on another machine, you need to make sure that the required packages - kernel source and compiler - are installed.

(9) - running aticonfig

Athough It is not necessary to run aticonfig anymore - since the post-install script of the fglrx package takes care of that - it doesn’t hurt to double check if a fglrx section is present in xorg.conf.

Deinstalling the driver

Since it is installed as a package, the fglrx driver can be removed like any other rpm with zypper remove. atiupgrade since version 4.1 provides an option to uninstall the driver. Notice that it can only deinstall fglrx if it was installed with atiupgrade or from a fglrx package created following the “hardway method” (provided you chose to build a rpm instead of installing directly) or downloaded from the ATI unofficial repo.

To deinstall fglrx and switch back to the open source driver, run atiupgrade with the option -d (or –deinstall)

atiupgrade -d

view screenshot

This option performs the following steps:

(1) - Deinstalling fglrx package
This is the package created by the ATI installer. You can find out its name and version by querying the rpm database:

$ rpm -qa | grep fglrx
**fglrx64_xpic_SUSE121**-8.951-1.x86_64

(2) - Re-enabling Kernel Mode Setting
atiupgrade asks if you want to re-enable KMS. If you had to start originally Linux with “nomodeset”, you should answer no. Otherwise, say yes.

(3 )Restoring original Xorg configuration
The postuninstall scriptlet of the rpm package normally takes care of that. However if /etc/X11/xorg.conf still exists and contains the string “fglrx”, it will be renamed to /etc/X11/xorg.conf.fglrx.

At next boot, X should use the open source driver.

screenshots

Fine. Let build atiupgrade for SLE_11_SP1/SLE_11_SP2 please…

I suppose I could do that. Did You try the script on SLE? Does it work? Does the package have a different name (look in /usr/share/atiupgrade)? Does it matter? It you ever build a rpm on SLE from the ati/amd run script, how is it called? And what would be the output of “lsb_release -a” on SLE?

Wow! Looks like the answer to a LOT of questions! Thanks for creating this, and for your commitment to keep it up to date.

It does however, create one question, as least for me. Will this “Directions Page” remain available? Somewhere I saw a utility to Download a web page including all the links and stuff. Can’t seem to find it now when I want it though. Suggestions?

worked fine, but needs some work…

first my videocard didn’t match. It says it is a HD6350, or something like that, it’s a HD5450.

then, it aks to install some files. if you walk away from your pc, like I did, then it just installs. Why not wait for the userinteraction?

Then I noticed, that you install the Xen-kernel sources… Why? Why if there is no xen-kernel installed?

And as last, the loki-installer did not pop-up. I had to invoke the run script manually.

If you want to know what my system is:
Suse 12.2
CPU Core2Duo 6300
RAM 2GB DDR2
Vid Ati Radeon HD5450 1GB

Great work, this is real time saver.

Suse 12.2
AMD A8 Quad
Radeon HD 6620G discrete-class graphics

Hi, I have ATI Radeon HD 6770, openSuSE 12.2. So I can install, even though the repo says 12.1?

Thanks in advance.

AMD Athlon™ II X3 450 Processor- 3.2 GHz
RAM-8.0 GiB
Video-AMD Radeon HD-6770

That’s right. But even if I would not, it would be installed at a later point by the rpm script of the fglrx package. I don’t have influence on that. It doesn’t matter if it is installed at step 3 by atiupgrade or at step 8 by dependencies of the fglrx package. You end up indeed with some devel packages you don’t need. :frowning:

**(8) - installing fglrx...**
       Do you want to install fglrx64_xpic_SUSE121-8.97.100.3-1.x86_64.rpm now? [yn] y
Loading repository data...
Reading installed packages...
Forcing installation of 'fglrx64_xpic_SUSE121-8.97.100.3-1.x86_64' from repository 'Plain RPM files cache'.
Resolving package dependencies...

The following NEW packages are going to be installed:
  fglrx64_xpic_SUSE121** kernel-default-devel kernel-syms kernel-xen-devel **libX11-6-32bit libXau6-32bit libXext6-32bit libxcb1-32bit 

I don’t know if kernel-syms is really needed, but the rpm wants to install it.

**$ rpm -q --requires fglrx64_xpic_SUSE121 | grep kernel**
kernel-devel  
kernel-source  
**kernel-syms**  

And the other kernel devel packages (among others default and Xen) are dependencies of kernel-syms.
Not my fault. :wink:

Now it says 12.2. It wouldn’t have matter for this script, but installing a repo for a previous release is not advisable - unless you uninstall or disable the repo afterwards.

PTA:

I ran the script a few days ago (you advised me on removing the ATI watermark) and things have been pretty good.
I have set my screen saver to miscellaneous->clock. This is the normal faced clock that shows a second hand.
When the screen saver activates (and you can see this in test mode) the screen draw is all messed up and it jumps around as each second ticks off.
I am running 12.2 KDE on an i7-3770

I assume this has to do with the video driver because the same screen saver works fine running on my old Celeron with an Intel 82865G.

I don’t know if this problem is fixable or not but I wanted to mention it just in case.

Rgds, Jon

#atiupgrade <== this doesnt work, gives error msg below , need to use ./atiupgrade

(1) - Analyzing system…
* Found ATI graphics card: HD 6600M
/usr/bin/atiupgrade: line 356: : amddriver-installer-catalyst-12.10-x86.x86_64.zip: integer expression expected
/usr/bin/atiupgrade: line 370: : too many arguments
* Found: Catalyst 12.6
(2) - Getting latest (or specified) Catalyst version: amd.driver-installer-catalyst-12-10-x86.x86_64.zipamd-driver-installer-catalyst-12.11-beta8-x86.x86_64.zip/usr/bin/atiupgrade: line 397: amddriver-installer-catalyst-12-10-x86.x86_64.zip amd-driver-installer-catalyst-12.11-beta8-x86.x86_64.zip1: syntax error: invalid arithmetic operator (error token is ".x86_64.zip amd-driver-installer-catalyst-12.11-beta8-x86.x86_64.zip1")

very thanks