mirror of
https://github.com/u-boot/u-boot.git
synced 2025-04-15 17:34:43 +00:00
d08653d369
Now that we have a shorter name, we don't need this sort of thing. Just use ubman instead. Signed-off-by: Simon Glass <sjg@chromium.org>
740 lines
27 KiB
Python
740 lines
27 KiB
Python
# SPDX-License-Identifier: GPL-2.0
|
|
# (C) Copyright 2023, Advanced Micro Devices, Inc.
|
|
|
|
import pytest
|
|
import random
|
|
import re
|
|
import utils
|
|
|
|
"""
|
|
Note: This test doesn't rely on boardenv_* configuration values but it can
|
|
change the test behavior. To test MMC file system cases (fat32, ext2, ext4),
|
|
MMC device should be formatted and valid partitions should be created for
|
|
different file system, otherwise it may leads to failure. This test will be
|
|
skipped if the MMC device is not detected.
|
|
|
|
For example:
|
|
|
|
# Setup env__mmc_device_test_skip to not skipping the test. By default, its
|
|
# value is set to True. Set it to False to run all tests for MMC device.
|
|
env__mmc_device_test_skip = False
|
|
|
|
# Setup env__mmc_device to set the supported mmc modes to be tested
|
|
env__mmc_device {
|
|
'mmc_modes': ['MMC_LEGACY', 'SD_HS'],
|
|
}
|
|
|
|
"""
|
|
|
|
mmc_set_up = False
|
|
controllers = 0
|
|
devices = {}
|
|
mmc_modes_name = []
|
|
mmc_modes = []
|
|
|
|
def setup_mmc_modes(ubman):
|
|
global mmc_modes, mmc_modes_name
|
|
f = ubman.config.env.get('env__mmc_device', None)
|
|
if f:
|
|
mmc_modes_name = f.get('mmc_modes', None)
|
|
|
|
# Set mmc mode to default mode (legacy), if speed mode config isn't enabled
|
|
if ubman.config.buildconfig.get('config_mmc_speed_mode_set', 'n') != 'y':
|
|
mmc_modes = [0]
|
|
return
|
|
|
|
if mmc_modes_name:
|
|
mmc_help = ubman.run_command('mmc -help')
|
|
m = re.search(r"\[MMC_LEGACY(.*\n.+])", mmc_help)
|
|
modes = [
|
|
x.strip()
|
|
for x in m.group()
|
|
.replace('\n', '')
|
|
.replace('[', '')
|
|
.replace(']', '')
|
|
.split(',')
|
|
]
|
|
|
|
for mode in mmc_modes_name:
|
|
mmc_modes += [modes.index(mode)]
|
|
else:
|
|
# Set mmc mode to default mode (legacy), if it is not defined in env
|
|
mmc_modes = [0]
|
|
|
|
def setup_mmc(ubman):
|
|
if ubman.config.env.get('env__mmc_device_test_skip', True):
|
|
pytest.skip('MMC device test is not enabled')
|
|
|
|
setup_mmc_modes(ubman)
|
|
|
|
@pytest.mark.buildconfigspec('cmd_mmc')
|
|
def test_mmc_list(ubman):
|
|
setup_mmc(ubman)
|
|
output = ubman.run_command('mmc list')
|
|
if 'No MMC device available' in output:
|
|
pytest.skip('No SD/MMC/eMMC controller available')
|
|
|
|
if 'Card did not respond to voltage select' in output:
|
|
pytest.skip('No SD/MMC card present')
|
|
|
|
array = output.split()
|
|
global devices
|
|
global controllers
|
|
controllers = int(len(array) / 2)
|
|
for x in range(0, controllers):
|
|
y = x * 2
|
|
devices[x] = {}
|
|
devices[x]['name'] = array[y]
|
|
|
|
global mmc_set_up
|
|
mmc_set_up = True
|
|
|
|
@pytest.mark.buildconfigspec('cmd_mmc')
|
|
def test_mmc_dev(ubman):
|
|
if not mmc_set_up:
|
|
pytest.skip('No SD/MMC/eMMC controller available')
|
|
|
|
fail = 0
|
|
for x in range(0, controllers):
|
|
devices[x]['detected'] = 'yes'
|
|
|
|
for y in mmc_modes:
|
|
output = ubman.run_command('mmc dev %d 0 %d' % x, y)
|
|
|
|
if 'Card did not respond to voltage select' in output:
|
|
fail = 1
|
|
devices[x]['detected'] = 'no'
|
|
|
|
if 'no mmc device at slot' in output:
|
|
devices[x]['detected'] = 'no'
|
|
|
|
if 'MMC: no card present' in output:
|
|
devices[x]['detected'] = 'no'
|
|
|
|
if fail:
|
|
pytest.fail('Card not present')
|
|
|
|
@pytest.mark.buildconfigspec('cmd_mmc')
|
|
def test_mmcinfo(ubman):
|
|
if not mmc_set_up:
|
|
pytest.skip('No SD/MMC/eMMC controller available')
|
|
|
|
for x in range(0, controllers):
|
|
if devices[x]['detected'] == 'yes':
|
|
for y in mmc_modes:
|
|
ubman.run_command('mmc dev %d 0 %d' % x, y)
|
|
output = ubman.run_command('mmcinfo')
|
|
if 'busy timeout' in output:
|
|
pytest.skip('No SD/MMC/eMMC device present')
|
|
|
|
assert mmc_modes_name[mmc_modes.index(y)] in output
|
|
|
|
obj = re.search(r'Capacity: (\d+|\d+[\.]?\d)', output)
|
|
try:
|
|
capacity = float(obj.groups()[0])
|
|
print(capacity)
|
|
devices[x]['capacity'] = capacity
|
|
print('Capacity of dev %d is: %g GiB' % (x, capacity))
|
|
except ValueError:
|
|
pytest.fail('MMC capacity not recognized')
|
|
|
|
@pytest.mark.buildconfigspec('cmd_mmc')
|
|
def test_mmc_info(ubman):
|
|
if not mmc_set_up:
|
|
pytest.skip('No SD/MMC/eMMC controller available')
|
|
|
|
for x in range(0, controllers):
|
|
if devices[x]['detected'] == 'yes':
|
|
for y in mmc_modes:
|
|
ubman.run_command('mmc dev %d 0 %d' % x, y)
|
|
|
|
output = ubman.run_command('mmc info')
|
|
assert mmc_modes_name[mmc_modes.index(y)] in output
|
|
|
|
obj = re.search(r'Capacity: (\d+|\d+[\.]?\d)', output)
|
|
try:
|
|
capacity = float(obj.groups()[0])
|
|
print(capacity)
|
|
if devices[x]['capacity'] != capacity:
|
|
pytest.fail("MMC capacity doesn't match mmcinfo")
|
|
|
|
except ValueError:
|
|
pytest.fail('MMC capacity not recognized')
|
|
|
|
@pytest.mark.buildconfigspec('cmd_mmc')
|
|
def test_mmc_rescan(ubman):
|
|
if not mmc_set_up:
|
|
pytest.skip('No SD/MMC/eMMC controller available')
|
|
|
|
if not devices:
|
|
pytest.skip('No devices detected')
|
|
|
|
for x in range(0, controllers):
|
|
if devices[x]['detected'] == 'yes':
|
|
for y in mmc_modes:
|
|
ubman.run_command('mmc dev %d 0 %d' % x, y)
|
|
output = ubman.run_command('mmc rescan')
|
|
if output:
|
|
pytest.fail('mmc rescan has something to check')
|
|
output = ubman.run_command('echo $?')
|
|
assert output.endswith('0')
|
|
|
|
@pytest.mark.buildconfigspec('cmd_mmc')
|
|
def test_mmc_part(ubman):
|
|
if not mmc_set_up:
|
|
pytest.skip('No SD/MMC/eMMC controller available')
|
|
|
|
if not devices:
|
|
pytest.skip('No devices detected')
|
|
|
|
for x in range(0, controllers):
|
|
if devices[x]['detected'] == 'yes':
|
|
ubman.run_command('mmc dev %d' % x)
|
|
output = ubman.run_command('mmc part')
|
|
|
|
lines = output.split('\n')
|
|
part_fat = []
|
|
part_ext2 = []
|
|
part_ext4 = []
|
|
for line in lines:
|
|
obj = re.search(
|
|
r'(\d)\s+\d+\s+\d+\s+\w+\d+\w+-\d+\s+(\d+\w+)', line)
|
|
if obj:
|
|
part_id = int(obj.groups()[0])
|
|
part_type = obj.groups()[1]
|
|
print('part_id:%d, part_type:%s' % (part_id, part_type))
|
|
|
|
if part_type in ['0c', '0b', '0e']:
|
|
print('Fat detected')
|
|
part_fat.append(part_id)
|
|
elif part_type == '83':
|
|
print('ext(2/4) detected')
|
|
output = ubman.run_command(
|
|
'fstype mmc %d:%d' % x, part_id
|
|
)
|
|
if 'ext2' in output:
|
|
part_ext2.append(part_id)
|
|
elif 'ext4' in output:
|
|
part_ext4.append(part_id)
|
|
else:
|
|
pytest.fail('Unsupported Filesystem on device %d' % x)
|
|
devices[x]['ext4'] = part_ext4
|
|
devices[x]['ext2'] = part_ext2
|
|
devices[x]['fat'] = part_fat
|
|
|
|
if not part_ext2 and not part_ext4 and not part_fat:
|
|
pytest.fail('No partition detected on device %d' % x)
|
|
|
|
@pytest.mark.buildconfigspec('cmd_mmc')
|
|
@pytest.mark.buildconfigspec('cmd_fat')
|
|
def test_mmc_fatls_fatinfo(ubman):
|
|
if not mmc_set_up:
|
|
pytest.skip('No SD/MMC/eMMC controller available')
|
|
|
|
if not devices:
|
|
pytest.skip('No devices detected')
|
|
|
|
part_detect = 0
|
|
fs = 'fat'
|
|
for x in range(0, controllers):
|
|
if devices[x]['detected'] == 'yes':
|
|
try:
|
|
partitions = devices[x][fs]
|
|
except:
|
|
print('No %s table on this device' % fs.upper())
|
|
continue
|
|
|
|
for part in partitions:
|
|
for y in mmc_modes:
|
|
ubman.run_command('mmc dev %d %d %d' % x, part, y)
|
|
output = ubman.run_command(
|
|
'fatls mmc %d:%s' % (x, part))
|
|
if 'Unrecognized filesystem type' in output:
|
|
partitions.remove(part)
|
|
pytest.fail('Unrecognized filesystem')
|
|
|
|
if not re.search(r'\d file\(s\), \d dir\(s\)', output):
|
|
pytest.fail('%s read failed on device %d' % (fs.upper, x))
|
|
output = ubman.run_command(
|
|
'fatinfo mmc %d:%s' % (x, part))
|
|
string = 'Filesystem: %s' % fs.upper
|
|
if re.search(string, output):
|
|
pytest.fail('%s FS failed on device %d' % (fs.upper(), x))
|
|
part_detect = 1
|
|
|
|
if not part_detect:
|
|
pytest.skip('No %s partition detected' % fs.upper())
|
|
|
|
|
|
@pytest.mark.buildconfigspec('cmd_mmc')
|
|
@pytest.mark.buildconfigspec('cmd_fat')
|
|
@pytest.mark.buildconfigspec('cmd_memory')
|
|
def test_mmc_fatload_fatwrite(ubman):
|
|
if not mmc_set_up:
|
|
pytest.skip('No SD/MMC/eMMC controller available')
|
|
|
|
if not devices:
|
|
pytest.skip('No devices detected')
|
|
|
|
part_detect = 0
|
|
fs = 'fat'
|
|
for x in range(0, controllers):
|
|
if devices[x]['detected'] == 'yes':
|
|
try:
|
|
partitions = devices[x][fs]
|
|
except:
|
|
print('No %s table on this device' % fs.upper())
|
|
continue
|
|
|
|
for part in partitions:
|
|
for y in mmc_modes:
|
|
ubman.run_command('mmc dev %d %d %d' % x, part, y)
|
|
part_detect = 1
|
|
addr = utils.find_ram_base(ubman)
|
|
devices[x]['addr_%d' % part] = addr
|
|
size = random.randint(4, 1 * 1024 * 1024)
|
|
devices[x]['size_%d' % part] = size
|
|
# count CRC32
|
|
output = ubman.run_command('crc32 %x %x' % (addr, size))
|
|
m = re.search('==> (.+?)', output)
|
|
if not m:
|
|
pytest.fail('CRC32 failed')
|
|
expected_crc32 = m.group(1)
|
|
devices[x]['expected_crc32_%d' % part] = expected_crc32
|
|
# do write
|
|
file = '%s_%d' % ('uboot_test', size)
|
|
devices[x]['file_%d' % part] = file
|
|
output = ubman.run_command(
|
|
'%swrite mmc %d:%s %x %s %x' % (fs, x, part, addr, file, size)
|
|
)
|
|
assert 'Unable to write' not in output
|
|
assert 'Error' not in output
|
|
assert 'overflow' not in output
|
|
expected_text = '%d bytes written' % size
|
|
assert expected_text in output
|
|
|
|
alignment = int(
|
|
ubman.config.buildconfig.get(
|
|
'config_sys_cacheline_size', 128
|
|
)
|
|
)
|
|
offset = random.randrange(alignment, 1024, alignment)
|
|
output = ubman.run_command(
|
|
'%sload mmc %d:%s %x %s' % (fs, x, part, addr + offset, file)
|
|
)
|
|
assert 'Invalid FAT entry' not in output
|
|
assert 'Unable to read file' not in output
|
|
assert 'Misaligned buffer address' not in output
|
|
expected_text = '%d bytes read' % size
|
|
assert expected_text in output
|
|
|
|
output = ubman.run_command(
|
|
'crc32 %x $filesize' % (addr + offset)
|
|
)
|
|
assert expected_crc32 in output
|
|
|
|
if not part_detect:
|
|
pytest.skip('No %s partition detected' % fs.upper())
|
|
|
|
@pytest.mark.buildconfigspec('cmd_mmc')
|
|
@pytest.mark.buildconfigspec('cmd_ext4')
|
|
def test_mmc_ext4ls(ubman):
|
|
if not mmc_set_up:
|
|
pytest.skip('No SD/MMC/eMMC controller available')
|
|
|
|
if not devices:
|
|
pytest.skip('No devices detected')
|
|
|
|
part_detect = 0
|
|
fs = 'ext4'
|
|
for x in range(0, controllers):
|
|
if devices[x]['detected'] == 'yes':
|
|
try:
|
|
partitions = devices[x][fs]
|
|
except:
|
|
print('No %s table on this device' % fs.upper())
|
|
continue
|
|
|
|
for part in partitions:
|
|
for y in mmc_modes:
|
|
ubman.run_command('mmc dev %d %d %d' % x, part, y)
|
|
output = ubman.run_command(
|
|
'%sls mmc %d:%s' % (fs, x, part)
|
|
)
|
|
if 'Unrecognized filesystem type' in output:
|
|
partitions.remove(part)
|
|
pytest.fail('Unrecognized filesystem')
|
|
part_detect = 1
|
|
|
|
if not part_detect:
|
|
pytest.skip('No %s partition detected' % fs.upper())
|
|
|
|
@pytest.mark.buildconfigspec('cmd_mmc')
|
|
@pytest.mark.buildconfigspec('cmd_ext4')
|
|
@pytest.mark.buildconfigspec('ext4_write')
|
|
@pytest.mark.buildconfigspec('cmd_memory')
|
|
def test_mmc_ext4load_ext4write(ubman):
|
|
if not mmc_set_up:
|
|
pytest.skip('No SD/MMC/eMMC controller available')
|
|
|
|
if not devices:
|
|
pytest.skip('No devices detected')
|
|
|
|
part_detect = 0
|
|
fs = 'ext4'
|
|
for x in range(0, controllers):
|
|
if devices[x]['detected'] == 'yes':
|
|
try:
|
|
partitions = devices[x][fs]
|
|
except:
|
|
print('No %s table on this device' % fs.upper())
|
|
continue
|
|
|
|
for part in partitions:
|
|
for y in mmc_modes:
|
|
ubman.run_command('mmc dev %d %d %d' % x, part, y)
|
|
part_detect = 1
|
|
addr = utils.find_ram_base(ubman)
|
|
devices[x]['addr_%d' % part] = addr
|
|
size = random.randint(4, 1 * 1024 * 1024)
|
|
devices[x]['size_%d' % part] = size
|
|
# count CRC32
|
|
output = ubman.run_command('crc32 %x %x' % (addr, size))
|
|
m = re.search('==> (.+?)', output)
|
|
if not m:
|
|
pytest.fail('CRC32 failed')
|
|
expected_crc32 = m.group(1)
|
|
devices[x]['expected_crc32_%d' % part] = expected_crc32
|
|
|
|
# do write
|
|
file = '%s_%d' % ('uboot_test', size)
|
|
devices[x]['file_%d' % part] = file
|
|
output = ubman.run_command(
|
|
'%swrite mmc %d:%s %x /%s %x' % (fs, x, part, addr, file, size)
|
|
)
|
|
assert 'Unable to write' not in output
|
|
assert 'Error' not in output
|
|
assert 'overflow' not in output
|
|
expected_text = '%d bytes written' % size
|
|
assert expected_text in output
|
|
|
|
offset = random.randrange(128, 1024, 128)
|
|
output = ubman.run_command(
|
|
'%sload mmc %d:%s %x /%s' % (fs, x, part, addr + offset, file)
|
|
)
|
|
expected_text = '%d bytes read' % size
|
|
assert expected_text in output
|
|
|
|
output = ubman.run_command(
|
|
'crc32 %x $filesize' % (addr + offset)
|
|
)
|
|
assert expected_crc32 in output
|
|
|
|
if not part_detect:
|
|
pytest.skip('No %s partition detected' % fs.upper())
|
|
|
|
@pytest.mark.buildconfigspec('cmd_mmc')
|
|
@pytest.mark.buildconfigspec('cmd_ext2')
|
|
def test_mmc_ext2ls(ubman):
|
|
if not mmc_set_up:
|
|
pytest.skip('No SD/MMC/eMMC controller available')
|
|
|
|
if not devices:
|
|
pytest.skip('No devices detected')
|
|
|
|
part_detect = 0
|
|
fs = 'ext2'
|
|
for x in range(0, controllers):
|
|
if devices[x]['detected'] == 'yes':
|
|
try:
|
|
partitions = devices[x][fs]
|
|
except:
|
|
print('No %s table on this device' % fs.upper())
|
|
continue
|
|
|
|
for part in partitions:
|
|
for y in mmc_modes:
|
|
ubman.run_command('mmc dev %d %d %d' % x, part, y)
|
|
part_detect = 1
|
|
output = ubman.run_command(
|
|
'%sls mmc %d:%s' % (fs, x, part)
|
|
)
|
|
if 'Unrecognized filesystem type' in output:
|
|
partitions.remove(part)
|
|
pytest.fail('Unrecognized filesystem')
|
|
part_detect = 1
|
|
|
|
if not part_detect:
|
|
pytest.skip('No %s partition detected' % fs.upper())
|
|
|
|
@pytest.mark.buildconfigspec('cmd_mmc')
|
|
@pytest.mark.buildconfigspec('cmd_ext2')
|
|
@pytest.mark.buildconfigspec('cmd_ext4')
|
|
@pytest.mark.buildconfigspec('ext4_write')
|
|
@pytest.mark.buildconfigspec('cmd_memory')
|
|
def test_mmc_ext2load(ubman):
|
|
if not mmc_set_up:
|
|
pytest.skip('No SD/MMC/eMMC controller available')
|
|
|
|
if not devices:
|
|
pytest.skip('No devices detected')
|
|
|
|
part_detect = 0
|
|
fs = 'ext2'
|
|
for x in range(0, controllers):
|
|
if devices[x]['detected'] == 'yes':
|
|
try:
|
|
partitions = devices[x][fs]
|
|
except:
|
|
print('No %s table on this device' % fs.upper())
|
|
continue
|
|
|
|
for part in partitions:
|
|
for y in mmc_modes:
|
|
ubman.run_command('mmc dev %d %d %d' % x, part, y)
|
|
part_detect = 1
|
|
addr = devices[x]['addr_%d' % part]
|
|
size = devices[x]['size_%d' % part]
|
|
expected_crc32 = devices[x]['expected_crc32_%d' % part]
|
|
file = devices[x]['file_%d' % part]
|
|
|
|
offset = random.randrange(128, 1024, 128)
|
|
output = ubman.run_command(
|
|
'%sload mmc %d:%s %x /%s' % (fs, x, part, addr + offset, file)
|
|
)
|
|
expected_text = '%d bytes read' % size
|
|
assert expected_text in output
|
|
|
|
output = ubman.run_command(
|
|
'crc32 %x $filesize' % (addr + offset)
|
|
)
|
|
assert expected_crc32 in output
|
|
|
|
if not part_detect:
|
|
pytest.skip('No %s partition detected' % fs.upper())
|
|
|
|
@pytest.mark.buildconfigspec('cmd_mmc')
|
|
@pytest.mark.buildconfigspec('cmd_fs_generic')
|
|
def test_mmc_ls(ubman):
|
|
if not mmc_set_up:
|
|
pytest.skip('No SD/MMC/eMMC controller available')
|
|
|
|
if not devices:
|
|
pytest.skip('No devices detected')
|
|
|
|
part_detect = 0
|
|
for x in range(0, controllers):
|
|
if devices[x]['detected'] == 'yes':
|
|
for fs in ['fat', 'ext4', 'ext2']:
|
|
try:
|
|
partitions = devices[x][fs]
|
|
except:
|
|
print('No %s table on this device' % fs.upper())
|
|
continue
|
|
|
|
for part in partitions:
|
|
for y in mmc_modes:
|
|
ubman.run_command('mmc dev %d %d %d' % x, part, y)
|
|
part_detect = 1
|
|
output = ubman.run_command('ls mmc %d:%s' % (x, part))
|
|
if re.search(r'No \w+ table on this device', output):
|
|
pytest.fail(
|
|
'%s: Partition table not found %d' % (fs.upper(), x)
|
|
)
|
|
|
|
if not part_detect:
|
|
pytest.skip('No partition detected')
|
|
|
|
@pytest.mark.buildconfigspec('cmd_mmc')
|
|
@pytest.mark.buildconfigspec('cmd_fs_generic')
|
|
def test_mmc_load(ubman):
|
|
if not mmc_set_up:
|
|
pytest.skip('No SD/MMC/eMMC controller available')
|
|
|
|
if not devices:
|
|
pytest.skip('No devices detected')
|
|
|
|
part_detect = 0
|
|
for x in range(0, controllers):
|
|
if devices[x]['detected'] == 'yes':
|
|
for fs in ['fat', 'ext4', 'ext2']:
|
|
try:
|
|
partitions = devices[x][fs]
|
|
except:
|
|
print('No %s table on this device' % fs.upper())
|
|
continue
|
|
|
|
for part in partitions:
|
|
for y in mmc_modes:
|
|
ubman.run_command('mmc dev %d %d %d' % x, part, y)
|
|
part_detect = 1
|
|
addr = devices[x]['addr_%d' % part]
|
|
size = devices[x]['size_%d' % part]
|
|
expected_crc32 = devices[x]['expected_crc32_%d' % part]
|
|
file = devices[x]['file_%d' % part]
|
|
|
|
offset = random.randrange(128, 1024, 128)
|
|
output = ubman.run_command(
|
|
'load mmc %d:%s %x /%s' % (x, part, addr + offset, file)
|
|
)
|
|
expected_text = '%d bytes read' % size
|
|
assert expected_text in output
|
|
|
|
output = ubman.run_command(
|
|
'crc32 %x $filesize' % (addr + offset)
|
|
)
|
|
assert expected_crc32 in output
|
|
|
|
if not part_detect:
|
|
pytest.skip('No partition detected')
|
|
|
|
@pytest.mark.buildconfigspec('cmd_mmc')
|
|
@pytest.mark.buildconfigspec('cmd_fs_generic')
|
|
def test_mmc_save(ubman):
|
|
if not mmc_set_up:
|
|
pytest.skip('No SD/MMC/eMMC controller available')
|
|
|
|
if not devices:
|
|
pytest.skip('No devices detected')
|
|
|
|
part_detect = 0
|
|
for x in range(0, controllers):
|
|
if devices[x]['detected'] == 'yes':
|
|
for fs in ['fat', 'ext4', 'ext2']:
|
|
try:
|
|
partitions = devices[x][fs]
|
|
except:
|
|
print('No %s table on this device' % fs.upper())
|
|
continue
|
|
|
|
for part in partitions:
|
|
for y in mmc_modes:
|
|
ubman.run_command('mmc dev %d %d %d' % x, part, y)
|
|
part_detect = 1
|
|
addr = devices[x]['addr_%d' % part]
|
|
size = 0
|
|
file = devices[x]['file_%d' % part]
|
|
|
|
offset = random.randrange(128, 1024, 128)
|
|
output = ubman.run_command(
|
|
'save mmc %d:%s %x /%s %d'
|
|
% (x, part, addr + offset, file, size)
|
|
)
|
|
expected_text = '%d bytes written' % size
|
|
assert expected_text in output
|
|
|
|
if not part_detect:
|
|
pytest.skip('No partition detected')
|
|
|
|
@pytest.mark.buildconfigspec('cmd_mmc')
|
|
@pytest.mark.buildconfigspec('cmd_fat')
|
|
@pytest.mark.buildconfigspec('cmd_memory')
|
|
def test_mmc_fat_read_write_files(ubman):
|
|
test_mmc_list(ubman)
|
|
test_mmc_dev(ubman)
|
|
test_mmcinfo(ubman)
|
|
test_mmc_part(ubman)
|
|
if not mmc_set_up:
|
|
pytest.skip('No SD/MMC/eMMC controller available')
|
|
|
|
if not devices:
|
|
pytest.skip('No devices detected')
|
|
|
|
part_detect = 0
|
|
fs = 'fat'
|
|
|
|
# Number of files to be written/read in MMC card
|
|
num_files = 100
|
|
|
|
for x in range(0, controllers):
|
|
if devices[x]['detected'] == 'yes':
|
|
try:
|
|
partitions = devices[x][fs]
|
|
except:
|
|
print('No %s table on this device' % fs.upper())
|
|
continue
|
|
|
|
for part in partitions:
|
|
for y in mmc_modes:
|
|
ubman.run_command('mmc dev %d %d %d' % x, part, y)
|
|
part_detect = 1
|
|
addr = utils.find_ram_base(ubman)
|
|
count_f = 0
|
|
addr_l = []
|
|
size_l = []
|
|
file_l = []
|
|
crc32_l = []
|
|
offset_l = []
|
|
addr_l.append(addr)
|
|
|
|
while count_f < num_files:
|
|
size_l.append(random.randint(4, 1 * 1024 * 1024))
|
|
|
|
# CRC32 count
|
|
output = ubman.run_command(
|
|
'crc32 %x %x' % (addr_l[count_f], size_l[count_f])
|
|
)
|
|
m = re.search('==> (.+?)', output)
|
|
if not m:
|
|
pytest.fail('CRC32 failed')
|
|
crc32_l.append(m.group(1))
|
|
|
|
# Write operation
|
|
file_l.append(
|
|
'%s_%d_%d' % ('uboot_test', count_f, size_l[count_f])
|
|
)
|
|
output = ubman.run_command(
|
|
'%swrite mmc %d:%s %x %s %x'
|
|
% (
|
|
fs,
|
|
x,
|
|
part,
|
|
addr_l[count_f],
|
|
file_l[count_f],
|
|
size_l[count_f],
|
|
)
|
|
)
|
|
assert 'Unable to write' not in output
|
|
assert 'Error' not in output
|
|
assert 'overflow' not in output
|
|
expected_text = '%d bytes written' % size_l[count_f]
|
|
assert expected_text in output
|
|
|
|
addr_l.append(addr_l[count_f] + size_l[count_f] + 1048576)
|
|
count_f += 1
|
|
|
|
count_f = 0
|
|
while count_f < num_files:
|
|
alignment = int(
|
|
ubman.config.buildconfig.get(
|
|
'config_sys_cacheline_size', 128
|
|
)
|
|
)
|
|
offset_l.append(random.randrange(alignment, 1024, alignment))
|
|
|
|
# Read operation
|
|
output = ubman.run_command(
|
|
'%sload mmc %d:%s %x %s'
|
|
% (
|
|
fs,
|
|
x,
|
|
part,
|
|
addr_l[count_f] + offset_l[count_f],
|
|
file_l[count_f],
|
|
)
|
|
)
|
|
assert 'Invalid FAT entry' not in output
|
|
assert 'Unable to read file' not in output
|
|
assert 'Misaligned buffer address' not in output
|
|
expected_text = '%d bytes read' % size_l[count_f]
|
|
assert expected_text in output
|
|
|
|
output = ubman.run_command(
|
|
'crc32 %x $filesize' % (addr_l[count_f] + offset_l[count_f])
|
|
)
|
|
assert crc32_l[count_f] in output
|
|
|
|
count_f += 1
|
|
|
|
if not part_detect:
|
|
pytest.skip('No %s partition detected' % fs.upper())
|