Update HAL CRC API

* Change "is supported" check to be a macro, so it can be done at
  compile-time.
* Eliminate weird shift on 7-bit CRCs.
* Add support for 32-bit CRCs and reversals to TMPM3HQ.

Author: kjbracey

TESTS/mbed_hal/crc/main.cpp

@@ -54,7 +54,7 @@ void crc_is_supported_test()
     uint32_t num_of_supported_polynomials = 0;
 
     for (unsigned int i = 0; i < (test_cases_size / sizeof(TEST_CASE)); i++) {
-        if (hal_crc_is_supported(&test_cases[i].config_data) == true) {
+        if (HAL_CRC_IS_SUPPORTED(test_cases[i].config_data.polynomial, test_cases[i].config_data.width)) {
 
             num_of_supported_polynomials++;
         }
@@ -68,7 +68,7 @@ void crc_is_supported_test()
 void crc_calc_single_test()
 {
     for (unsigned int i = 0; i < (test_cases_size / sizeof(TEST_CASE)); i++) {
-        if (hal_crc_is_supported(&test_cases[i].config_data) == true) {
+        if (HAL_CRC_IS_SUPPORTED(test_cases[i].config_data.polynomial, test_cases[i].config_data.width)) {
 
             hal_crc_compute_partial_start(&test_cases[i].config_data);
             hal_crc_compute_partial((uint8_t *) input_data, strlen((const char *) input_data));
@@ -84,7 +84,7 @@ void crc_calc_single_test()
 void crc_calc_multi_test()
 {
     for (unsigned int i = 0; i < (test_cases_size / sizeof(TEST_CASE)); i++) {
-        if (hal_crc_is_supported(&test_cases[i].config_data) == true) {
+        if (HAL_CRC_IS_SUPPORTED(test_cases[i].config_data.polynomial, test_cases[i].config_data.width)) {
 
             const uint32_t first_part_bytes = 3;
             const uint32_t second_part_bytes = 1;
@@ -117,7 +117,7 @@ void crc_reconfigure_test()
     for (unsigned int i = 0; i < (test_cases_size / sizeof(TEST_CASE)); i++) {
 
         /* Find two supported polynomials if possible. */
-        if (hal_crc_is_supported(&test_cases[i].config_data) == true) {
+        if (HAL_CRC_IS_SUPPORTED(test_cases[i].config_data.polynomial, test_cases[i].config_data.width)) {
             if (pol_cnt == 0) {
                 pol_idx[pol_cnt] = i;
                 pol_cnt++;
@@ -159,7 +159,7 @@ void crc_compute_partial_invalid_param_test()
 
     /* At least one polynomial must be supported. */
     for (unsigned int i = 0; i < (test_cases_size / sizeof(TEST_CASE)); i++) {
-        if (hal_crc_is_supported(&test_cases[i].config_data) == true) {
+        if (HAL_CRC_IS_SUPPORTED(test_cases[i].config_data.polynomial, test_cases[i].config_data.width)) {
 
             hal_crc_compute_partial_start(&test_cases[i].config_data);
 
@@ -180,19 +180,12 @@ void crc_compute_partial_invalid_param_test()
     }
 }
 
-/* Test that hal_crc_is_supported() returns false if pointer to the config structure is undefined. */
-void crc_is_supported_invalid_param_test()
-{
-    TEST_ASSERT_EQUAL(false, hal_crc_is_supported(NULL));
-}
-
 Case cases[] = {
     Case("test: supported polynomials.", crc_is_supported_test),
     Case("test: CRC calculation - single input.", crc_calc_single_test),
     Case("test: CRC calculation - multi input.", crc_calc_multi_test),
     Case("test: re-configure without getting the result.", crc_reconfigure_test),
     Case("test: hal_crc_compute_partial() - invalid parameters.", crc_compute_partial_invalid_param_test),
-    Case("test: hal_crc_is_supported() - invalid parameter.", crc_is_supported_invalid_param_test),
 };
 
 utest::v1::status_t greentea_test_setup(const size_t number_of_cases)
@@ -208,12 +201,12 @@ int main()
     // *INDENT-OFF*
     TEST_CASE local_test_cases[] = {
         /* Predefined polynomials. */
-        /* 00 */{ {POLY_7BIT_SD     ,  7, 0x00000000, 0x00000000, false, false}, 0xEA       },
-        /* 01 */{ {POLY_7BIT_SD     ,  7, 0x0000007F, 0x00000000, false, false}, 0xA0       },
-        /* 02 */{ {POLY_7BIT_SD     ,  7, 0x0000002B, 0x00000000, false, false}, 0x74       },
-        /* 03 */{ {POLY_7BIT_SD     ,  7, 0x00000000, 0x0000007F, false, false}, 0x95       },
-        /* 04 */{ {POLY_7BIT_SD     ,  7, 0x00000000, 0x0000002B, false, false}, 0xC1       },
-        /* 05 */{ {POLY_7BIT_SD     ,  7, 0x00000000, 0x00000000, true , false}, 0xA4       },
+        /* 00 */{ {POLY_7BIT_SD     ,  7, 0x00000000, 0x00000000, false, false}, 0x75       },
+        /* 01 */{ {POLY_7BIT_SD     ,  7, 0x0000007F, 0x00000000, false, false}, 0x50       },
+        /* 02 */{ {POLY_7BIT_SD     ,  7, 0x0000002B, 0x00000000, false, false}, 0x3A       },
+        /* 03 */{ {POLY_7BIT_SD     ,  7, 0x00000000, 0x0000007F, false, false}, 0x0A       },
+        /* 04 */{ {POLY_7BIT_SD     ,  7, 0x00000000, 0x0000002B, false, false}, 0x5E       },
+        /* 05 */{ {POLY_7BIT_SD     ,  7, 0x00000000, 0x00000000, true , false}, 0x52       },
         /* 06 */{ {POLY_7BIT_SD     ,  7, 0x00000000, 0x00000000, false, true }, 0x57       },
 
         /* 07 */{ {POLY_8BIT_CCITT  ,  8, 0x00000000, 0x00000000, false, false}, 0xF4       },

UNITTESTS/empty_baseline/unittest.cmake

@@ -48,7 +48,7 @@ set(unittest-test-sources
   empty_baseline/empty_baseline.cpp
 )
 
-set(DEVICE_FLAGS "-DDEVICE_ANALOGIN -DDEVICE_ANALOGOUT -DDEVICE_CAN -DDEVICE_CRC -DDEVICE_ETHERNET -DDEVICE_FLASH -DDEVICE_I2C -DDEVICE_I2CSLAVE -DDEVICE_I2C_ASYNCH -DDEVICE_INTERRUPTIN -DDEVICE_LPTICKER -DDEVICE_PORTIN -DDEVICE_PORTINOUT -DDEVICE_PORTOUT -DDEVICE_PWMOUT -DDEVICE_QSPI -DDEVICE_SERIAL -DDEVICE_SERIAL_ASYNCH -DDEVICE_SERIAL_FC -DDEVICE_SPI -DDEVICE_SPISLAVE -DDEVICE_SPI_ASYNCH -DDEVICE_FLASH -DCOMPONENT_FLASHIAP")
+set(DEVICE_FLAGS "-DDEVICE_ANALOGIN -DDEVICE_ANALOGOUT -DDEVICE_CAN -DDEVICE_ETHERNET -DDEVICE_FLASH -DDEVICE_I2C -DDEVICE_I2CSLAVE -DDEVICE_I2C_ASYNCH -DDEVICE_INTERRUPTIN -DDEVICE_LPTICKER -DDEVICE_PORTIN -DDEVICE_PORTINOUT -DDEVICE_PORTOUT -DDEVICE_PWMOUT -DDEVICE_QSPI -DDEVICE_SERIAL -DDEVICE_SERIAL_ASYNCH -DDEVICE_SERIAL_FC -DDEVICE_SPI -DDEVICE_SPISLAVE -DDEVICE_SPI_ASYNCH -DDEVICE_FLASH -DCOMPONENT_FLASHIAP")
 set(CONF_FLAGS "-DMBED_CONF_PLATFORM_CTHUNK_COUNT_MAX=10 -DMBED_CONF_DATAFLASH_SPI_FREQ=1 -DMBED_CONF_FLASHIAP_BLOCK_DEVICE_BASE_ADDRESS=0 -DMBED_CONF_FLASHIAP_BLOCK_DEVICE_SIZE=0 -DMBED_CONF_QSPIF_QSPI_FREQ=1 -DMBED_CONF_QSPIF_QSPI_MIN_READ_SIZE=1 -DMBED_CONF_QSPIF_QSPI_MIN_PROG_SIZE=1 -DMBED_LFS_READ_SIZE=64 -DMBED_LFS_PROG_SIZE=64 -DMBED_LFS_BLOCK_SIZE=512 -DMBED_LFS_LOOKAHEAD=512 -DFLASHIAP_APP_ROM_END_ADDR=0x80000 -DMBED_CONF_STORAGE_TDB_INTERNAL_INTERNAL_SIZE=1024 -DMBED_CONF_STORAGE_TDB_INTERNAL_INTERNAL_BASE_ADDRESS=0x80000 -DMBED_CONF_STORAGE_STORAGE_TYPE=default")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${DEVICE_FLAGS} ${CONF_FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${DEVICE_FLAGS} ${CONF_FLAGS}")

hal/crc_api.h

@@ -28,17 +28,15 @@
  * Different polynomial values supported
  */
 typedef enum crc_polynomial {
-    POLY_OTHER       = 0,            ///< Custom polynomial
+    POLY_7BIT_SD     = 0x09,         ///< x7+x3+1
     POLY_8BIT_CCITT  = 0x07,         ///< x8+x2+x+1
-    POLY_7BIT_SD     = 0x9,          ///< x7+x3+1
     POLY_16BIT_CCITT = 0x1021,       ///< x16+x12+x5+1
     POLY_16BIT_IBM   = 0x8005,       ///< x16+x15+x2+1
-    POLY_32BIT_ANSI  = 0x04C11DB7,   ///< x32+x26+x23+x22+x16+x12+x11+x10+x8+x7+x5+x4+x2+x+1
-    POLY_32BIT_REV_ANSI = 0xEDB88320 ///< x31+x30+x29+x27+x26+x24+x23+x21+x20+x19+x15+x9+x8+x5
+    POLY_32BIT_ANSI  = 0x04C11DB7    ///< x32+x26+x23+x22+x16+x12+x11+x10+x8+x7+x5+x4+x2+x+1
 } crc_polynomial_t;
 
 typedef struct crc_mbed_config {
-    /** CRC Polynomial. Example polynomial: 0x21 = 0010_0011 = x^5+x+1 */
+    /** CRC Polynomial. Example polynomial: x^8+x^5+x+1 -> width = 8, polynomial = 0010_0011 = 0x21 */
     uint32_t polynomial;
     /** CRC Bit Width */
     uint32_t width;
@@ -66,14 +64,12 @@ extern "C" {
  *
  * # Defined behaviour
  *
- * * Function hal_crc_is_supported() returns true if platform supports hardware
+ * * Macro HAL_CRC_IS_SUPPORTED() evaluates true if platform supports hardware
  *   CRC for the given polynomial/width - verified by test ::crc_is_supported_test.
- * * Function hal_crc_is_supported() returns false if platform does not support hardware
+ * * Macro HAL_CRC_IS_SUPPORTED() evaluates false if platform does not support hardware
  *   CRC for the given polynomial/width - verified by test ::crc_is_supported_test.
- * * Function hal_crc_is_supported() returns false if given pointer to configuration
- *   structure is undefined (NULL) - verified by test ::crc_is_supported_invalid_param_test.
- * * If CRC module does not support one of the following settings: initial_xor, final_xor
- *   reflect_in, reflect_out, then these operations should be handled by the driver
+ * * If CRC module does not support any of the following settings: initial_xor, final_xor
+ *   reflect_in, reflect_out, then these operations must be handled by the driver
  *   - Verified by test ::crc_calc_single_test.
  * * Platform which supports hardware CRC must be able to handle at least one of the predefined
  *   polynomial/width configurations that can be constructed in the MbedCRC class: POLY_8BIT_CCITT,
@@ -109,6 +105,24 @@ extern "C" {
  *
  * # Potential bugs
  *
+ * # Macros
+ *
+ * Platform support for particular CRC polynomials is indicated by the
+ * macro HAL_CRC_IS_SUPPORTED(polynomial, width), which must be defined
+ * in device.h, or a file included from there.
+ *
+ * The macro must evaluate to a constant boolean expression when given
+ * constant parameters.
+ *
+ * The current platform must support the given polynomial with all possible
+ * other config parameters if the macro evaluates to true. These are:
+ * reflect in, reflect out, initial xor and final xor. If any of these settings
+ * of these settings cannot be configured, the polynomial is not supported.
+ *
+ * Example:
+ *
+ *    #define HAL_CRC_IS_SUPPORTED(polynomial, width) \
+ *         ((width) == 16 || ((width) == 32 && (polynomial) == POLY_32BIT_ANSI)
  * @{
  */
 
@@ -122,33 +136,6 @@ extern "C" {
  *
  */
 
-/** Determine if the current platform supports hardware CRC for given polynomial
- *
- * The purpose of this function is to inform the CRC Platform API whether the
- * current platform has a hardware CRC module and that it can support the
- * requested polynomial.
- *
- * Supported polynomials are restricted to the named polynomials that can be
- * constructed in the MbedCRC class, POLY_8BIT_CCITT, POLY_7BIT_SD,
- * POLY_16BIT_CCITT, POLY_16BIT_IBM and POLY_32BIT_ANSI.
- *
- * The current platform must support the given polynomials default parameters
- * in order to return a true response. These include: reflect in, reflect out,
- * initial xor and final xor. For example, POLY_32BIT_ANSI requires an initial
- * and final xor of 0xFFFFFFFF, and reflection of both input and output. If any
- * of these settings cannot be configured, the polynomial is not supported.
- *
- * This function is thread safe; it safe to call from multiple contexts if
- * required.
- *
- * \param config Contains CRC configuration parameters for initializing the
- *               hardware CRC module. For example, polynomial and initial seed
- *               values.
- *
- * \return  True if running if the polynomial is supported, false if not.
- */
-bool hal_crc_is_supported(const crc_mbed_config_t *config);
-
 /** Initialize the hardware CRC module with the given polynomial
  *
  * After calling this function, the CRC HAL module is ready to receive data
@@ -163,7 +150,7 @@ bool hal_crc_is_supported(const crc_mbed_config_t *config);
  *
  * This function must be called with a valid polynomial supported by the
  * platform. The polynomial must be checked for support using the
- * hal_crc_is_supported() function.
+ * HAL_CRC_IS_SUPPORTED() macro.
  *
  * Calling hal_crc_compute_partial_start() multiple times without finalizing the
  * CRC calculation with hal_crc_get_result() overrides the current

targets/TARGET_Cypress/TARGET_PSOC6/cy_crc_api.c

@@ -19,6 +19,7 @@
 #include "mbed_assert.h"
 #include "mbed_error.h"
 #include "cyhal_crc.h"
+#include "objects.h"
 
 #if DEVICE_CRC
 
@@ -30,11 +31,6 @@ static cyhal_crc_t cy_crc;
 static crc_algorithm_t cy_crc_cfg;
 static bool cy_crc_initialized = false;
 
-bool hal_crc_is_supported(const crc_mbed_config_t *config)
-{
-    return config->width <= 32;
-}
-
 void hal_crc_compute_partial_start(const crc_mbed_config_t *config)
 {
     if (!cy_crc_initialized) {
@@ -43,7 +39,7 @@ void hal_crc_compute_partial_start(const crc_mbed_config_t *config)
         }
         cy_crc_initialized = true;
     }
-    if (!hal_crc_is_supported(config)) {
+    if (!HAL_CRC_IS_SUPPORTED(config->polynomial, config->width)) {
         MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_DRIVER, MBED_ERROR_CODE_UNSUPPORTED), "unsupported CRC width");
     }
     cy_crc_cfg.width = config->width;
@@ -77,12 +73,6 @@ uint32_t hal_crc_get_result(void)
     }
     cyhal_crc_free(&cy_crc);
     cy_crc_initialized = false;
-    // mbed expects result to be aligned unusually in this case
-    if (0 != (cy_crc_cfg.width % 8) && 0 == cy_crc_cfg.remReverse) {
-        value ^= cy_crc_cfg.remXor; // Undo result XOR
-        value <<= 8 - (cy_crc_cfg.width % 8);   // Left align to nearest byte
-        value ^= cy_crc_cfg.remXor; // Redo result XOR
-    }
     return value;
 }
 

targets/TARGET_Cypress/TARGET_PSOC6/objects.h

@@ -118,6 +118,10 @@ struct qspi_s {
 };
 #endif
 
+#if DEVICE_CRC
+#define HAL_CRC_IS_SUPPORTED(polynomial, width) ((width) <= 32)
+#endif
+
 #ifdef __cplusplus
 }
 #endif

targets/TARGET_Freescale/TARGET_MCUXpresso_MCUS/TARGET_MCU_K64F/mbed_crc_api.c

@@ -23,19 +23,6 @@
 static crc_bits_t width;
 static uint32_t final_xor;
 
-bool hal_crc_is_supported(const crc_mbed_config_t* config)
-{
-    if (config == NULL) {
-        return false;
-    }
-
-    if ((config->width != 32) && (config->width != 16)) {
-        return false;
-    }
-
-    return true;
-}
-
 void hal_crc_compute_partial_start(const crc_mbed_config_t* config)
 {
     if (config == NULL) {
@@ -50,12 +37,7 @@ void hal_crc_compute_partial_start(const crc_mbed_config_t* config)
     platform_config.seed = config->initial_xor;
     platform_config.reflectIn = config->reflect_in;
     platform_config.reflectOut = config->reflect_out;
-    if ((width == kCrcBits16 && config->final_xor == 0xFFFFU) ||
-        (width == kCrcBits32 && config->final_xor == 0xFFFFFFFFU)) {
-        platform_config.complementChecksum = true;
-    } else {
-        platform_config.complementChecksum = false;
-    }
+    platform_config.complementChecksum = false;
     platform_config.crcBits = width;
     platform_config.crcResult = kCrcFinalChecksum;
 
@@ -79,24 +61,15 @@ uint32_t hal_crc_get_result(void)
 {
     uint32_t result;
 
-    const bool manual_final_xor = ((final_xor != 0x00000000U) &&
-                                   ((final_xor != 0xFFFFFFFFU && width == kCrcBits32) ||
-                                    (final_xor != 0xFFFFU && width == kCrcBits16)));
-
     switch (width)
     {
         case kCrcBits16:
             result = CRC_Get16bitResult(CRC0);
-            if (manual_final_xor) {
-                result ^= final_xor;
-                result &= 0xFFFF;
-            }
+            result ^= final_xor;
             return result;
         case kCrcBits32:
             result = CRC_Get32bitResult(CRC0);
-            if (manual_final_xor) {
-                result ^= final_xor;
-            }
+             result ^= final_xor;
             return result;
         default:
             MBED_ASSERT("Unhandled switch case");

targets/TARGET_Freescale/TARGET_MCUXpresso_MCUS/api/objects.h

@@ -105,6 +105,10 @@ struct qspi_s {
 
 #include "us_ticker_defines.h"
 
+#if DEVICE_CRC
+#define HAL_CRC_IS_SUPPORTED(polynomial, width) ((width) == 16 || (width) == 32)
+#endif
+
 #ifdef __cplusplus
 }
 #endif

targets/TARGET_STM/TARGET_STM32F0/common_objects.h

@@ -36,6 +36,7 @@
 #include "PinNames.h"
 #include "stm32f0xx_ll_usart.h"
 #include "stm32f0xx_ll_tim.h"
+#include "stm32f0xx_ll_crc.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -119,6 +120,13 @@ struct analogin_s {
     uint8_t channel;
 };
 
+
+#ifdef CRC_PROG_POLYNOMIAL_SUPPORT
+#define HAL_CRC_IS_SUPPORTED(polynomial, width) ((width) == 7 || (width) == 8 || (width) == 16 || (width) == 32)
+#else
+#define HAL_CRC_IS_SUPPORTED(polynomial, width) ((width) == 32 && (polynomial) == 0x04C11DB7)
+#endif
+
 #include "gpio_object.h"
 
 #if DEVICE_ANALOGOUT

targets/TARGET_STM/TARGET_STM32F3/common_objects.h

@@ -141,6 +141,8 @@ struct flash_s {
 };
 #endif
 
+#define HAL_CRC_IS_SUPPORTED(polynomial, width) ((width) == 7 || (width) == 8 || (width) == 16 || (width) == 32)
+
 #include "gpio_object.h"
 
 #ifdef __cplusplus

targets/TARGET_STM/TARGET_STM32F7/common_objects.h

@@ -161,6 +161,8 @@ struct qspi_s {
 };
 #endif
 
+#define HAL_CRC_IS_SUPPORTED(polynomial, width) ((width) == 7 || (width) == 8 || (width) == 16 || (width) == 32)
+
 #ifdef __cplusplus
 }
 #endif