~ubuntu-branches/ubuntu/trusty/jockey/trusty

« back to all changes in this revision

Viewing changes to data/handlers/pvr-omap4.py

  • Committer: Package Import Robot
  • Author(s): Ricardo Salveti de Araujo
  • Date: 2012-04-11 01:43:02 UTC
  • Revision ID: package-import@ubuntu.com-20120411014302-s8jmq12lslsvu8jx
Tags: 0.9.7-0ubuntu6
* data/handlers/pvr-omap4.py:
  - Adding handler for PowerVR SGX driver for OMAP 4 based boards, like
    Pandaboard and Blaze (LP: #978563)

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# -*- coding: utf-8 -*-
 
2
# (c) 2008-2010 Canonical Ltd.
 
3
# (c) 2012 Linaro Ltd.
 
4
# Authors: Ricardo Salveti de Araujo <rsalveti@linaro.org>
 
5
#
 
6
# Alternatives from nvidia-common, created by
 
7
# Alberto Milone <alberto.milone@canonical.com>
 
8
#
 
9
# License: GPL v2 or later
 
10
 
 
11
import logging, os, re, subprocess
 
12
 
 
13
from jockey.xorg_driver import XorgDriverHandler
 
14
from subprocess import Popen, PIPE, CalledProcessError
 
15
 
 
16
# dummy stub for xgettext
 
17
def _(x): return x
 
18
 
 
19
class Alternatives(object):
 
20
 
 
21
    def __init__(self, master_link):
 
22
        self._open_egl_drivers_alternative = 'mesa-egl/ld.so.conf'
 
23
        self._command = 'update-alternatives'
 
24
        self._master_link = master_link
 
25
 
 
26
        # Make sure that the PATH environment variable is set
 
27
        if not os.environ.get('PATH'):
 
28
            os.environ['PATH'] = '/sbin:/usr/sbin:/bin:/usr/bin'
 
29
 
 
30
    def list_alternatives(self):
 
31
        '''Get the list of alternatives for the master link'''
 
32
        dev_null = open('/dev/null', 'w')
 
33
        alternatives = []
 
34
        p1 = Popen([self._command, '--list', self._master_link],
 
35
                   stdout=PIPE, stderr=dev_null)
 
36
        p = p1.communicate()[0]
 
37
        dev_null.close()
 
38
        c = p.split('\n')
 
39
        for line in c:
 
40
            line.strip() and alternatives.append(line.strip())
 
41
 
 
42
        return alternatives
 
43
 
 
44
    def get_current_alternative(self):
 
45
        '''Get the alternative in use'''
 
46
        dev_null = open('/dev/null', 'w')
 
47
        current_alternative = None
 
48
        p1 = Popen([self._command, '--query', self._master_link],
 
49
                   stdout=PIPE, stderr=dev_null)
 
50
        p = p1.communicate()[0]
 
51
        dev_null.close()
 
52
        c = p.split('\n')
 
53
        for line in c:
 
54
            if line.strip().startswith('Value:'):
 
55
                return line.replace('Value:', '').strip()
 
56
        return None
 
57
 
 
58
    def get_alternative_by_name(self, name, ignore_pattern=None):
 
59
        '''Get the alternative link by providing the driver name
 
60
 
 
61
        ignore_pattern allows ignoring a substring in the name'''
 
62
        if ignore_pattern:
 
63
            name = name.replace(ignore_pattern, '')
 
64
        alternatives = self.list_alternatives()
 
65
 
 
66
        for alternative in alternatives:
 
67
            if alternative.split('/')[-2] == name:
 
68
                return alternative
 
69
 
 
70
        return None
 
71
 
 
72
    def get_open_egl_drivers_alternative(self):
 
73
        '''Get the alternative link for open EGL/GLES drivers'''
 
74
        return self.get_alternative_by_name(self._open_egl_drivers_alternative)
 
75
 
 
76
    def set_alternative(self, path):
 
77
        '''Tries to set an alternative and returns the boolean exit status'''
 
78
        try:
 
79
            subprocess.check_call([self._command, '--set',
 
80
                                   self._master_link, path])
 
81
            self.ldconfig()
 
82
        except CalledProcessError:
 
83
            return False
 
84
 
 
85
        return True
 
86
 
 
87
    def ldconfig(self):
 
88
        '''Call ldconfig'''
 
89
        try:
 
90
            subprocess.check_call(['ldconfig'])
 
91
        except CalledProcessError:
 
92
            return False
 
93
        return True
 
94
 
 
95
class PVROmap4Driver(XorgDriverHandler):
 
96
    def __init__(self, backend, package=None):
 
97
        self._free = False
 
98
 
 
99
        name=_('PowerVR SGX proprietary graphics driver for OMAP 4')
 
100
 
 
101
        XorgDriverHandler.__init__(self, backend, 'omapdrm_pvr', 'pvr-omap4',
 
102
            None, None, name=name,
 
103
            description=_('3D-accelerated proprietary graphics driver for '
 
104
                'OMAP 4 SoCs.'),
 
105
            rationale=_('This driver is required to fully utilise the 3D '
 
106
                'potential of OMAP 4 powered boards.'))
 
107
 
 
108
        self.pkg_alternative = 'pvr-omap4-egl'
 
109
        self._module_alias = 'omapdrm_pvr'
 
110
        self._alternatives = self._get_alternatives()
 
111
        self.omap4_re = re.compile('^Hardware.*OMAP4.*')
 
112
        self.needs_kernel_headers = True
 
113
 
 
114
    def _get_architecture(self):
 
115
        dev_null = open('/dev/null', 'w')
 
116
        p1 = Popen(['dpkg', '--print-architecture'], stdout=PIPE,
 
117
                   stderr=dev_null)
 
118
        p = p1.communicate()[0]
 
119
        dev_null.close()
 
120
        architecture = p.strip()
 
121
        return architecture
 
122
 
 
123
    def _get_alternatives(self):
 
124
        '''Get multi-arch alternatives names'''
 
125
        main_name = "arm-linux-gnueabi_egl_conf"
 
126
        if self._get_architecture() == "armhf":
 
127
            main_name = "arm-linux-gnueabihf_egl_conf"
 
128
        return Alternatives(main_name)
 
129
 
 
130
    def available(self):
 
131
        '''Check /proc/cpuinfo for an OMAP 4 board.'''
 
132
        if XorgDriverHandler.available(self) == False:
 
133
            return False
 
134
 
 
135
        try:
 
136
            for l in open('/proc/cpuinfo'):
 
137
                if self.omap4_re.match(l):
 
138
                    return True
 
139
        except IOError as e:
 
140
            logging.error('could not open /proc/cpuinfo: %s' % str(e))
 
141
 
 
142
        return False
 
143
 
 
144
    def enable(self):
 
145
        XorgDriverHandler.enable(self)
 
146
 
 
147
        # Set the alternative to PowerVR SGX (EGL)
 
148
        pvr_omap4_alternative = self._alternatives.get_alternative_by_name(
 
149
                self.pkg_alternative, ignore_pattern='-updates')
 
150
        if not pvr_omap4_alternative:
 
151
            logging.error('%s: get_alternative_by_name(%s) returned nothing' % (
 
152
                self.id(), self.pkg_alternative))
 
153
            return
 
154
        self._alternatives.set_alternative(pvr_omap4_alternative)
 
155
 
 
156
    def enabled(self):
 
157
        # See if pvr-omap4 is the current alternative
 
158
        target_alternative = \
 
159
            self._alternatives.get_alternative_by_name(self.pkg_alternative)
 
160
        current_alternative = self._alternatives.get_current_alternative()
 
161
 
 
162
        logging.debug('pvr-omap4.enabled(%s): target_alt %s current_alt %s',
 
163
                self.module, target_alternative, current_alternative)
 
164
 
 
165
        if current_alternative is None:
 
166
            logging.debug('current alternative of %s is None, not enabled',
 
167
                    self.pkg_alternative)
 
168
            return False
 
169
        if current_alternative != target_alternative:
 
170
            logging.debug('%s is not the alternative in use',
 
171
                    self.pkg_alternative)
 
172
            return False
 
173
 
 
174
        return XorgDriverHandler.enabled(self)
 
175
 
 
176
    def disable(self):
 
177
        XorgDriverHandler.disable(self)
 
178
 
 
179
        # Set the alternative back to open drivers
 
180
        open_drivers = self._alternatives.get_open_egl_drivers_alternative()
 
181
        logging.debug('pvr-omap4.disable(%s): open_drivers: %s',
 
182
                self.module, open_drivers)
 
183
        if open_drivers:
 
184
            self._alternatives.set_alternative(open_drivers)
 
185
 
 
186
        return False
 
187
 
 
188
    def enables_composite(self):
 
189
        '''Return whether this driver supports the composite extension.'''
 
190
 
 
191
        if KernelModuleHandler.module_loaded('omapdrm_pvr'):
 
192
            logging.debug('enables_composite(): already using pvr-omap4 '
 
193
                    'driver from nondefault package')
 
194
            return False
 
195
 
 
196
        return True