Design and Architecture

#ifndef DONT_KNOW_IF_REG_IS_STILL_SUPPORTED_YOU_HAVE_TO_ASK
#define DONT_KNOW_IF_REG_IS_STILL_SUPPORTED_YOU_HAVE_TO_ASK    (0xFF)
#endif
#ifndef REG_IS_NO_LONGER_SUPPORTED
#define REG_IS_NO_LONGER_SUPPORTED                             (0)
#endif
#ifndef REG_IS_STILL_SUPPORTED
#define REG_IS_STILL_SUPPORTED                                 (1)
#endif

typedef struct __attribute__((__packed__)) {
    uint8_t versionMajorFunc;
    uint8_t versionMinorFunc;
    uint8_t versionMajorBug;
    uint8_t versionMinorBug;
    uint8_t variant;
} versionAndVariant_s;

typedef struct __attribute__((__packed__)) {
    uint32_t          addr;
    uint8_t           versionMajorFuncRegWasIntroduced;
    uint8_t           versionMinorFuncRegWasIntroduced;
    uint8_t           versionMajorBugRegWasIntroduced;
    uint8_t           versionMinorBugRegWasIntroduced;
    uint32_t          supportedVariantsMask;
    uint8_t           isRegStillSupported;
} regSpec_s;


#ifndef IS_REG_COMPATIBLE
#define IS_REG_COMPATIBLE(__FW_VERSION_AND_VARIANT_PTR__,__REG_SPEC_PTR__)                                                    \
       ((((((uint32_t)(__REG_SPEC_PTR__)->versionMajorFunc)               << 24) |                                            \
          (((uint32_t)(__REG_SPEC_PTR__)->versionMinorFunc)               << 16) |                                            \
          (((uint32_t)(__REG_SPEC_PTR__)->versionMajorBug)                <<  8) |                                            \
          (((uint32_t)(__REG_SPEC_PTR__)->versionMinorBug)                <<  0)) <=                                          \
         ((((uint32_t)(__FW_VERSION_AND_VARIANT_PTR__)->versionMajorFunc) << 24) |                                            \
          (((uint32_t)(__FW_VERSION_AND_VARIANT_PTR__)->versionMinorFunc) << 16) |                                            \
          (((uint32_t)(__FW_VERSION_AND_VARIANT_PTR__)->versionMajorBug)  <<  8) |                                            \
          (((uint32_t)(__FW_VERSION_AND_VARIANT_PTR__)->versionMinorBug)  <<  0))) &&                                         \
        (0 < ((__REG_SPEC_PTR__)->supportedVariantsMask & VARIANT_TO_VARIANT_MASK((__FW_VERSION_AND_VARIANT_PTR__)->variant))) && \
                                                  (!(((__FW_VERSION_AND_VARIANT_PTR__)->versionMajorFunc == 0xFF) &&          \
                                                     ((__FW_VERSION_AND_VARIANT_PTR__)->versionMinorFunc == 0xFF) &&          \
                                                     ((__FW_VERSION_AND_VARIANT_PTR__)->versionMajorBug  == 0xFF) &&          \
                                                     ((__FW_VERSION_AND_VARIANT_PTR__)->versionMinorBug  == 0xFF))))
#endif

extern const regSpec_s MY_REG_1;
extern const regSpec_s MY_REG_2;

const regSpec_s MY_REG_1 = {1000, 0, 0, 0, 4, ALL_VARIANTS_MASK, DONT_KNOW_IF_REG_IS_STILL_SUPPORTED_YOU_HAVE_TO_ASK};
const regSpec_s MY_REG_2 = {1002, 0, 0, 0, 4, ALL_VARIANTS_MASK, DONT_KNOW_IF_REG_IS_STILL_SUPPORTED_YOU_HAVE_TO_ASK};

versionAndVariant_s* versionAndVariantOfOtherProduct = getVersionAndVariant(otherProduct);
if (!IS_REG_COMPATIBLE(versionAndVariantOfOtherProduct, &MY_REG_1)) {
    return FALSE; // Error! The other product's fw is too old to have this register
}
if (MY_REG_1.isRegStillSupported == DONT_KNOW_IF_REG_IS_STILL_SUPPORTED_YOU_HAVE_TO_ASK) {
    MY_REG_1.isRegStillSupported = isRegStillSupported(otherProduct, MY_REG_1.addr);
}
if (MY_REG_1.isRegStillSupported == REG_IS_NO_LONGER_SUPPORTED) {
    return FALSE; // Error! At some point the other product supported this register, but not anymore
}