@mchp-mcc/clock-16bit-driver 1.0.1 → 1.1.0

package/package.json

@@ -1,8 +1,8 @@
 {
     "name": "@mchp-mcc/clock-16bit-driver",
-    "version": "1.0.1",
+    "version": "1.1.0",
     "scf": {
-        "reducer": "auto",
+        "reducer": "output/reducer.js",
         "creator": "output/creator.js",
         "processor": "output/processor.js",
         "nullPrototype": "output/nullPrototype.json",
@@ -10,13 +10,18 @@
             "main": "auto"
         },
         "displayName": "Clock",
-        "category": "System"
+        "category": "System",
+        "autoProcessor": "output/autoProcessor.js",
+        "autoCreator": "output/autoCreator.js"
     },
     "scf-automodule": {
-        "mode": "standard",
+        "mode": "react",
         "hookPaths": {
-            "processor": "generated_module/src/processor.tsx",
-            "creator": "generated_module/src/creator.tsx"
+            "processor": "generated_module/src/processor.ts",
+            "creator": "generated_module/src/creator.ts",
+            "reducer": "src/reducer.tsx",
+            "App": "src/App.tsx",
+            "view": "src/index.tsx"
         },
         "shouldNotifyOnDeploy": false
     },
@@ -38,7 +43,8 @@
         "update-auto-module": "yarn add @microchip/scf-automodule -D && yarn updateProject",
         "build-run-dir-future": "node config/extract-run-directory-future.js",
         "profile": "jest profile",
-        "release": "yarn build && yarn test && node -e 'require(\"./config/scf-project-scripts\").releaseProject()'"
+        "release": "yarn build && yarn test && node -e 'require(\"./config/scf-project-scripts\").releaseProject()'",
+        "postprocess": "node config/appendPrototype.js"
     },
     "husky": {
         "hooks": {
@@ -66,21 +72,24 @@
             "<rootDir>/run"
         ],
         "preset": "ts-jest",
-        "collectCoverage": true
+        "collectCoverage": true,
+        "moduleNameMapper": {
+            "\\.(css|less|scss|sss|styl)$": "<rootDir>/node_modules/jest-css-modules"
+        }
     },
     "dependencies": {
         "@mchp-mcc/pic-8bit-types": "^5.4.1",
         "@microchip/api-prefix-registration": "^0.1.0",
         "@microchip/canfd-clock-interface": "^1.0.0",
-        "@microchip/clock-16bit-config-interface": "^1.0.0",
+        "@microchip/clock-16bit-config-interface": "^1.1.2",
+        "@microchip/clock-16bit-interface": "^1.1.0",
         "@microchip/fosc-hz": "^0.1.2",
-        "@microchip/pin-standard": "^0.2.14",
-        "@microchip/scf-automodule-interface": "^0.17.0",
-        "@microchip/scf-common": "^3.13.4",
-        "@microchip/scf-device": "^8.2.0",
+        "@microchip/pin-standard": "^0.4.1",
+        "@microchip/scf-common": "^3.17.0",
+        "@microchip/scf-device": "^8.5.0",
         "@microchip/scf-integration-test": "^1.0.0",
         "@microchip/scf-interface": "^1.4.0",
-        "@microchip/scf-register-view-helper": "^2.4.0"
+        "@microchip/scf-register-view-helper": "^2.5.0"
     },
     "devDependencies": {
         "@babel/core": "^7.9.6",
@@ -89,11 +98,13 @@
         "@babel/preset-react": "^7.9.4",
         "@babel/preset-typescript": "^7.9.0",
         "@microchip/initializer-system": "^0.5.3",
+        "@microchip/melody-automodule-interface": "^1.6.2",
         "@microchip/pic-8bit-types": "^5.0.1",
-        "@microchip/run-directory": "^2.4.1",
-        "@microchip/run-directory-future": "^1.0.5",
-        "@microchip/scf-automodule": "^4.14.6",
-        "@microchip/scf-autoview": "^3.17.0",
+        "@microchip/run-directory": "^4.2.0",
+        "@microchip/scf-automodule": "^5.6.3",
+        "@microchip/scf-automodule-impl": "^1.8.2",
+        "@microchip/scf-autoview": "^3.26.1",
+        "@microchip/scf-autoview-impl": "^3.9.2",
         "@microchip/scf-project-scripts": "^1.0.0",
         "@types/core-js": "^2.5.1",
         "@types/enzyme": "^3.9.3",
@@ -106,10 +117,14 @@
         "@types/semver": "^7.1.0",
         "@typescript-eslint/eslint-plugin": "^3.2.0",
         "@typescript-eslint/parser": "^3.6.0",
+        "autoprefixer": "^9.7.6",
         "babel-eslint": "^10.1.0",
         "babel-loader": "^8.0.6",
         "babel-plugin-named-asset-import": "^0.3.2",
         "babel-preset-react-app": "^9.0.0",
+        "classnames": "^2.2.6",
+        "core-js": "^3.6.5",
+        "css-loader": "^3.5.2",
         "del": "^4.1.1",
         "eslint": "^7.4.0",
         "eslint-config-prettier": "^6.11.0",
@@ -117,6 +132,7 @@
         "eslint-loader": "^4.0.2",
         "eslint-plugin-prettier": "^3.1.3",
         "eslint-plugin-react": "^7.20.0",
+        "file-loader": "^6.0.0",
         "fork-ts-checker-webpack-plugin": "^1.3.7",
         "fs": "^0.0.1-security",
         "gulp": "^4.0.2",
@@ -125,17 +141,31 @@
         "gulp-if": "^3.0.0",
         "gulp-typescript": "^5.0.1",
         "hard-source-webpack-plugin": "^0.13.1",
+        "html-webpack-plugin": "^4.2.0",
         "husky": "^4.2.4",
         "is-wsl": "^2.1.0",
         "jest": "^24.8.0",
+        "jest-css-modules": "^2.1.0",
         "jest-html-reporter": "^2.5.0",
         "jest-pnp-resolver": "^1.2.1",
         "lint-staged": "^10.1.3",
+        "mini-css-extract-plugin": "^0.9.0",
+        "node-sass": "^4.13.1",
+        "optimize-css-assets-webpack-plugin": "^5.0.3",
         "pnp-webpack-plugin": "^1.5.0",
+        "postcss-loader": "^3.0.0",
+        "postcss-safe-parser": "^4.0.2",
         "prettier": "^2.0.5",
+        "react": "^17.0.1",
+        "react-dom": "^17.0.1",
+        "react-redux": "^7.2.0",
+        "sass": "~1.32.0",
+        "sass-loader": "^9.0.2",
+        "style-loader": "^1.2.1",
         "ts-jest": "^24.0.2",
         "ts-pnp": "^1.1.2",
         "typescript": "^4.0.5",
+        "url-loader": "^4.1.0",
         "webpack": "^4.34.0",
         "webpack-cli": "^3.3.4",
         "webpack-merge": "^4.2.2",

package/src/App.tsx

@@ -0,0 +1,54 @@
+/*
+ *  @license:
+ *  © 2019 Microchip Technology Inc. and its subsidiaries.
+ *
+ *  You may use this software and any derivatives exclusively with Microchip products.
+ *
+ *  THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS".  NO WARRANTIES, WHETHER EXPRESS,
+ *  IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE, INCLUDING ANY IMPLIED WARRANTIES OF
+ *  NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE, OR ITS
+ *  INTERACTION WITH MICROCHIP PRODUCTS, COMBINATION WITH ANY OTHER PRODUCTS, OR USE
+ *  IN ANY APPLICATION.
+ *
+ *  IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE, INCIDENTAL
+ *  OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND WHATSOEVER RELATED TO
+ *  THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS BEEN ADVISED OF THE POSSIBILITY
+ *  OR THE DAMAGES ARE FORESEEABLE.  TO THE FULLEST EXTENT ALLOWED BY LAW, MICROCHIP'S
+ *  TOTAL LIABILITY ON ALL CLAIMS IN ANY WAY RELATED TO THIS SOFTWARE WILL NOT EXCEED
+ *  THE AMOUNT OF FEES, IF ANY, THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
+ *
+ *  MICROCHIP PROVIDES THIS SOFTWARE CONDITIONALLY UPON YOUR ACCEPTANCE OF THESE TERMS.
+ */
+
+import React, { Component } from "react";
+import { connect } from "react-redux";
+import { Dispatch } from "redux";
+import { AutoView } from "@microchip/scf-autoview-impl/src/lib/views/src/autoview";
+import { AutoViewModule } from "@microchip/scf-autoview/lib/autoview-types";
+
+export type State = AutoViewModule;
+
+interface Props {
+    state: State;
+    dispatch: Dispatch;
+}
+
+class App extends Component<Props> {
+    constructor(props: Props, context: any) {
+        super(props, context);
+    }
+
+    render(): any {
+        return (
+            <div>
+                <AutoView state={this.props.state} dispatch={this.props.dispatch} />
+            </div>
+        );
+    }
+}
+
+function mapStateToProps(state: State, ownProps?: any): any {
+    return { state: state };
+}
+
+export default connect(mapStateToProps)(App);

package/src/CreatorFunctions.ts

@@ -1,4 +1,4 @@
-import { CreatorFunctions } from "@microchip/scf-automodule-interface";
+import { CreatorFunctions } from "@microchip/melody-automodule-interface";
 import { MyState } from "../generated_module/src/types/AutoModuleTypes";
 
 export const getCreatorFunctions = (): CreatorFunctions => {

package/src/{DerivedData.tsx → DerivedData.ts}

@@ -6,23 +6,31 @@ import {
     DerivedData,
     DerivedFunctions,
 } from "../generated_module/src/types/AutoModuleTypes";
-import { forEach } from "../generated_module/src/Utils";
+import { forEach, getKeys } from "../generated_module/src/Utils";
 import { getCanClkDivFreq, getCanfdClockFrequency, MAX_CANFD_CLK_SRC_FREQ } from "./Util";
-
+import * as clock_16bit_drv_interface from "@microchip/clock-16bit-config-interface";
+import { ExportArg } from "@microchip/melody-automodule-interface/lib/src/InterfaceTypes";
+import _find from "lodash.find";
+import { InterfaceId } from "@microchip/scf-common";
+
+export const ARGUMENT_MAIN_CLK = "mainClockArg";
+const ARGUMENT_AUX_CLK = "auxClockArg";
+const ARGUMENT_REF_CLK = "refClockArg";
 const CLOCK_16BIT_CONFIG_INTERFACE = "clock_16bit_config_interface";
 const DIGITS_AFTER_DECIMAL_POINT = 2;
 const COMPONENT_AUX_CLOCK_SOURCE = "auxClockSource";
 const COMPONENT_MAIN_CLOCK_SOURCE = "mainClockSource";
-const COMPONENT_AUX_CLOCK_INPUT_FREQUENCY = "auxClockInputFrequency_Hz";
-const COMPONENT_MAIN_CLOCK_INPUT_FREQUENCY = "mainClockInputFrequency_Hz";
+export const COMPONENT_AUX_CLOCK_INPUT_FREQUENCY = "auxClockInputFrequency_Hz";
+export const COMPONENT_MAIN_CLOCK_INPUT_FREQUENCY = "mainClockInputFrequency_Hz";
 const COMPONENT_REF_CLOCK_SOURCE = "refClockSource";
 const COMPONENT_CANFD_CLOCK_SOURCE = "canfdClockSource";
-const COMPONENT_REQUESTED_SYSTEM_FREQUENCY = "requestedSystemFrequency_Hz";
+export const COMPONENT_REQUESTED_SYSTEM_FREQUENCY = "requestedSystemFrequency_Hz";
 const COMPONENT_FVCO_DIVIDER = "fvcoDivider";
-const COMPONENT_REQUESTED_AUX_CLOCK_OUTPUT_FREQUENCY =
+export const COMPONENT_SET_MAX_FREQUENCY = "setMaximumSystemFrequency";
+export const COMPONENT_REQUESTED_AUX_CLOCK_OUTPUT_FREQUENCY =
     "requestedAuxClockOutputFrequency_Hz";
 const COMPONENT_AFVCO_DIVIDER = "afvcoDivider";
-const COMPONENT_REQUESTED_REF_CLOCK_OUTPUT_FREQUENCY =
+export const COMPONENT_REQUESTED_REF_CLOCK_OUTPUT_FREQUENCY =
     "requestedRefClockOutputFrequency_Hz";
 const COMPONENT_REQUESTED_CANFD_CLOCK_OUTPUT_FREQUENCY =
     "requestedCanfdClockOutputFrequency_Hz";
@@ -31,6 +39,7 @@ const PRIMARY = "Primary";
 const PLL = "PLL";
 const POSTSCALER = "Postscaler";
 const EXTERNAL = "External";
+const CLOCK_16BIT_DRV_INTERFACE = "clock-16bit-drv-interface";
 
 const MEGA_HERTZ = 1000000;
 const KILO_HERTZ = 1000;
@@ -102,6 +111,10 @@ class MyDerivedData implements DerivedData {
             requestedRefClockOutputFrequency_HzValidator: this
                 .requestedRefClockOutputFrequency_HzValidator,
             getCustomUiErrors: this.getCustomUiErrors,
+            "clock-16bit-drv-interface_payloads": this
+                .getClockApplicationInterfacePayload,
+            importName: this.friendlyImportName,
+            exportName: this.friendlyExportName,
         };
     };
 
@@ -152,7 +165,8 @@ class MyDerivedData implements DerivedData {
 
     private mainClockInputFrequency_HzValidator = (): any => {
         return {
-            minimum: 1,
+            minimum: this.getMinClockFrequency(),
+            maximum: this.getMaxClockFrequency(),
         };
     };
 
@@ -171,6 +185,7 @@ class MyDerivedData implements DerivedData {
     private requestedSystemFrequency_HzValidator = (): any => {
         return {
             minimum: 1,
+            maximum: this.getMaxSystemClockFrequency(),
         };
     };
 
@@ -180,6 +195,42 @@ class MyDerivedData implements DerivedData {
         };
     };
 
+    private getMinClockFrequency = (): number => {
+        let minClockFrequency = 0;
+        const interfaceData: clock_16bit_config_interface.ProcessedPayload = this.dataModel.getImportValue(
+            CLOCK_16BIT_CONFIG_INTERFACE,
+        );
+        if (interfaceData != undefined) {
+            minClockFrequency =
+                interfaceData?.mainClockPayload?.mainClockInputMinFrequency ?? 0;
+        }
+        return minClockFrequency;
+    };
+
+    private getMaxClockFrequency = (): number => {
+        let maxClockFrequency = 0;
+        const interfaceData: clock_16bit_config_interface.ProcessedPayload = this.dataModel.getImportValue(
+            CLOCK_16BIT_CONFIG_INTERFACE,
+        );
+        if (interfaceData != undefined) {
+            maxClockFrequency =
+                interfaceData?.mainClockPayload?.mainClockInputMaxFrequency ?? 0;
+        }
+        return maxClockFrequency;
+    };
+
+    private getMaxSystemClockFrequency = (): number => {
+        let maxSystemClockFrequency = 0;
+        const interfaceData: clock_16bit_config_interface.ProcessedPayload = this.dataModel.getImportValue(
+            CLOCK_16BIT_CONFIG_INTERFACE,
+        );
+        if (interfaceData != undefined) {
+            maxSystemClockFrequency =
+                interfaceData?.mainClockPayload?.maxSystemClockFrequency ?? 0;
+        }
+        return maxSystemClockFrequency;
+    };
+
     private getUiBehavior = (component: string): any => {
         let uiBehavior = {};
         switch (component) {
@@ -245,15 +296,17 @@ class MyDerivedData implements DerivedData {
 
     private isMainClockInputFrequencyVisible = (): boolean => {
         let visible = false;
-        const mainClockSource = this.dataModel.getComponentValue(
-            COMPONENT_MAIN_CLOCK_SOURCE,
-        );
-        if (mainClockSource != undefined) {
-            if (
-                mainClockSource?.indexOf(PRIMARY) >= 0 ||
-                mainClockSource?.indexOf(EXTERNAL) >= 0
-            ) {
-                visible = true;
+        if (!this.dataModel.getComponentValue(COMPONENT_SET_MAX_FREQUENCY)) {
+            const mainClockSource = this.dataModel.getComponentValue(
+                COMPONENT_MAIN_CLOCK_SOURCE,
+            );
+            if (mainClockSource != undefined) {
+                if (
+                    mainClockSource?.indexOf(PRIMARY) >= 0 ||
+                    mainClockSource?.indexOf(EXTERNAL) >= 0
+                ) {
+                    visible = true;
+                }
             }
         }
         return visible;
@@ -261,15 +314,17 @@ class MyDerivedData implements DerivedData {
 
     private isRequestedSystemFrequencyVisible = (): boolean => {
         let visible = false;
-        const mainClockSource = this.dataModel.getComponentValue(
-            COMPONENT_MAIN_CLOCK_SOURCE,
-        );
-        if (mainClockSource != undefined) {
-            if (
-                mainClockSource?.indexOf(PLL) >= 0 ||
-                mainClockSource.indexOf(POSTSCALER) >= 0
-            ) {
-                visible = true;
+        if (!this.dataModel.getComponentValue(COMPONENT_SET_MAX_FREQUENCY)) {
+            const mainClockSource = this.dataModel.getComponentValue(
+                COMPONENT_MAIN_CLOCK_SOURCE,
+            );
+            if (mainClockSource != undefined) {
+                if (
+                    mainClockSource?.indexOf(PLL) >= 0 ||
+                    mainClockSource.indexOf(POSTSCALER) >= 0
+                ) {
+                    visible = true;
+                }
             }
         }
         return visible;
@@ -345,6 +400,10 @@ class MyDerivedData implements DerivedData {
             componentName === "canfdClkSrcFreq"
         ) {
             return this.isCanfdClockSupported();
+        } else if (componentName === COMPONENT_MAIN_CLOCK_SOURCE) {
+            if (this.dataModel.getComponentValue(COMPONENT_SET_MAX_FREQUENCY)) {
+                return false;
+            }
         }
         return true;
     };
@@ -421,6 +480,16 @@ class MyDerivedData implements DerivedData {
         return;
     };
 
+    private getActualMainClockSource = (): string | undefined => {
+        const interfaceData: clock_16bit_config_interface.ProcessedPayload = this.dataModel.getImportValue(
+            CLOCK_16BIT_CONFIG_INTERFACE,
+        );
+        if (interfaceData != undefined) {
+            return interfaceData.mainClockPayload?.mainClockSource;
+        }
+        return undefined;
+    };
+
     private getActualSystemFrequency = (): string => {
         let systemFrequency: number | undefined;
         const interfaceData: clock_16bit_config_interface.ProcessedPayload = this.dataModel.getImportValue(
@@ -791,11 +860,39 @@ class MyDerivedData implements DerivedData {
     };
 
     private overrideDefaultValues = (componentName: string): any => {
-        if (componentName == "canfdClockSource") {
-            const canClock = this.getDefaultCanClock();
-            if (canClock) {
-                return canClock;
-            }
+        switch (componentName) {
+            case "canfdClockSource":
+                {
+                    const canClock = this.getDefaultCanClock();
+                    if (canClock) {
+                        return canClock;
+                    }
+                }
+                break;
+            case COMPONENT_MAIN_CLOCK_SOURCE:
+                return this.getMainClockSource();
+            case COMPONENT_MAIN_CLOCK_INPUT_FREQUENCY:
+                return this.getMainClockInputFrequencyInHz();
+            case COMPONENT_REQUESTED_SYSTEM_FREQUENCY:
+                return this.getRequestedSystemFrequencyInHz();
+            case COMPONENT_FVCO_DIVIDER:
+                return this.getFvcoDivider();
+            case COMPONENT_AUX_CLOCK_SOURCE:
+                return this.getAuxClockSource();
+            case COMPONENT_AUX_CLOCK_INPUT_FREQUENCY:
+                return this.getAuxClockInputFrequencyInHz();
+            case COMPONENT_REQUESTED_AUX_CLOCK_OUTPUT_FREQUENCY:
+                return this.getRequestedAuxClockOutputFrequencyInHz();
+            case COMPONENT_AFVCO_DIVIDER:
+                return this.getAfvcoDivider();
+            case COMPONENT_REF_CLOCK_SOURCE:
+                return this.getRefClockSource();
+            case COMPONENT_REQUESTED_REF_CLOCK_OUTPUT_FREQUENCY:
+                return this.getRequestedRefClockOutputFrequencyInHz();
+            case COMPONENT_SET_MAX_FREQUENCY:
+                return this.getMaxFrequencySetFlag();
+            default:
+                break;
         }
     };
 
@@ -836,6 +933,9 @@ class MyDerivedData implements DerivedData {
                 COMPONENT_REQUESTED_SYSTEM_FREQUENCY,
             ),
             fvcoDivider: Number(this.dataModel.getComponentValue(COMPONENT_FVCO_DIVIDER)),
+            setMaximumSystemFrequency: this.dataModel.getComponentValue(
+                COMPONENT_SET_MAX_FREQUENCY,
+            ),
         };
     };
 
@@ -886,6 +986,180 @@ class MyDerivedData implements DerivedData {
 
         return getCanClkDivFreq(canClkSrc, canClkFreq);
     };
+
+    public getExportArgFromDriverInterface = (
+        componentName: string,
+    ): ExportArg | undefined => {
+        const exportData = this.dataModel.getExportInterfaces().getInterfaceData();
+        if (exportData != undefined) {
+            const expArg = _find(
+                exportData,
+                (i) =>
+                    i.interface === CLOCK_16BIT_DRV_INTERFACE && i.name === componentName,
+            );
+            return expArg;
+        }
+    };
+
+    private getMainClockSource = (): any => {
+        const mainClockArg = this.getExportArgFromDriverInterface(ARGUMENT_MAIN_CLK)
+            ?.value;
+        if (mainClockArg != undefined) {
+            return mainClockArg?.mainClockSource;
+        }
+    };
+
+    private getMaxFrequencySetFlag = (): any => {
+        const mainClockArg = this.getExportArgFromDriverInterface(ARGUMENT_MAIN_CLK)
+            ?.value;
+        if (mainClockArg != undefined) {
+            return Boolean(mainClockArg?.setMaximumSystemFrequency);
+        }
+    };
+
+    private getMainClockInputFrequencyInHz = (): any => {
+        const mainClockArg = this.getExportArgFromDriverInterface(ARGUMENT_MAIN_CLK)
+            ?.value;
+        if (mainClockArg != undefined) {
+            return mainClockArg?.mainClockInputFrequency_Hz;
+        }
+    };
+
+    private getRequestedSystemFrequencyInHz = (): any => {
+        const mainClockArg = this.getExportArgFromDriverInterface(ARGUMENT_MAIN_CLK)
+            ?.value;
+        if (mainClockArg != undefined) {
+            return mainClockArg?.requestedSystemFrequency_Hz;
+        }
+    };
+
+    private getFvcoDivider = (): any => {
+        const mainClockArg = this.getExportArgFromDriverInterface(ARGUMENT_MAIN_CLK)
+            ?.value;
+        if (mainClockArg != undefined) {
+            return String(mainClockArg.fvcoDivider);
+        }
+    };
+
+    private getAuxClockSource = (): any => {
+        const auxClockArg = this.getExportArgFromDriverInterface(ARGUMENT_AUX_CLK)?.value;
+        if (auxClockArg != undefined) {
+            return auxClockArg.auxClockSource;
+        }
+    };
+
+    private getAuxClockInputFrequencyInHz = (): any => {
+        const auxClockArg = this.getExportArgFromDriverInterface(ARGUMENT_AUX_CLK)?.value;
+        if (auxClockArg != undefined) {
+            return auxClockArg.auxClockInputFrequency_Hz;
+        }
+    };
+
+    private getRequestedAuxClockOutputFrequencyInHz = (): any => {
+        const auxClockArg = this.getExportArgFromDriverInterface(ARGUMENT_AUX_CLK)?.value;
+        if (auxClockArg != undefined) {
+            return auxClockArg.requestedAuxClockOutputFrequency_Hz;
+        }
+    };
+
+    private getAfvcoDivider = (): any => {
+        const auxClockArg = this.getExportArgFromDriverInterface(ARGUMENT_AUX_CLK)?.value;
+        if (auxClockArg != undefined) {
+            return auxClockArg.afvcoDivider;
+        }
+    };
+
+    private getRefClockSource = (): any => {
+        const refClockArg = this.getExportArgFromDriverInterface(ARGUMENT_REF_CLK)?.value;
+        if (refClockArg != undefined) {
+            return refClockArg.refClockSource;
+        }
+    };
+
+    private getRequestedRefClockOutputFrequencyInHz = (): any => {
+        const refClockArg = this.getExportArgFromDriverInterface(ARGUMENT_REF_CLK)?.value;
+        if (refClockArg != undefined) {
+            return refClockArg.requestedRefClockOutputFrequency_Hz;
+        }
+    };
+
+    private getCanfdClockSource = (): any => {
+        const refClockArg = this.getExportArgFromDriverInterface("canfdClockArg")?.value;
+        if (refClockArg != undefined) {
+            return refClockArg.canfdClockSource;
+        }
+    };
+
+    private getClock16bitDrvInterfaceId = (): InterfaceId => {
+        return {
+            name: CLOCK_16BIT_DRV_INTERFACE,
+            version: "1.0.0",
+        };
+    };
+
+    private getClockApplicationInterfacePayload = ():
+        | Processor.Dictionary<clock_16bit_config_interface.ProcessedPayload>
+        | undefined => {
+        const clockApplicationInterfacePayloads: Processor.Dictionary<clock_16bit_drv_interface.ProcessedPayload> = {};
+        const clockApplicationInterfaceRequests:
+            | Processor.Dictionary<clock_16bit_drv_interface.Arguments>
+            | undefined = this.dataModel
+            .getExportInterfaces()
+            .getInterface("clock_16bit_drv_interface", this.getClock16bitDrvInterfaceId())
+            ?.args;
+        const interfaceData: clock_16bit_config_interface.ProcessedPayload = this.dataModel.getImportValue(
+            CLOCK_16BIT_CONFIG_INTERFACE,
+        );
+        if (
+            clockApplicationInterfaceRequests != undefined &&
+            interfaceData != undefined
+        ) {
+            getKeys(clockApplicationInterfaceRequests)?.forEach((module) => {
+                clockApplicationInterfacePayloads[module] = {
+                    ...clockApplicationInterfacePayloads[module],
+                    mainClockPayload: interfaceData.mainClockPayload,
+                    hasUSB: interfaceData.hasUSB,
+                    hasAuxClock: interfaceData.hasAuxClock,
+                    hasRefClock: interfaceData.hasRefClock,
+                    hasCanfdClock: interfaceData.hasCanfdClock,
+                    hasSecondaryOscillator: interfaceData.hasSecondaryOscillator,
+                    isSecondaryOscillatorEnabled:
+                        interfaceData.isSecondaryOscillatorEnabled,
+                    auxClockPayload: interfaceData.auxClockPayload,
+                    refClockPayload: interfaceData.refClockPayload,
+                    canfdClockPayload: interfaceData.canfdClockPayload,
+                };
+            });
+        }
+        return clockApplicationInterfacePayloads;
+    };
+    private friendlyExportName = (exportKey: string): string => {
+        let exportName: string;
+        switch (exportKey) {
+            case "canfd_clock":
+                exportName = "CAN FD Clock";
+                break;
+            case "clock_16bit_drv_interface":
+                exportName = "Clock Drv Config";
+                break;
+            default:
+                exportName = exportKey;
+                break;
+        }
+        return exportName;
+    };
+    private friendlyImportName = (importKey: string): string => {
+        let importName: string;
+        switch (importKey) {
+            case "clock_16bit_config_interface":
+                importName = "Clock Configuration";
+                break;
+            default:
+                importName = importKey;
+                break;
+        }
+        return importName;
+    };
 }
 
 export const getSelectedCanfdFreq = (freqList: number[]): number => {

package/src/actions.ts

@@ -0,0 +1,22 @@
+import { Action } from "@microchip/scf-common";
+
+export const ClockActions = {
+    FORCE_UPDATE: "FORCE_UPDATE",
+};
+
+export type ClockAction = Action<string, ClockActionPayload>;
+
+export type ClockActionPayload = {
+    key: string;
+    value: string;
+};
+
+export const updateClockState = (key: string, value: string): ClockAction => {
+    return {
+        type: ClockActions.FORCE_UPDATE,
+        payload: {
+            key,
+            value,
+        },
+    };
+};