Merge lp:~milo/linaro-image-tools/boards-refactoring into lp:linaro-image-tools/11.11

[Milo Casagrande]

Boards class refactoring and clean-up.

Second, and a little big, merge request.

This is the initial refactoring work of the boards module moving from class methods to instance methods.
Some code needs further clean-up. In this branch tests have not been fixed.

[lp:~milo/linaro-image-tools/boards-refactoring]

592. By Milo Casagrande on 2012-12-07

Merged hwpack-handler into boards-refactoring.

593. By Milo Casagrande on 2012-12-10

Merged from trunk.

594. By Milo Casagrande on 2012-12-10

Readedd wrongly removed attribute.

[Paul Sokolovsky (pfalcon)]

No reason was given for going from class to instance attributes, neither in commit message, nor in MR. Why would that matter? And character content of changes is massive, typo can lurk in easily. Merging this without passing tests is a bit brave IMHO.

review: Abstain

[Milo Casagrande (milo)]

> No reason was given for going from class to instance attributes, neither in
> commit message, nor in MR. Why would that matter?

You are right, I just discussed this with Danilo.
The problem is due to the introduction of the Android hwpack: a config file that needs to be parsed, and whose values have to be stored in the already defined board classes (both in AndrodiBoardConfig and in BoardConfig, since the former inherits from the latter and uses methods defined in its own and also from the parent one).

The problem I had with the first easy implementation (just parse the file and use everything as it was), was that it was not working, and tests were failing simply because the values were not correctly stored and the "default" ones were used. After a little bit of investigation and trying with different approaches, the "easiest" solution would have been to switch to instance attributes and methods instead of class based ones.

This is due to the fact that I wanted to have an easy way to set-up the attribute values, moslty using getattr and setattr, that work only with instances, not classes. In the old code, the attribute or properties where custom-defined as "classproperty", something that python does not have natively: keeping that approach would have meant an hack to be able to properly set the "classproperty" (not really an hack, but something that doesn't feel natual and definitely not easy to implement: we would have had to use "metaclasses"), since the get part is the only one to work correctly, and defining a class-based setter is close to impossible.

> And character content of
> changes is massive, typo can lurk in easily. Merging this without passing
> tests is a bit brave IMHO.

You are right, but if I fix the tests in the same MP, it will be even bigger than it is now (and there will be that complaint :-P). The tests have been fixed and the branches should be applied one on top of the other until the last one. I know it is sub-optimal, but at least changes have been split out into "smaller" review chunks (even if they result in more than 2000 lines). If I put the test fixes here, I will add almost 3000 more lines.

[Paul Sokolovsky (pfalcon)]

Thanks for explanation, makes sense to clean up that mess.

If tests are updated in following merge and pass, then it looks good.

review: Approve

[lp:~milo/linaro-image-tools/boards-refactoring]

595. By Milo Casagrande on 2012-12-27

Merged from trunk.

596. By Milo Casagrande on 2012-12-27

Refactored OrigenQuad to be an instance.

597. By Milo Casagrande on 2012-12-27

Merged from trunk.

598. By Milo Casagrande on 2012-12-27

Merged from trunk.

=== modified file 'linaro-media-create'
--- linaro-media-create	2012-10-22 06:57:20 +0000
+++ linaro-media-create	2012-12-27 15:00:29 +0000
@@ -25,7 +25,7 @@
 
 from linaro_image_tools import cmd_runner
 
-from linaro_image_tools.media_create.boards import board_configs
+from linaro_image_tools.media_create.boards import get_board_config
 from linaro_image_tools.media_create.check_device import (
     confirm_device_selection_and_ensure_it_is_ready)
 from linaro_image_tools.media_create.chroot_utils import (
@@ -131,9 +131,9 @@
         logger.error(e.value)
         sys.exit(1)
 
-    board_config = board_configs[args.dev]
+    board_config = get_board_config(args.dev)
     board_config.set_metadata(args.hwpacks, args.bootloader, args.dev)
-    board_config.set_board(args.dev)
+    board_config.board(args.dev)
     board_config.add_boot_args(args.extra_boot_args)
     board_config.add_boot_args_from_file(args.extra_boot_args_file)
 

=== modified file 'linaro_image_tools/media_create/boards.py'
--- linaro_image_tools/media_create/boards.py	2012-12-23 12:49:02 +0000
+++ linaro_image_tools/media_create/boards.py	2012-12-27 15:00:29 +0000
@@ -24,24 +24,59 @@
 board_configs at the bottom of this file.
 """
 
+from binascii import crc32
+from parted import Device
 import atexit
 import glob
+import logging
 import os
 import re
+import string
+import struct
 import tempfile
-import struct
-from binascii import crc32
-import string
-import logging
-
-from parted import Device
 
 from linaro_image_tools import cmd_runner
 
+from linaro_image_tools.hwpack.handler import HardwarepackHandler
 from linaro_image_tools.media_create.partitions import (
-    partition_mounted, SECTOR_SIZE, register_loopback)
+    SECTOR_SIZE,
+    partition_mounted,
+    register_loopback,
+    )
 
-from linaro_image_tools.hwpack.handler import HardwarepackHandler
+from linaro_image_tools.hwpack.hwpack_fields import (
+    BOOTFS,
+    BOOTFS16,
+    BOOT_MIN_SIZE_FIELD,
+    BOOT_SCRIPT_FIELD,
+    DTB_ADDR_FIELD,
+    DTB_FILES_FIELD,
+    DTB_FILE_FIELD,
+    ENV_DD_FIELD,
+    EXTRA_BOOT_OPTIONS_FIELD,
+    EXTRA_SERIAL_OPTIONS_FIELD,
+    INITRD_ADDR_FIELD,
+    KERNEL_ADDR_FIELD,
+    LOADER_MIN_SIZE_FIELD,
+    LOADER_START_FIELD,
+    LOAD_ADDR_FIELD,
+    MMC_ID_FIELD,
+    PARTITION_LAYOUT_FIELD,
+    RESERVED_BOOTFS,
+    ROOT_MIN_SIZE_FIELD,
+    SAMSUNG_BL1_LEN_FIELD,
+    SAMSUNG_BL1_START_FIELD,
+    SAMSUNG_BL2_LEN_FIELD,
+    SAMSUNG_BL2_START_FIELD,
+    SAMSUNG_ENV_LEN_FIELD,
+    SAMSUNG_ENV_START_FILED,
+    SERIAL_TTY_FIELD,
+    SNOWBALL_STARTUP_FILES_CONFIG_FIELD,
+    SPL_DD_FIELD,
+    SPL_IN_BOOT_PART_FIELD,
+    WIRED_INTERFACES_FIELD,
+    WIRELESS_INTERFACES_FIELD,
+    )
 
 logger = logging.getLogger(__name__)
 
@@ -102,310 +137,290 @@
     cmd_runner.run(cmd, as_root=True).wait()
 
 
-class classproperty(object):
-    """A descriptor that provides @property behavior on class methods."""
-    def __init__(self, getter):
-        self.getter = getter
-
-    def __get__(self, instance, cls):
-        return self.getter(cls)
-
-
 class BoardConfig(object):
-    board = None
     """The configuration used when building an image for a board."""
-    hwpack_format = None
-    # These attributes may not need to be redefined on some subclasses.
-    bootloader_flavor = None
-    # whether to copy u-boot to the boot partition
-    bootloader_file_in_boot_part = False
-    bootloader_dd = False
-    spl_in_boot_part = False
-    spl_dd = False
-    env_dd = False
-    fatload_command = 'fatload'
-    mmc_option = '0:1'
-    mmc_device_id = 0
-    mmc_part_offset = 0
-    uimage_path = ''
-    fat_size = 32
-    extra_serial_opts = ''
-    _extra_serial_opts = ''
-    _live_serial_opts = ''
-    extra_boot_args_options = None
-    supports_writing_to_mmc = True
+
     LOADER_MIN_SIZE_S = align_up(1 * 1024 ** 2, SECTOR_SIZE) / SECTOR_SIZE
     BOOT_MIN_SIZE_S = align_up(50 * 1024 ** 2, SECTOR_SIZE) / SECTOR_SIZE
     ROOT_MIN_SIZE_S = align_up(50 * 1024 ** 2, SECTOR_SIZE) / SECTOR_SIZE
 
-    # These attributes must be defined on all subclasses for backwards
-    # compatibility with hwpacks v1 format. Hwpacks v2 format allows these to
-    # be specified in the hwpack metadata.
-    kernel_addr = None
-    initrd_addr = None
-    initrd_high = '0xffffffff'
-    load_addr = None
-    dtb_addr = None
-    dtb_name = None
-    dtb_file = None
-    fdt_high = '0xffffffff'
-    kernel_flavors = None
-    boot_script = None
-    serial_tty = None
-    wired_interfaces = None
-    wireless_interfaces = None
-    mmc_id = None
-    vmlinuz = None
-    initrd = None
-    partition_layout = None
-    LOADER_START_S = 1
-
-    # Support for dtb_files as per hwpack v3 format.
-    dtb_files = None
-
-    # Samsung Boot-loader implementation notes and terminology
-    #
-    # * BL0, BL1 etc. are the various bootloaders in order of execution
-    # * BL0 is the first stage bootloader, located in ROM; it loads BL1/SPL
-    # from MMC offset +1s and runs it.
-    # * BL1 is the secondary program loader (SPL), a small version
-    #   of U-Boot with a checksum; it inits DRAM and loads a 1024s long BL2
-    #   from MMC and runs it.
-    # * BL2 is the U-Boot.
-    #
-    # samsung_bl1_{start,len}: Offset and maximum size for BL1
-    # samsung_bl2_{start,len}: Offset and maximum size for BL2
-    # samsung_env_{start,len}: Offset and maximum size for Environment settings
-    #
-    samsung_bl1_start = 1
-    samsung_bl1_len = 32
-    samsung_bl2_start = 65
-    samsung_bl2_len = 1024
-    samsung_env_start = 33
-    samsung_env_len = 32
-
-    hardwarepack_handler = None
-
-    @classmethod
-    def get_metadata_field(cls, field_name):
+    def __init__(self):
+        super(BoardConfig, self).__init__()
+        # XXX: when killing v1 hwpack, we might rename these two without the
+        # leading underscore. It is done in this way since sublcasses use
+        # placeholders in the string for dinamically change values. But this
+        # is done only for hwpack v1.
+        self._extra_serial_opts = ''
+        self._live_serial_opts = ''
+        self.board = None
+        self.boot_script = None
+        self.bootloader_dd = False
+        self.bootloader_file_in_boot_part = False
+        self.bootloader_flavor = None
+        self.dtb_addr = None
+        self.dtb_file = None
+        self.dtb_files = None
+        self.dtb_name = None
+        self.env_dd = False
+        self.extra_boot_args_options = None
+        self.fat_size = 32
+        self.fatload_command = 'fatload'
+        self.fdt_high = '0xffffffff'
+        self.hardwarepack_handler = None
+        self.hwpack_format = None
+        self.initrd_addr = None
+        self.initrd_high = '0xffffffff'
+        self.kernel_addr = None
+        self.kernel_flavors = None
+        self.load_addr = None
+        self.loader_start_s = 1
+        self.mmc_device_id = 0
+        self.mmc_id = None
+        self.mmc_option = '0:1'
+        self.mmc_part_offset = 0
+        self.partition_layout = None
+        self.serial_tty = None
+        self.spl_dd = False
+        self.spl_in_boot_part = False
+        self.supports_writing_to_mmc = True
+        self.uimage_path = ''
+        self.wired_interfaces = None
+        self.wireless_interfaces = None
+        # Samsung Boot-loader implementation notes and terminology
+        #
+        # * BL0, BL1 etc. are the various bootloaders in order of execution
+        # * BL0 is the first stage bootloader, located in ROM; it loads BL1/SPL
+        # from MMC offset +1s and runs it.
+        # * BL1 is the secondary program loader (SPL), a small version
+        #   of U-Boot with a checksum; it inits DRAM and loads a 1024s long BL2
+        #   from MMC and runs it.
+        # * BL2 is the U-Boot.
+        #
+        # samsung_bl1_{start,len}: Offset and maximum size for BL1
+        # samsung_bl2_{start,len}: Offset and maximum size for BL2
+        # samsung_env_{start,len}: Offset and maximum size for Environment settings
+        #
+        self.samsung_bl1_start = 1
+        self.samsung_bl1_len = 32
+        self.samsung_bl2_start = 65
+        self.samsung_bl2_len = 1024
+        self.samsung_env_start = 33
+        self.samsung_env_len = 32
+        # XXX: attributes that are not listed in hwpackV3, should be removed?
+        self.vmlinuz = None
+        self.initrd = None
+
+    # XXX: can be removed when killing v1 hwpack.
+    def _get_live_serial_opts(self):
+        return_value = self._live_serial_opts
+        if self._check_placeholder_presence(return_value, r'%s'):
+            return_value = self._live_serial_opts % self.serial_tty
+        return return_value
+
+    def _set_live_serial_opts(self, value):
+        self._live_serial_opts = value
+
+    live_serial_opts = property(_get_live_serial_opts, _set_live_serial_opts)
+
+    # XXX: can be removed when killing v1 hwpack.
+    def _get_extra_serial_opts(self):
+        return_value = self._extra_serial_opts
+        if self._check_placeholder_presence(return_value, r'%s'):
+            return_value = return_value % self.serial_tty
+        return return_value
+
+    def _set_extra_serial_opts(self, value):
+        self._extra_serial_opts = value
+
+    extra_serial_opts = property(_get_extra_serial_opts,
+                                 _set_extra_serial_opts)
+
+    def get_metadata_field(self, field_name):
         """ Return the metadata value for field_name if it can be found.
         """
-        data, _ = cls.hardwarepack_handler.get_field(field_name)
+        data, _ = self.hardwarepack_handler.get_field(field_name)
         return data
 
-    @classmethod
-    def set_board(cls, board):
-        cls.board = board
-
-    @classmethod
-    def set_metadata(cls, hwpacks, bootloader=None, board=None):
-        cls.hardwarepack_handler = HardwarepackHandler(hwpacks, bootloader,
+    def set_metadata(self, hwpacks, bootloader=None, board=None):
+        self.hardwarepack_handler = HardwarepackHandler(hwpacks, bootloader,
                                                        board)
-        with cls.hardwarepack_handler:
-            cls.hwpack_format = cls.hardwarepack_handler.get_format()
-            if (cls.hwpack_format == cls.hardwarepack_handler.FORMAT_1):
+        with self.hardwarepack_handler:
+            self.hwpack_format = self.hardwarepack_handler.get_format()
+            if (self.hwpack_format == self.hardwarepack_handler.FORMAT_1):
                 return
 
-            if (cls.hwpack_format != cls.hardwarepack_handler.FORMAT_1):
+            if (self.hwpack_format != self.hardwarepack_handler.FORMAT_1):
                 # Clear V1 defaults.
-                cls.kernel_addr = None
-                cls.initrd_addr = None
-                cls.load_addr = None
-                cls.serial_tty = None
-                cls.fat_size = None
-                cls.dtb_name = None
-                cls.dtb_addr = None
-                cls.extra_boot_args_options = None
-                cls.boot_script = None
-                cls.kernel_flavors = None
-                cls.mmc_option = None
-                cls.mmc_part_offset = None
-                cls.samsung_bl1_start = None
-                cls.samsung_bl1_len = None
-                cls.samsung_env_len = None
-                cls.samsung_bl2_len = None
+                # TODO When removing v1 support, remove also default values
+                # in the constructor and avoid all this.
+                self.kernel_addr = None
+                self.initrd_addr = None
+                self.load_addr = None
+                self.serial_tty = None
+                self.fat_size = None
+                self.dtb_name = None
+                self.dtb_addr = None
+                self.extra_boot_args_options = None
+                self.boot_script = None
+                self.kernel_flavors = None
+                self.mmc_option = None
+                self.mmc_part_offset = None
+                self.samsung_bl1_start = None
+                self.samsung_bl1_len = None
+                self.samsung_env_len = None
+                self.samsung_bl2_len = None
                 # cls.samsung_bl2_start and cls.samsung_env_start should
-                # be initialized to default value for backward compatibility.
+                # be initialized to default values for backward compatibility.
 
+            self.board = board
             # Set new values from metadata.
-            cls.kernel_addr = cls.get_metadata_field('kernel_addr')
-            cls.initrd_addr = cls.get_metadata_field('initrd_addr')
-            cls.load_addr = cls.get_metadata_field('load_addr')
-            cls.dtb_addr = cls.get_metadata_field('dtb_addr')
-            cls.serial_tty = cls.get_metadata_field('serial_tty')
-            wired_interfaces = cls.get_metadata_field('wired_interfaces')
-            if wired_interfaces is not None:
-                cls.wired_interfaces = wired_interfaces
-            wireless_interfaces = cls.get_metadata_field(
-                'wireless_interfaces')
-            if wireless_interfaces is not None:
-                cls.wireless_interfaces = wireless_interfaces
-            cls.vmlinuz = cls.get_metadata_field('vmlinuz')
-            cls.initrd = cls.get_metadata_field('initrd')
-            cls.dtb_file = cls.get_metadata_field('dtb_file')
-            cls.dtb_files = cls.get_metadata_field('dtb_files')
-            cls.extra_boot_args_options = cls.get_metadata_field(
-                'extra_boot_options')
-            cls.boot_script = cls.get_metadata_field('boot_script')
-            cls.extra_serial_opts = cls.get_metadata_field(
-                'extra_serial_opts')
-            cls.snowball_startup_files_config = cls.get_metadata_field(
-                'snowball_startup_files_config')
-
-            cls.partition_layout = cls.get_metadata_field('partition_layout')
-            if cls.partition_layout in [
-                'bootfs_rootfs', 'reserved_bootfs_rootfs', None]:
-                cls.fat_size = 32
-            elif cls.partition_layout == 'bootfs16_rootfs':
-                cls.fat_size = 16
+            self.kernel_addr = self.get_metadata_field(KERNEL_ADDR_FIELD)
+            self.initrd_addr = self.get_metadata_field(INITRD_ADDR_FIELD)
+            self.load_addr = self.get_metadata_field(LOAD_ADDR_FIELD)
+            self.dtb_addr = self.get_metadata_field(DTB_ADDR_FIELD)
+            self.serial_tty = self.get_metadata_field(SERIAL_TTY_FIELD)
+            wired_interfaces = self.get_metadata_field(WIRED_INTERFACES_FIELD)
+            if wired_interfaces:
+                self.wired_interfaces = wired_interfaces
+            wireless_interfaces = self.get_metadata_field(
+                WIRELESS_INTERFACES_FIELD)
+            if wireless_interfaces:
+                self.wireless_interfaces = wireless_interfaces
+            self.dtb_file = self.get_metadata_field(DTB_FILE_FIELD)
+            # XXX: need to deprecate dtb_file field and use only dtb_files
+            # for multiple entries.
+            if self.dtb_file:
+                logger.warn("Deprecation warning: use the 'dtb_files' field "
+                            "instead of 'dtb_file'.")
+            self.dtb_files = self.get_metadata_field(DTB_FILES_FIELD)
+            self.extra_boot_args_options = self.get_metadata_field(
+                EXTRA_BOOT_OPTIONS_FIELD)
+            self.boot_script = self.get_metadata_field(BOOT_SCRIPT_FIELD)
+            self.extra_serial_opts = self.get_metadata_field(
+                EXTRA_SERIAL_OPTIONS_FIELD)
+            self.snowball_startup_files_config = self.get_metadata_field(
+                SNOWBALL_STARTUP_FILES_CONFIG_FIELD)
+            self.partition_layout = self.get_metadata_field(
+                PARTITION_LAYOUT_FIELD)
+            if self.partition_layout in [BOOTFS, RESERVED_BOOTFS, None]:
+                self.fat_size = 32
+            elif self.partition_layout == BOOTFS16:
+                self.fat_size = 16
             else:
                 raise AssertionError("Unknown partition layout '%s'." % \
-                                         cls.partition_layout)
-
-            cls.mmc_option = cls.get_metadata_field('mmc_id')
-            if cls.mmc_option is not None:
-                cls.mmc_device_id = int(cls.mmc_option.split(':')[0])
-                cls.mmc_part_offset = int(cls.mmc_option.split(':')[1]) - 1
-
-            boot_min_size = cls.get_metadata_field('boot_min_size')
-            if boot_min_size is not None:
-                cls.BOOT_MIN_SIZE_S = align_up(int(boot_min_size) * 1024 ** 2,
-                                               SECTOR_SIZE) / SECTOR_SIZE
-            root_min_size = cls.get_metadata_field('root_min_size')
-            if root_min_size is not None:
-                cls.ROOT_MIN_SIZE_S = align_up(int(root_min_size) * 1024 ** 2,
-                                               SECTOR_SIZE) / SECTOR_SIZE
-            loader_min_size = cls.get_metadata_field('loader_min_size')
-            if loader_min_size is not None:
-                cls.LOADER_MIN_SIZE_S = (
+                                         self.partition_layout)
+
+            self.mmc_option = self.get_metadata_field(MMC_ID_FIELD)
+            if self.mmc_option:
+                self.mmc_device_id = int(self.mmc_option.split(':')[0])
+                self.mmc_part_offset = int(self.mmc_option.split(':')[1]) - 1
+
+            # XXX: need to fix these values.
+            boot_min_size = self.get_metadata_field(BOOT_MIN_SIZE_FIELD)
+            if boot_min_size:
+                self.BOOT_MIN_SIZE_S = align_up(int(boot_min_size) * 1024 ** 2,
+                                               SECTOR_SIZE) / SECTOR_SIZE
+            root_min_size = self.get_metadata_field(ROOT_MIN_SIZE_FIELD)
+            if root_min_size:
+                self.ROOT_MIN_SIZE_S = align_up(int(root_min_size) * 1024 ** 2,
+                                               SECTOR_SIZE) / SECTOR_SIZE
+            loader_min_size = self.get_metadata_field(LOADER_MIN_SIZE_FIELD)
+            if loader_min_size:
+                self.LOADER_MIN_SIZE_S = (
                     align_up(int(loader_min_size) * 1024 ** 2,
                              SECTOR_SIZE) / SECTOR_SIZE)
 
-            bootloader_file_in_boot_part = cls.get_metadata_field(
-                'bootloader_file_in_boot_part')
-            if bootloader_file_in_boot_part is None:
-                cls.bootloader_file_in_boot_part = False
-            elif string.lower(bootloader_file_in_boot_part) == 'yes':
-                cls.bootloader_file_in_boot_part = True
-            elif string.lower(bootloader_file_in_boot_part) == 'no':
-                cls.bootloader_file_in_boot_part = False
-            spl_in_boot_part = cls.get_metadata_field('spl_in_boot_part')
+            spl_in_boot_part = self.get_metadata_field(SPL_IN_BOOT_PART_FIELD)
             if spl_in_boot_part is None:
-                cls.spl_in_boot_part = False
+                self.spl_in_boot_part = False
             elif string.lower(spl_in_boot_part) == 'yes':
-                cls.spl_in_boot_part = True
+                self.spl_in_boot_part = True
             elif string.lower(spl_in_boot_part) == 'no':
-                cls.spl_in_boot_part = False
-            env_dd = cls.get_metadata_field('env_dd')
+                self.spl_in_boot_part = False
+
+            env_dd = self.get_metadata_field(ENV_DD_FIELD)
             if env_dd is None:
-                cls.env_dd = False
+                self.env_dd = False
             elif string.lower(env_dd) == 'yes':
-                cls.env_dd = True
+                self.env_dd = True
             elif string.lower(env_dd) == 'no':
-                cls.env_dd = False
+                self.env_dd = False
 
-            bootloader_dd = cls.get_metadata_field('bootloader_dd')
+            # XXX: in hwpack v3 this field is just called 'dd'.
+            # Need to check its use.
+            bootloader_dd = self.get_metadata_field('bootloader_dd')
             # Either bootloader_dd is not specified, or it contains the dd
             # offset.
             if bootloader_dd is None:
-                cls.bootloader_dd = False
+                self.bootloader_dd = False
             else:
-                cls.bootloader_dd = int(bootloader_dd)
-            spl_dd = cls.get_metadata_field('spl_dd')
+                self.bootloader_dd = int(bootloader_dd)
+            spl_dd = self.get_metadata_field(SPL_DD_FIELD)
             # Either spl_dd is not specified, or it contains the dd offset.
             if spl_dd is None:
-                cls.spl_dd = False
+                self.spl_dd = False
             else:
-                cls.spl_dd = int(spl_dd)
-
-            loader_start = cls.get_metadata_field('loader_start')
-            if loader_start is not None:
-                cls.LOADER_START_S = int(loader_start)
-
-            samsung_bl1_start = cls.get_metadata_field('samsung_bl1_start')
-            if samsung_bl1_start is not None:
-                cls.samsung_bl1_start = int(samsung_bl1_start)
-
-            samsung_bl1_len = cls.get_metadata_field('samsung_bl1_len')
-            if samsung_bl1_len is not None:
-                cls.samsung_bl1_len = int(samsung_bl1_len)
-
-            samsung_bl2_len = cls.get_metadata_field('samsung_bl2_len')
-            if samsung_bl2_len is not None:
-                cls.samsung_bl2_len = int(samsung_bl2_len)
-
-            samsung_bl2_start = cls.get_metadata_field('samsung_bl2_start')
-            if samsung_bl2_start is not None:
-                cls.samsung_bl2_start = int(samsung_bl2_start)
-
-            samsung_env_len = cls.get_metadata_field('samsung_env_len')
-            if samsung_env_len is not None:
-                cls.samsung_env_len = int(samsung_env_len)
-
-            samsung_env_start = cls.get_metadata_field('samsung_env_start')
-            if samsung_env_start is not None:
-                cls.samsung_env_start = int(samsung_env_start)
-
-            cls.bootloader_copy_files = cls.hardwarepack_handler.get_field(
+                self.spl_dd = int(spl_dd)
+
+            loader_start = self.get_metadata_field(LOADER_START_FIELD)
+            if loader_start:
+                self.loader_start_s = int(loader_start)
+
+            samsung_bl1_start = self.get_metadata_field(
+                SAMSUNG_BL1_START_FIELD)
+            if samsung_bl1_start:
+                self.samsung_v310_bl1_start = int(samsung_bl1_start)
+            samsung_bl1_len = self.get_metadata_field(SAMSUNG_BL1_LEN_FIELD)
+            if samsung_bl1_len:
+                self.samsung_v310_bl1_len = int(samsung_bl1_len)
+            samsung_env_len = self.get_metadata_field(SAMSUNG_ENV_LEN_FIELD)
+            if samsung_env_len:
+                self.samsung_v310_env_len = int(samsung_env_len)
+            samsung_bl2_len = self.get_metadata_field(SAMSUNG_BL2_LEN_FIELD)
+            if samsung_bl2_len:
+                self.samsung_v310_bl2_len = int(samsung_bl2_len)
+            samsung_bl2_start = self.get_metadata_field(
+                SAMSUNG_BL2_START_FIELD)
+            if samsung_bl2_start:
+                self.samsung_bl2_start = int(samsung_bl2_start)
+            samsung_env_start = self.get_metadata_field(
+                SAMSUNG_ENV_START_FILED)
+            if samsung_env_start:
+                self.samsung_env_start = int(samsung_env_start)
+
+            self.bootloader_copy_files = self.hardwarepack_handler.get_field(
                 "bootloader_copy_files")[0]
 
-            cls.bootloader = cls.hardwarepack_handler.get_field(
-                                "bootloader")
-            cls.board = board
+            # XXX: no reference in hwpackV3 format of these fields, double
+            # check if they can be dropped when killing v1.
+            self.bootloader = self.hardwarepack_handler.get_field(
+                "bootloader")
+            self.vmlinuz = self.get_metadata_field('vmlinuz')
+            self.initrd = self.get_metadata_field('initrd')
+            bootloader_file_in_boot_part = self.get_metadata_field(
+                'bootloader_file_in_boot_part')
+            if bootloader_file_in_boot_part is None:
+                self.bootloader_file_in_boot_part = False
+            elif string.lower(bootloader_file_in_boot_part) == 'yes':
+                self.bootloader_file_in_boot_part = True
+            elif string.lower(bootloader_file_in_boot_part) == 'no':
+                self.bootloader_file_in_boot_part = False
 
-    @classmethod
-    def get_file(cls, file_alias, default=None):
+    def get_file(self, file_alias, default=None):
         # XXX remove the 'default' parameter when V1 support is removed!
-        file_in_hwpack = cls.hardwarepack_handler.get_file(file_alias)
+        file_in_hwpack = self.hardwarepack_handler.get_file(file_alias)
         if file_in_hwpack is not None:
             return file_in_hwpack
         else:
             return default
 
-    @classmethod
-    def get_v1_sfdisk_cmd(cls, should_align_boot_part=False):
-        """Return the sfdisk command to partition the media.
-
-        :param should_align_boot_part: Whether to align the boot partition too.
-
-        This default implementation returns a boot vfat partition of type
-        FAT16 or FAT32, followed by a root partition.
-
-        XXX: This default implementation and all overrides are left for V1
-        compatibility only. They should be removed as part of the work to
-        kill off hwpacks V1.
-        """
-        if cls.fat_size == 32:
-            partition_type = '0x0C'
-        else:
-            partition_type = '0x0E'
-
-        # align on sector 63 for compatibility with broken versions of x-loader
-        # unless align_boot_part is set
-        boot_align = 63
-        if should_align_boot_part:
-            boot_align = PART_ALIGN_S
-
-        # can only start on sector 1 (sector 0 is MBR / partition table)
-        boot_start, boot_end, boot_len = align_partition(
-            1, cls.BOOT_MIN_SIZE_S, boot_align, PART_ALIGN_S)
-        # apparently OMAP3 ROMs require the vfat length to be an even number
-        # of sectors (multiple of 1 KiB); decrease the length if it's odd,
-        # there should still be enough room
-        boot_len = boot_len - boot_len % 2
-        boot_end = boot_start + boot_len - 1
-
-        # we ignore _root_end / _root_len and return a sfdisk command to
-        # instruct the use of all remaining space; XXX if we had some root size
-        # config, we could do something more sensible
-        root_start, _root_end, _root_len = align_partition(
-            boot_end + 1, cls.ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
-
-        return '%s,%s,%s,*\n%s,,,-' % (
-            boot_start, boot_len, partition_type, root_start)
-
-    @classmethod
-    def get_normal_sfdisk_cmd(cls, should_align_boot_part=False):
+    def get_v1_sfdisk_cmd(self, should_align_boot_part=False):
+        # XXX: This default implementation and all overrides are left for V1
+        # compatibility only. They should be removed as part of the work to
+        # kill off hwpacks V1.
+        return self.get_normal_sfdisk_cmd(should_align_boot_part)
+
+    def get_normal_sfdisk_cmd(self, should_align_boot_part=False):
         """Return the sfdisk command to partition the media.
 
         :param should_align_boot_part: Whether to align the boot partition too.
@@ -413,7 +428,7 @@
         This returns a boot vfat partition of type FAT16
         or FAT32, followed by a root partition.
         """
-        if cls.fat_size == 32:
+        if self.fat_size == 32:
             partition_type = '0x0C'
         else:
             partition_type = '0x0E'
@@ -427,7 +442,7 @@
 
         # can only start on sector 1 (sector 0 is MBR / partition table)
         boot_start, boot_end, boot_len = align_partition(
-            1, cls.BOOT_MIN_SIZE_S, boot_align, PART_ALIGN_S)
+            1, self.BOOT_MIN_SIZE_S, boot_align, PART_ALIGN_S)
         # apparently OMAP3 ROMs require the vfat length to be an even number
         # of sectors (multiple of 1 KiB); decrease the length if it's odd,
         # there should still be enough room
@@ -439,13 +454,12 @@
         # instruct the use of all remaining space; XXX we now have root size
         # config, so we can do something more sensible
         root_start, _root_end, _root_len = align_partition(
-            boot_end + 1, cls.ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
+            boot_end + 1, self.ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
 
         return '%s,%s,%s,*\n%s,,,-' % (
             boot_start, boot_len, partition_type, root_start)
 
-    @classmethod
-    def get_reserved_sfdisk_cmd(cls, should_align_boot_part=None):
+    def get_reserved_sfdisk_cmd(self, should_align_boot_part=None):
         """Return the sfdisk command to partition the media.
 
         :param should_align_boot_part: Ignored.
@@ -454,40 +468,38 @@
         FAT16 or FAT32, followed by a root partition.
         """
         loader_start, loader_end, loader_len = align_partition(
-            cls.LOADER_START_S, cls.LOADER_MIN_SIZE_S, 1, PART_ALIGN_S)
+            self.loader_start_s, self.LOADER_MIN_SIZE_S, 1, PART_ALIGN_S)
 
         boot_start, boot_end, boot_len = align_partition(
-            loader_end + 1, cls.BOOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
+            loader_end + 1, self.BOOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
 
         root_start, _root_end, _root_len = align_partition(
-            boot_end + 1, cls.ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
+            boot_end + 1, self.ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
 
         return '%s,%s,0xDA\n%s,%s,0x0C,*\n%s,,,-' % (
         loader_start, loader_len, boot_start, boot_len, root_start)
 
-    @classmethod
-    def get_sfdisk_cmd(cls, should_align_boot_part=False):
-        if (cls.partition_layout in ['bootfs_rootfs', 'bootfs16_rootfs'] or
-            cls.board == 'snowball_sd'):
-            return cls.get_normal_sfdisk_cmd(should_align_boot_part)
-        elif cls.partition_layout in ['reserved_bootfs_rootfs']:
-            return cls.get_reserved_sfdisk_cmd(should_align_boot_part)
+    def get_sfdisk_cmd(self, should_align_boot_part=False):
+        if (self.partition_layout in ['bootfs_rootfs', 'bootfs16_rootfs'] or
+            self.board == 'snowball_sd'):
+            return self.get_normal_sfdisk_cmd(should_align_boot_part)
+        elif self.partition_layout in ['reserved_bootfs_rootfs']:
+            return self.get_reserved_sfdisk_cmd(should_align_boot_part)
         else:
-            assert (cls.hwpack_format == HardwarepackHandler.FORMAT_1), (
+            assert (self.hwpack_format == HardwarepackHandler.FORMAT_1), (
                 "Hwpack format is not 1.0 but "
                 "partition_layout is unspecified.")
-            return cls.get_v1_sfdisk_cmd(should_align_boot_part)
+            return self.get_v1_sfdisk_cmd(should_align_boot_part)
 
-    @classmethod
-    def _get_bootcmd(cls, i_img_data, d_img_data):
+    def _get_bootcmd(self, i_img_data, d_img_data):
         """Get the bootcmd for this board.
 
         In general subclasses should not have to override this.
         """
         replacements = dict(
-            fatload_command=cls.fatload_command, uimage_path=cls.uimage_path,
-            mmc_option=cls.mmc_option, kernel_addr=cls.kernel_addr,
-            initrd_addr=cls.initrd_addr, dtb_addr=cls.dtb_addr)
+            fatload_command=self.fatload_command, uimage_path=self.uimage_path,
+            mmc_option=self.mmc_option, kernel_addr=self.kernel_addr,
+            initrd_addr=self.initrd_addr, dtb_addr=self.dtb_addr)
         boot_script = (
             ("%(fatload_command)s mmc %(mmc_option)s %(kernel_addr)s " +
              "%(uimage_path)suImage; ")) % replacements
@@ -496,7 +508,7 @@
             ("%(fatload_command)s mmc %(mmc_option)s %(initrd_addr)s " +
              "%(uimage_path)suInitrd; ")) % replacements
             if d_img_data is not None:
-                assert cls.dtb_addr is not None, (
+                assert self.dtb_addr is not None, (
                     "Need a dtb_addr when passing d_img_data")
                 boot_script += (
                     ("%(fatload_command)s mmc %(mmc_option)s %(dtb_addr)s " +
@@ -508,37 +520,34 @@
                 boot_script += ((" %(dtb_addr)s")) % replacements
         return boot_script
 
-    @classmethod
-    def add_boot_args(cls, extra_args):
+    def add_boot_args(self, extra_args):
         if extra_args is not None:
-            if cls.extra_boot_args_options is None:
-                cls.extra_boot_args_options = extra_args
+            if self.extra_boot_args_options is None:
+                self.extra_boot_args_options = extra_args
             else:
-                cls.extra_boot_args_options += ' %s' % extra_args
+                self.extra_boot_args_options += ' %s' % extra_args
 
-    @classmethod
-    def add_boot_args_from_file(cls, path):
+    def add_boot_args_from_file(self, path):
         if path is not None:
             with open(path, 'r') as boot_args_file:
-                cls.add_boot_args(boot_args_file.read().strip())
+                self.add_boot_args(boot_args_file.read().strip())
 
-    @classmethod
-    def _get_bootargs(cls, is_live, is_lowmem, consoles, rootfs_id):
+    def _get_bootargs(self, is_live, is_lowmem, consoles, rootfs_id):
         """Get the bootargs for this board.
 
         In general subclasses should not have to override this.
         """
         boot_args_options = 'rootwait ro'
-        if cls.extra_boot_args_options is not None:
-            boot_args_options += ' %s' % cls.extra_boot_args_options
-        serial_opts = cls.extra_serial_opts
+        if self.extra_boot_args_options:
+            boot_args_options += ' %s' % self.extra_boot_args_options
+        serial_opts = self.extra_serial_opts
         for console in consoles:
             serial_opts += ' console=%s' % console
 
         lowmem_opt = ''
         boot_snippet = 'root=%s' % rootfs_id
         if is_live:
-            serial_opts += ' %s' % cls.live_serial_opts
+            serial_opts += ' %s' % self.live_serial_opts
             boot_snippet = 'boot=casper'
             if is_lowmem:
                 lowmem_opt = 'only-ubiquity'
@@ -552,45 +561,42 @@
                 "%(boot_snippet)s %(boot_args_options)s"
              % replacements)
 
-    @classmethod
-    def _get_boot_env(cls, is_live, is_lowmem, consoles, rootfs_id,
+    def _get_boot_env(self, is_live, is_lowmem, consoles, rootfs_id,
                       i_img_data, d_img_data):
         """Get the boot environment for this board.
 
         In general subclasses should not have to override this.
         """
         boot_env = {}
-        boot_env["bootargs"] = cls._get_bootargs(
+        boot_env["bootargs"] = self._get_bootargs(
             is_live, is_lowmem, consoles, rootfs_id)
-        boot_env["bootcmd"] = cls._get_bootcmd(i_img_data, d_img_data)
-        boot_env["initrd_high"] = cls.initrd_high
-        boot_env["fdt_high"] = cls.fdt_high
+        boot_env["bootcmd"] = self._get_bootcmd(i_img_data, d_img_data)
+        boot_env["initrd_high"] = self.initrd_high
+        boot_env["fdt_high"] = self.fdt_high
         return boot_env
 
-    @classmethod
-    def make_boot_files(cls, bootloader_parts_dir, is_live, is_lowmem,
+    def make_boot_files(self, bootloader_parts_dir, is_live, is_lowmem,
                         consoles, chroot_dir, rootfs_id, boot_dir,
                         boot_device_or_file):
-        if cls.hwpack_format == HardwarepackHandler.FORMAT_1:
+        if self.hwpack_format == HardwarepackHandler.FORMAT_1:
             parts_dir = bootloader_parts_dir
         else:
             parts_dir = chroot_dir
-        (k_img_data, i_img_data, d_img_data) = cls._get_kflavor_files(
+        (k_img_data, i_img_data, d_img_data) = self._get_kflavor_files(
             parts_dir)
-        boot_env = cls._get_boot_env(is_live, is_lowmem, consoles, rootfs_id,
+        boot_env = self._get_boot_env(is_live, is_lowmem, consoles, rootfs_id,
                                      i_img_data, d_img_data)
 
-        if cls.hwpack_format == HardwarepackHandler.FORMAT_1:
-            cls._make_boot_files(
+        if self.hwpack_format == HardwarepackHandler.FORMAT_1:
+            self._make_boot_files(
                 boot_env, chroot_dir, boot_dir,
                 boot_device_or_file, k_img_data, i_img_data, d_img_data)
         else:
-            cls._make_boot_files_v2(
+            self._make_boot_files_v2(
                 boot_env, chroot_dir, boot_dir,
                 boot_device_or_file, k_img_data, i_img_data, d_img_data)
 
-    @classmethod
-    def _copy_dtb_files(cls, dtb_files, dest_dir, search_dir):
+    def _copy_dtb_files(self, dtb_files, dest_dir, search_dir):
         """Copy the files defined in dtb_files into the boot directory.
 
         :param dtb_files: The list of dtb files
@@ -630,13 +636,12 @@
                 else:
                     # Hopefully we should never get here.
                     # This should only happen if the hwpack config YAML file is
-                    # wrong
+                    # wrong.
                     logger.warn('WARNING: Wrong syntax in metadata file. '
                                 'Check the hwpack configuration file used to '
                                 'generate the hwpack archive.')
 
-    @classmethod
-    def _dd_file(cls, from_file, to_file, seek, max_size=None):
+    def _dd_file(self, from_file, to_file, seek, max_size=None):
         assert from_file is not None, "No source file name given."
         if max_size is not None:
             assert os.path.getsize(from_file) <= max_size, (
@@ -644,23 +649,21 @@
         logger.info("Writing '%s' to '%s' at %s." % (from_file, to_file, seek))
         _dd(from_file, to_file, seek=seek)
 
-    @classmethod
-    def install_samsung_boot_loader(cls, samsung_spl_file, bootloader_file,
+    def install_samsung_boot_loader(self, samsung_spl_file, bootloader_file,
                                     boot_device_or_file):
-                cls._dd_file(samsung_spl_file, boot_device_or_file,
-                             cls.samsung_bl1_start,
-                             cls.samsung_bl1_len * SECTOR_SIZE)
-                cls._dd_file(bootloader_file, boot_device_or_file,
-                             cls.samsung_bl2_start,
-                             cls.samsung_bl2_len * SECTOR_SIZE)
+                self._dd_file(samsung_spl_file, boot_device_or_file,
+                             self.samsung_bl1_start,
+                             self.samsung_bl1_len * SECTOR_SIZE)
+                self._dd_file(bootloader_file, boot_device_or_file,
+                             self.samsung_bl2_start,
+                             self.samsung_bl2_len * SECTOR_SIZE)
 
-    @classmethod
-    def _make_boot_files_v2(cls, boot_env, chroot_dir, boot_dir,
+    def _make_boot_files_v2(self, boot_env, chroot_dir, boot_dir,
                          boot_device_or_file, k_img_data, i_img_data,
                          d_img_data):
-        with cls.hardwarepack_handler:
-            spl_file = cls.get_file('spl_file')
-            if cls.spl_in_boot_part:
+        with self.hardwarepack_handler:
+            spl_file = self.get_file('spl_file')
+            if self.spl_in_boot_part:
                 assert spl_file is not None, (
                     "SPL binary could not be found")
                 logger.info(
@@ -670,15 +673,15 @@
                 # XXX: Is this really needed?
                 cmd_runner.run(["sync"]).wait()
 
-            if cls.spl_dd:
-                cls._dd_file(spl_file, boot_device_or_file, cls.spl_dd)
-
-            bootloader_file = cls.get_file('bootloader_file')
-            if cls.bootloader_dd:
-                cls._dd_file(bootloader_file, boot_device_or_file,
-                             cls.bootloader_dd)
-
-        make_uImage(cls.load_addr, k_img_data, boot_dir)
+            if self.spl_dd:
+                self._dd_file(spl_file, boot_device_or_file, self.spl_dd)
+
+            bootloader_file = self.get_file('bootloader_file')
+            if self.bootloader_dd:
+                self._dd_file(bootloader_file, boot_device_or_file,
+                             self.bootloader_dd)
+
+        make_uImage(self.load_addr, k_img_data, boot_dir)
 
         if i_img_data is not None:
             make_uInitrd(i_img_data, boot_dir)
@@ -686,29 +689,28 @@
         if d_img_data is not None:
             make_dtb(d_img_data, boot_dir)
 
-        if cls.boot_script is not None:
-            boot_script_path = os.path.join(boot_dir, cls.boot_script)
+        if self.boot_script is not None:
+            boot_script_path = os.path.join(boot_dir, self.boot_script)
             make_boot_script(boot_env, boot_script_path)
 
             # Only used for Omap, will this be bad for the other boards?
             make_boot_ini(boot_script_path, boot_dir)
 
-        if (cls.snowball_startup_files_config is not None and
-            cls.board != 'snowball_sd'):
-            cls.populate_raw_partition(boot_device_or_file, chroot_dir)
+        if (self.snowball_startup_files_config is not None and
+            self.board != 'snowball_sd'):
+            self.populate_raw_partition(boot_device_or_file, chroot_dir)
 
-        if cls.env_dd:
+        if self.env_dd:
             # Do we need to zero out the env before flashing it?
             _dd("/dev/zero", boot_device_or_file,
-                count=cls.samsung_env_len,
-                seek=cls.samsung_env_start)
-            env_size = cls.samsung_env_len * SECTOR_SIZE
+                count=self.samsung_env_len,
+                seek=self.samsung_env_start)
+            env_size = self.samsung_env_len * SECTOR_SIZE
             env_file = make_flashable_env(boot_env, env_size)
-            cls._dd_file(env_file, boot_device_or_file,
-                         cls.samsung_env_start)
+            self._dd_file(env_file, boot_device_or_file,
+                         self.samsung_env_start)
 
-    @classmethod
-    def _make_boot_files(cls, boot_env, chroot_dir, boot_dir,
+    def _make_boot_files(self, boot_env, chroot_dir, boot_dir,
                          boot_device_or_file, k_img_data, i_img_data,
                          d_img_data):
         """Make the necessary boot files for this board.
@@ -718,8 +720,7 @@
         """
         raise NotImplementedError()
 
-    @classmethod
-    def populate_boot(cls, chroot_dir, rootfs_id, boot_partition, boot_disk,
+    def populate_boot(self, chroot_dir, rootfs_id, boot_partition, boot_disk,
                       boot_device_or_file, is_live, is_lowmem, consoles):
         parts_dir = 'boot'
         if is_live:
@@ -727,21 +728,21 @@
         bootloader_parts_dir = os.path.join(chroot_dir, parts_dir)
         cmd_runner.run(['mkdir', '-p', boot_disk]).wait()
         with partition_mounted(boot_partition, boot_disk):
-            with cls.hardwarepack_handler:
-                if cls.bootloader_file_in_boot_part:
+            with self.hardwarepack_handler:
+                if self.bootloader_file_in_boot_part:
                     # <legacy v1 support>
-                    if cls.bootloader_flavor is not None:
+                    if self.bootloader_flavor is not None:
                         default = os.path.join(
                             chroot_dir, 'usr', 'lib', 'u-boot',
-                            cls.bootloader_flavor, 'u-boot.img')
+                            self.bootloader_flavor, 'u-boot.img')
                         if not os.path.exists(default):
                             default = os.path.join(
                                 chroot_dir, 'usr', 'lib', 'u-boot',
-                                cls.bootloader_flavor, 'u-boot.bin')
+                                self.bootloader_flavor, 'u-boot.bin')
                     else:
                         default = None
                     # </legacy v1 support>
-                    bootloader_bin = cls.get_file('bootloader_file',
+                    bootloader_bin = self.get_file('bootloader_file',
                                                    default=default)
                     assert bootloader_bin is not None, (
                         "bootloader binary could not be found")
@@ -751,18 +752,17 @@
                     proc.wait()
 
                 # Handle copy_files field.
-                cls.copy_files(boot_disk)
+                self.copy_files(boot_disk)
 
             # Handle dtb_files field.
-            if cls.dtb_files:
-                cls._copy_dtb_files(cls.dtb_files, boot_disk, chroot_dir)
+            if self.dtb_files:
+                self._copy_dtb_files(self.dtb_files, boot_disk, chroot_dir)
 
-            cls.make_boot_files(
+            self.make_boot_files(
                 bootloader_parts_dir, is_live, is_lowmem, consoles, chroot_dir,
                 rootfs_id, boot_disk, boot_device_or_file)
 
-    @classmethod
-    def copy_files(cls, boot_disk):
+    def copy_files(self, boot_disk):
         """Handle the copy_files metadata field."""
 
         # Extract anything specified by copy_files sections
@@ -772,13 +772,14 @@
         #   {'source_path': 'dest_path'}
         #  ]
         # }
-        if cls.bootloader_copy_files is None:
+        if self.bootloader_copy_files is None:
             return
 
-        for source_package, file_list in cls.bootloader_copy_files.iteritems():
+        for source_package, file_list in \
+                self.bootloader_copy_files.iteritems():
             for file_info in file_list:
                 for source_path, dest_path in file_info.iteritems():
-                    source = cls.hardwarepack_handler.get_file_from_package(
+                    source = self.hardwarepack_handler.get_file_from_package(
                         source_path, source_package)
                     dest_path = dest_path.lstrip("/\\")
                     dirname = os.path.dirname(dest_path)
@@ -791,25 +792,24 @@
                          os.path.join(boot_disk, dest_path)], as_root=True)
                     proc.wait()
 
-    @classmethod
-    def _get_kflavor_files(cls, path):
+    def _get_kflavor_files(self, path):
         """Search for kernel, initrd and optional dtb in path."""
-        if cls.kernel_flavors is None:
+        if self.kernel_flavors is None:
             # V2 metadata specifies each glob, not flavors.
             # XXX This duplication is temporary until V1 dies.
-            return cls._get_kflavor_files_v2(path)
+            return self._get_kflavor_files_v2(path)
 
-        for flavor in cls.kernel_flavors:
+        for flavor in self.kernel_flavors:
             kregex = KERNEL_GLOB % {'kernel_flavor': flavor}
             iregex = INITRD_GLOB % {'kernel_flavor': flavor}
             dregex = DTB_GLOB % {'kernel_flavor': flavor,
-                                 'dtb_name': cls.dtb_name}
+                                 'dtb_name': self.dtb_name}
             kernel = _get_file_matching(os.path.join(path, kregex))
             if kernel is not None:
                 initrd = _get_file_matching(os.path.join(path, iregex))
                 if initrd is not None:
                     dtb = None
-                    if cls.dtb_name is not None:
+                    if self.dtb_name is not None:
                         dtb = _get_file_matching(os.path.join(path, dregex))
                     return (kernel, initrd, dtb)
                 raise ValueError(
@@ -817,83 +817,83 @@
                         flavor, iregex))
         raise ValueError(
             "No kernel found matching %s for flavors %s" % (
-                KERNEL_GLOB, " ".join(cls.kernel_flavors)))
+                KERNEL_GLOB, " ".join(self.kernel_flavors)))
 
-    @classmethod
-    def _get_kflavor_files_v2(cls, path):
+    def _get_kflavor_files_v2(self, path):
         kernel = initrd = dtb = None
 
-        if cls.vmlinuz:
-            kernel = _get_file_matching(os.path.join(path, cls.vmlinuz))
-        if not cls.vmlinuz or not kernel:
+        if self.vmlinuz:
+            kernel = _get_file_matching(os.path.join(path, self.vmlinuz))
+        if not self.vmlinuz or not kernel:
             raise ValueError("Unable to find a valid kernel image.")
 
-        if cls.initrd:
-            initrd = _get_file_matching(os.path.join(path, cls.initrd))
-        if not cls.initrd or not initrd:
+        if self.initrd:
+            initrd = _get_file_matching(os.path.join(path, self.initrd))
+        if not self.initrd or not initrd:
             logger.warn("Could not find a valid initrd, skipping uInitd.")
 
-        if cls.dtb_file:
-            dtb = _get_file_matching(os.path.join(path, cls.dtb_file))
-        if not cls.dtb_file or not dtb:
+        if self.dtb_file:
+            dtb = _get_file_matching(os.path.join(path, self.dtb_file))
+        if not self.dtb_file or not dtb:
             logger.warn("Could not find a valid dtb file, skipping it.")
 
         logger.info("Will use kernel=%s, initrd=%s, dtb=%s." % \
                              (kernel, initrd, dtb))
         return (kernel, initrd, dtb)
 
-    @classmethod
-    def populate_raw_partition(cls, media, boot_dir):
+    def populate_raw_partition(self, media, boot_dir):
         # Override in subclass if needed
         pass
 
-    @classmethod
-    def snowball_config(cls, chroot_dir):
+    def snowball_config(self, chroot_dir):
         # Override in subclasses where applicable
         raise NotImplementedError(
             "snowball_config() must only be called on BoardConfigs that "
             "use the Snowball startupfiles.")
 
+    # XXX: can be removed when killing v1 hwpack and updating the attributes
+    # that use it.
+    @staticmethod
+    def _check_placeholder_presence(string, placeholder):
+        """Checks if the passed string contains the particular placeholder."""
+        # Very simple way of achieving that.
+        presence = False
+        if placeholder in string:
+            presence = True
+        return presence
+
 
 class OmapConfig(BoardConfig):
-    kernel_flavors = ['linaro-omap4', 'linaro-lt-omap', 'linaro-omap', 'omap4']
-    bootloader_file_in_boot_part = True
-
-    # XXX: Here we define these things as dynamic properties because our
-    # temporary hack to fix bug 697824 relies on changing the board's
-    # serial_tty at run time.
-    _extra_serial_opts = None
-    _live_serial_opts = None
-    _serial_tty = None
-
-    @classproperty
-    def serial_tty(cls):
-        # This is just to make sure no callsites use .serial_tty before
-        # calling set_appropriate_serial_tty(). If we had this in the first
-        # place we'd have uncovered bug 710971 before releasing.
-        raise AttributeError(
-            "You must not use this attribute before calling "
-            "set_appropriate_serial_tty")
-
-    @classproperty
-    def live_serial_opts(cls):
-        return cls._live_serial_opts % cls.serial_tty
-
-    @classproperty
-    def extra_serial_opts(cls):
-        return cls._extra_serial_opts % cls.serial_tty
-
-    @classmethod
-    def set_appropriate_serial_tty(cls, chroot_dir):
+
+    def __init__(self):
+        super(OmapConfig, self).__init__()
+        self.kernel_flavors = ['linaro-omap4', 'linaro-lt-omap',
+                               'linaro-omap', 'omap4']
+        self.bootloader_file_in_boot_part = True
+        # XXX: Here we define these things as dynamic properties because our
+        # temporary hack to fix bug 697824 relies on changing the board's
+        # serial_tty at run time.
+        self._serial_tty = None
+
+    # XXX: when killing v1 hwpack this should be safely removed.
+    def _get_serial_tty(self):
+        return self._serial_tty
+
+    def _set_serial_tty(self, value):
+        self._serial_tty = value
+
+    serial_tty = property(_get_serial_tty, _set_serial_tty)
+
+    def set_appropriate_serial_tty(self, chroot_dir):
         """Set the appropriate serial_tty depending on the kernel used.
 
         If the kernel found in the chroot dir is << 2.6.36 we use tyyS2, else
         we use the default value (_serial_tty).
         """
         # XXX: delete this method when hwpacks V1 can die
-        assert cls.hwpack_format == HardwarepackHandler.FORMAT_1
+        assert self.hwpack_format == HardwarepackHandler.FORMAT_1
         # XXX: This is also part of our temporary hack to fix bug 697824.
-        cls.serial_tty = classproperty(lambda cls: cls._serial_tty)
+        # cls.serial_tty = classproperty(lambda cls: cls._serial_tty)
         vmlinuz = _get_file_matching(
             os.path.join(chroot_dir, 'boot', 'vmlinuz*'))
         basename = os.path.basename(vmlinuz)
@@ -902,135 +902,134 @@
         if match is not None:
             minor_version = match.group(1)
             if int(minor_version) < 36:
-                cls.serial_tty = classproperty(lambda cls: 'ttyS2')
+                self.serial_tty = 'ttyS2'
 
-    @classmethod
-    def make_boot_files(cls, bootloader_parts_dir, is_live, is_lowmem,
+    def make_boot_files(self, bootloader_parts_dir, is_live, is_lowmem,
                         consoles, chroot_dir, rootfs_id, boot_dir,
                         boot_device_or_file):
         # XXX: This is also part of our temporary hack to fix bug 697824; we
         # need to call set_appropriate_serial_tty() before doing anything that
-        # may use cls.serial_tty.
-        if cls.hwpack_format == HardwarepackHandler.FORMAT_1:
-            cls.set_appropriate_serial_tty(chroot_dir)
-        super(OmapConfig, cls).make_boot_files(
+        # may use self.serial_tty.
+        if self.hwpack_format == HardwarepackHandler.FORMAT_1:
+            self.set_appropriate_serial_tty(chroot_dir)
+        super(OmapConfig, self).make_boot_files(
             bootloader_parts_dir, is_live, is_lowmem, consoles, chroot_dir,
             rootfs_id, boot_dir, boot_device_or_file)
 
-    @classmethod
-    def _make_boot_files(cls, boot_env, chroot_dir, boot_dir,
+    def _make_boot_files(self, boot_env, chroot_dir, boot_dir,
                          boot_device_or_file, k_img_data, i_img_data,
                          d_img_data):
         # XXX: delete this method when hwpacks V1 can die
-        assert cls.hwpack_format == HardwarepackHandler.FORMAT_1
-        install_omap_boot_loader(chroot_dir, boot_dir, cls)
-        make_uImage(cls.load_addr, k_img_data, boot_dir)
+        assert self.hwpack_format == HardwarepackHandler.FORMAT_1
+        install_omap_boot_loader(chroot_dir, boot_dir, self)
+        make_uImage(self.load_addr, k_img_data, boot_dir)
         make_uInitrd(i_img_data, boot_dir)
         make_dtb(d_img_data, boot_dir)
-        boot_script_path = os.path.join(boot_dir, cls.boot_script)
+        boot_script_path = os.path.join(boot_dir, self.boot_script)
         make_boot_script(boot_env, boot_script_path)
         make_boot_ini(boot_script_path, boot_dir)
 
 
 class BeagleConfig(OmapConfig):
-    bootloader_flavor = 'omap3_beagle'
-    dtb_name = 'omap3-beagle.dtb'
-    _serial_tty = 'ttyO2'
-    _extra_serial_opts = 'console=tty0 console=%s,115200n8'
-    _live_serial_opts = 'serialtty=%s'
-    kernel_addr = '0x80000000'
-    dtb_addr = '0x815f0000'
-    initrd_addr = '0x81600000'
-    load_addr = '0x80008000'
-    boot_script = 'boot.scr'
-    extra_boot_args_options = (
-        'earlyprintk fixrtc nocompcache vram=12M '
-        'omapfb.mode=dvi:1280x720MR-16@60 mpurate=${mpurate}')
+
+    def __init__(self):
+        super(BeagleConfig, self).__init__()
+        self.boot_script = 'boot.scr'
+        self.bootloader_flavor = 'omap3_beagle'
+        self.dtb_addr = '0x815f0000'
+        self.dtb_name = 'omap3-beagle.dtb'
+        self.extra_boot_args_options = (
+            'earlyprintk fixrtc nocompcache vram=12M '
+            'omapfb.mode=dvi:1280x720MR-16@60 mpurate=${mpurate}')
+        self.initrd_addr = '0x81600000'
+        self.kernel_addr = '0x80000000'
+        self.load_addr = '0x80008000'
+        self._serial_tty = 'ttyO2'
+        self._extra_serial_opts = 'console=tty0 console=%s,115200n8'
+        self._live_serial_opts = 'serialtty=%s'
 
 
 class OveroConfig(OmapConfig):
-    bootloader_flavor = 'omap3_overo'
-    dtb_name = 'omap3-overo.dtb'
-    _serial_tty = 'ttyO2'
-    _extra_serial_opts = 'console=tty0 console=%s,115200n8'
-    kernel_addr = '0x80000000'
-    dtb_addr = '0x815f0000'
-    initrd_addr = '0x81600000'
-    load_addr = '0x80008000'
-    boot_script = 'boot.scr'
-    extra_boot_args_options = (
-        'earlyprintk mpurate=${mpurate} vram=12M '
-        'omapdss.def_disp=${defaultdisplay} omapfb.mode=dvi:${dvimode}')
+    def __init__(self):
+        super(OveroConfig, self).__init__()
+        self.boot_script = 'boot.scr'
+        self.bootloader_flavor = 'omap3_overo'
+        self.dtb_addr = '0x815f0000'
+        self.dtb_name = 'omap3-overo.dtb'
+        self.extra_boot_args_options = (
+            'earlyprintk mpurate=${mpurate} vram=12M '
+            'omapdss.def_disp=${defaultdisplay} omapfb.mode=dvi:${dvimode}')
+        self.initrd_addr = '0x81600000'
+        self.kernel_addr = '0x80000000'
+        self.load_addr = '0x80008000'
+        self._extra_serial_opts = 'console=tty0 console=%s,115200n8'
+        self._serial_tty = 'ttyO2'
 
 
 class PandaConfig(OmapConfig):
-    bootloader_flavor = 'omap4_panda'
-    dtb_name = 'omap4-panda.dtb'
-    _serial_tty = 'ttyO2'
-    _extra_serial_opts = 'console=tty0 console=%s,115200n8'
-    _live_serial_opts = 'serialtty=%s'
-    kernel_addr = '0x80200000'
-    dtb_addr = '0x815f0000'
-    initrd_addr = '0x81600000'
-    load_addr = '0x80008000'
-    boot_script = 'boot.scr'
-    extra_boot_args_options = (
-        'earlyprintk fixrtc nocompcache vram=48M '
-        'omapfb.vram=0:24M mem=456M@0x80000000 mem=512M@0xA0000000')
+    def __init__(self):
+        super(PandaConfig, self).__init__()
+        self._serial_tty = 'ttyO2'
+        self.boot_script = 'boot.scr'
+        self.bootloader_flavor = 'omap4_panda'
+        self.dtb_addr = '0x815f0000'
+        self.dtb_name = 'omap4-panda.dtb'
+        self.extra_boot_args_options = (
+            'earlyprintk fixrtc nocompcache vram=48M '
+            'omapfb.vram=0:24M mem=456M@0x80000000 mem=512M@0xA0000000')
+        self.initrd_addr = '0x81600000'
+        self.kernel_addr = '0x80200000'
+        self.load_addr = '0x80008000'
+        self._extra_serial_opts = 'console=tty0 console=%s,115200n8'
+        self._live_serial_opts = 'serialtty=%s'
 
 
 class IgepConfig(BeagleConfig):
-    bootloader_file_in_boot_part = False
-    bootloader_flavor = None
-    dtb_name = 'isee-igep-v2.dtb'
+    def __init__(self):
+        super(IgepConfig, self).__init__()
+        self.bootloader_file_in_boot_part = False
+        self.bootloader_flavor = None
+        self.dtb_name = 'isee-igep-v2.dtb'
 
-    @classmethod
-    def _make_boot_files(cls, boot_env, chroot_dir, boot_dir,
+    def _make_boot_files(self, boot_env, chroot_dir, boot_dir,
                          boot_device_or_file, k_img_data, i_img_data,
                          d_img_data):
         # XXX: delete this method when hwpacks V1 can die
-        assert cls.hwpack_format == HardwarepackHandler.FORMAT_1
-        make_uImage(cls.load_addr, k_img_data, boot_dir)
+        assert self.hwpack_format == HardwarepackHandler.FORMAT_1
+        make_uImage(self.load_addr, k_img_data, boot_dir)
         make_uInitrd(i_img_data, boot_dir)
         make_dtb(d_img_data, boot_dir)
-        boot_script_path = os.path.join(boot_dir, cls.boot_script)
+        boot_script_path = os.path.join(boot_dir, self.boot_script)
         make_boot_script(boot_env, boot_script_path)
         make_boot_ini(boot_script_path, boot_dir)
 
 
 class Ux500Config(BoardConfig):
-    serial_tty = 'ttyAMA2'
-    _extra_serial_opts = 'console=tty0 console=%s,115200n8'
-    _live_serial_opts = 'serialtty=%s'
-    kernel_addr = '0x00100000'
-    initrd_addr = '0x08000000'
-    load_addr = '0x00008000'
-    kernel_flavors = ['u8500', 'ux500']
-    boot_script = 'flash.scr'
-    extra_boot_args_options = (
-        'earlyprintk rootdelay=1 fixrtc nocompcache '
-        'mem=96M@0 mem_modem=32M@96M mem=44M@128M pmem=22M@172M '
-        'mem=30M@194M mem_mali=32M@224M pmem_hwb=54M@256M '
-        'hwmem=48M@302M mem=152M@360M')
-    mmc_option = '1:1'
-
-    @classproperty
-    def live_serial_opts(cls):
-        return cls._live_serial_opts % cls.serial_tty
-
-    @classproperty
-    def extra_serial_opts(cls):
-        return cls._extra_serial_opts % cls.serial_tty
-
-    @classmethod
-    def _make_boot_files(cls, boot_env, chroot_dir, boot_dir,
+    def __init__(self):
+        super(Ux500Config, self).__init__()
+        self.boot_script = 'flash.scr'
+        self.extra_boot_args_options = (
+            'earlyprintk rootdelay=1 fixrtc nocompcache '
+            'mem=96M@0 mem_modem=32M@96M mem=44M@128M pmem=22M@172M '
+            'mem=30M@194M mem_mali=32M@224M pmem_hwb=54M@256M '
+            'hwmem=48M@302M mem=152M@360M')
+        self.initrd_addr = '0x08000000'
+        self.kernel_addr = '0x00100000'
+        self.kernel_flavors = ['u8500', 'ux500']
+        self.load_addr = '0x00008000'
+        self.mmc_option = '1:1'
+        self.serial_tty = 'ttyAMA2'
+        self._extra_serial_opts = 'console=tty0 console=%s,115200n8'
+        self._live_serial_opts = 'serialtty=%s'
+
+    def _make_boot_files(self, boot_env, chroot_dir, boot_dir,
                          boot_device_or_file, k_img_data, i_img_data,
                          d_img_data):
         # XXX: delete this method when hwpacks V1 can die
-        assert cls.hwpack_format == HardwarepackHandler.FORMAT_1
-        make_uImage(cls.load_addr, k_img_data, boot_dir)
+        assert self.hwpack_format == HardwarepackHandler.FORMAT_1
+        make_uImage(self.load_addr, k_img_data, boot_dir)
         make_uInitrd(i_img_data, boot_dir)
-        boot_script_path = os.path.join(boot_dir, cls.boot_script)
+        boot_script_path = os.path.join(boot_dir, self.boot_script)
         make_boot_script(boot_env, boot_script_path)
 
 
@@ -1040,15 +1039,16 @@
        Note that the Snowball board needs a loader partition on the
        internal eMMC flash to boot. That partition is created with
        the SnowballConfigImage configuration.'''
+    def __init__(self):
+        super(SnowballSdConfig, self).__init__()
 
-    @classmethod
-    def _make_boot_files(cls, boot_env, chroot_dir, boot_dir,
+    def _make_boot_files(self, boot_env, chroot_dir, boot_dir,
                          boot_device_or_file, k_img_data, i_img_data,
                          d_img_data):
         # XXX: delete this method when hwpacks V1 can die
-        assert cls.hwpack_format == HardwarepackHandler.FORMAT_1
-        make_uImage(cls.load_addr, k_img_data, boot_dir)
-        boot_script_path = os.path.join(boot_dir, cls.boot_script)
+        assert self.hwpack_format == HardwarepackHandler.FORMAT_1
+        make_uImage(self.load_addr, k_img_data, boot_dir)
+        boot_script_path = os.path.join(boot_dir, self.boot_script)
         make_boot_script(boot_env, boot_script_path)
 
 
@@ -1056,16 +1056,18 @@
     '''Use only with --image option. Creates a raw image which contains an
        additional (raw) loader partition, containing some boot stages
        and u-boot.'''
-    # Boot ROM looks for a boot table of contents (TOC) at 0x20000
-    # Actually, it first looks at address 0, but that's where l-m-c
-    # puts the MBR, so the boot loader skips that address.
-    supports_writing_to_mmc = False
     SNOWBALL_LOADER_START_S = (128 * 1024) / SECTOR_SIZE
-    snowball_startup_files_config = 'startfiles.cfg'
     TOC_SIZE = 512
 
-    @classmethod
-    def get_v1_sfdisk_cmd(cls, should_align_boot_part=None):
+    def __init__(self):
+        super(SnowballEmmcConfig, self).__init__()
+        # Boot ROM looks for a boot table of contents (TOC) at 0x20000
+        # Actually, it first looks at address 0, but that's where l-m-c
+        # puts the MBR, so the boot loader skips that address.
+        self.supports_writing_to_mmc = False
+        self.snowball_startup_files_config = 'startfiles.cfg'
+
+    def get_v1_sfdisk_cmd(self, should_align_boot_part=None):
         """Return the sfdisk command to partition the media.
 
         :param should_align_boot_part: Ignored.
@@ -1083,68 +1085,64 @@
         # with the usual SECTOR_SIZE of 0x200.
         # (sector 0 is MBR / partition table)
         loader_start, loader_end, loader_len = align_partition(
-            SnowballEmmcConfig.SNOWBALL_LOADER_START_S,
-            cls.LOADER_MIN_SIZE_S, 1, PART_ALIGN_S)
+            self.SNOWBALL_LOADER_START_S,
+            self.LOADER_MIN_SIZE_S, 1, PART_ALIGN_S)
 
         boot_start, boot_end, boot_len = align_partition(
-            loader_end + 1, cls.BOOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
+            loader_end + 1, self.BOOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
         # we ignore _root_end / _root_len and return an sfdisk command to
         # instruct the use of all remaining space; XXX if we had some root size
         # config, we could do something more sensible
         root_start, _root_end, _root_len = align_partition(
-            boot_end + 1, cls.ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
+            boot_end + 1, self.ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
 
         return '%s,%s,0xDA\n%s,%s,0x0C,*\n%s,,,-' % (
         loader_start, loader_len, boot_start, boot_len, root_start)
 
-    @classmethod
-    def _make_boot_files(cls, boot_env, chroot_dir, boot_dir,
+    def _make_boot_files(self, boot_env, chroot_dir, boot_dir,
                          boot_device_or_file, k_img_data, i_img_data,
                          d_img_data):
         # XXX: delete this method when hwpacks V1 can die
-        assert cls.hwpack_format == HardwarepackHandler.FORMAT_1
-        make_uImage(cls.load_addr, k_img_data, boot_dir)
-        boot_script_path = os.path.join(boot_dir, cls.boot_script)
+        assert self.hwpack_format == HardwarepackHandler.FORMAT_1
+        make_uImage(self.load_addr, k_img_data, boot_dir)
+        boot_script_path = os.path.join(boot_dir, self.boot_script)
         make_boot_script(boot_env, boot_script_path)
-        cls.populate_raw_partition(boot_device_or_file, chroot_dir)
+        self.populate_raw_partition(boot_device_or_file, chroot_dir)
 
-    @classmethod
-    def populate_raw_partition(cls, boot_device_or_file, chroot_dir):
+    def populate_raw_partition(self, boot_device_or_file, chroot_dir):
         # Populate created raw partition with TOC and startup files.
         _, toc_filename = tempfile.mkstemp()
-        config_files_dir = cls.snowball_config(chroot_dir)
-        new_files = cls.get_file_info(chroot_dir, config_files_dir)
+        config_files_dir = self.snowball_config(chroot_dir)
+        new_files = self.get_file_info(chroot_dir, config_files_dir)
         with open(toc_filename, 'wb') as toc:
-            cls.create_toc(toc, new_files)
-        cls.install_snowball_boot_loader(toc_filename, new_files,
+            self.create_toc(toc, new_files)
+        self.install_snowball_boot_loader(toc_filename, new_files,
                                          boot_device_or_file,
-                                         cls.SNOWBALL_LOADER_START_S,
-                                         cls.delete_startupfiles)
-        cls.delete_file(toc_filename)
-        if cls.delete_startupfiles:
-            cls.delete_file(os.path.join(config_files_dir,
-                                         cls.snowball_startup_files_config))
+                                         self.SNOWBALL_LOADER_START_S,
+                                         self.delete_startupfiles)
+        self.delete_file(toc_filename)
+        if self.delete_startupfiles:
+            self.delete_file(os.path.join(config_files_dir,
+                                         self.snowball_startup_files_config))
 
-    @classmethod
-    def snowball_config(cls, chroot_dir):
+    def snowball_config(self, chroot_dir):
         # We will find the startupfiles in the target boot partition.
         return os.path.join(chroot_dir, 'boot')
 
-    @classproperty
-    def delete_startupfiles(cls):
+    @property
+    def delete_startupfiles(self):
         # The startupfiles will have been installed to the target boot
         # partition by the hwpack, and should be deleted so we don't leave
         # them on the target system.
         return True
 
-    @classmethod
-    def install_snowball_boot_loader(cls, toc_file_name, files,
+    def install_snowball_boot_loader(self, toc_file_name, files,
                                      boot_device_or_file, start_sector,
                                      delete_startupfiles=False):
         ''' Copies TOC and boot files into the boot partition.
         A sector size of 1 is used for some files, as they do not
         necessarily start on an even address. '''
-        assert os.path.getsize(toc_file_name) <= cls.TOC_SIZE
+        assert os.path.getsize(toc_file_name) <= self.TOC_SIZE
         _dd(toc_file_name, boot_device_or_file, seek=start_sector)
 
         for file in files:
@@ -1159,16 +1157,14 @@
                 seek_sectors = start_sector + file['offset'] / SECTOR_SIZE
                 _dd(filename, boot_device_or_file, seek=seek_sectors)
             if delete_startupfiles:
-                cls.delete_file(filename)
+                self.delete_file(filename)
 
-    @classmethod
-    def delete_file(cls, file_path):
+    def delete_file(self, file_path):
             cmd = ["rm", "%s" % file_path]
             proc = cmd_runner.run(cmd, as_root=True)
             proc.wait()
 
-    @classmethod
-    def create_toc(cls, f, files):
+    def create_toc(self, f, files):
         ''' Writes a table of contents of the boot binaries.
         Boot rom searches this table to find the binaries.'''
         # Format string means: < little endian,
@@ -1190,15 +1186,14 @@
                                file['section_name'])
             f.write(data)
 
-    @classmethod
-    def get_file_info(cls, chroot_dir, config_files_dir):
+    def get_file_info(self, chroot_dir, config_files_dir):
         ''' Fills in the offsets of files that are located in
         non-absolute memory locations depending on their sizes.'
         Also fills in file sizes'''
-        ofs = cls.TOC_SIZE
+        ofs = self.TOC_SIZE
         files = []
         with open(os.path.join(config_files_dir,
-                               cls.snowball_startup_files_config),
+                               self.snowball_startup_files_config),
                   'r') as info_file:
             for line in info_file:
                 file_data = line.split()
@@ -1229,23 +1224,16 @@
 
 
 class Mx5Config(BoardConfig):
-    serial_tty = 'ttymxc0'
-    _extra_serial_opts = 'console=tty0 console=%s,115200n8'
-    _live_serial_opts = 'serialtty=%s'
-    boot_script = 'boot.scr'
-    mmc_part_offset = 1
-    mmc_option = '0:2'
-
-    @classproperty
-    def live_serial_opts(cls):
-        return cls._live_serial_opts % cls.serial_tty
-
-    @classproperty
-    def extra_serial_opts(cls):
-        return cls._extra_serial_opts % cls.serial_tty
-
-    @classmethod
-    def get_v1_sfdisk_cmd(cls, should_align_boot_part=None):
+    def __init__(self):
+        super(Mx5Config, self).__init__()
+        self.boot_script = 'boot.scr'
+        self.mmc_option = '0:2'
+        self.mmc_part_offset = 1
+        self.serial_tty = 'ttymxc0'
+        self._extra_serial_opts = 'console=tty0 console=%s,115200n8'
+        self._live_serial_opts = 'serialtty=%s'
+
+    def get_v1_sfdisk_cmd(self, should_align_boot_part=None):
         """Return the sfdisk command to partition the media.
 
         :param should_align_boot_part: Ignored.
@@ -1259,103 +1247,107 @@
         # onwards, so it's safer to just start at the first sector, sector 1
         # (sector 0 is MBR / partition table)
         loader_start, loader_end, loader_len = align_partition(
-            1, cls.LOADER_MIN_SIZE_S, 1, PART_ALIGN_S)
+            1, self.LOADER_MIN_SIZE_S, 1, PART_ALIGN_S)
 
         boot_start, boot_end, boot_len = align_partition(
-            loader_end + 1, cls.BOOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
+            loader_end + 1, self.BOOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
         # we ignore _root_end / _root_len and return a sfdisk command to
         # instruct the use of all remaining space; XXX if we had some root size
         # config, we could do something more sensible
         root_start, _root_end, _root_len = align_partition(
-            boot_end + 1, cls.ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
+            boot_end + 1, self.ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
 
         return '%s,%s,0xDA\n%s,%s,0x0C,*\n%s,,,-' % (
             loader_start, loader_len, boot_start, boot_len, root_start)
 
-    @classmethod
-    def _make_boot_files(cls, boot_env, chroot_dir, boot_dir,
+    def _make_boot_files(self, boot_env, chroot_dir, boot_dir,
                          boot_device_or_file, k_img_data, i_img_data,
                          d_img_data):
         # XXX: delete this method when hwpacks V1 can die
-        assert cls.hwpack_format == HardwarepackHandler.FORMAT_1
-        with cls.hardwarepack_handler:
-            bootloader_file = cls.get_file('bootloader_file',
+        assert self.hwpack_format == HardwarepackHandler.FORMAT_1
+        with self.hardwarepack_handler:
+            bootloader_file = self.get_file('bootloader_file',
                 default=os.path.join(
-                    chroot_dir, 'usr', 'lib', 'u-boot', cls.bootloader_flavor,
+                    chroot_dir, 'usr', 'lib', 'u-boot', self.bootloader_flavor,
                     'u-boot.imx'))
             install_mx5_boot_loader(bootloader_file, boot_device_or_file,
-                                    cls.LOADER_MIN_SIZE_S)
-        make_uImage(cls.load_addr, k_img_data, boot_dir)
+                                    self.LOADER_MIN_SIZE_S)
+        make_uImage(self.load_addr, k_img_data, boot_dir)
         make_uInitrd(i_img_data, boot_dir)
         make_dtb(d_img_data, boot_dir)
-        boot_script_path = os.path.join(boot_dir, cls.boot_script)
+        boot_script_path = os.path.join(boot_dir, self.boot_script)
         make_boot_script(boot_env, boot_script_path)
 
 
 class Mx51Config(Mx5Config):
-    kernel_addr = '0x90000000'
-    dtb_addr = '0x91ff0000'
-    initrd_addr = '0x92000000'
-    load_addr = '0x90008000'
-    kernel_flavors = ['linaro-mx51', 'linaro-lt-mx5']
+    def __init__(self):
+        super(Mx51Config, self).__init__()
+        self.dtb_addr = '0x91ff0000'
+        self.initrd_addr = '0x92000000'
+        self.kernel_addr = '0x90000000'
+        self.kernel_flavors = ['linaro-mx51', 'linaro-lt-mx5']
+        self.load_addr = '0x90008000'
 
 
 class Mx53Config(Mx5Config):
-    kernel_addr = '0x70000000'
-    dtb_addr = '0x71ff0000'
-    initrd_addr = '0x72000000'
-    load_addr = '0x70008000'
-    kernel_flavors = ['linaro-lt-mx53', 'linaro-lt-mx5']
+    def __init__(self):
+        super(Mx53Config, self).__init__()
+        self.dtb_addr = '0x71ff0000'
+        self.initrd_addr = '0x72000000'
+        self.kernel_addr = '0x70000000'
+        self.kernel_flavors = ['linaro-lt-mx53', 'linaro-lt-mx5']
+        self.load_addr = '0x70008000'
 
 
 class EfikamxConfig(Mx51Config):
-    bootloader_flavor = 'efikamx'
-    dtb_name = 'genesi-efikamx.dtb'
+    def __init__(self):
+        super(EfikamxConfig, self).__init__()
+        self.bootloader_flavor = 'efikamx'
+        self.dtb_name = 'genesi-efikamx.dtb'
 
 
 class EfikasbConfig(Mx51Config):
-    bootloader_flavor = 'efikasb'
-    dtb_name = 'genesi-efikasb.dtb'
+    def __init__(self):
+        super(EfikasbConfig, self).__init__()
+        self.bootloader_flavor = 'efikasb'
+        self.dtb_name = 'genesi-efikasb.dtb'
 
 
 class Mx51evkConfig(Mx51Config):
-    bootloader_flavor = 'mx51evk'
-    dtb_name = 'mx51-babbage.dtb'
+    def __init__(self):
+        super(Mx51evkConfig, self).__init__()
+        self.bootloader_flavor = 'mx51evk'
+        self.dtb_name = 'mx51-babbage.dtb'
 
 
 class Mx53LoCoConfig(Mx53Config):
-    bootloader_flavor = 'mx53loco'
-    dtb_name = 'mx53-loco.dtb'
+    def __init__(self):
+        super(Mx53LoCoConfig, self).__init__()
+        self.bootloader_flavor = 'mx53loco'
+        self.dtb_name = 'mx53-loco.dtb'
 
 
 class VexpressConfig(BoardConfig):
-    bootloader_flavor = 'ca9x4_ct_vxp'
-    bootloader_file_in_boot_part = True
-    serial_tty = 'ttyAMA0'
-    _extra_serial_opts = 'console=tty0 console=%s,38400n8'
-    _live_serial_opts = 'serialtty=%s'
-    kernel_addr = '0x60000000'
-    initrd_addr = '0x62000000'
-    load_addr = '0x60008000'
-    kernel_flavors = ['linaro-vexpress']
-    boot_script = 'boot.scr'
-    # ARM Boot Monitor is used to load u-boot, uImage etc. into flash and
-    # only allows for FAT16
-    fat_size = 16
-
-    @classproperty
-    def live_serial_opts(cls):
-        return cls._live_serial_opts % cls.serial_tty
-
-    @classproperty
-    def extra_serial_opts(cls):
-        return cls._extra_serial_opts % cls.serial_tty
-
-    @classmethod
-    def _make_boot_files(cls, boot_env, chroot_dir, boot_dir,
+    def __init__(self):
+        super(VexpressConfig, self).__init__()
+        self.boot_script = 'boot.scr'
+        self.bootloader_file_in_boot_part = True
+        self.bootloader_flavor = 'ca9x4_ct_vxp'
+        # ARM Boot Monitor is used to load u-boot, uImage etc. into flash and
+        # only allows for FAT16
+        self.fat_size = 16
+        self.initrd_addr = '0x62000000'
+        self.kernel_addr = '0x60000000'
+        self.kernel_flavors = ['linaro-vexpress']
+        self.load_addr = '0x60008000'
+        self.serial_tty = 'ttyAMA0'
+        self._extra_serial_opts = 'console=tty0 console=%s,38400n8'
+        self._live_serial_opts = 'serialtty=%s'
+
+    def _make_boot_files(self, boot_env, chroot_dir, boot_dir,
                          boot_device_or_file, k_img_data, i_img_data,
                          d_img_data):
-        make_uImage(cls.load_addr, k_img_data, boot_dir)
+        make_uImage(self.load_addr, k_img_data, boot_dir)
         make_uInitrd(i_img_data, boot_dir)
 
 
@@ -1363,22 +1355,23 @@
     # For now, this is a duplicate of VexpressConfig.
     # In future, there will also be A5 and A15 variants.
     # For all of these, there should never be any V1 hardware packs.
-    pass
+    def __init__(self):
+        super(VexpressA9Config, self).__init__()
 
 
 class FastModelConfig(BoardConfig):
-    supports_writing_to_mmc = False
+    def __init__(self):
+        super(FastModelConfig, self).__init__()
+        self.supports_writing_to_mmc = False
 
-    @classmethod
-    def _get_bootcmd(cls, i_img_data, d_img_data):
+    def _get_bootcmd(self, i_img_data, d_img_data):
         """Get the bootcmd for FastModel.
 
         We override this as we don't do uboot.
         """
         return ""
 
-    @classmethod
-    def _make_boot_files_v2(cls, boot_env, chroot_dir, boot_dir,
+    def _make_boot_files_v2(self, boot_env, chroot_dir, boot_dir,
                          boot_device_or_file, k_img_data, i_img_data,
                          d_img_data):
         output_dir = os.path.dirname(boot_device_or_file)
@@ -1395,16 +1388,14 @@
 
 
 class SamsungConfig(BoardConfig):
-    @classproperty
-    def extra_serial_opts(cls):
-        return cls._extra_serial_opts % cls.serial_tty
+    def __init__(self):
+        super(SamsungConfig, self).__init__()
+        self._extra_serial_opts = None
 
-    @classmethod
-    def get_v1_sfdisk_cmd(cls, should_align_boot_part=False):
+    def get_v1_sfdisk_cmd(self, should_align_boot_part=False):
         # bootloaders partition needs to hold BL1, U-Boot environment, and BL2
-        loaders_min_len = (
-            cls.samsung_bl1_start + cls.samsung_bl1_len + cls.samsung_bl2_len +
-            cls.samsung_env_len)
+        loaders_min_len = (self.samsung_bl1_start + self.samsung_bl1_len +
+            self.samsung_bl2_len + self.samsung_env_len)
 
         # bootloaders partition
         loaders_start, loaders_end, loaders_len = align_partition(
@@ -1412,44 +1403,42 @@
 
         # FAT boot partition
         boot_start, boot_end, boot_len = align_partition(
-            loaders_end + 1, cls.BOOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
+            loaders_end + 1, self.BOOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
 
         # root partition
         # we ignore _root_end / _root_len and return a sfdisk command to
         # instruct the use of all remaining space; XXX if we had some root size
         # config, we could do something more sensible
         root_start, _root_end, _root_len = align_partition(
-            boot_end + 1, cls.ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
+            boot_end + 1, self.ROOT_MIN_SIZE_S, PART_ALIGN_S, PART_ALIGN_S)
 
         return '%s,%s,0xDA\n%s,%s,0x0C,*\n%s,,,-' % (
             loaders_start, loaders_len, boot_start, boot_len, root_start)
 
-    @classmethod
-    def _make_boot_files(cls, boot_env, chroot_dir, boot_dir,
+    def _make_boot_files(self, boot_env, chroot_dir, boot_dir,
                          boot_device_or_file, k_img_data, i_img_data,
                          d_img_data):
         # XXX: delete this method when hwpacks V1 can die
-        assert cls.hwpack_format == HardwarepackHandler.FORMAT_1
-        cls.install_samsung_boot_loader(cls._get_samsung_spl(chroot_dir),
-            cls._get_samsung_bootloader(chroot_dir), boot_device_or_file)
-        env_size = cls.samsung_env_len * SECTOR_SIZE
+        assert self.hwpack_format == HardwarepackHandler.FORMAT_1
+        self.install_samsung_boot_loader(self._get_samsung_spl(chroot_dir),
+            self._get_samsung_bootloader(chroot_dir), boot_device_or_file)
+        env_size = self.samsung_env_len * SECTOR_SIZE
         env_file = make_flashable_env(boot_env, env_size)
-        _dd(env_file, boot_device_or_file, seek=cls.samsung_env_start)
+        _dd(env_file, boot_device_or_file, seek=self.samsung_env_start)
 
-        make_uImage(cls.load_addr, k_img_data, boot_dir)
+        make_uImage(self.load_addr, k_img_data, boot_dir)
         make_uInitrd(i_img_data, boot_dir)
 
         # unused at the moment once FAT support enabled for the
         # Samsung u-boot this can be used bug 727978
-        boot_script_path = os.path.join(boot_dir, cls.boot_script)
+        boot_script_path = os.path.join(boot_dir, self.boot_script)
         make_boot_script(boot_env, boot_script_path)
 
-    @classmethod
-    def _get_samsung_spl(cls, chroot_dir):
+    def _get_samsung_spl(self, chroot_dir):
         # XXX: delete this method when hwpacks V1 can die
-        assert cls.hwpack_format == HardwarepackHandler.FORMAT_1
+        assert self.hwpack_format == HardwarepackHandler.FORMAT_1
         spl_dir = os.path.join(
-            chroot_dir, 'usr', 'lib', 'u-boot', cls.bootloader_flavor)
+            chroot_dir, 'usr', 'lib', 'u-boot', self.bootloader_flavor)
         old_spl_path = os.path.join(spl_dir, 'v310_mmc_spl.bin')
         new_spl_path = os.path.join(spl_dir, 'u-boot-mmc-spl.bin')
         spl_path_origen2 = os.path.join(spl_dir, 'origen-spl.bin')
@@ -1479,49 +1468,48 @@
                                  % (old_spl_path, new_spl_path))
         return spl_file
 
-    @classmethod
-    def _get_samsung_bootloader(cls, chroot_dir):
+    def _get_samsung_bootloader(self, chroot_dir):
         # XXX: delete this method when hwpacks V1 can die
-        assert cls.hwpack_format == HardwarepackHandler.FORMAT_1
+        assert self.hwpack_format == HardwarepackHandler.FORMAT_1
         bootloader_file = os.path.join(
-            chroot_dir, 'usr', 'lib', 'u-boot', cls.bootloader_flavor,
+            chroot_dir, 'usr', 'lib', 'u-boot', self.bootloader_flavor,
             'u-boot.bin')
         return bootloader_file
 
-    @classmethod
-    def populate_raw_partition(cls, boot_device_or_file, chroot_dir):
+    def populate_raw_partition(self, boot_device_or_file, chroot_dir):
         # Zero the env so that the boot_script will get loaded
-        _dd("/dev/zero", boot_device_or_file, count=cls.samsung_env_len,
-            seek=cls.samsung_env_start)
+        _dd("/dev/zero", boot_device_or_file, count=self.samsung_env_len,
+            seek=self.samsung_env_start)
         # Populate created raw partition with BL1 and u-boot
         spl_file = os.path.join(chroot_dir, 'boot', 'u-boot-mmc-spl.bin')
         assert os.path.getsize(spl_file) <= (
-            cls.samsung_bl1_len * SECTOR_SIZE), (
+            self.samsung_bl1_len * SECTOR_SIZE), (
             "%s is larger than Samsung BL1 size" % spl_file)
-        _dd(spl_file, boot_device_or_file, seek=cls.samsung_bl1_start)
+        _dd(spl_file, boot_device_or_file, seek=self.samsung_bl1_start)
         uboot_file = os.path.join(chroot_dir, 'boot', 'u-boot.bin')
         assert os.path.getsize(uboot_file) <= (
-            cls.samsung_bl2_len * SECTOR_SIZE), (
+            self.samsung_bl2_len * SECTOR_SIZE), (
             "%s is larger than Samsung BL2 size" % uboot_file)
-        _dd(uboot_file, boot_device_or_file, seek=cls.samsung_bl2_start)
+        _dd(uboot_file, boot_device_or_file, seek=self.samsung_bl2_start)
 
 
 class SMDKV310Config(SamsungConfig):
-    bootloader_flavor = 'smdkv310'
-    serial_tty = 'ttySAC1'
-    _extra_serial_opts = 'console=%s,115200n8'
-    kernel_addr = '0x40007000'
-    initrd_addr = '0x42000000'
-    load_addr = '0x40008000'
-    kernel_flavors = ['s5pv310']
-    boot_script = 'boot.scr'
-    mmc_part_offset = 1
-    mmc_option = '0:2'
+    def __init__(self):
+        super(SMDKV310Config, self).__init__()
+        self.boot_script = 'boot.scr'
+        self.bootloader_flavor = 'smdkv310'
+        self.initrd_addr = '0x42000000'
+        self.kernel_addr = '0x40007000'
+        self.kernel_flavors = ['s5pv310']
+        self.load_addr = '0x40008000'
+        self.mmc_option = '0:2'
+        self.mmc_part_offset = 1
+        self.serial_tty = 'ttySAC1'
+        self._extra_serial_opts = 'console=%s,115200n8'
 
-    @classmethod
-    def _get_boot_env(cls, is_live, is_lowmem, consoles, rootfs_id,
+    def _get_boot_env(self, is_live, is_lowmem, consoles, rootfs_id,
                       i_img_data, d_img_data):
-        boot_env = super(SamsungConfig, cls)._get_boot_env(
+        boot_env = super(SamsungConfig, self)._get_boot_env(
             is_live, is_lowmem, consoles, rootfs_id, i_img_data, d_img_data)
 
         boot_env["ethact"] = "smc911x-0"
@@ -1531,60 +1519,59 @@
 
 
 class OrigenConfig(SamsungConfig):
-    bootloader_flavor = 'origen'
-    serial_tty = 'ttySAC2'
-    _extra_serial_opts = 'console=%s,115200n8'
-    kernel_addr = '0x40007000'
-    initrd_addr = '0x42000000'
-    load_addr = '0x40008000'
-    kernel_flavors = ['origen']
-    boot_script = 'boot.scr'
-    mmc_part_offset = 1
-    mmc_option = '0:2'
+    # TODO test
+    def __init__(self):
+        super(OrigenConfig, self).__init__()
+        self.boot_script = 'boot.scr'
+        self.bootloader_flavor = 'origen'
+        self.initrd_addr = '0x42000000'
+        self.kernel_addr = '0x40007000'
+        self.kernel_flavors = ['origen']
+        self.load_addr = '0x40008000'
+        self.mmc_option = '0:2'
+        self.mmc_part_offset = 1
+        self.serial_tty = 'ttySAC2'
+        self._extra_serial_opts = 'console=%s,115200n8'
 
 
 class OrigenQuadConfig(SamsungConfig):
-    bootloader_flavor = 'origen_quad'
-    serial_tty = 'ttySAC2'
-    _extra_serial_opts = 'console=%s,115200n8'
-    kernel_addr = '0x40007000'
-    initrd_addr = '0x42000000'
-    load_addr = '0x40008000'
-    kernel_flavors = ['origen_quad']
-    boot_script = 'boot.scr'
-    mmc_part_offset = 1
-    mmc_option = '0:2'
-    samsung_bl1_len = 48
-    samsung_bl2_start = 49
-    samsung_env_start = 1073
+    def __init__(self):
+        super(OrigenQuadConfig, self).__init__()
+        self.boot_script = 'boot.scr'
+        self.bootloader_flavor = 'origen_quad'
+        self.initrd_addr = '0x42000000'
+        self.kernel_addr = '0x40007000'
+        self.kernel_flavors = ['origen_quad']
+        self.load_addr = '0x40008000'
+        self.mmc_option = '0:2'
+        self.mmc_part_offset = 1
+        self.samsung_bl1_len = 48
+        self.samsung_bl2_start = 49
+        self.samsung_env_start = 1073
+        self.serial_tty = 'ttySAC2'
+        self._extra_serial_opts = 'console=%s,115200n8'
 
 
 class ArndaleConfig(SamsungConfig):
-    bootloader_flavor = 'arndale'
-    serial_tty = 'ttySAC2'
-    _extra_serial_opts = 'console=%s,115200n8'
-    kernel_addr = '0x40007000'
-    initrd_addr = '0x42000000'
-    dtb_addr = '0x41f00000'
-    load_addr = '0x40008000'
-    kernel_flavors = ['arndale']
-    boot_script = 'boot.scr'
-    mmc_part_offset = 1
-    mmc_option = '0:2'
-    samsung_bl1_start = 17
-    samsung_bl2_start = 49
-    samsung_env_start = 1073
+    def __init__(self):
+        super(ArndaleConfig, self).__init__()
+        self.boot_script = 'boot.scr'
+        self.bootloader_flavor = 'arndale'
+        self.dtb_addr = '0x41f00000'
+        self.initrd_addr = '0x42000000'
+        self.kernel_addr = '0x40007000'
+        self.kernel_flavors = ['arndale']
+        self.load_addr = '0x40008000'
+        self.mmc_option = '0:2'
+        self.mmc_part_offset = 1
+        self.samsung_bl1_start = 17
+        self.samsung_bl2_start = 49
+        self.samsung_env_start = 1073
+        self.serial_tty = 'ttySAC2'
+        self._extra_serial_opts = 'console=%s,115200n8'
 
 
 class I386Config(BoardConfig):
-    # define serial
-    serial_tty = 'ttyS0'
-    _extra_serial_opts = 'console=tty0 console=%s,115200n8'
-    _live_serial_opts = 'serialtty=%s'
-
-    # define kernel image
-    kernel_flavors = ['generic', 'pae']
-
     # define bootloader
     BOOTLOADER_CMD = 'grub-install'
     BOOTLOADER_CFG_FILE = 'grub/grub.cfg'
@@ -1596,16 +1583,14 @@
             initrd /%s
     }"""
 
-    @classproperty
-    def live_serial_opts(cls):
-        return cls._live_serial_opts % cls.serial_tty
-
-    @classproperty
-    def extra_serial_opts(cls):
-        return cls._extra_serial_opts % cls.serial_tty
-
-    @classmethod
-    def _make_boot_files(cls, boot_env, chroot_dir, boot_dir,
+    def __init__(self):
+        super(I386Config, self).__init__()
+        self.kernel_flavors = ['generic', 'pae']
+        self.serial_tty = 'ttyS0'
+        self._extra_serial_opts = 'console=tty0 console=%s,115200n8'
+        self._live_serial_opts = 'serialtty=%s'
+
+    def _make_boot_files(self, boot_env, chroot_dir, boot_dir,
                          boot_device_or_file, k_img_data, i_img_data,
                          d_img_data):
         # copy image and init into boot partition
@@ -1618,13 +1603,13 @@
         img_loop = register_loopback(boot_device_or_file, 0, img_size)
 
         # install bootloader
-        cmd_runner.run([cls.BOOTLOADER_CMD, '--boot-directory=%s' % boot_dir,
+        cmd_runner.run([self.BOOTLOADER_CMD, '--boot-directory=%s' % boot_dir,
             '--modules', 'part_msdos', img_loop],
             as_root=True).wait()
 
         # generate loader config file
-        loader_config = cls.BOOTLOADER_CFG % (os.path.basename(k_img_data),
-            cls.extra_serial_opts, os.path.basename(i_img_data))
+        loader_config = self.BOOTLOADER_CFG % (os.path.basename(k_img_data),
+            self.extra_serial_opts, os.path.basename(i_img_data))
 
         _, tmpfile = tempfile.mkstemp()
         atexit.register(os.unlink, tmpfile)
@@ -1632,42 +1617,59 @@
             fd.write(loader_config)
 
         cmd_runner.run(['cp', tmpfile, os.path.join(boot_dir,
-            cls.BOOTLOADER_CFG_FILE)], as_root=True).wait()
+            self.BOOTLOADER_CFG_FILE)], as_root=True).wait()
 
-    @classmethod
-    def _make_boot_files_v2(cls, boot_env, chroot_dir, boot_dir,
+    def _make_boot_files_v2(self, boot_env, chroot_dir, boot_dir,
                             boot_device_or_file, k_img_data, i_img_data,
                             d_img_data):
         # reuse hwpack v1 function
-        cls._make_boot_files(boot_env, chroot_dir, boot_dir,
-                             boot_device_or_file, k_img_data, i_img_data,
-                             d_img_data)
+        self._make_boot_files(boot_env, chroot_dir, boot_dir,
+                              boot_device_or_file, k_img_data, i_img_data,
+                              d_img_data)
+
+
+class BoardConfigException(Exception):
+    """General board config exception."""
 
 
 board_configs = {
     'arndale': ArndaleConfig,
     'beagle': BeagleConfig,
-    'igep': IgepConfig,
-    'panda': PandaConfig,
-    'vexpress': VexpressConfig,
-    'vexpress-a9': VexpressA9Config,
-    'fastmodel': FastModelConfig,
-    'ux500': Ux500Config,
-    'snowball_sd': SnowballSdConfig,
-    'snowball_emmc': SnowballEmmcConfig,
     'efikamx': EfikamxConfig,
     'efikasb': EfikasbConfig,
+    'fastmodel': FastModelConfig,
+    'i386': I386Config,
+    'igep': IgepConfig,
     'mx51evk': Mx51evkConfig,
     'mx53loco': Mx53LoCoConfig,
+    'mx6qsabrelite': BoardConfig,
+    'origen': OrigenConfig,
+    'origen_quad': OrigenQuadConfig,
     'overo': OveroConfig,
+    'panda': PandaConfig,
     'smdkv310': SMDKV310Config,
-    'origen': OrigenConfig,
-    'origen_quad': OrigenQuadConfig,
-    'mx6qsabrelite': BoardConfig,
-    'i386': I386Config,
+    'snowball_emmc': SnowballEmmcConfig,
+    'snowball_sd': SnowballSdConfig,
+    'ux500': Ux500Config,
+    'vexpress': VexpressConfig,
+    'vexpress-a9': VexpressA9Config,
     }
 
 
+def get_board_config(board):
+    """Get the board configuration for the specified board.
+
+    :param board: The name of the board to get the configuration of.
+    :type board: str
+    """
+    clazz = board_configs.get(board, None)
+    if clazz:
+        return clazz()
+    else:
+        raise BoardConfigException("Board name '%s' has no configuration "
+                                   "available." % board)
+
+
 def _dd(input_file, output_file, block_size=SECTOR_SIZE, count=None, seek=None,
         skip=None):
     """Wrapper around the dd command"""