| # Copyright 2014 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import logging, os, re, struct, time |
| |
| from autotest_lib.client.bin import test |
| from autotest_lib.client.bin import utils |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.common_lib.cros import chrome |
| from autotest_lib.client.cros import cros_logging |
| |
| |
| class graphics_Idle(test.test): |
| """Class for graphics_Idle. See 'control' for details.""" |
| version = 1 |
| _gpu_type = None |
| _cpu_type = None |
| |
| |
| def run_once(self): |
| # Try to protect against runaway previous tests. |
| if not utils.wait_for_idle_cpu(20.0, 0.1): |
| logging.warning('Could not get idle CPU before running tests.') |
| # We use kiosk mode to make sure Chrome is idle. |
| with chrome.Chrome(logged_in=False, extra_browser_args=['--kiosk']): |
| self._gpu_type = utils.get_gpu_family() |
| self._cpu_type = utils.get_cpu_soc_family() |
| self._board = utils.get_board() |
| errors = '' |
| errors += self.verify_graphics_dvfs() |
| errors += self.verify_graphics_fbc() |
| errors += self.verify_graphics_psr() |
| errors += self.verify_graphics_gem_idle() |
| errors += self.verify_graphics_i915_min_clock() |
| errors += self.verify_graphics_rc6() |
| errors += self.verify_lvds_downclock() |
| errors += self.verify_short_blanking() |
| if errors: |
| raise error.TestFail(errors) |
| |
| |
| def verify_lvds_downclock(self): |
| """On systems which support LVDS downclock, checks the kernel log for |
| a message that an LVDS downclock mode has been added.""" |
| logging.info('Running verify_lvds_downclock') |
| board = utils.get_board() |
| if not (board == 'alex' or board == 'lumpy' or |
| board == 'stout'): |
| return '' |
| |
| # Get the downclock message from the logs. |
| reader = cros_logging.LogReader() |
| reader.set_start_by_reboot(-1) |
| if not reader.can_find('Adding LVDS downclock mode'): |
| logging.error('Error: LVDS downclock quirk not applied.') |
| return 'LVDS downclock quirk not applied. ' |
| |
| return '' |
| |
| |
| def verify_short_blanking(self): |
| """On baytrail systems with a known panel, checks the kernel log for a |
| message that a short blanking mode has been added.""" |
| logging.info('Running verify_short_blanking') |
| if self._gpu_type != 'baytrail': |
| return '' |
| |
| # Open the EDID to find the panel model. |
| param_path = '/sys/class/drm/card0-eDP-1/edid' |
| if not os.path.exists(param_path): |
| logging.error('Error: %s not found.', param_path) |
| return 'Short blanking not added (no EDID found). ' |
| |
| with open(param_path, 'r') as edp_edid_file: |
| edp_edid_file.seek(8) |
| bytes = edp_edid_file.read(2) |
| manufacturer = int(struct.unpack('<H', bytes)[0]) |
| bytes = edp_edid_file.read(2) |
| product_code = int(struct.unpack('<H', bytes)[0]) |
| |
| # This is not the panel we are looking for (AUO B116XTN02.2) |
| if manufacturer != 0xaf06 or product_code != 0x225c: |
| return '' |
| |
| # Get the downclock message from the logs. |
| reader = cros_logging.LogReader() |
| reader.set_start_by_reboot(-1) |
| if not reader.can_find('Modified preferred into a short blanking mode'): |
| logging.error('Error: short blanking not added.') |
| return 'Short blanking not added. ' |
| |
| return '' |
| |
| |
| def verify_graphics_rc6(self): |
| """ On systems which support RC6 (non atom), check that we are able to |
| get into rc6; idle before doing so, and retry every second for 20 |
| seconds.""" |
| logging.info('Running verify_graphics_rc6') |
| if (self._gpu_type == 'broadwell' or self._gpu_type == 'haswell' or |
| self._gpu_type == 'ivybridge' or self._gpu_type == 'sandybridge'): |
| tries = 0 |
| found = False |
| while found == False and tries < 20: |
| time.sleep(1) |
| param_path = '/sys/kernel/debug/dri/0/i915_drpc_info' |
| if not os.path.exists(param_path): |
| logging.error('Error: %s not found.', param_path) |
| break |
| with open(param_path, 'r') as drpc_info_file: |
| for line in drpc_info_file: |
| match = re.search(r'Current RC state: (.*)', line) |
| if match and match.group(1) != 'on': |
| found = True |
| break |
| |
| tries += 1 |
| |
| if not found: |
| utils.log_process_activity() |
| logging.error('Error: did not see the GPU in RC6.') |
| return 'Did not see the GPU in RC6. ' |
| |
| return '' |
| |
| |
| def verify_graphics_i915_min_clock(self): |
| """ On i915 systems, check that we get into the lowest clock frequency; |
| idle before doing so, and retry every second for 20 seconds.""" |
| logging.info('Running verify_graphics_i915_min_clock') |
| if (self._gpu_type == 'baytrail' or self._gpu_type == 'broadwell' or |
| self._gpu_type == 'haswell' or self._gpu_type == 'ivybridge' or |
| self._gpu_type == 'sandybridge'): |
| tries = 0 |
| found = False |
| while not found and tries < 80: |
| time.sleep(0.25) |
| param_path = '/sys/kernel/debug/dri/0/i915_cur_delayinfo' |
| if not os.path.exists(param_path): |
| logging.error('Error: %s not found.', param_path) |
| break |
| |
| with open(param_path, 'r') as delayinfo_file: |
| for line in delayinfo_file: |
| # This file has a different format depending on the board, |
| # so we parse both. Also, it would be tedious to add the |
| # minimum clock for each board, so instead we use 650MHz |
| # which is the max of the minimum clocks. |
| match = re.search(r'CAGF: (.*)MHz', line) |
| if match and int(match.group(1)) <= 650: |
| found = True |
| break |
| |
| match = re.search(r'current GPU freq: (.*) MHz', line) |
| if match and int(match.group(1)) <= 650: |
| found = True |
| break |
| |
| tries += 1 |
| |
| if not found: |
| utils.log_process_activity() |
| logging.error('Error: did not see the min i915 clock') |
| return 'Did not see the min i915 clock. ' |
| |
| return '' |
| |
| |
| def verify_graphics_dvfs(self): |
| """ On systems which support DVFS, check that we get into the lowest |
| clock frequency; idle before doing so, and retry every second for 20 |
| seconds.""" |
| logging.info('Running verify_graphics_dvfs') |
| if self._gpu_type == 'mali': |
| if self._cpu_type == 'exynos5': |
| node = '/sys/devices/11800000.mali/' |
| enable_node = 'dvfs' |
| enable_value = 'on' |
| elif self._cpu_type == 'rockchip': |
| node = '/sys/devices/ffa30000.gpu/' |
| enable_node = 'dvfs_enable' |
| enable_value = '1' |
| else: |
| logging.error('Error: Unknown CPU type (%s) for mali GPU.', |
| self._cpu_type) |
| return 'Unknown CPU type for mali GPU. ' |
| |
| clock_path = utils.locate_file('clock', node) |
| enable_path = utils.locate_file(enable_node, node) |
| freqs_path = utils.locate_file('available_frequencies', node) |
| |
| enable = utils.read_one_line(enable_path) |
| logging.info('DVFS enable = %s', enable) |
| if not enable == enable_value: |
| logging.error('Error: DVFS is not enabled') |
| return 'DVFS is not enabled. ' |
| |
| # available_frequencies are always sorted in ascending order |
| lowest_freq = int(utils.read_one_line(freqs_path)) |
| |
| # daisy_* (exynos5250) boards set idle frequency to 266000000 |
| # See: crbug.com/467401 and crosbug.com/p/19710 |
| if self._board.startswith('daisy'): |
| lowest_freq = 266000000 |
| |
| logging.info('Expecting idle DVFS clock = %u', lowest_freq) |
| |
| tries = 0 |
| found = False |
| while not found and tries < 80: |
| time.sleep(0.25) |
| clock = int(utils.read_one_line(clock_path)) |
| if clock <= lowest_freq: |
| logging.info('Found idle DVFS clock = %u', clock) |
| found = True |
| break |
| |
| tries += 1 |
| |
| if not found: |
| utils.log_process_activity() |
| logging.error('Error: DVFS clock (%u) > min (%u)', |
| clock, lowest_freq) |
| return 'Did not see the min DVFS clock. ' |
| |
| return '' |
| |
| |
| def verify_graphics_fbc(self): |
| """ On systems which support FBC, check that we can get into FBC; |
| idle before doing so, and retry every second for 20 seconds.""" |
| logging.info('Running verify_graphics_fbc') |
| |
| # Link's FBC is disabled (crbug.com/338588). |
| # TODO(marcheu): remove this when/if we fix this bug. |
| board = utils.get_board() |
| if board == 'link': |
| return '' |
| |
| # Machines which don't have a monitor can't get FBC. |
| if utils.has_no_monitor(): |
| return '' |
| |
| if (self._gpu_type == 'haswell' or self._gpu_type == 'ivybridge' or |
| self._gpu_type == 'sandybridge'): |
| tries = 0 |
| found = False |
| while not found and tries < 20: |
| time.sleep(1) |
| # Kernel 3.4 has i915_fbc, kernel 3.8+ has i915_fbc_status, |
| # so we check for both. |
| param_path = '/sys/kernel/debug/dri/0/i915_fbc_status' |
| if not os.path.exists(param_path): |
| param_path = '/sys/kernel/debug/dri/0/i915_fbc' |
| if not os.path.exists(param_path): |
| logging.error('Error: %s not found.', param_path) |
| break |
| with open(param_path, 'r') as fbc_info_file: |
| for line in fbc_info_file: |
| if re.search('FBC enabled', line): |
| found = True |
| break |
| |
| tries += 1 |
| |
| if not found: |
| logging.error('Error: did not see FBC enabled.') |
| return 'Did not see FBC enabled. ' |
| |
| |
| return '' |
| |
| |
| def verify_graphics_psr(self): |
| """ On systems which support PSR, check that we can get into PSR; |
| idle before doing so, and retry every second for 20 seconds.""" |
| logging.info('Running verify_graphics_psr') |
| |
| board = utils.get_board() |
| if board != 'samus': |
| return '' |
| |
| tries = 0 |
| found = False |
| while not found and tries < 20: |
| time.sleep(1) |
| param_path = '/sys/kernel/debug/dri/0/i915_edp_psr_state' |
| if not os.path.exists(param_path): |
| logging.error('Error: %s not found.', param_path) |
| break |
| with open(param_path, 'r') as fbc_info_file: |
| for line in fbc_info_file: |
| match = re.search(r'Performance_Counter: (.*)', line) |
| if match and int(match.group(1)) > 0: |
| found = True |
| break |
| |
| tries += 1 |
| |
| if not found: |
| logging.error('Error: did not see PSR enabled.') |
| return 'Did not see PSR enabled. ' |
| |
| |
| return '' |
| |
| |
| def verify_graphics_gem_idle(self): |
| """ On systems which have i915, check that we can get all gem objects |
| to become idle (i.e. the i915_gem_active list need to go to 0); |
| idle before doing so, and retry every second for 20 seconds.""" |
| logging.info('Running verify_graphics_gem_idle') |
| if (self._gpu_type == 'baytrail' or self._gpu_type == 'broadwell' or |
| self._gpu_type == 'haswell' or self._gpu_type == 'ivybridge' or |
| self._gpu_type == 'sandybridge'): |
| tries = 0 |
| found = False |
| while not found and tries < 240: |
| time.sleep(0.25) |
| gem_path = '/sys/kernel/debug/dri/0/i915_gem_active' |
| if not os.path.exists(gem_path): |
| logging.error('Error: %s not found.', gem_path) |
| break |
| with open(gem_path, 'r') as gem_file: |
| for line in gem_file: |
| if re.search('Total 0 objects', line): |
| found = True |
| break |
| |
| tries += 1 |
| |
| if not found: |
| utils.log_process_activity() |
| logging.error('Error: did not reach 0 gem actives.') |
| return 'Did not reach 0 gem actives. ' |
| |
| return '' |
| |
| |
