Viewing file:  videocard.py (17.89 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
#
# videocard.py - Install data and probing for video cards
#
# Matt Wilson <msw@redhat.com>
# Brent Fox <bfox@redhat.com>
# Mike Fulbright <msf@redhat.com>
#
# Copyright 2001-2002 Red Hat, Inc.
#
# This software may be freely redistributed under the terms of the GNU
# library public license.
#
# You should have received a copy of the GNU Library Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#
import copy
import kudzu
import string
import os
from rhpl.log import log
from rhpl.executil import execWithCapture
from rhpl.translate import _
import rhpl.translate as translate
import rhpl
translate.textdomain('rhpl')
Video_cardslist = {}
def Video_cardsDBLookup(thecard):
card = Video_cardslist[thecard]
return card
class VideoCard:
#
# This class represents the base data about a videocard. These are
# the internal members - PLEASE use methods to access values!
#
# device - if framebuffer running on card this is entry in /dev (string)
# descr - human readable description (string)
# server - X server to use (string)
# probedcard - value returned for kudzu containing 'Card:........'
# cardManf - name of manufacturer (string)
# vidRam - amount of video ram (in kB) (string)
# cardData - record from X card database, contains a dictionary of
# key/values.
# devID - ID from ddcprobe (string)
# fbmodes - if framebuffer running, video mode in use (string)
# fbbpp - if framebuffer running, pixel depth in use (string)
# pcibus - PCI bus number of the card
# pcidev - PCI device number of the card
# pcifn - PCI fn number of the card
#
# These values will be None if undefined or not applicable.
#
def __str__ (self):
return "device: %s\ndescr : %s\nserver: %s\ncardManf: %s\nvidRam: %s\ncarddata: %s\ndevID: %s\nfbmodes: %s\nfbbpp: %s\n" % (self.device, self.descr, self.server, self.cardManf, self.vidRam, self.cardData, self.devID, self.fbmodes, self.fbbpp)
def __init__ (self):
self.device = None
self.probedcard = None
self.descr = None
self.server = None
self.cardManf = None
self.vidRam = None
self.cardData = None
self.devID = None
self.fbmodes = None
self.fbbpp = None
self.pcibus = None
self.pcidev = None
self.pcifn = None
def setDevice(self, device):
self.device = device
def setDescription(self, descr):
self.descr = descr
def setProbedCard(self, card):
self.probedcard = card
def setXServer(self, server):
self.server = server
def setVideoRam(self, vidRam):
self.vidRam = vidRam
def setCardData(self, card):
self.cardData = card
def setDevID(self, devid):
self.devID = devid
def setCardManf(self, manf):
self.cardManf = manf
def setFBModes(self, fbmodes):
self.fbmodes = fbmodes
def setFBBpp(self, bpp):
self.fbbpp = bpp
def setPCIBus(self, num):
self.pcibus = num
def setPCIDev(self, num):
self.pcidev = num
def setPCIFn(self, num):
self.pcifn = num
def getProbedCard(self):
return self.probedcard
def getVideoRam(self):
return self.vidRam
def getDescription(self):
return self.descr
def getDevice(self):
return self.device
def getDevID(self):
return self.devID
def getXServer(self):
return self.server
def getFBBpp(self):
return self.fbbpp
def getPCIBus(self):
return self.pcibus
def getPCIDev(self):
return self.pcidev
def getPCIFn(self):
return self.pcifn
def isFrameBuffer(self):
return 0
def shortDescription(self):
if self.devID and self.devID != "":
return self.devID
else:
return _("Unable to probe")
def getDriver(self):
cardData = self.getCardData()
if not cardData:
return None
if cardData.has_key("DRIVER"):
return cardData["DRIVER"]
else:
return None
# dontResolve = 1 tells us to not follow 'SEE' records to find
# true card definition
def getCardData(self, dontResolve = 0):
if dontResolve:
return self.cardData
else:
if self.cardData:
return Video_cardsDBLookup(self.cardData["NAME"])
else:
return None
def canTestSafely(self):
cardData = self.getCardData()
if not cardData:
return 1
if cardData.has_key("DRIVER"):
curdriver = cardData["DRIVER"]
noprobedriverList = ("i810", "tdfx")
for adriver in noprobedriverList:
if curdriver == adriver:
return 0
return 1
def hasFixedMode(self):
return 0
# fake card entry for frame buffer
class FrameBufferCard(VideoCard):
def getCardData(self, dontResolve = 0):
# fake entry for a frame buffer (not in cards db)
card = {}
card["DRIVER"] = "fbdev"
card["NAME"] = "Framebuffer driver (generic)"
return card
def getXServer(self):
return "Xorg"
def isFrameBuffer(self):
return 1
def hasFixedMode(self):
return 1
def __init__(self):
VideoCard.__init__(self)
# fake card entry for frame buffer
class VGA16Card(VideoCard):
def getCardData(self, dontResolve = 0):
# fake entry for a frame buffer (not in cards db)
card = {}
card["DRIVER"] = "vga"
card["NAME"] = "Generic VGA"
return card
def getXServer(self):
return "Xorg"
def hasFixedMode(self):
return 1
def FixedMode(self):
return { "4" : ["640x480"]}
def VESADriverCard(vram=None):
try:
card = 'VESA driver (generic)'
vc = VideoCard()
if vram:
vc.setVideoRam(vram)
info = Video_cardslist[card]
vc.setProbedCard(card)
vc.setDevice(None)
vc.setDescription(card)
vc.setCardData(info)
vc.setDevID(info["NAME"])
vc.setXServer('Xorg')
vc.setPCIBus(card.pcibus)
vc.setPCIDev(card.pcidev)
vc.setPCIFn(card.pcifn)
except:
vc = None
return vc
class VideoCardInfo:
#
# This class represents the video cards on the system.
#
# Currently we only care about the primary card on the system.
# This can be found by using the VideoCardInfo::primaryCard() function.
#
# NOTE - X configuration is not represented here. This class is
# intended only to reprsent the available hardware on the system
#
def primaryCard(self, useProbed = 0):
if useProbed:
if self.orig_videocards and self.orig_primary < len(self.orig_videocards):
return self.orig_videocards[self.orig_primary]
else:
return None
else:
if self.videocards and self.primary < len(self.videocards):
return self.videocards[self.primary]
else:
return None
def possible_ram_sizes(self):
#--Valid video ram sizes--
return [512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072]
def index_closest_ram_size(self, detected):
possram = self.possible_ram_sizes()
match = -1
for i in range(0, len(possram)-1):
if detected <= possram[i]:
match = i
break
elif detected >= possram[i]-64 and detected < possram[i+1]-65:
match = i
break
if match < 0:
match = len(possram)-1
return match
def possible_depths(self):
#--Valid bit depths--
return ["8", "16", "24", "32"]
# returns list of modes we know card can do
# returns None if no restrictions
def getSupportedModes(self):
vc = self.primaryCard()
if not vc:
return None
carddata = vc.getCardData()
if carddata.has_key('DRIVER') and carddata['DRIVER'] == 'vesa':
return ['640x480', '800x600', '1024x768']
else:
return None
return None
def manufacturerDB(self):
return ["3DLabs",
"ABit", "AOpen", "ASUS", "ATI", "Actix", "Ark Logic", "Avance Logic",
"Compaq", "Canopus", "Cardex", "Chaintech",
"Chips & Technologies", "Cirrus", "Creative Labs",
"DFI", "DSV", "DataExpert", "Dell", "Diamond", "Digital",
"ELSA", "EONtronics", "Epson", "ExpertColor",
"Gainward", "Genoa", "Guillemot",
"Hercules",
"Intel",
"Jaton",
"LeadTek",
"MELCO", "MachSpeed", "Matrox", "Miro",
"NVIDIA", "NeoMagic", "Number Nine",
"Oak", "Octek", "Orchid",
"Paradise", "PixelView",
"Quantum",
"RIVA", "Real3D", "Rendition",
"S3", "Sharp", "SNI", "SPEA", "STB", "SiS",
"Sierra", "Sigma", "Silicon Motion", "Soyo", "Spider", "Sun",
"TechWorks", "Toshiba", "Trident",
"VideoLogic", "ViewTop", "Voodoo",
"WD", "Weitek", "WinFast"]
def readCardsDB (self):
# all the straight servers
# uncomment if you're meaning to support XFree86 3.x servers
# will probably require hacking elsewhere to make sure the
# appropriate X Server package is in selected package list
if not os.access('/usr/share/hwdata/Cards', os.R_OK):
return -1
db = open ('/usr/share/hwdata/Cards')
lines = db.readlines ()
db.close ()
card = {}
name = None
for line in lines:
line = string.strip (line)
if not line and name:
# if card.has_key("DRIVER") and card.has_key("UNSUPPORTED"):
# print "WARNING: CardsDB entry for %s says XFree86 4.x is unsupported!" % name
if card.has_key("SERVER") and not card.has_key("DRIVER"):
# print "WARNING: CardsDB entry for %s is XFree86 3.x only, dropping" % name
pass
else:
Video_cardslist[name] = card
card = {}
name = None
continue
if line and line[0] == '#':
continue
if len (line) > 4 and line[0:4] == 'NAME':
name = line[5:]
if len (line) > 3 and line[0:3] == 'SEE':
info = string.splitfields (line, ' ')
seecard = string.joinfields(info[1:], ' ')
try:
refcard = Video_cardslist[seecard]
except:
continue
for k in ["CHIPSET", "SERVER", "RAMDAC", "CLOCKCHIP",
"DACSPEED", "DRIVER", "UNSUPPORTED", "NOCLOCKPROBE"]:
if not card.has_key(k) and refcard.has_key(k):
card[k] = refcard[k]
if refcard.has_key("LINE"):
if not card.has_key("LINE"):
card["LINE"] = refcard["LINE"]
else:
card["LINE"] = card["LINE"] + "\n" + refcard["LINE"]
info = string.splitfields (line, ' ')
if card.has_key (info[0]):
card[info[0]] = card[info[0]] + '\n' + (string.joinfields (info[1:], ' '))
else:
card[info[0]] = string.joinfields (info[1:], ' ')
return 0
def cardsDB(self):
return Video_cardslist
def __str__(self):
retstr = "primary: %s\nvidCards: %s\n" % (self.primary, self.videocards)
if self.primaryCard():
retstr = retstr + ("Primary Video Card Info:\n%s" % (str(self.primaryCard())))
return retstr
def reset(self):
self.videocards = copy.deepcopy(self.orig_videocards)
self.primary = self.orig_primary
def runDDCProbeStub(self):
cardID = None
cardMem = None
cardDescr = None
probe = string.split (execWithCapture("/usr/sbin/ddcprobe",
['ddcprobe', '--raw',
'--videocard']), '\n')
for line in probe:
l = string.strip(line)
if len(l)<1:
continue
rc = string.split(l, "=")
try:
key = rc[0]
val = rc[1]
if key == "id":
cardID = val
elif key == "mem":
cardMem = int(val)
elif key == "description":
cardDescr = val
else:
log("Unknown key/val in videocard::runDDCProbeStub = %s %s", key, val)
except:
log("Ignoring bad ddcprobe output line |%s|", line)
pass
return (cardID, cardMem, cardDescr)
def __init__ (self, skipDDCProbe = 0):
cards = kudzu.probe (kudzu.CLASS_VIDEO,
kudzu.BUS_PCI | kudzu.BUS_SBUS,
kudzu.PROBE_ALL);
cardID = None
cardMem = None
cardDescr = None
if not skipDDCProbe:
try:
(cardID, cardMem, cardDescr) = self.runDDCProbeStub()
except:
log("Running videocard::runDDCProbeStub failed")
pass
# self.ddcprobe_data = (cardID, cardMem)
# just use first video card we recognize
# store as a list of class VideoCard
self.videocards = []
self.primary = None
if self.readCardsDB() < 0:
return None
for card in cards:
(device, server, descr) = card
info = None
if len (server) > 9 and server[0:10] == "Server:Sun" and descr[0:4] == "Sun|":
server = "Card:Sun " + descr[4:]
if len (server) > 5 and server[0:5] == "Card:":
if server[5:] in Video_cardslist.keys():
info = Video_cardslist [server[5:]]
else:
info = None
if len (server) > 7 and server[0:7] == "Server:":
info = { "NAME" : "Generic " + server[7:],
"SERVER" : server[7:] }
if info:
vc = VideoCard()
vc.setProbedCard(server)
vc.setDevice(device)
vc.setDescription(descr)
vc.setCardData (info)
vc.setDevID (info["NAME"])
vc.setPCIBus(card.pcibus)
vc.setPCIDev(card.pcidev)
vc.setPCIFn(card.pcifn)
#
# We are now not supporting XFree86 3.x at all, so we will take the
# XFree86 4.x driver and complain if its unsupported
#
if vc.getCardData().has_key("DRIVER"):
server = "Xorg"
if vc.getCardData().has_key("UNSUPPORTED"):
log("Using CardsDB entry for %s even tho its "
"marked unsupported" % info["NAME"])
else:
server = None
if server:
vc.setXServer(server)
self.videocards.append(vc)
if len(self.videocards) == 0:
# insert a best guess at a card - if we got memory
# from probe we hope this means VESA BIOS works
# or assume that if you're sticking a video card into an
# x86_64 box, it supports vesa
if (cardMem and cardMem > 0) or rhpl.getArch() == "x86_64":
try:
card = 'VESA driver (generic)'
vc = VideoCard()
if cardMem:
vc.setVideoRam("%d" % (cardMem,))
else:
log("no cardMem, assuming 8192")
vc.setVideoRam("8192")
info = Video_cardslist[card]
vc.setProbedCard(card)
vc.setDevice(None)
vc.setDescription(card)
vc.setCardData(info)
vc.setDevID(info["NAME"])
vc.setXServer('Xorg')
except:
vc = None
else:
vc = None
# only append if we have something other than None. then
# if videohw.videocards = [], we have no video hardware
# (aka the headless case)
if vc is not None:
self.videocards.append(vc)
self.primary = 0
self.orig_videocards = copy.deepcopy(self.videocards)
self.orig_primary = self.primary
return
# default primary card to be the first card found
self.primary = 0
# VESA probe for videoram, etc.
# for now assume fb corresponds to primary video card
if cardMem and cardMem > 0:
self.primaryCard().setVideoRam("%d" % (cardMem,))
# this is a hack, but it's probably safe to assume at least
# 8 megs of video ram on our non-i386 arches (since we can't
# probe them)
elif rhpl.getArch() != "i386":
self.primaryCard().setVideoRam("8192")
# kludge to handle i810 displays which require at least 16 Meg
if (self.primaryCard().getCardData()).has_key("DRIVER"):
cardData = self.primaryCard().getCardData()
if cardData["DRIVER"] == "i810":
self.primaryCard().setVideoRam("16384")
self.orig_videocards = copy.deepcopy(self.videocards)
self.orig_primary = self.primary
#
# XXX needed for kickstart only (via installclass.py::configureX())
# some useful routines for setting videocard in various ways
# needs to be ported to new VideoCard object
# pass videocard object for desired card; this sets card to be
# primary card
def setVidcard (self, videocard):
self.primary = self.videocards.index(videocard)
# find the appropriate videocard object for the requested card name
# this will only find the first instance of any card
def locateVidcardByName (self, card):
for vc in self.videocards:
print vc.getDescription()
if (vc.getDescription() == card):
return vc
raise RuntimeError, "Could not find valid video card driver"
# find the appropriate videocard object for the requested server name
# this will only find the first instance of any card
def locateVidcardByServer (self, server):
for vc in self.videocards:
if (vc.getXServer() == server):
return vc
raise RuntimeError, "Could not find valid video card driver."
|