diff mbox series

test/py: mmc: Add support for different mmc modes

Message ID 885b2f4019dd9a4d76a6ed9b8393bd99bf813392.1731401816.git.love.kumar@amd.com
State Accepted
Delegated to: Tom Rini
Headers show
Series test/py: mmc: Add support for different mmc modes | expand

Commit Message

Love Kumar Nov. 12, 2024, 8:57 a.m. UTC
Currently, MMC test runs on default mmc modes, adding a provision to
support multiple mmc modes through user defined parameters.

Signed-off-by: Love Kumar <love.kumar@amd.com>
---
 test/py/tests/test_mmc.py | 608 +++++++++++++++++++++-----------------
 1 file changed, 335 insertions(+), 273 deletions(-)

Comments

Tom Rini Nov. 18, 2024, 2:19 p.m. UTC | #1
On Tue, 12 Nov 2024 14:27:56 +0530, Love Kumar wrote:

> Currently, MMC test runs on default mmc modes, adding a provision to
> support multiple mmc modes through user defined parameters.
> 
> 

Applied to u-boot/next, thanks!
diff mbox series

Patch

diff --git a/test/py/tests/test_mmc.py b/test/py/tests/test_mmc.py
index 1193f4a95737..462404338844 100644
--- a/test/py/tests/test_mmc.py
+++ b/test/py/tests/test_mmc.py
@@ -18,16 +18,55 @@  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(cons):
+    global mmc_modes, mmc_modes_name
+    f = cons.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 cons.config.buildconfig.get('config_mmc_speed_mode_set', 'n') != 'y':
+        mmc_modes = [0]
+        return
+
+    if mmc_modes_name:
+        mmc_help = cons.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(u_boot_console):
     if u_boot_console.config.env.get('env__mmc_device_test_skip', True):
         pytest.skip('MMC device test is not enabled')
 
+    setup_mmc_modes(u_boot_console)
+
 @pytest.mark.buildconfigspec('cmd_mmc')
 def test_mmc_list(u_boot_console):
     setup_mmc(u_boot_console)
@@ -58,21 +97,22 @@  def test_mmc_dev(u_boot_console):
     fail = 0
     for x in range(0, controllers):
         devices[x]['detected'] = 'yes'
-        output = u_boot_console.run_command('mmc dev %d' % x)
 
-        # Some sort of switch here
-        if 'Card did not respond to voltage select' in output:
-            fail = 1
-            devices[x]['detected'] = 'no'
+        for y in mmc_modes:
+            output = u_boot_console.run_command('mmc dev %d 0 %d' % x, y)
 
-        if 'no mmc device at slot' in output:
-            devices[x]['detected'] = 'no'
+            if 'Card did not respond to voltage select' in output:
+                fail = 1
+                devices[x]['detected'] = 'no'
 
-        if 'MMC: no card present' in output:
-            devices[x]['detected'] = 'no'
+            if 'no mmc device at slot' in output:
+                devices[x]['detected'] = 'no'
 
-    if fail:
-        pytest.fail('Card not present')
+            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(u_boot_console):
@@ -81,19 +121,22 @@  def test_mmcinfo(u_boot_console):
 
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
-            output = u_boot_console.run_command('mmcinfo')
-            if 'busy timeout' in output:
-                pytest.skip('No SD/MMC/eMMC device present')
+            for y in mmc_modes:
+                u_boot_console.run_command('mmc dev %d 0 %d' % x, y)
+                output = u_boot_console.run_command('mmcinfo')
+                if 'busy timeout' in output:
+                    pytest.skip('No SD/MMC/eMMC device present')
 
-            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')
+                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(u_boot_console):
@@ -102,19 +145,21 @@  def test_mmc_info(u_boot_console):
 
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
+            for y in mmc_modes:
+                u_boot_console.run_command('mmc dev %d 0 %d' % x, y)
 
-            output = u_boot_console.run_command('mmc info')
+                output = u_boot_console.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")
+                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')
+                except ValueError:
+                    pytest.fail('MMC capacity not recognized')
 
 @pytest.mark.buildconfigspec('cmd_mmc')
 def test_mmc_rescan(u_boot_console):
@@ -126,12 +171,13 @@  def test_mmc_rescan(u_boot_console):
 
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
-            output = u_boot_console.run_command('mmc rescan')
-            if output:
-                pytest.fail('mmc rescan has something to check')
-            output = u_boot_console.run_command('echo $?')
-            assert output.endswith('0')
+            for y in mmc_modes:
+                u_boot_console.run_command('mmc dev %d 0 %d' % x, y)
+                output = u_boot_console.run_command('mmc rescan')
+                if output:
+                    pytest.fail('mmc rescan has something to check')
+                output = u_boot_console.run_command('echo $?')
+                assert output.endswith('0')
 
 @pytest.mark.buildconfigspec('cmd_mmc')
 def test_mmc_part(u_boot_console):
@@ -192,7 +238,6 @@  def test_mmc_fatls_fatinfo(u_boot_console):
     fs = 'fat'
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
             try:
                 partitions = devices[x][fs]
             except:
@@ -200,20 +245,22 @@  def test_mmc_fatls_fatinfo(u_boot_console):
                 continue
 
             for part in partitions:
-                output = u_boot_console.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 = u_boot_console.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
+                for y in mmc_modes:
+                    u_boot_console.run_command('mmc dev %d %d %d' % x, part, y)
+                    output = u_boot_console.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 = u_boot_console.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())
@@ -233,7 +280,6 @@  def test_mmc_fatload_fatwrite(u_boot_console):
     fs = 'fat'
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
             try:
                 partitions = devices[x][fs]
             except:
@@ -241,49 +287,51 @@  def test_mmc_fatload_fatwrite(u_boot_console):
                 continue
 
             for part in partitions:
-                part_detect = 1
-                addr = u_boot_utils.find_ram_base(u_boot_console)
-                devices[x]['addr_%d' % part] = addr
-                size = random.randint(4, 1 * 1024 * 1024)
-                devices[x]['size_%d' % part] = size
-                # count CRC32
-                output = u_boot_console.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 = u_boot_console.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(
-                    u_boot_console.config.buildconfig.get(
-                        'config_sys_cacheline_size', 128
+                for y in mmc_modes:
+                    u_boot_console.run_command('mmc dev %d %d %d' % x, part, y)
+                    part_detect = 1
+                    addr = u_boot_utils.find_ram_base(u_boot_console)
+                    devices[x]['addr_%d' % part] = addr
+                    size = random.randint(4, 1 * 1024 * 1024)
+                    devices[x]['size_%d' % part] = size
+                    # count CRC32
+                    output = u_boot_console.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 = u_boot_console.run_command(
+                        '%swrite mmc %d:%s %x %s %x' % (fs, x, part, addr, file, size)
                     )
-                )
-                offset = random.randrange(alignment, 1024, alignment)
-                output = u_boot_console.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 = u_boot_console.run_command(
-                    'crc32 %x $filesize' % (addr + offset)
-                )
-                assert expected_crc32 in output
+                    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(
+                        u_boot_console.config.buildconfig.get(
+                            'config_sys_cacheline_size', 128
+                        )
+                    )
+                    offset = random.randrange(alignment, 1024, alignment)
+                    output = u_boot_console.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 = u_boot_console.run_command(
+                        'crc32 %x $filesize' % (addr + offset)
+                    )
+                    assert expected_crc32 in output
 
     if not part_detect:
         pytest.skip('No %s partition detected' % fs.upper())
@@ -307,13 +355,16 @@  def test_mmc_ext4ls(u_boot_console):
                 print('No %s table on this device' % fs.upper())
                 continue
 
-            u_boot_console.run_command('mmc dev %d' % x)
             for part in partitions:
-                output = u_boot_console.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
+                for y in mmc_modes:
+                    u_boot_console.run_command('mmc dev %d %d %d' % x, part, y)
+                    output = u_boot_console.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())
@@ -333,7 +384,6 @@  def test_mmc_ext4load_ext4write(u_boot_console):
     fs = 'ext4'
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
             try:
                 partitions = devices[x][fs]
             except:
@@ -341,42 +391,44 @@  def test_mmc_ext4load_ext4write(u_boot_console):
                 continue
 
             for part in partitions:
-                part_detect = 1
-                addr = u_boot_utils.find_ram_base(u_boot_console)
-                devices[x]['addr_%d' % part] = addr
-                size = random.randint(4, 1 * 1024 * 1024)
-                devices[x]['size_%d' % part] = size
-                # count CRC32
-                output = u_boot_console.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 = u_boot_console.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 = u_boot_console.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 = u_boot_console.run_command(
-                    'crc32 %x $filesize' % (addr + offset)
-                )
-                assert expected_crc32 in output
+                for y in mmc_modes:
+                    u_boot_console.run_command('mmc dev %d %d %d' % x, part, y)
+                    part_detect = 1
+                    addr = u_boot_utils.find_ram_base(u_boot_console)
+                    devices[x]['addr_%d' % part] = addr
+                    size = random.randint(4, 1 * 1024 * 1024)
+                    devices[x]['size_%d' % part] = size
+                    # count CRC32
+                    output = u_boot_console.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 = u_boot_console.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 = u_boot_console.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 = u_boot_console.run_command(
+                        'crc32 %x $filesize' % (addr + offset)
+                    )
+                    assert expected_crc32 in output
 
     if not part_detect:
         pytest.skip('No %s partition detected' % fs.upper())
@@ -394,7 +446,6 @@  def test_mmc_ext2ls(u_boot_console):
     fs = 'ext2'
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
             try:
                 partitions = devices[x][fs]
             except:
@@ -402,12 +453,16 @@  def test_mmc_ext2ls(u_boot_console):
                 continue
 
             for part in partitions:
-                part_detect = 1
-                output = u_boot_console.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
+                for y in mmc_modes:
+                    u_boot_console.run_command('mmc dev %d %d %d' % x, part, y)
+                    part_detect = 1
+                    output = u_boot_console.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())
@@ -428,7 +483,6 @@  def test_mmc_ext2load(u_boot_console):
     fs = 'ext2'
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
             try:
                 partitions = devices[x][fs]
             except:
@@ -436,23 +490,25 @@  def test_mmc_ext2load(u_boot_console):
                 continue
 
             for part in partitions:
-                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 = u_boot_console.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 = u_boot_console.run_command(
-                    'crc32 %x $filesize' % (addr + offset)
-                )
-                assert expected_crc32 in output
+                for y in mmc_modes:
+                    u_boot_console.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 = u_boot_console.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 = u_boot_console.run_command(
+                        'crc32 %x $filesize' % (addr + offset)
+                    )
+                    assert expected_crc32 in output
 
     if not part_detect:
         pytest.skip('No %s partition detected' % fs.upper())
@@ -469,7 +525,6 @@  def test_mmc_ls(u_boot_console):
     part_detect = 0
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
             for fs in ['fat', 'ext4', 'ext2']:
                 try:
                     partitions = devices[x][fs]
@@ -478,12 +533,14 @@  def test_mmc_ls(u_boot_console):
                     continue
 
                 for part in partitions:
-                    part_detect = 1
-                    output = u_boot_console.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)
-                        )
+                    for y in mmc_modes:
+                        u_boot_console.run_command('mmc dev %d %d %d' % x, part, y)
+                        part_detect = 1
+                        output = u_boot_console.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')
@@ -500,7 +557,6 @@  def test_mmc_load(u_boot_console):
     part_detect = 0
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
             for fs in ['fat', 'ext4', 'ext2']:
                 try:
                     partitions = devices[x][fs]
@@ -509,23 +565,25 @@  def test_mmc_load(u_boot_console):
                     continue
 
                 for part in partitions:
-                    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 = u_boot_console.run_command(
-                        'load mmc %d:%s %x /%s' % (x, part, addr + offset, file)
-                    )
-                    expected_text = '%d bytes read' % size
-                    assert expected_text in output
+                    for y in mmc_modes:
+                        u_boot_console.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 = u_boot_console.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 = u_boot_console.run_command(
-                        'crc32 %x $filesize' % (addr + offset)
-                    )
-                    assert expected_crc32 in output
+                        output = u_boot_console.run_command(
+                            'crc32 %x $filesize' % (addr + offset)
+                        )
+                        assert expected_crc32 in output
 
     if not part_detect:
         pytest.skip('No partition detected')
@@ -542,7 +600,6 @@  def test_mmc_save(u_boot_console):
     part_detect = 0
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
             for fs in ['fat', 'ext4', 'ext2']:
                 try:
                     partitions = devices[x][fs]
@@ -551,18 +608,20 @@  def test_mmc_save(u_boot_console):
                     continue
 
                 for part in partitions:
-                    part_detect = 1
-                    addr = devices[x]['addr_%d' % part]
-                    size = 0
-                    file = devices[x]['file_%d' % part]
-
-                    offset = random.randrange(128, 1024, 128)
-                    output = u_boot_console.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
+                    for y in mmc_modes:
+                        u_boot_console.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 = u_boot_console.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')
@@ -589,7 +648,6 @@  def test_mmc_fat_read_write_files(u_boot_console):
 
     for x in range(0, controllers):
         if devices[x]['detected'] == 'yes':
-            u_boot_console.run_command('mmc dev %d' % x)
             try:
                 partitions = devices[x][fs]
             except:
@@ -597,82 +655,86 @@  def test_mmc_fat_read_write_files(u_boot_console):
                 continue
 
             for part in partitions:
-                part_detect = 1
-                addr = u_boot_utils.find_ram_base(u_boot_console)
-                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 = u_boot_console.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 = u_boot_console.run_command(
-                        '%swrite mmc %d:%s %x %s %x'
-                        % (
-                            fs,
-                            x,
-                            part,
-                            addr_l[count_f],
-                            file_l[count_f],
-                            size_l[count_f],
+                for y in mmc_modes:
+                    u_boot_console.run_command('mmc dev %d %d %d' % x, part, y)
+                    part_detect = 1
+                    addr = u_boot_utils.find_ram_base(u_boot_console)
+                    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 = u_boot_console.run_command(
+                            'crc32 %x %x' % (addr_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(
-                        u_boot_console.config.buildconfig.get(
-                            'config_sys_cacheline_size', 128
+                        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])
                         )
-                    )
-                    offset_l.append(random.randrange(alignment, 1024, alignment))
+                        output = u_boot_console.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(
+                            u_boot_console.config.buildconfig.get(
+                                'config_sys_cacheline_size', 128
+                            )
+                        )
+                        offset_l.append(random.randrange(alignment, 1024, alignment))
 
-                    # Read operation
-                    output = u_boot_console.run_command(
-                        '%sload mmc %d:%s %x %s'
-                        % (
-                            fs,
-                            x,
-                            part,
-                            addr_l[count_f] + offset_l[count_f],
-                            file_l[count_f],
+                        # Read operation
+                        output = u_boot_console.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
+                        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 = u_boot_console.run_command(
-                        'crc32 %x $filesize' % (addr_l[count_f] + offset_l[count_f])
-                    )
-                    assert crc32_l[count_f] in output
+                        output = u_boot_console.run_command(
+                            'crc32 %x $filesize' % (addr_l[count_f] + offset_l[count_f])
+                        )
+                        assert crc32_l[count_f] in output
 
-                    count_f += 1
+                        count_f += 1
 
     if not part_detect:
         pytest.skip('No %s partition detected' % fs.upper())