Initial commit. DEV.FAULT_MGMT.01.00.01.02
authorRaj Sivarajan <rsivarajan@ti.com>
Mon, 29 Jun 2015 22:36:43 +0000 (18:36 -0400)
committerRaj Sivarajan <rsivarajan@ti.com>
Mon, 29 Jun 2015 22:36:43 +0000 (18:36 -0400)
95 files changed:
Settings.xdc.xdt [new file with mode: 0644]
build/buildlib.xs [new file with mode: 0644]
config.bld [new file with mode: 0644]
device/Module.xs [new file with mode: 0644]
device/k2e/src/fm_device.c [new file with mode: 0644]
device/k2h/src/fm_device.c [new file with mode: 0644]
device/k2k/src/fm_device.c [new file with mode: 0644]
device/k2l/src/fm_device.c [new file with mode: 0644]
device/tci6614/src/fm_device.c [new file with mode: 0644]
docs/Module.xs [new file with mode: 0644]
docs/ReleaseNotes_fault_mgmt.doc [new file with mode: 0644]
docs/ReleaseNotes_fault_mgmt.pdf [new file with mode: 0644]
docs/doxyfile.xdt [new file with mode: 0644]
docs/tifooter.htm [new file with mode: 0644]
docs/tiheader.htm [new file with mode: 0644]
docs/tilogo.gif [new file with mode: 0644]
docs/titagline.gif [new file with mode: 0644]
fault_mgmt.h [new file with mode: 0644]
fault_mgmt_osal.h [new file with mode: 0644]
fault_mgmtlibver.h.xdt [new file with mode: 0644]
include/Module.xs [new file with mode: 0644]
include/fm_cleanloc.h [new file with mode: 0644]
include/fm_exclusionloc.h [new file with mode: 0644]
include/fm_loc.h [new file with mode: 0644]
package.bld [new file with mode: 0644]
package.xdc [new file with mode: 0644]
package.xs [new file with mode: 0644]
src/Module.xs [new file with mode: 0644]
src/fault_mgmt.c [new file with mode: 0644]
src/fm_clean.c [new file with mode: 0644]
src/fm_exclusion.c [new file with mode: 0644]
test/Module.xs [new file with mode: 0644]
test/README.txt [new file with mode: 0644]
test/k2e/c66/bios/fmCoredump_K2ETestInstrumentationProject.txt [new file with mode: 0644]
test/k2e/c66/bios/fm_coredump_test.cfg [new file with mode: 0644]
test/k2h/c66/bios/fmCoredump_K2HTestInstrumentationProject.txt [new file with mode: 0644]
test/k2h/c66/bios/fm_coredump_test.cfg [new file with mode: 0644]
test/k2k/c66/bios/fmCoredump_K2KTestInstrumentationProject.txt [new file with mode: 0644]
test/k2k/c66/bios/fm_coredump_test.cfg [new file with mode: 0644]
test/k2l/c66/bios/fmCoredump_K2LTestInstrumentationProject.txt [new file with mode: 0644]
test/k2l/c66/bios/fm_coredump_test.cfg [new file with mode: 0644]
test/src/k2/fm_coredump_osal.c [new file with mode: 0644]
test/src/k2/fm_coredump_test.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/fm_cleanup_test.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/fm_cleanup_test.cfg [new file with mode: 0644]
test/src/tci6614/cleanup_test/fm_cleanup_test_osal.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/navigator_src/mnav_descriptors.h [new file with mode: 0644]
test/src/tci6614/cleanup_test/navigator_src/nav_test.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/navigator_src/nav_test.h [new file with mode: 0644]
test/src/tci6614/cleanup_test/netcp_src/classify1_bin.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/netcp_src/classify2_bin.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/netcp_src/config.h [new file with mode: 0644]
test/src/tci6614/cleanup_test/netcp_src/cpsw_mgmt.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/netcp_src/ex1util.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/netcp_src/expa.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/netcp_src/memory.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/netcp_src/memory.h [new file with mode: 0644]
test/src/tci6614/cleanup_test/netcp_src/pa1.h [new file with mode: 0644]
test/src/tci6614/cleanup_test/netcp_src/paExample.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/netcp_src/paExample.h [new file with mode: 0644]
test/src/tci6614/cleanup_test/netcp_src/pam_bin.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/netcp_src/pkttxrx.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/netcp_src/setupqm.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/tcp3d_src/tcp3dDrv.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/tcp3d_src/tcp3dDrv.h [new file with mode: 0644]
test/src/tci6614/cleanup_test/tcp3d_src/tcp3d_Demo.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/tcp3d_src/tcp3d_Demo.h [new file with mode: 0644]
test/src/tci6614/cleanup_test/tcp3d_src/tcp3d_betaState.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/tcp3d_src/tcp3d_itg.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/tcp3d_src/tcp3d_utils.h [new file with mode: 0644]
test/src/tci6614/cleanup_test/tcp3d_src/testvector_hd.h [new file with mode: 0644]
test/src/tci6614/cleanup_test/tcp3d_src/testvector_tc.h [new file with mode: 0644]
test/src/tci6614/cleanup_test/vcp2_src/vcp2_defs.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/vcp2_src/vcp2_edma.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/vcp2_src/vcp2_edma3.h [new file with mode: 0644]
test/src/tci6614/cleanup_test/vcp2_src/vcp2_interrupt.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/vcp2_src/vcp2_parameters.h [new file with mode: 0644]
test/src/tci6614/cleanup_test/vcp2_src/vcp2_test.c [new file with mode: 0644]
test/src/tci6614/cleanup_test/vcp2_src/vcp2_test.h [new file with mode: 0644]
test/src/tci6614/cleanup_test/vcp2_src/vcp2_testInit.h [new file with mode: 0644]
test/src/tci6614/fm_coredump_test.c [new file with mode: 0644]
test/tci6614/c66/bios/fmCleanup_C6614TestInstrumentationProject.txt [new file with mode: 0644]
test/tci6614/c66/bios/fmCoredump_C6614TestInstrumentationProject.txt [new file with mode: 0644]
test/tci6614/c66/bios/fm_coredump_osal.c [new file with mode: 0644]
test/tci6614/c66/bios/fm_coredump_test.cfg [new file with mode: 0644]
util/Module.xs [new file with mode: 0644]
util/tci6614/.ccsproject [new file with mode: 0644]
util/tci6614/.cproject [new file with mode: 0644]
util/tci6614/.project [new file with mode: 0644]
util/tci6614/fm_cleanup.cfg [new file with mode: 0644]
util/tci6614/fm_cleanup.cmd [new file with mode: 0644]
util/tci6614/macros.ini [new file with mode: 0644]
util/tci6614/src/fm_cleanup.c [new file with mode: 0644]
util/tci6614/src/fm_cleanup_osal.c [new file with mode: 0644]
util/tci6614/tci6614_secureMemMap.bld [new file with mode: 0644]

diff --git a/Settings.xdc.xdt b/Settings.xdc.xdt
new file mode 100644 (file)
index 0000000..87370b0
--- /dev/null
@@ -0,0 +1,38 @@
+
+%%{
+/*!
+ *  This template implements the Settings.xdc
+ */  
+  /* Versioning */
+  var ver = this;
+  for each(i=0;i<ver.length;i++)
+  {
+      if(String(ver[i]).length < 2)
+      {
+        ver[i]="0"+ver[i];
+      }
+  }
+  
+  var packageVersion = "\""+ver[0]+"."+ver[1]+"."+ver[2]+"."+ver[3]+"\"";
+
+%%}
+
+module Settings
+{
+    /*! This is the Fault Management Version */
+    config string fault_mgmtlibVersionString = `packageVersion`;
+    
+    /*! This variable is to control the device type selection.
+     * By default this variable is set to NULL.
+     * 
+     * To use FM for the selected device, add the following lines to config
+     * file and set the deviceType correctly:
+     * 
+     *      var fault_mgmt = xdc.useModule ('ti.instrumentation.fault_mgmt.Settings');
+     *      fault_mgmt.deviceType = "tci6614";
+     *      OR
+     *      fault_mgmt.deviceType = "k2k"; OR "k2h"; OR "k2l"; OR "k2e";
+     */     
+    metaonly config string deviceType = "";
+}
+
diff --git a/build/buildlib.xs b/build/buildlib.xs
new file mode 100644 (file)
index 0000000..195ba15
--- /dev/null
@@ -0,0 +1,527 @@
+/******************************************************************************
+ * FILE PURPOSE: Build Library Utilities
+ ******************************************************************************
+ * FILE NAME: buildlib.xs
+ *
+ * DESCRIPTION: 
+ *  This file contains common routines that are used by the Fault Management 
+ *  component.
+ *
+ * Copyright (C) 2012-2014, Texas Instruments, Inc.
+ *****************************************************************************/
+
+/**************************************************************************
+ * FUNCTION NAME : listAllFiles
+ **************************************************************************
+ * DESCRIPTION   :
+ *  Utility function which lists all files with a specific extension 
+ *  present in a directory and any directory inside it.
+ **************************************************************************/
+function listAllFiles(ext, dir, recurse)
+{     
+    var srcFile = [];
+    var d;
+
+    /* If recurse parameter is not specified we default to recursive search. */
+    if (recurse == null)
+        recurse = true;
+
+    if (dir == undefined) 
+          d = ".";
+    else 
+      d = dir;
+
+    /* Get access to the current directory. */
+    var file = new java.io.File(d);
+
+    /* Check if the file exists and it is a directory. */
+    if (file.exists() && file.isDirectory()) 
+    {
+        /* Get a list of all files in the specific directory. */
+        var fileList = file.listFiles();
+        for (var i = 0; i < fileList.length; i++) 
+        {
+            /* Dont add the generated directory 'package' and any of its files 
+             * to the list here. */
+            if (fileList[i].getName().matches("package") == false)
+            {
+                /* Check if the detected file is a directory */
+                if (fileList[i].isDirectory())
+                {
+                    /* We will recurse into the subdirectory only if required to do so. */
+                    if (recurse == true)
+                    {
+                        /* Generate the directory Name in which we will recurse. */ 
+                        var directoryName = d + "/" + fileList[i].getName();
+
+                        /* Get a list of all files in this directory */
+                        var fileListing = listAllFiles (ext, directoryName, recurse);
+                        if (fileListing != null)
+                        {
+                            /* Return a list of all file names in the directory. */
+                            for (var j = 0 ; j < fileListing.length; j++) 
+                                srcFile[srcFile.length++] = fileListing[j];
+                        }
+                    }
+                }
+                else
+                {
+                    /* This was a file. Check if the file name matches the extension */
+                    if (fileList[i].getName().endsWith(ext) == true)
+                        srcFile[srcFile.length++] = d + "/" + fileList[i].getName();
+                }
+            }
+        }
+
+        return srcFile;
+    }
+    return null;
+}
+
+function createMake(makefile)
+{
+    /* Create the main make file */
+    var fileModule = xdc.module('xdc.services.io.File');
+    if(makefile==undefined)
+    {
+      try{
+          makefile = fileModule.open("makefile", "w");
+         } catch (ex)
+         {
+           print("makefile cannot be written to. Please check Writing Permissions.");
+           java.lang.System.exit(1);
+         }   
+    
+      Pkg.makePrologue += "\ninclude makefile\n"; 
+         
+      Pkg.makeEpilogue += "\nclean::\n\t-$(RM)  makefile\n";
+      makefile.writeLine("#*******************************************************************************");
+      makefile.writeLine("#* FILE PURPOSE: Top level makefile for Creating Component Libraries");
+      makefile.writeLine("#*******************************************************************************");
+      makefile.writeLine("#* FILE NAME: makefile");
+      makefile.writeLine("#*");
+      makefile.writeLine("#* DESCRIPTION: Defines Compiler tools paths, libraries , Build Options ");
+      makefile.writeLine("#*");
+      makefile.writeLine("#*");
+      makefile.writeLine("#*******************************************************************************");
+      makefile.writeLine("#*");
+      makefile.writeLine("# (Mandatory) Specify where various tools are installed.");
+
+      var file = xdc.module('xdc.services.io.File');
+    
+      var xdcTargetType = java.lang.System.getenv("XDCTARGET");
+      var toolsBaseDir = java.lang.System.getenv("XDCCGROOT");   
+      
+      makefile.writeLine("\n# Output for prebuilt generated libraries");
+      makefile.writeLine("export LIBDIR ?= ./lib");
+
+      /* Create INCDIR from XDCPATH */
+    
+      /* copy the environment array from the current environment */
+      var env   = java.lang.System.getenv();
+      var getxdcpath=String(java.lang.System.getenv("XDCPATH"));
+      getxdcpath= getxdcpath.replace(/\\/g,"/");
+      var keys  = env.keySet().toArray();
+      var key;
+      var stat={};
+      var env_j=[];
+      var listxdcpath = new Array();
+      for (var i = 0; i < keys.length; i++) {
+           key = String(keys[i]);
+           if((key.match("INSTALL_PATH")) || (key.match("INSTALLDIR")))
+           {
+             var keyPath=String(env.get(key));
+             keyPath=keyPath.replace(/\\/g,"/");
+             var file = xdc.module('xdc.services.io.File');
+             keyPath=file.getDOSPath(keyPath);
+             if(getxdcpath.toString().match(keyPath))
+             {
+                 listxdcpath.push({keyname: key,keypath: keyPath});
+                 while(getxdcpath.toString().match(keyPath))
+                 {
+                   getxdcpath=getxdcpath.toString().replace(keyPath,"$("+key+")");
+                 }
+             }
+           }
+    
+     }
+       var pkgroot="..";
+       for (var i = Pkg.name.split('.').length; i > 1; i--) {
+              pkgroot+="/..";
+          }
+        
+      makefile.writeLine("\n# ROOT Directory");        
+      makefile.writeLine("export ROOTDIR := "+pkgroot);
+    
+      makefile.writeLine("\n# INCLUDE Directory");
+      makefile.writeLine("export INCDIR := "+getxdcpath+";$(ROOTDIR)");       
+    
+      makefile.writeLine("\n# Common Macros used in make");  
+      makefile.writeLine("\nifndef RM");     
+      makefile.writeLine("export RM = rm -f");
+      makefile.writeLine("endif");        
+    
+      makefile.writeLine("\nifndef CP");     
+      makefile.writeLine("export CP = cp -p");    
+      makefile.writeLine("endif");    
+        
+      makefile.writeLine("\nexport MKDIR = mkdir -p");
+    
+      makefile.writeLine("\nifndef RMDIR");         
+      makefile.writeLine("export RMDIR = rm -rf");
+      makefile.writeLine("endif");        
+    
+      makefile.writeLine("\nifndef SED"); 
+      makefile.writeLine("export SED = sed");    
+      makefile.writeLine("endif");    
+    
+      makefile.writeLine("\nifndef MAKE"); 
+      makefile.writeLine("export MAKE = make");    
+      makefile.writeLine("endif");        
+
+      makefile.writeLine("\n# PHONY Targets");                
+      makefile.writeLine(".PHONY: all clean cleanall ");    
+      
+      makefile.writeLine("\n# FORCE Targets");                
+      makefile.writeLine("FORCE: ");          
+      
+      makefile.writeLine("\n# all rule");                
+      makefile.writeLine("all: .executables");           
+      makefile.writeLine(".executables: .libraries");
+      makefile.writeLine(".libraries:");
+      
+      makefile.writeLine("\n# Clean Rule");          
+      makefile.writeLine("clean:: clean_package");          
+      makefile.writeLine("# Clean Top Level Object Directory ");  
+      makefile.writeLine("clean_package:")
+      for each (var libdir in devices)
+      {         
+        makefile.writeLine("\t$(RMDIR) $(LIBDIR)/"+libdir.toString()+"/*/");  
+      }    
+      makefile.writeLine("\t$(RMDIR) package/cfg");            
+   }
+   else
+   {
+     try{
+          makefile = fileModule.open("makefile", "a");
+         } catch (ex)
+         {
+           print("makefile cannot be written to. Please check Writing Permissions.");
+           java.lang.System.exit(1);
+         }  
+    
+    }
+
+ return makefile;
+}
+
+function createLibMake(device, makelibname,targetname, objectPath)
+{
+   var tooldir;
+   var stringname=String(targetname).replace("(xdc.bld.ITarget.Module)","");
+   if(stringname.match("ARM11"))
+   {
+     tooldir="TI_ARM11_GEN_INSTALL_PATH"; 
+   }
+   else
+   {
+     tooldir="C6X_GEN_INSTALL_PATH";
+   }
+   switch(stringname)
+   {
+    case String(C66LE):
+      targetname=C66LE;
+      break;
+    case String(C66BE):
+      targetname=C66BE;
+      break;
+
+   }
+    var fileModule = xdc.module('xdc.services.io.File');
+    try{
+     var dstFile = new java.io.File(makelibname);
+     dstFile.getParentFile().mkdirs();    
+     libmakefile = fileModule.open(makelibname, "w");
+     /* Add to Archive list */
+    } catch (ex)
+    {
+     print(makelibname+" cannot be written to. Please check Writing Permissions.");
+     java.lang.System.exit(1);
+    }   
+    libmakefile.writeLine("#*******************************************************************************");
+    libmakefile.writeLine("#* FILE PURPOSE: Lower level makefile for Creating Component Libraries");
+    libmakefile.writeLine("#*******************************************************************************");
+    libmakefile.writeLine("#* FILE NAME: "+makelibname);
+    libmakefile.writeLine("#*");
+    libmakefile.writeLine("#* DESCRIPTION: Defines Source Files, Compilers flags and build rules");
+    libmakefile.writeLine("#*");
+    libmakefile.writeLine("#*");
+    libmakefile.writeLine("#*******************************************************************************");
+    libmakefile.writeLine("#");
+    libmakefile.writeLine("");
+    libmakefile.writeLine("#");
+    libmakefile.writeLine("# Macro definitions referenced below");
+    libmakefile.writeLine("#");
+    libmakefile.writeLine("empty =");
+    libmakefile.writeLine("space =$(empty) $(empty)");
+         
+    if(stringname.match("ti.targets"))
+    {
+
+       var rtslibtemp = targetname.lnkOpts.suffix.toString().split("/");
+       var rtslib;
+       for(n=0;n<rtslibtemp.length;n++)
+       {
+          if(rtslibtemp[n].match(".lib"))
+          { 
+             rtslib=rtslibtemp[n];
+          }
+       }
+
+      libmakefile.writeLine("CC = $("+tooldir+")/bin/"+targetname.cc.cmd +" "+targetname.ccOpts.prefix+" "+targetname.cc.opts);
+      libmakefile.writeLine("AC = $("+tooldir+")/bin/"+targetname.asm.cmd +" "+targetname.asmOpts.prefix+" "+targetname.asm.opts);    
+      libmakefile.writeLine("ARIN = $("+tooldir+")/bin/"+targetname.ar.cmd +" "+targetname.ar.opts);    
+      libmakefile.writeLine("LD = $("+tooldir+")/bin/"+targetname.lnk.cmd +" "+targetname.lnk.opts);   
+      libmakefile.writeLine("RTSLIB = -l $("+tooldir+")/lib/"+rtslib);        
+    }
+    else
+    {
+      print("Error: Non-TI targets are not currently supported ");
+      java.lang.System.exit(1);
+
+    }
+       
+    libmakefile.writeLine("INCS = -I. -I$(strip $(subst ;, -I,$(subst $(space),\\$(space),$(INCDIR))))");
+    libmakefile.writeLine("OBJEXT = o"+targetname.suffix); 
+    libmakefile.writeLine("AOBJEXT = s"+targetname.suffix);     
+    /* libmakefile.writeLine("INTERNALDEFS = -D"+stringname.replace(/\./g,"_")+" -Dxdc_target_types__=ti/targets/std.h -DMAKEFILE_BUILD -eo.$(OBJEXT) -ea.$(AOBJEXT) -fr=$(@D) -fs=$(@D) -ppa -ppd=$@.dep");*/
+    libmakefile.writeLine("INTERNALDEFS = -D"+stringname.replace(/\./g,"_")+"  -DMAKEFILE_BUILD -eo.$(OBJEXT) -ea.$(AOBJEXT) -fr=$(@D) -fs=$(@D) -ppa -ppd=$@.dep");
+    libmakefile.writeLine("INTERNALLINKDEFS = -o $@ -m $@.map");
+    libmakefile.writeLine("OBJDIR = $(LIBDIR)/" + device.toString() + "/obj");
+   
+    return libmakefile;
+
+}
+
+function makeAddObjects(srcString, makefilename, srcfiles, flags,fileExt, targetName)
+{
+  var  sourcestring = (srcString + fileExt).toString().toUpperCase();
+  var  compileflagstring = sourcestring + "FLAGS";
+  var  objectliststring = sourcestring + "OBJS";
+  /* List all the source files */
+  makefilename.writeLine("\n#List the "+srcString+" Files");  
+  makefilename.writeLine(sourcestring + "= \\");
+  for(var i=0;i<srcfiles.length-1;i++)
+  {
+    makefilename.writeLine("    "+srcfiles[i]+"\\");
+  }
+    makefilename.writeLine("    "+srcfiles[i]+"\n");
+    
+ /* Flags for the source files */
+ makefilename.writeLine("# FLAGS for the "+srcString+" Files"); 
+ var compileflags="";
+ if(fileExt == "asm" && flags.aopts != undefined)
+ {
+   compileflags+=" "+flags.aopts;
+ }
+ else if((fileExt == "c" || fileExt == "sa")&& flags.copts != undefined)
+ {
+   compileflags+=" "+flags.copts;
+ } 
+
+ if(flags.incs != undefined)
+ {
+   compileflags+=" "+flags.incs;
+ }
+
+
+ makefilename.writeLine(compileflagstring+" = "+compileflags +" \n");     
+ makefilename.writeLine("# Make Rule for the "+srcString+" Files");  
+ makefilename.writeLine(objectliststring +" = $(patsubst %."+fileExt+", $(OBJDIR)/%.$(OBJEXT), $(" + sourcestring + "))"); 
+ makefilename.writeLine("\n$("+objectliststring+"): $(OBJDIR)/%.$(OBJEXT): %."+fileExt);   
+ if(fileExt == "c")
+ { 
+   makefilename.writeLine("\t-@echo cl"+targetName.suffix +" $< ...");     
+ }
+ else
+ {
+   makefilename.writeLine("\t-@echo asm"+targetName.suffix +" $< ...");      
+ }
+ makefilename.writeLine("\tif [ ! -d $(@D) ]; then $(MKDIR) $(@D) ; fi;");           
+ if(fileExt == "c")
+ {
+   makefilename.writeLine("\t$(RM) $@.dep");
+   makefilename.writeLine("\t$(CC) $("+compileflagstring+") $(INTERNALDEFS) $(INCS) -fc $< ");
+   makefilename.writeLine("\t-@$(CP) $@.dep $@.pp; \\");
+   makefilename.writeLine("         $(SED) -e 's/#.*//' -e 's/^[^:]*: *//' -e 's/ *\\\\$$//' \\");
+   makefilename.writeLine("             -e '/^$$/ d' -e 's/$$/ :/' < $@.pp >> $@.dep; \\");
+   makefilename.writeLine("         $(RM) $@.pp ");
+ }
+ else if(fileExt == "asm")
+ {
+   makefilename.writeLine("\t$(AC) $("+compileflagstring+") $(INTERNALDEFS) $(INCS) -fa $< ");
+ }
+ else if(fileExt == "sa")
+ {
+   makefilename.writeLine("\t$(AC) $("+compileflagstring+") $(INTERNALDEFS) $(INCS) $< ");
+ }
+   makefilename.writeLine("\n#Create Empty rule for dependency");
+   makefilename.writeLine("$("+objectliststring+"):"+makefilename.$private.fd);
+   makefilename.writeLine(makefilename.$private.fd+":");
+   makefilename.writeLine("\n#Include Depedency for "+srcString+" Files");
+   makefilename.writeLine("ifneq (clean,$(MAKECMDGOALS))");
+   makefilename.writeLine(" -include $("+objectliststring+":%.$(OBJEXT)=%.$(OBJEXT).dep)");
+   makefilename.writeLine("endif");
+}
+
+/**************************************************************************
+ * FUNCTION NAME : buildLibrary
+ **************************************************************************
+ * DESCRIPTION   :
+ *  Utility function which will build a specific library
+ **************************************************************************/
+var makefilelocal;
+function buildLibrary (device, libOptions, libName, target, libFiles) 
+{
+    var lldFullLibraryPath = "./lib/" + device.toString() + "/" + libName;
+    var lldFullBuildPath = "./build/" + device.toString() + "/" + libName;
+    var lldFullLibraryPathMake = "$(LIBDIR)/" + device.toString() + "/" + libName;
+
+    /* Create Main make file in the root of package folder */
+    makefilelocal = createMake(makefilelocal);
+
+    /* Write the rule to make library in main makefile */
+    lib = lldFullBuildPath+".a"+target.suffix;
+    libMake = lldFullLibraryPathMake+".a"+target.suffix;
+    var objectPath= "./package/"+lldFullBuildPath;
+    makefilelocal.writeLine("\n\n# Make rule to create "+libMake+" library");
+    makefilelocal.writeLine(".libraries: "+ libMake);
+    makefilelocal.writeLine(libMake+": FORCE\n\t$(MAKE) -f "+lib+".mk $@");                                 
+
+    /* Create Library make file in the lib folder */
+    var makefilelib= createLibMake(device, lib+".mk",target,objectPath);  
+
+    /* Rule to clean library in main makefile */
+    makefilelocal.writeLine("# Rule to clean "+libMake+" library");                                              
+    makefilelocal.writeLine("clean ::\n\t$(RM) "+ libMake);                                          
+    librule="\n\n"+libMake+" :";
+
+    /* Add files to be compiled */
+    /* Separate out the C and assembly files */
+    var cfiles= new Array();
+    var afiles= new Array();
+    var safiles= new Array();
+    for each(var srcFile in libFiles)
+    {
+        var srcFile=String(srcFile);
+        var dot = srcFile.lastIndexOf(".");
+        var extension = srcFile.substr(dot,srcFile.length);      
+        if(extension == ".c")
+        {
+          cfiles.push(srcFile);
+        }
+        else if(extension == ".sa")
+        {
+          safiles.push(srcFile);
+        }
+        else if(extension == ".asm")
+        {
+           afiles.push(srcFile);
+        }
+        else
+        {
+           print("ERROR: Unsupported file extension");
+           java.lang.System.exit(1);
+        }
+     }
+    if(cfiles.length > 0)
+    {                                                
+      makeAddObjects("COMMONSRC",makefilelib,cfiles,libOptions,"c",target);
+      librule += " $(COMMONSRCCOBJS)";                   
+    }
+    if(afiles.length > 0)
+    {                                                
+      makeAddObjects("COMMONSRC",makefilelib,afiles,libOptions,"asm",target);
+      librule += " $(COMMONSRCASMOBJS)";                   
+    }
+    if(safiles.length > 0)
+    {                                                
+      makeAddObjects("COMMONSRC",makefilelib,safiles,libOptions,"sa",target);
+      librule += " $(COMMONSRCSAOBJS)";                   
+    }
+
+    makefilelib.writeLine(librule);
+    makefilelib.writeLine("\t@echo archiving $? into $@ ...");
+    makefilelib.writeLine("\tif [ ! -d $(LIBDIR)/" + device.toString() + " ]; then $(MKDIR) $(LIBDIR)/" + device.toString() + " ; fi;"); 
+               makefilelib.writeLine("\t$(ARIN) $@ $?");
+               makefilelib.close();   
+
+    
+    /* Create the Epilogue; which executes after all the builds are completed. 
+     * This is used to generate the benchmark information for the built library. 
+     * Also add the benchmarking information file to the package. */
+     /*
+    Pkg.makeEpilogue += ".libraries: benchmarking_"  + device + "_" + target.suffix + "\n";
+    Pkg.makeEpilogue += "benchmarking_" + device + "_" + target.suffix + ":";
+    Pkg.makeEpilogue += "\n\t ofd6x -x " + lldFullLibraryPath + ".a" + target.suffix + " > tmp.xml";
+    Pkg.makeEpilogue += "\n\t sectti tmp.xml > " + lldFullLibraryPath + ".a" + target.suffix +  "_size.txt";
+    Pkg.makeEpilogue += "\n\t $(RM) tmp.xml\n\n";
+    Pkg.otherFiles[Pkg.otherFiles.length++] = lldFullLibraryPath + ".a" + target.suffix + "_size.txt";
+    */
+    Pkg.otherFiles[Pkg.otherFiles.length++] = lldFullBuildPath + ".a" + target.suffix + ".mk";
+    Pkg.otherFiles[Pkg.otherFiles.length++] = lldFullLibraryPath + ".a" + target.suffix;
+
+    /* We need to clean after ourselves; extend the 'clean' target to take care of this. */
+    Pkg.makeEpilogue += "clean::\n";
+    Pkg.makeEpilogue += "\t$(RM) " + lldFullBuildPath + ".a" + target.suffix + "_size.txt\n";
+    Pkg.makeEpilogue += "\t$(RMDIR) " + "$(LIBDIR)/" + device.toString() + " \n\n";
+
+    return lib;
+}
+
+/**************************************************************************
+ * FUNCTION NAME : createMiniPkg
+ **************************************************************************
+ * DESCRIPTION   :
+ *  The function is responsible for creating the mini tar package
+ *  The MINI package has the following files:- 
+ *      - Driver Source Files. 
+ *      - Header files (exported and internal driver files) 
+ *      - Simple Makefiles. 
+ **************************************************************************/
+function createMiniPkg(pkgName)
+{
+    /* Get the package Name. */
+    var packageRepository = xdc.getPackageRepository(Pkg.name);
+    var packageBase       = xdc.getPackageBase(Pkg.name);
+    var packageName       = packageBase.substring(packageRepository.length + 1);
+
+    /* Convert the Package name by replacing back slashes with forward slashes. This is required because
+     * otherwise with long names the tar is unable to change directory. */
+    var newPkgName = new java.lang.String(packageRepository);
+    var newPkgRep  = newPkgName.replace('\\', '/');
+
+    /* Step1: Create the MINI Package and add the simple Big and Little Endian Makefiles to the package */
+    Pkg.makeEpilogue += "release: mini_pkg\n";
+    Pkg.makeEpilogue += "mini_pkg:\n";
+    Pkg.makeEpilogue += "\t tar -C " + '"' + newPkgRep + '"' + " -cf packages/" + pkgName + "_mini.tar " +
+                        packageName + "simpleC66LE.mak " +
+                        packageName + "simpleC66BE.mak\n";
+
+    /* Step2: Add the exported header files to the package */
+    var includeFiles = listAllFiles (".h", ".", false);
+    for (var k = 0 ; k < includeFiles.length; k++)
+        Pkg.makeEpilogue += "\t tar -C " + '"' + newPkgRep + '"' + " -rf packages/" + pkgName + "_mini.tar " + 
+                        packageName + includeFiles[k] + "\n";
+
+    /* Step3: Add the driver source files to the package; the filter should have generated a source listing */
+    Pkg.makeEpilogue += "\t tar -C " + '"' + newPkgRep + '"' + " -T src.lst -rf packages/" + pkgName + "_mini.tar " + "\n";
+
+    /* Ensure that we clean up the mini package */
+    Pkg.makeEpilogue += "clean::\n";
+    Pkg.makeEpilogue += "\t $(RM) packages/" + pkgName + "_mini.tar\n";
+}
+
diff --git a/config.bld b/config.bld
new file mode 100644 (file)
index 0000000..e024c2c
--- /dev/null
@@ -0,0 +1,113 @@
+/******************************************************************************
+ * FILE PURPOSE: Build configuration Script for the Fault Management
+ ******************************************************************************
+ * FILE NAME: config.bld
+ *
+ * DESCRIPTION: 
+ *  This file contains the build configuration script for Fault Management
+ *  and is responsible for configuration of the paths for the various tools
+ *  required to build Fault Management.
+ *
+ * Copyright (C) 2012-2014, Texas Instruments, Inc.
+ *****************************************************************************/
+
+/* Get the Tools Base directory from the Environment Variable. */
+var toolsBaseDir = java.lang.System.getenv("XDCCGROOT");
+
+/* Get the base directory for the RM LLD Package */
+var fault_mgmtlibPath = new java.io.File(".//").getPath();
+
+var fault_mgmtlibInstallType;
+
+/* Read the part number from the environment variable. */
+var fault_mgmtlibPartNumber = java.lang.System.getenv("PARTNO");
+
+/* Read the SOC family from the environment variable. */
+var fault_mgmtlibSocFamily = java.lang.System.getenv("SOC_FAMILY");
+if (fault_mgmtlibSocFamily == null) {
+    fault_mgmtlibSocFamily = "";
+}
+
+/* Include Path */
+var fault_mgmtlibIncludePath = " -i" + fault_mgmtlibPath + "/src" + " -i" + fault_mgmtlibPath  + " -i" + fault_mgmtlibPath + "/test";
+
+/* Configure the Fault Management Release Version Information */
+/* 3 steps: remove SPACE and TAB, convert to string and split to make array */
+var fault_mgmtlibReleaseVersion = (""+Pkg.version.replace(/\s/g, "")).split(',');
+
+/* Fault Management Coverity Analysis: Check the environment variable to determine if Static
+ * Analysis has to be done on the Fault Management Code base or not? */
+var fault_mgmtlibCoverityAnalysis = java.lang.System.getenv("STATIC_ANALYZE");
+
+/* C66 ELF compiler configuration for Little Endian Mode. */
+var C66LE          = xdc.useModule('ti.targets.elf.C66');
+C66LE.rootDir       = toolsBaseDir;
+C66LE.ccOpts.prefix  = "-mo -o3 -q -k -eo.o";
+
+/* C66 ELF compiler configuration for Big Endian Mode. */
+var C66BE          = xdc.useModule('ti.targets.elf.C66_big_endian');
+C66BE.rootDir       = toolsBaseDir;
+C66BE.ccOpts.prefix  = "-mo -o3 -q -k -eo.o -DBIGENDIAN";
+
+/* Check if we need to run the STATIC Analysis or not? */
+var coverityAnalysis = java.lang.System.getenv("STATIC_ANALYZE");
+
+/* Setup the Coverity Filters to perform Static Analysis. */
+if (coverityAnalysis == "ON") {
+    var coverityInstallPath = java.lang.System.getenv("STATIC_ANALYZE_PATH");
+    var cfgBase = xdc.getPackageBase("tisb.coverity.filters") + "cfg";
+
+    var coverityFilter = [
+    {
+        moduleName: "tisb.coverity.filters.Coverity",
+        params: {
+            cfgDir:  cfgBase,  // The Coverity configuration file directory
+            rootDir: coverityInstallPath,
+            outDir: xdc.csd() + "cov_out",
+            analyzeLibs: true
+        }
+    },
+    ];
+
+    /* Run the coverity filters on the LE Build only. */
+    C66LE.profiles["release"].filters = coverityFilter;
+}
+
+/* Check if we need to create the Makefiles? */
+var miniBuild = java.lang.System.getenv("MINI_PACKAGE");
+
+if (miniBuild == "ON")
+{
+    /* Add the filter for simple Makefile generation. */
+
+    var makeC66LEFilter = {
+        moduleName: "build.filter.Make",
+        params: {
+          makefileName: "simpleC66LE.mak",
+        }
+    };
+
+    C66LE.profiles["release"].filters[C66LE.profiles["release"].filters.length++] = makeC66LEFilter;
+
+    var makeC66BEFilter = {
+        moduleName: "build.filter.Make",
+        params: {
+          makefileName: "simpleC66BE.mak",
+        }
+    }; 
+
+    C66BE.profiles["release"].filters[C66BE.profiles["release"].filters.length++] = makeC66BEFilter;
+
+}
+
+/* List all the build targets here. */
+Build.targets = [ C66LE, C66BE ];
+
+/* List of all devices that combine to make the fault_mgmt library. */
+var devices = [ "tci6614/c66", "k2h/c66", "k2k/c66", "k2e/c66", "k2l/c66" ];
+
+/* Order must exactly match list in "var devices" */
+var devicesCCOpt = [ "", " -DDEVICE_K2H", " -DDEVICE_K2K", " -DDEVICE_K2E", " -DDEVICE_K2L"];
+
+/* Order must exactly match list in "var devices" */
+var devicesSocFamily = [ "", "KeyStone2", "KeyStone2", "KeyStone2", "KeyStone2"];
diff --git a/device/Module.xs b/device/Module.xs
new file mode 100644 (file)
index 0000000..4109a4d
--- /dev/null
@@ -0,0 +1,28 @@
+/******************************************************************************
+ * FILE PURPOSE: Fault Management device specific files.
+ ******************************************************************************
+ * FILE NAME: Module.xs
+ *
+ * DESCRIPTION: 
+ *  This file contains the module specification for Fault Management device specific files.
+ *
+ * Copyright (C) 2013, Texas Instruments, Inc.
+ *****************************************************************************/
+
+/* Load the library utility. */
+var libUtility = xdc.loadCapsule ("../build/buildlib.xs");
+
+/**************************************************************************
+ * FUNCTION NAME : modBuild
+ **************************************************************************
+ * DESCRIPTION   :
+ *  The function is used to add all the source files in the device 
+ *  directory into the package.
+ **************************************************************************/
+function modBuild() 
+{
+    /* Add all the .c files to the release package. */
+    var configFiles = libUtility.listAllFiles (".c", "device", true);
+    for (var k = 0 ; k < configFiles.length; k++)
+        Pkg.otherFiles[Pkg.otherFiles.length++] = configFiles[k];
+}
diff --git a/device/k2e/src/fm_device.c b/device/k2e/src/fm_device.c
new file mode 100644 (file)
index 0000000..74782cd
--- /dev/null
@@ -0,0 +1,126 @@
+/**
+ *   @file  k2e/src/fm_device.c
+ *
+ *   @brief   
+ *      This file contains the device specific configuration and initialization routines
+ *      for Fault Management Module.
+ *
+ *  \par
+ *  ============================================================================
+ *  @n   (C) Copyright 2011-2014, Texas Instruments, Inc.
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  \par
+*/
+
+/* CSL include */
+#include <ti/csl/cslr_device.h>
+
+/* LLD includes */
+#include <ti/drv/cppi/cppi_drv.h>
+
+/* Fault Management Include File */
+#include <ti/instrumentation/fault_mgmt/fault_mgmt.h>
+
+/** @addtogroup FAULT_MGMT_DATA_STRUCTURE
+@{ 
+*/
+
+/** @brief FM Module initialization parameters */
+Fm_GlobalConfigParams fmGblCfgParams =
+{
+    /** Number of cores on device to notify on exception */
+    0u,
+    /** Maximum number of EDMA3 CCs */
+    5u,
+    /** Maximum number of AIF PE channels */
+    128u,
+    /** Maximum number of AIF PD channels */
+    128u,
+
+    /* Below only valid for the fault cleanup feature which is not available for K2E.
+     * Therefore, set remaining values to 0 */
+
+    /** Maximum number of QMSS Accumulator channels */
+    0u,
+    /** High priority accumulator channels */
+    { 0u, 0u},
+    /** Low priority accumulator channels */
+    { 0u, 0u},
+    /** Maximum number of PA PDSPs */
+    0u,
+    /** Maximum number of LUT1 entries */
+    0u,
+    /** Maximum number of CICs */
+    0u,
+    /** Pointer to CIC params */
+    NULL,
+    /** Maximum number of Timers */
+    0u,
+    /** Pointer to Timer params */
+    NULL,
+};
+
+/** @brief FM Resource exclusion list containing resources used by Linux*/
+Fm_ExcludedResource linuxResources[] = {
+    /** CPDMA PA Rx channels used by Linux */
+    {Fm_res_CpdmaRxCh,     {    0,   90}, Cppi_CpDma_NETCP_CPDMA},
+    /** CPDMA QMSS Rx channels used by Linux */        
+    {Fm_res_CpdmaRxCh,     {    0,    1}, Cppi_CpDma_QMSS_CPDMA},
+    /** CPDMA PA Tx channels used by Linux (first range) */
+    {Fm_res_CpdmaTxCh,     {    0,   18}, Cppi_CpDma_NETCP_CPDMA},
+    /** CPDMA PA Tx channels used by Linux (second range) */        
+    {Fm_res_CpdmaTxCh,     {   20,   20}, Cppi_CpDma_NETCP_CPDMA},
+    /** CPDMA QMSS Tx channels used by Linux */
+    {Fm_res_CpdmaTxCh,     {    0,    1}, Cppi_CpDma_QMSS_CPDMA},
+    /** CPDMA PA Rx flows used by Linux (first range) */
+    {Fm_res_CpdmaRxFlow,   {    0,    0}, Cppi_CpDma_NETCP_CPDMA},
+    /** CPDMA PA Rx flows used by Linux (second range) */
+    {Fm_res_CpdmaRxFlow,   {    8,    8}, Cppi_CpDma_NETCP_CPDMA},
+    /** CPDMA PA Rx flows used by Linux (third range) */
+    {Fm_res_CpdmaRxFlow,   {   31,   31}, Cppi_CpDma_NETCP_CPDMA},        
+    /** CPDMA QMSS Rx flows used by Linux */
+    {Fm_res_CpdmaRxFlow,   {    0,    1}, Cppi_CpDma_QMSS_CPDMA},
+    /** CPDMA XGE Rx channels used by Linux */
+    {Fm_res_CpdmaRxFlow,   {    0,   15}, Cppi_CpDma_XGE_CPDMA},
+    /** CPDMA XGE Tx channels used by Linux */
+    {Fm_res_CpdmaRxFlow,   {    0,    7}, Cppi_CpDma_XGE_CPDMA},
+    /** CPDMA XGE Rx flows used by Linux (first range) */
+    {Fm_res_CpdmaRxFlow,   {    0,    0}, Cppi_CpDma_XGE_CPDMA},
+    /** CPDMA XGE Rx flows used by Linux (second range) */
+    {Fm_res_CpdmaRxFlow,   {    8,    8}, Cppi_CpDma_XGE_CPDMA},        
+    /** End of exclusion array */
+    {Fm_res_END}
+};
+
+/**
+@}
+*/
+
diff --git a/device/k2h/src/fm_device.c b/device/k2h/src/fm_device.c
new file mode 100644 (file)
index 0000000..3aa5839
--- /dev/null
@@ -0,0 +1,124 @@
+/**
+ *   @file  k2h/src/fm_device.c
+ *
+ *   @brief   
+ *      This file contains the device specific configuration and initialization routines
+ *      for Fault Management Module.
+ *
+ *  \par
+ *  ============================================================================
+ *  @n   (C) Copyright 2011-2014, Texas Instruments, Inc.
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  \par
+*/
+
+/* CSL include */
+#include <ti/csl/cslr_device.h>
+
+/* LLD includes */
+#include <ti/drv/cppi/cppi_drv.h>
+
+/* Fault Management Include File */
+#include <ti/instrumentation/fault_mgmt/fault_mgmt.h>
+
+/** @addtogroup FAULT_MGMT_DATA_STRUCTURE
+@{ 
+*/
+
+/** @brief FM Module initialization parameters */
+Fm_GlobalConfigParams fmGblCfgParams =
+{
+    /** Number of cores on device to notify on exception */
+    8u,
+    /** Maximum number of EDMA3 CCs */
+    5u,
+    /** Maximum number of AIF PE channels */
+    128u,
+    /** Maximum number of AIF PD channels */
+    128u,
+
+    /* Below only valid for the fault cleanup feature which is not available for K2H.
+     * Therefore, set remaining values to 0 */
+
+    /** Maximum number of QMSS Accumulator channels */
+    0u,
+    /** High priority accumulator channels */
+    { 0u, 0u},
+    /** Low priority accumulator channels */
+    { 0u, 0u},
+    /** Maximum number of PA PDSPs */
+    0u,
+    /** Maximum number of LUT1 entries */
+    0u,
+    /** Maximum number of CICs */
+    0u,
+    /** Pointer to CIC params */
+    NULL,
+    /** Maximum number of Timers */
+    0u,
+    /** Pointer to Timer params */
+    NULL,
+};
+
+/** @brief FM Resource exclusion list containing resources used by Linux*/
+Fm_ExcludedResource linuxResources[] = {
+    /** CPDMA PA Rx channels used by Linux */
+    {Fm_res_CpdmaRxCh,     {    0,   23}, Cppi_CpDma_PASS_CPDMA},
+    /** CPDMA QMSS Rx channels used by Linux */        
+    {Fm_res_CpdmaRxCh,     {    0,   11}, Cppi_CpDma_QMSS_CPDMA},
+    /** CPDMA PA Tx channels used by Linux (first range) */
+    {Fm_res_CpdmaTxCh,     {    0,    6}, Cppi_CpDma_PASS_CPDMA},
+    /** CPDMA PA Tx channels used by Linux (second range) */        
+    {Fm_res_CpdmaTxCh,     {    8,    8}, Cppi_CpDma_PASS_CPDMA},
+    /** CPDMA QMSS Tx channels used by Linux */
+    {Fm_res_CpdmaTxCh,     {    0,   11}, Cppi_CpDma_QMSS_CPDMA},
+    /** CPDMA PA Rx flows used by Linux (first range) */
+    {Fm_res_CpdmaRxFlow,   {   22,   26}, Cppi_CpDma_PASS_CPDMA},
+    /** CPDMA PA Rx flows used by Linux (second range) */
+    {Fm_res_CpdmaRxFlow,   {   30,   31}, Cppi_CpDma_PASS_CPDMA},
+    /** CPDMA QMSS Rx flows used by Linux */
+    {Fm_res_CpdmaRxFlow,   {    0,   11}, Cppi_CpDma_QMSS_CPDMA},
+    /** CPDMA XGE Rx channels used by Linux */
+    {Fm_res_CpdmaRxFlow,   {    0,   15}, Cppi_CpDma_XGE_CPDMA},
+    /** CPDMA XGE Tx channels used by Linux */
+    {Fm_res_CpdmaRxFlow,   {    0,    7}, Cppi_CpDma_XGE_CPDMA},
+    /** CPDMA XGE Rx flows used by Linux (first range) */
+    {Fm_res_CpdmaRxFlow,   {    0,    0}, Cppi_CpDma_XGE_CPDMA},
+    /** CPDMA XGE Rx flows used by Linux (second range) */
+    {Fm_res_CpdmaRxFlow,   {    8,    8}, Cppi_CpDma_XGE_CPDMA},        
+    /** End of exclusion array */
+    {Fm_res_END}
+};
+
+/**
+@}
+*/
+
diff --git a/device/k2k/src/fm_device.c b/device/k2k/src/fm_device.c
new file mode 100644 (file)
index 0000000..91edbdd
--- /dev/null
@@ -0,0 +1,124 @@
+/**
+ *   @file  k2k/src/fm_device.c
+ *
+ *   @brief   
+ *      This file contains the device specific configuration and initialization routines
+ *      for Fault Management Module.
+ *
+ *  \par
+ *  ============================================================================
+ *  @n   (C) Copyright 2011-2014, Texas Instruments, Inc.
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  \par
+*/
+
+/* CSL include */
+#include <ti/csl/cslr_device.h>
+
+/* LLD includes */
+#include <ti/drv/cppi/cppi_drv.h>
+
+/* Fault Management Include File */
+#include <ti/instrumentation/fault_mgmt/fault_mgmt.h>
+
+/** @addtogroup FAULT_MGMT_DATA_STRUCTURE
+@{ 
+*/
+
+/** @brief FM Module initialization parameters */
+Fm_GlobalConfigParams fmGblCfgParams =
+{
+    /** Number of cores on device to notify on exception */
+    8u,
+    /** Maximum number of EDMA3 CCs */
+    5u,
+    /** Maximum number of AIF PE channels */
+    128u,
+    /** Maximum number of AIF PD channels */
+    128u,
+
+    /* Below only valid for the fault cleanup feature which is not available for K2K.
+     * Therefore, set remaining values to 0 */
+
+    /** Maximum number of QMSS Accumulator channels */
+    0u,
+    /** High priority accumulator channels */
+    { 0u, 0u},
+    /** Low priority accumulator channels */
+    { 0u, 0u},
+    /** Maximum number of PA PDSPs */
+    0u,
+    /** Maximum number of LUT1 entries */
+    0u,
+    /** Maximum number of CICs */
+    0u,
+    /** Pointer to CIC params */
+    NULL,
+    /** Maximum number of Timers */
+    0u,
+    /** Pointer to Timer params */
+    NULL,
+};
+
+/** @brief FM Resource exclusion list containing resources used by Linux*/
+Fm_ExcludedResource linuxResources[] = {
+    /** CPDMA PA Rx channels used by Linux */
+    {Fm_res_CpdmaRxCh,     {    0,   23}, Cppi_CpDma_PASS_CPDMA},
+    /** CPDMA QMSS Rx channels used by Linux */        
+    {Fm_res_CpdmaRxCh,     {    0,   11}, Cppi_CpDma_QMSS_CPDMA},
+    /** CPDMA PA Tx channels used by Linux (first range) */
+    {Fm_res_CpdmaTxCh,     {    0,    6}, Cppi_CpDma_PASS_CPDMA},
+    /** CPDMA PA Tx channels used by Linux (second range) */        
+    {Fm_res_CpdmaTxCh,     {    8,    8}, Cppi_CpDma_PASS_CPDMA},
+    /** CPDMA QMSS Tx channels used by Linux */
+    {Fm_res_CpdmaTxCh,     {    0,   11}, Cppi_CpDma_QMSS_CPDMA},
+    /** CPDMA PA Rx flows used by Linux (first range) */
+    {Fm_res_CpdmaRxFlow,   {   22,   26}, Cppi_CpDma_PASS_CPDMA},
+    /** CPDMA PA Rx flows used by Linux (second range) */
+    {Fm_res_CpdmaRxFlow,   {   30,   31}, Cppi_CpDma_PASS_CPDMA},
+    /** CPDMA QMSS Rx flows used by Linux */
+    {Fm_res_CpdmaRxFlow,   {    0,   11}, Cppi_CpDma_QMSS_CPDMA},
+    /** CPDMA XGE Rx channels used by Linux */
+    {Fm_res_CpdmaRxFlow,   {    0,   15}, Cppi_CpDma_XGE_CPDMA},
+    /** CPDMA XGE Tx channels used by Linux */
+    {Fm_res_CpdmaRxFlow,   {    0,    7}, Cppi_CpDma_XGE_CPDMA},
+    /** CPDMA XGE Rx flows used by Linux (first range) */
+    {Fm_res_CpdmaRxFlow,   {    0,    0}, Cppi_CpDma_XGE_CPDMA},
+    /** CPDMA XGE Rx flows used by Linux (second range) */
+    {Fm_res_CpdmaRxFlow,   {    8,    8}, Cppi_CpDma_XGE_CPDMA},        
+    /** End of exclusion array */
+    {Fm_res_END}
+};
+
+/**
+@}
+*/
+
diff --git a/device/k2l/src/fm_device.c b/device/k2l/src/fm_device.c
new file mode 100644 (file)
index 0000000..d078182
--- /dev/null
@@ -0,0 +1,118 @@
+/**
+ *   @file  k2l/src/fm_device.c
+ *
+ *   @brief   
+ *      This file contains the device specific configuration and initialization routines
+ *      for Fault Management Module.
+ *
+ *  \par
+ *  ============================================================================
+ *  @n   (C) Copyright 2011-2014, Texas Instruments, Inc.
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  \par
+*/
+
+/* CSL include */
+#include <ti/csl/cslr_device.h>
+
+/* LLD includes */
+#include <ti/drv/cppi/cppi_drv.h>
+
+/* Fault Management Include File */
+#include <ti/instrumentation/fault_mgmt/fault_mgmt.h>
+
+/** @addtogroup FAULT_MGMT_DATA_STRUCTURE
+@{ 
+*/
+
+/** @brief FM Module initialization parameters */
+Fm_GlobalConfigParams fmGblCfgParams =
+{
+    /** Number of cores on device to notify on exception */
+    0u,
+    /** Maximum number of EDMA3 CCs */
+    3u,
+    /** Maximum number of AIF PE channels */
+    128u,
+    /** Maximum number of AIF PD channels */
+    128u,
+
+    /* Below only valid for the fault cleanup feature which is not available for K2L.
+     * Therefore, set remaining values to 0 */
+
+    /** Maximum number of QMSS Accumulator channels */
+    0u,
+    /** High priority accumulator channels */
+    { 0u, 0u},
+    /** Low priority accumulator channels */
+    { 0u, 0u},
+    /** Maximum number of PA PDSPs */
+    0u,
+    /** Maximum number of LUT1 entries */
+    0u,
+    /** Maximum number of CICs */
+    0u,
+    /** Pointer to CIC params */
+    NULL,
+    /** Maximum number of Timers */
+    0u,
+    /** Pointer to Timer params */
+    NULL,
+};
+
+/** @brief FM Resource exclusion list containing resources used by Linux*/
+Fm_ExcludedResource linuxResources[] = {
+    /** CPDMA PA Rx channels used by Linux */
+    {Fm_res_CpdmaRxCh,     {    0,   90}, Cppi_CpDma_NETCP_CPDMA},
+    /** CPDMA QMSS Rx channels used by Linux */        
+    {Fm_res_CpdmaRxCh,     {    0,    7}, Cppi_CpDma_QMSS_CPDMA},
+    /** CPDMA PA Tx channels used by Linux (first range) */
+    {Fm_res_CpdmaTxCh,     {    0,   18}, Cppi_CpDma_NETCP_CPDMA},
+    /** CPDMA PA Tx channels used by Linux (second range) */        
+    {Fm_res_CpdmaTxCh,     {   20,   20}, Cppi_CpDma_NETCP_CPDMA},
+    /** CPDMA QMSS Tx channels used by Linux */
+    {Fm_res_CpdmaTxCh,     {    0,    7}, Cppi_CpDma_QMSS_CPDMA},
+    /** CPDMA PA Rx flows used by Linux (first range) */
+    {Fm_res_CpdmaRxFlow,   {    0,    0}, Cppi_CpDma_NETCP_CPDMA},
+    /** CPDMA PA Rx flows used by Linux (second range) */
+    {Fm_res_CpdmaRxFlow,   {    8,    8}, Cppi_CpDma_NETCP_CPDMA},
+    /** CPDMA PA Rx flows used by Linux (third range) */
+    {Fm_res_CpdmaRxFlow,   {   31,   31}, Cppi_CpDma_NETCP_CPDMA},        
+    /** CPDMA QMSS Rx flows used by Linux */
+    {Fm_res_CpdmaRxFlow,   {    0,    7}, Cppi_CpDma_QMSS_CPDMA},        
+    /** End of exclusion array */
+    {Fm_res_END}
+};
+
+/**
+@}
+*/
+
diff --git a/device/tci6614/src/fm_device.c b/device/tci6614/src/fm_device.c
new file mode 100644 (file)
index 0000000..f4f52df
--- /dev/null
@@ -0,0 +1,207 @@
+/**
+ *   @file  tci6614/src/fm_device.c
+ *
+ *   @brief   
+ *      This file contains the device specific configuration and initialization routines
+ *      for Fault Management Module.
+ *
+ *  \par
+ *  ============================================================================
+ *  @n   (C) Copyright 2011-2014, Texas Instruments, Inc.
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  \par
+*/
+
+
+/* CSL include */
+#include <ti/csl/csl_cppi.h>
+#include <ti/csl/cslr_device.h>
+
+/* Fault Management Include File */
+#include <ti/instrumentation/fault_mgmt/fault_mgmt.h>
+
+/** @addtogroup FAULT_MGMT_DATA_STRUCTURE
+@{ 
+*/
+
+/** Maximum number of CICs - 4 CICs on Appleton */
+#define NUM_CIC           4u
+
+/** Maximum number of Timers - 12 timers on Appleton */
+#define NUM_TIMERS        12u
+
+/** @brief FM Module CIC parameters */
+Fm_CicParams cicInfo[NUM_CIC] = {
+    {
+        (volatile CSL_CPINTCRegs *) CSL_CP_INTC_0_REGS,
+        202,
+        152,
+    },
+    {
+        (volatile CSL_CPINTCRegs *) CSL_CP_INTC_1_REGS,
+        160,
+        59,
+    },
+    {
+        (volatile CSL_CPINTCRegs *) CSL_CP_INTC_2_REGS,
+        64,
+        42,
+    },
+    {
+        (volatile CSL_CPINTCRegs *) CSL_CP_INTC_3_REGS,
+        256,
+        48,
+    },
+};
+
+/** @brief FM Module Timer paramers */
+Fm_TimerParams timerInfo[NUM_TIMERS] = {
+    {
+        (volatile CSL_TmrRegs *) CSL_TIMER_0_REGS,
+    },
+    {
+        (volatile CSL_TmrRegs *) CSL_TIMER_1_REGS,
+    },
+    {
+        (volatile CSL_TmrRegs *) CSL_TIMER_2_REGS,
+    },
+    {
+        (volatile CSL_TmrRegs *) CSL_TIMER_3_REGS,
+    },
+    {
+        (volatile CSL_TmrRegs *) CSL_TIMER_4_REGS,
+    },
+    {
+        (volatile CSL_TmrRegs *) CSL_TIMER_5_REGS,
+    },
+    {
+        (volatile CSL_TmrRegs *) CSL_TIMER_6_REGS,
+    },
+    {
+        (volatile CSL_TmrRegs *) CSL_TIMER_7_REGS,
+    },
+    {
+        (volatile CSL_TmrRegs *) CSL_TIMER_8_REGS,
+    },
+    {
+        (volatile CSL_TmrRegs *) CSL_TIMER_9_REGS,
+    },
+    {
+        (volatile CSL_TmrRegs *) CSL_TIMER_10_REGS,
+    },
+    {
+        (volatile CSL_TmrRegs *) CSL_TIMER_11_REGS,
+    },
+};
+
+/** @brief FM Module initialization parameters */
+Fm_GlobalConfigParams fmGblCfgParams =
+{
+    /** Number of cores on device to notify on exception */
+    4u,
+    /** Maximum number of EDMA3 CCs */
+    3u,
+    /** Maximum number of AIF PE channels */
+    128u,
+    /** Maximum number of AIF PD channels */
+    128u,
+    /** Maximum number of QMSS Accumulator channels */
+    48u,
+    /** High priority accumulator channels */
+    { 0u, 31u},
+    /** Low priority accumulator channels */
+    {32u, 47u},
+    /** Maximum number of PA PDSPs */
+    6u,
+    /** Maximum number of LUT1 entries */
+    64u,
+    /** Maximum number of CICs */
+    NUM_CIC,
+    /** Pointer to CIC params */
+    &cicInfo[0],
+    /** Maximum number of Timers */
+    NUM_TIMERS,
+    /** Pointer to Timer params */
+    &timerInfo[0],
+};
+
+/** @brief FM Resource exclusion list containing resources used by Linux*/
+Fm_ExcludedResource linuxResources[] = {
+    /** CPDMA PA Rx channels used by Linux */
+    {Fm_res_CpdmaRxCh,     {    0,   23}, Cppi_CpDma_PASS_CPDMA},
+    /** CPDMA QMSS Rx channels used by Linux */        
+    {Fm_res_CpdmaRxCh,     {    0,   11}, Cppi_CpDma_QMSS_CPDMA},
+    /** CPDMA PA Tx channels used by Linux (first range) */
+    {Fm_res_CpdmaTxCh,     {    0,    6}, Cppi_CpDma_PASS_CPDMA},
+    /** CPDMA PA Tx channels used by Linux (second range) */        
+    {Fm_res_CpdmaTxCh,     {    8,    8}, Cppi_CpDma_PASS_CPDMA},
+    /** CPDMA QMSS Tx channels used by Linux */
+    {Fm_res_CpdmaTxCh,     {    0,   11}, Cppi_CpDma_QMSS_CPDMA},
+    /** CPDMA PA Rx flows used by Linux (first range) */
+    {Fm_res_CpdmaRxFlow,   {   22,   23}, Cppi_CpDma_PASS_CPDMA},
+    /** CPDMA PA Rx flows used by Linux (second range) */
+    {Fm_res_CpdmaRxFlow,   {   30,   31}, Cppi_CpDma_PASS_CPDMA},
+    /** CPDMA QMSS Rx flows used by Linux */
+    {Fm_res_CpdmaRxFlow,   {    0,   11}, Cppi_CpDma_QMSS_CPDMA},
+    /** CPDMA SRIO Rx flows used by Linux */
+    {Fm_res_CpdmaRxFlow,   {   21,   21}, Cppi_CpDma_SRIO_CPDMA},
+    /** QMSS Accumulator channels owned by Linux */
+    {Fm_res_QmssAccumCh,   {   32,   35}, NULL},
+    /** QMSS Queues owned by Linux */
+    {Fm_res_QmssQueue,     {    0,  127}, NULL},
+    {Fm_res_QmssQueue,     {  640,  648}, NULL},
+    {Fm_res_QmssQueue,     {  650,  657}, NULL},
+    {Fm_res_QmssQueue,     {  672,  672}, NULL},
+    {Fm_res_QmssQueue,     {  800,  811}, NULL},
+    {Fm_res_QmssQueue,     { 4000, 4063}, NULL},
+    {Fm_res_QmssQueue,     { 8000, 8191}, NULL},     
+    /** QMSS Memory regions owned by Linux */
+    {Fm_res_QmssMemRegion, {   12,   12}, NULL},
+    /** PA PDSPs */
+    {Fm_res_PaPdsp,        {    0,    0}, NULL},
+    /** PA LUT entries */
+    {Fm_res_PaLutEntry,    {    0,   43}, 1},
+    {Fm_res_PaLutEntry,    {   56,   63}, 1},
+    /** EDMA3 CC0 channels, and interrupts */
+    {Fm_res_Edma3DmaCh,    {    0,   15}, 0},
+    {Fm_res_Edma3IntCh,    {    0,   15}, 0},
+    /** All CIC3 host events owned by Linux */
+    {Fm_res_CicHostInt,    {    0,   47}, 3},
+    /** Timers 7 and 8 used by Linux for clockevent/source and watchdog, respectively */
+    {Fm_res_Timer,         {    7,    8}, NULL},
+    /** End of exclusion array */
+    {Fm_res_END}
+};
+
+/**
+@}
+*/
+
diff --git a/docs/Module.xs b/docs/Module.xs
new file mode 100644 (file)
index 0000000..984a61d
--- /dev/null
@@ -0,0 +1,53 @@
+/******************************************************************************
+ * FILE PURPOSE: Fault Management Library DOCS Module specification file.
+ ******************************************************************************
+ * FILE NAME: module.xs
+ *
+ * DESCRIPTION: 
+ *  This file contains the module specification for the Fault Management Lib Documentation .
+ *
+ * Copyright (C) 2012, Texas Instruments, Inc.
+ *****************************************************************************/
+
+/* Load the library utility. */
+var libUtility = xdc.loadCapsule ("../build/buildlib.xs");
+
+/**************************************************************************
+ * FUNCTION NAME : modBuild
+ **************************************************************************
+ * DESCRIPTION   :
+ *  The function is used to build all the components of the documentation
+ **************************************************************************/
+function modBuild() 
+{
+    /* Create the actual PROLOGUE Section for the Documentation.*/
+    Pkg.makePrologue += "release: fault_mgmtlib_document_generation\n";
+    Pkg.makePrologue += "fault_mgmtlib_document_generation:\n";
+    Pkg.makePrologue += "\t @echo -------------------------------------------------------\n";
+    Pkg.makePrologue += "\t @echo Generating Fault Management Lib Documentation\n";
+    Pkg.makePrologue += "\t doxygen docs/Doxyfile\n";
+    Pkg.makePrologue += "\t @echo Fault Management Library Documentation Generated \n";
+    Pkg.makePrologue += "\t @echo -------------------------------------------------------\n";
+
+    /* Add the documentation file to the package. */
+    Pkg.otherFiles[Pkg.otherFiles.length++] = "docs/fault_mgmtlibDocs.chm";
+    Pkg.otherFiles[Pkg.otherFiles.length++] = "docs/tifooter.htm";
+    Pkg.otherFiles[Pkg.otherFiles.length++] = "docs/tiheader.htm";
+    Pkg.otherFiles[Pkg.otherFiles.length++] = "docs/tilogo.gif";
+    Pkg.otherFiles[Pkg.otherFiles.length++] = "docs/titagline.gif";
+    Pkg.otherFiles[Pkg.otherFiles.length++] = "docs/doxygen";
+    Pkg.otherFiles[Pkg.otherFiles.length++] = "docs/ReleaseNotes_fault_mgmt.pdf";
+
+    if (fault_mgmtlibInstallType == "SETUP")
+    {
+        /* Generate the ECLIPSE Plugin Generation */
+        Pkg.makePrologue += "all: eclipse_plugin_generation\n";
+        Pkg.makePrologue += "eclipse_plugin_generation:\n";
+        Pkg.makePrologue += "\t @echo -------------------------------------------------------\n";
+        Pkg.makePrologue += "\t @echo RM LLD Eclipse Plugin Generation\n";
+        Pkg.makePrologue += "\t xs xdc.tools.eclipsePluginGen -o . -x ./eclipseDocs/sample.xml -c ./eclipseDocs/toc_cdoc_sample.xml\n";
+        Pkg.makePrologue += "\t @echo RM LLD Eclipse Plugin Generated \n";
+        Pkg.makePrologue += "\t @echo -------------------------------------------------------\n";
+    }   
+}
+
diff --git a/docs/ReleaseNotes_fault_mgmt.doc b/docs/ReleaseNotes_fault_mgmt.doc
new file mode 100644 (file)
index 0000000..9161875
Binary files /dev/null and b/docs/ReleaseNotes_fault_mgmt.doc differ
diff --git a/docs/ReleaseNotes_fault_mgmt.pdf b/docs/ReleaseNotes_fault_mgmt.pdf
new file mode 100644 (file)
index 0000000..4d21bb9
Binary files /dev/null and b/docs/ReleaseNotes_fault_mgmt.pdf differ
diff --git a/docs/doxyfile.xdt b/docs/doxyfile.xdt
new file mode 100644 (file)
index 0000000..e040a65
--- /dev/null
@@ -0,0 +1,1250 @@
+%%{
+/*!
+ *  This template implements the Doxyfile
+ */  
+  /* Versioning */
+  var ver = this;
+  var packageVersion = ver[0]+"."+ver[1]+"."+ver[2]+"."+ver[3];
+
+%%}
+
+
+# Doxyfile 1.7.3
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+#       TAG = value [value, ...]
+# For lists items can also be appended using:
+#       TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded 
+# by quotes) that should identify the project.
+
+PROJECT_NAME           = "Fault Management Library"
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. 
+# This could be handy for archiving the generated documentation or 
+# if some version control system is used.
+
+PROJECT_NUMBER         =  `packageVersion`
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
+# base path where the generated documentation will be put. 
+# If a relative path is entered, it will be relative to the location 
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = ./docs/doxygen
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 
+# 4096 sub-directories (in 2 levels) under the output directory of each output 
+# format and will distribute the generated files over these directories. 
+# Enabling this option can be useful when feeding doxygen a huge amount of 
+# source files, where putting all generated files in the same directory would 
+# otherwise cause performance problems for the file system.
+
+CREATE_SUBDIRS         = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all 
+# documentation generated by doxygen is written. Doxygen will use this 
+# information to generate all constant output in the proper language. 
+# The default language is English, other supported languages are: 
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, 
+# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German, 
+# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English 
+# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, 
+# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak, 
+# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
+
+OUTPUT_LANGUAGE        = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will 
+# include brief member descriptions after the members that are listed in 
+# the file and class documentation (similar to JavaDoc). 
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend 
+# the brief description of a member or function before the detailed description. 
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the 
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator 
+# that is used to form the text in various listings. Each string 
+# in this list, if found as the leading text of the brief description, will be 
+# stripped from the text and the result after processing the whole list, is 
+# used as the annotated text. Otherwise, the brief description is used as-is. 
+# If left blank, the following values are used ("$name" is automatically 
+# replaced with the name of the entity): "The $name class" "The $name widget" 
+# "The $name file" "is" "provides" "specifies" "contains" 
+# "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then 
+# Doxygen will generate a detailed section even if there is only a brief 
+# description.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all 
+# inherited members of a class in the documentation of that class as if those 
+# members were ordinary class members. Constructors, destructors and assignment 
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full 
+# path before files name in the file list and in the header files. If set 
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES        = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag 
+# can be used to strip a user-defined part of the path. Stripping is 
+# only done if one of the specified strings matches the left-hand part of 
+# the path. The tag can be used to show relative paths in the file list. 
+# If left blank the directory from which doxygen is run is used as the 
+# path to strip.
+
+STRIP_FROM_PATH        = 
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of 
+# the path mentioned in the documentation of a class, which tells 
+# the reader which header file to include in order to use a class. 
+# If left blank only the name of the header file containing the class 
+# definition is used. Otherwise one should specify the include paths that 
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH    = 
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter 
+# (but less readable) file names. This can be useful if your file system 
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen 
+# will interpret the first line (until the first dot) of a JavaDoc-style 
+# comment as the brief description. If set to NO, the JavaDoc 
+# comments will behave just like regular Qt-style comments 
+# (thus requiring an explicit @brief command for a brief description.)
+
+JAVADOC_AUTOBRIEF      = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen 
+# treat a multi-line C++ special comment block (i.e. a block of //! or /// 
+# comments) as a brief description. This used to be the default behaviour. 
+# The new default is to treat a multi-line C++ comment block as a detailed 
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented 
+# member inherits the documentation from any documented member that it 
+# re-implements.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce 
+# a new page for each member. If set to NO, the documentation of a member will 
+# be part of the file/class/namespace that contains it.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. 
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE               = 8
+
+# This tag can be used to specify a number of aliases that acts 
+# as commands in the documentation. An alias has the form "name=value". 
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to 
+# put the command \sideeffect (or @sideeffect) in the documentation, which 
+# will result in a user-defined paragraph with heading "Side Effects:". 
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES                = 
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C 
+# sources only. Doxygen will then generate output that is more tailored for C. 
+# For instance, some of the names that are used will be different. The list 
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C  = YES
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java 
+# sources only. Doxygen will then generate output that is more tailored for 
+# Java. For instance, namespaces will be presented as packages, qualified 
+# scopes will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want 
+# to include (a tag file for) the STL sources as input, then you should 
+# set this tag to YES in order to let doxygen match functions declarations and 
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s. 
+# func(std::string) {}). This also makes the inheritance and collaboration 
+# diagrams that involve STL classes more complete and accurate.
+
+BUILTIN_STL_SUPPORT    = NO
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC 
+# tag is set to YES, then doxygen will reuse the documentation of the first 
+# member in the group (if any) for the other members of the group. By default 
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of 
+# the same type (for instance a group of public functions) to be put as a 
+# subgroup of that type (e.g. under the Public Functions section). Set it to 
+# NO to prevent subgrouping. Alternatively, this can be done per class using 
+# the \nosubgrouping command.
+
+SUBGROUPING            = YES
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in 
+# documentation are documented, even if no documentation was available. 
+# Private class members and static file members will be hidden unless 
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL            = NO
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class 
+# will be included in the documentation.
+
+EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file 
+# will be included in the documentation.
+
+EXTRACT_STATIC         = YES
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) 
+# defined locally in source files will be included in the documentation. 
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. When set to YES local 
+# methods, which are defined in the implementation section but not in 
+# the interface are included in the documentation. 
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all 
+# undocumented members of documented classes, files or namespaces. 
+# If set to NO (the default) these members will be included in the 
+# various overviews, but no documentation section is generated. 
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS     = YES
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all 
+# undocumented classes that are normally visible in the class hierarchy. 
+# If set to NO (the default) these classes will be included in the various 
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES     = YES
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all 
+# friend (class|struct|union) declarations. 
+# If set to NO (the default) these declarations will be included in the 
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any 
+# documentation blocks found inside the body of a function. 
+# If set to NO (the default) these blocks will be appended to the 
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation 
+# that is typed after a \internal command is included. If the tag is set 
+# to NO (the default) then the documentation will be excluded. 
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS          = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate 
+# file names in lower-case letters. If set to YES upper-case letters are also 
+# allowed. This is useful if you have classes or files whose names only differ 
+# in case and if your file system supports case sensitive file names. Windows 
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES       = NO
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen 
+# will show members with their full class and namespace scopes in the 
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen 
+# will put a list of the files that are included by a file in the documentation 
+# of that file.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] 
+# is inserted in the documentation for inline members.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen 
+# will sort the (detailed) documentation of file and class members 
+# alphabetically by member name. If set to NO the members will appear in 
+# declaration order.
+
+SORT_MEMBER_DOCS       = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the 
+# brief documentation of file, namespace and class members alphabetically 
+# by member name. If set to NO (the default) the members will appear in 
+# declaration order.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be 
+# sorted by fully-qualified names, including namespaces. If set to 
+# NO (the default), the class list will be sorted only by class name, 
+# not including the namespace part. 
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. 
+# Note: This option applies only to the class list, not to the 
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or 
+# disable (NO) the todo list. This list is created by putting \todo 
+# commands in the documentation.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or 
+# disable (NO) the test list. This list is created by putting \test 
+# commands in the documentation.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or 
+# disable (NO) the bug list. This list is created by putting \bug 
+# commands in the documentation.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or 
+# disable (NO) the deprecated list. This list is created by putting 
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional 
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS       = 
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines 
+# the initial value of a variable or macro consists of for it to appear in 
+# the documentation. If the initializer consists of more lines than specified 
+# here it will be hidden. Use a value of 0 to hide initializers completely. 
+# The appearance of the initializer of individual variables and macros in the 
+# documentation can be controlled using \showinitializer or \hideinitializer 
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated 
+# at the bottom of the documentation of classes and structs. If set to YES the 
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES        = YES
+
+# If the sources in your project are distributed over multiple directories 
+# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy 
+# in the documentation. The default is NO.
+
+SHOW_DIRECTORIES       = NO
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that 
+# doxygen should invoke to get the current version for each file (typically from 
+# the version control system). Doxygen will invoke the program by executing (via 
+# popen()) the command <command> <input-file>, where <command> is the value of 
+# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file 
+# provided by doxygen. Whatever the program writes to standard output 
+# is used as the file version. See the manual for examples.
+
+FILE_VERSION_FILTER    = 
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated 
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are 
+# generated by doxygen. Possible values are YES and NO. If left blank 
+# NO is used.
+
+WARNINGS               = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings 
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will 
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for 
+# potential errors in the documentation, such as not documenting some 
+# parameters in a documented function, or documenting parameters that 
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR      = YES
+
+# The WARN_NO_PARAMDOC option can be enabled to get warnings for 
+# functions that are documented, but have no documentation for their parameters 
+# or return value. If set to NO (the default) doxygen will only warn about 
+# wrong or incomplete parameter documentation, but not about the absence of 
+# documentation.
+
+WARN_NO_PARAMDOC       = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that 
+# doxygen can produce. The string should contain the $file, $line, and $text 
+# tags, which will be replaced by the file and line number from which the 
+# warning originated and the warning text. Optionally the format may contain 
+# $version, which will be replaced by the version of the file (if it could 
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning 
+# and error messages should be written. If left blank the output is written 
+# to stderr.
+
+WARN_LOGFILE           = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain 
+# documented source files. You may enter file names like "myfile.cpp" or 
+# directories like "/usr/src/myproject". Separate the files or directories 
+# with spaces.
+
+INPUT                  = ./src \
+                              . 
+
+# If the value of the INPUT tag contains directories, you can use the 
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank the following patterns are tested: 
+# *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh 
+# *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py 
+# *.f90 *.f *.for *.vhd *.vhdl
+
+FILE_PATTERNS          = *.h 
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories 
+# should be searched for input files as well. Possible values are YES and NO. 
+# If left blank NO is used.
+
+RECURSIVE              = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should 
+# excluded from the INPUT source files. This way you can easily exclude a 
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+
+EXCLUDE                = YES \
+                         ./test \
+                         ./package \
+                         ./packages
+
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or 
+# directories that are symbolic links (a Unix file system feature) are excluded 
+# from the input.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the 
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude 
+# certain files from those directories. Note that the wildcards are matched 
+# against the file with absolute path, so to exclude all test directories 
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       = 
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or 
+# directories that contain example code fragments that are included (see 
+# the \include command).
+
+EXAMPLE_PATH           = 
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the 
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank all files are included.
+
+EXAMPLE_PATTERNS       = *
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be 
+# searched for input files to be used with the \include or \dontinclude 
+# commands irrespective of the value of the RECURSIVE tag. 
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or 
+# directories that contain image that are included in the documentation (see 
+# the \image command).
+
+IMAGE_PATH             = 
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should 
+# invoke to filter for each input file. Doxygen will invoke the filter program 
+# by executing (via popen()) the command <filter> <input-file>, where <filter> 
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an 
+# input file. Doxygen will then use the output that the filter program writes 
+# to standard output.  If FILTER_PATTERNS is specified, this tag will be 
+# ignored.
+
+INPUT_FILTER           = 
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern 
+# basis.  Doxygen will compare the file name with each pattern and apply the 
+# filter if there is a match.  The filters are a list of the form: 
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further 
+# info on how filters are used. If FILTER_PATTERNS is empty or if 
+# non of the patterns match the file name, INPUT_FILTER is applied.
+
+FILTER_PATTERNS        = 
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using 
+# INPUT_FILTER) will be used to filter the input files when producing source 
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES    = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will 
+# be generated. Documented entities will be cross-referenced with these sources. 
+# Note: To get rid of all source code in the generated output, make sure also 
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER         = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body 
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct 
+# doxygen to hide any special comment blocks from generated source code 
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES 
+# then for each documented function all documented 
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES 
+# then for each documented function all documented entities 
+# called/used by that function will be listed.
+
+REFERENCES_RELATION    = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default) 
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from 
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will 
+# link to the source code.  Otherwise they will link to the documentation.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code 
+# will point to the HTML generated by the htags(1) tool instead of doxygen 
+# built-in source browser. The htags tool is part of GNU's global source 
+# tagging system (see http://www.gnu.org/software/global/global.html). You 
+# will need version 4.8.6 or higher.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen 
+# will generate a verbatim copy of the header file for each class for 
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS       = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index 
+# of all compounds will be generated. Enable this if the project 
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX     = NO
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then 
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns 
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all 
+# classes will be put under the same header in the alphabetical index. 
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that 
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX          = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will 
+# generate HTML output.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT            = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for 
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank 
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard header.
+
+HTML_HEADER            = ./docs/tiheader.htm
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard footer.
+
+HTML_FOOTER            = ./docs/tifooter.htm
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading 
+# style sheet that is used by each HTML page. It can be used to 
+# fine-tune the look of the HTML output. If the tag is left blank doxygen 
+# will generate a default style sheet. Note that doxygen will try to copy 
+# the style sheet file to the HTML output directory, so don't put your own 
+# stylesheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET        = 
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, 
+# files or namespaces will be aligned in HTML using tables. If set to 
+# NO a bullet list will be used.
+
+HTML_ALIGN_MEMBERS     = YES
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files 
+# will be generated that can be used as input for tools like the 
+# Microsoft HTML help workshop to generate a compiled HTML help file (.chm) 
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP      = YES
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can 
+# be used to specify the file name of the resulting .chm file. You 
+# can add a path in front of the file if the result should not be 
+# written to the html output directory.
+
+CHM_FILE               = ..\..\fault_mgmtlibDocs.chm
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can 
+# be used to specify the location (absolute path including file name) of 
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run 
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION           = hhc.exe
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag 
+# controls if a separate .chi index file is generated (YES) or that 
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI           = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag 
+# controls whether a binary table of contents is generated (YES) or a 
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members 
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND             = NO
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at 
+# top of each HTML page. The value NO (the default) enables the index and 
+# the value YES disables it.
+
+DISABLE_INDEX          = NO
+
+# This tag can be used to set the number of enum values (range [0,1..20]) 
+# that doxygen will group on one line in the generated HTML documentation. 
+# Note that a value of 0 will completely suppress the enum values from
+# appearing in the overview section.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index 
+# structure should be generated to display hierarchical information. 
+# If the tag value is set to YES, a side panel will be generated 
+# containing a tree-like index structure (just like the one that 
+# is generated for HTML Help). For this to work a browser that supports 
+# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser). 
+# Windows users are probably better off using the HTML help feature.
+
+GENERATE_TREEVIEW      = NO
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be 
+# used to set the initial width (in pixels) of the frame in which the tree 
+# is shown.
+
+TREEVIEW_WIDTH         = 250
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box 
+# for the HTML output. The underlying search engine uses javascript 
+# and DHTML and should work on any modern browser. Note that when using 
+# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets 
+# (GENERATE_DOCSET) there is already a search function so this one should 
+# typically be disabled. For large projects the javascript based search engine 
+# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
+
+SEARCHENGINE           = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will 
+# generate Latex output.
+
+GENERATE_LATEX         = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be 
+# invoked. If left blank `latex' will be used as the default command name. 
+# Note that when enabling USE_PDFLATEX this option is only used for 
+# generating bitmaps for formulas in the HTML output, but not in the 
+# Makefile that is written to the output directory.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to 
+# generate index for LaTeX. If left blank `makeindex' will be used as the 
+# default command name.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact 
+# LaTeX documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used 
+# by the printer. Possible values are: a4, letter, legal and 
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE             = a4wide
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX 
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES         = 
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for 
+# the generated latex document. The header should contain everything until 
+# the first chapter. If it is left blank doxygen will generate a 
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER           = 
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated 
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will 
+# contain links (just like the HTML output) instead of page references 
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS         = NO
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of 
+# plain latex in the generated Makefile. Set this option to YES to get a 
+# higher quality PDF documentation.
+
+USE_PDFLATEX           = NO
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. 
+# command to the generated LaTeX files. This will instruct LaTeX to keep 
+# running if errors occur, instead of asking the user for help. 
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE        = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not 
+# include the index chapters (such as File Index, Compound Index, etc.) 
+# in the output.
+
+LATEX_HIDE_INDICES     = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output 
+# The RTF output is optimized for Word 97 and may not look very pretty with 
+# other RTF readers or editors.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact 
+# RTF documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated 
+# will contain hyperlink fields. The RTF file will 
+# contain links (just like the HTML output) instead of page references. 
+# This makes the output suitable for online browsing using WORD or other 
+# programs which support those fields. 
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's 
+# config file, i.e. a series of assignments. You only have to provide 
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE    = 
+
+# Set optional variables used in the generation of an rtf document. 
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE    = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will 
+# generate man pages
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to 
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION          = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output, 
+# then it will generate one additional man file for each entity 
+# documented in the real man page(s). These additional files 
+# only source the real man page, but without them the man command 
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will 
+# generate an XML file that captures the structure of 
+# the code including all documentation.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT             = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_SCHEMA             = 
+
+# The XML_DTD tag can be used to specify an XML DTD, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_DTD                = 
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will 
+# dump the program listings (including syntax highlighting 
+# and cross-referencing information) to the XML output. Note that 
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will 
+# generate an AutoGen Definitions (see autogen.sf.net) file 
+# that captures the structure of the code including all 
+# documentation. Note that this feature is still experimental 
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will 
+# generate a Perl module file that captures the structure of 
+# the code including all documentation. Note that this 
+# feature is still experimental and incomplete at the 
+# moment.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate 
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able 
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be 
+# nicely formatted so it can be parsed by a human reader.  This is useful 
+# if you want to understand what is going on.  On the other hand, if this 
+# tag is set to NO the size of the Perl module output will be much smaller 
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file 
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. 
+# This is useful so different doxyrules.make files included by the same 
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX = 
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will 
+# evaluate all C-preprocessor directives found in the sources and include 
+# files.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro 
+# names in the source code. If set to NO (the default) only conditional 
+# compilation will be performed. Macro expansion can be done in a controlled 
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION        = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES 
+# then the macro expansion is limited to the macros specified with the 
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files 
+# in the INCLUDE_PATH (see below) will be search if a #include is found.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that 
+# contain include files that are not input files but should be processed by 
+# the preprocessor.
+
+INCLUDE_PATH           = 
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard 
+# patterns (like *.h and *.hpp) to filter out the header-files in the 
+# directories. If left blank, the patterns specified with FILE_PATTERNS will 
+# be used.
+
+INCLUDE_FILE_PATTERNS  = 
+
+# The PREDEFINED tag can be used to specify one or more macro names that 
+# are defined before the preprocessor is started (similar to the -D option of 
+# gcc). The argument of the tag is a list of macros of the form: name 
+# or name=definition (no spaces). If the definition and the = are 
+# omitted =1 is assumed. To prevent a macro definition from being 
+# undefined via #undef or recursively expanded use the := operator 
+# instead of the = operator.
+
+PREDEFINED             = 
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then 
+# this tag can be used to specify a list of macro names that should be expanded. 
+# The macro definition that is found in the sources will be used. 
+# Use the PREDEFINED tag if you want to use a different macro definition that
+# overrules the definition found in the source code.
+
+EXPAND_AS_DEFINED      = 
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then 
+# doxygen's preprocessor will remove all references to function-like macros 
+# that are alone on a line, have an all uppercase name, and do not end with a 
+# semicolon, because these will confuse the parser if not removed.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles. 
+# Optionally an initial location of the external documentation 
+# can be added for each tagfile. The format of a tag file without 
+# this location is as follows: 
+#   TAGFILES = file1 file2 ... 
+# Adding location for the tag files is done as follows: 
+#   TAGFILES = file1=loc1 "file2 = loc2" ... 
+# where "loc1" and "loc2" can be relative or absolute paths or 
+# URLs. If a location is present for each tag, the installdox tool 
+# does not have to be run to correct the links. 
+# Note that each tag file must have a unique name 
+# (where the name does NOT include the path) 
+# If a tag file is not located in the directory in which doxygen 
+# is run, you must also specify the path to the tagfile here.
+
+TAGFILES               = 
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create 
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE       = 
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed 
+# in the class index. If set to NO only the inherited external classes 
+# will be listed.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed 
+# in the modules index. If set to NO, only the current project's groups will 
+# be listed.
+
+EXTERNAL_GROUPS        = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script 
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will 
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base 
+# or super classes. Setting the tag to NO turns the diagrams off. Note that 
+# this option also works with HAVE_DOT disabled, but it is recommended to 
+# install and use dot, since it yields more powerful graphs.
+
+CLASS_DIAGRAMS         = YES
+
+# If set to YES, the inheritance and collaboration graphs will hide 
+# inheritance and usage relations if the target is undocumented 
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is 
+# available from the path. This tool is part of Graphviz, a graph visualization 
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section 
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT               = NO
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect inheritance relations. Setting this tag to YES will force the 
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect implementation dependencies (inheritance, containment, and 
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for groups, showing the direct groups dependencies
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and 
+# collaboration diagrams in a style similar to the OMG's Unified Modeling 
+# Language.
+
+UML_LOOK               = NO
+
+# If set to YES, the inheritance and collaboration graphs will show the 
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS     = NO
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT 
+# tags are set to YES then doxygen will generate a graph for each documented 
+# file showing the direct and indirect include dependencies of the file with 
+# other documented files.
+
+INCLUDE_GRAPH          = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and 
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each 
+# documented header file showing the documented files that directly or 
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH and HAVE_DOT options are set to YES then 
+# doxygen will generate a call dependency graph for every global function 
+# or class method. Note that enabling this option will significantly increase 
+# the time of a run. So in most cases it will be better to enable call graphs 
+# for selected functions only using the \callgraph command.
+
+CALL_GRAPH             = NO
+
+# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then 
+# doxygen will generate a caller dependency graph for every global function 
+# or class method. Note that enabling this option will significantly increase 
+# the time of a run. So in most cases it will be better to enable caller 
+# graphs for selected functions only using the \callergraph command.
+
+CALLER_GRAPH           = NO
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES 
+# then doxygen will show the dependencies a directory has on other directories 
+# in a graphical way. The dependency relations are determined by the #include 
+# relations between the files in the directories.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images 
+# generated by dot. Possible values are png, svg, gif or svg. 
+# If left blank png will be used.
+
+DOT_IMAGE_FORMAT       = png
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be 
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH               = 
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that 
+# contain dot files that are included in the documentation (see the 
+# \dotfile command).
+
+DOTFILE_DIRS           = 
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the 
+# graphs generated by dot. A depth value of 3 means that only nodes reachable 
+# from the root by following a path via at most 3 edges will be shown. Nodes 
+# that lay further from the root node will be omitted. Note that setting this 
+# option to 1 or 2 may greatly reduce the computation time needed for large 
+# code bases. Also note that the size of a graph can be further restricted by 
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+
+MAX_DOT_GRAPH_DEPTH    = 1000
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent 
+# background. This is disabled by default, because dot on Windows does not 
+# seem to support this out of the box. Warning: Depending on the platform used, 
+# enabling this option may lead to badly anti-aliased labels on the edges of 
+# a graph (i.e. they become hard to read).
+
+DOT_TRANSPARENT        = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output 
+# files in one run (i.e. multiple -o and -T options on the command line). This 
+# makes dot run faster, but since only newer versions of dot (>1.8.10) 
+# support this, this feature is disabled by default.
+
+DOT_MULTI_TARGETS      = NO
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will 
+# generate a legend page explaining the meaning of the various boxes and 
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will 
+# remove the intermediate dot files that are used to generate 
+# the various graphs.
+
+DOT_CLEANUP            = YES
diff --git a/docs/tifooter.htm b/docs/tifooter.htm
new file mode 100644 (file)
index 0000000..4bdf9c9
--- /dev/null
@@ -0,0 +1,4 @@
+<hr size="1"><small>
+Copyright  $year, Texas Instruments Incorporated</small>
+</body>
+</html>
diff --git a/docs/tiheader.htm b/docs/tiheader.htm
new file mode 100644 (file)
index 0000000..3c61efe
--- /dev/null
@@ -0,0 +1,12 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1">
+<title>$title</title>
+<link href="$relpath$doxygen.css" rel="stylesheet" type="text/css">
+<link href="$relpath$tabs.css" rel="stylesheet" type="text/css">
+</head><body>
+<table width=100%>
+<tr>
+  <td bgcolor="black" width="1"><a href="http://www.ti.com"><img border=0 src="../../tilogo.gif"></a></td>
+  <td bgcolor="red"><img src="../../titagline.gif"></td>
+</tr>
+</table>
diff --git a/docs/tilogo.gif b/docs/tilogo.gif
new file mode 100644 (file)
index 0000000..f2fab2d
Binary files /dev/null and b/docs/tilogo.gif differ
diff --git a/docs/titagline.gif b/docs/titagline.gif
new file mode 100644 (file)
index 0000000..743a024
Binary files /dev/null and b/docs/titagline.gif differ
diff --git a/fault_mgmt.h b/fault_mgmt.h
new file mode 100644 (file)
index 0000000..34c2870
--- /dev/null
@@ -0,0 +1,644 @@
+/**
+ *   @file  fault_mgmt.h
+ *
+ *   @brief
+ *      Header file for the Fault Management library. The file exposes the 
+ *      data structures and exported API which are available for use by 
+ *      applications.
+ *
+ *  \par
+ *  NOTE:
+ *      (C) Copyright 2012-2014 Texas Instruments, Inc.
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/**  @mainpage Fault Management Module
+ *
+ *   @section intro  Introduction
+ *
+ *   The Fault Management Module can be used to save DSP state and notify the Host
+ *   when an exception occurs.  The module's APIs provide the following specific
+ *   functionalities:
+ *      - Notification of a local DSP core fault on all remote DSP cores through
+ *        manual fault generation on remote DSP cores via the remote core's NMI.
+ *      - ARM notification of a DSP core fault
+ *      - Halting of all hardware data transfer mechanisms
+ *          - Ability to exclude resources from the halt capability in case
+ *            something the like the Linux kernel must continue to run after
+ *            the DSP fault causes the IO halt code to execute.
+ *      - Saving of system core register status.  The register status can be used
+ *        in a core dump to extract information as to where and how the exception
+ *        occurred.
+ *      - Cleanup of DSP peripherals after a DSP application crash.  The peripheral
+ *        resources can be excluded so that any resources used by another core
+ *        (ARM Linux for example) will not be part of the cleanup process.  The
+ *        cleanup allows a DSP application to be reloaded to the DSP cores after
+ *        exception without a hard or soft reset of the board.  Only a DSP local
+ *        reset is needed on all DSP cores..
+ *
+ *   The IO halt feature currently allows disabling of the following IO
+ *      - All CPDMA transmit and receive channels
+ *      - AIF PE (transmit) and PD (receive) channels
+ *      - SGMII
+ *      - EDMA3 DMA, QDMA, and INT channels
+ *
+ *   The exception APIs can be called from a system exception context in
+ *   order to completely stop all data transfer, to preserve system crash state, and
+ *   then notify all remote DSP cores and the ARM of an exception.
+ *
+ *
+ *   The cleanup API is only available for TCI6614 devices
+ *
+ *   The cleanup API is called from a standalone DSP application loaded onto a DSP
+ *   core after an exception has occurred and a DSP local reset is performed.  The
+ *   fault management library provides the standalone DSP application in the 
+ *   fault_mgmt/util directory.  On the Linux side the dsp_cleanup.sh script can be
+ *   found at /sbin/dsp_cleanup.sh.  The prebuilt cleanup utility can be copied
+ *   into the Linux filesystem and executed using the dsp_cleanup.sh script.  The
+ *   script will handle the reset of DSPs and loading of the cleanup utility via
+ *   remoteproc.  Executing the dsp_cleanup.sh script with no input parameters
+ *   will list the help.  The cleanup utility will not clean a single DSP.  It
+ *   assumed all DSPs will be reloaded once the cleanup is complete.
+ *
+ *   The cleanup API performs the following actions when cleanup for each of the
+ *   following peripherals is enabled:
+ *      - CPPI:       Resets CPDMA tx channels, rx channels, and rx flows
+ *      - QMSS:       Disables QMSS accumulator channels and clears any pending
+ *                    accumulator channel INTD interrupts.  Resets memory
+ *                    regions.  Empties all QMSS queues.  Queues owned by
+ *                    Linux are swept of all descriptors that originate
+ *                    from memory regions inserted by a DSP application
+ *      - PA:         Redownloads firmware for PDSPs 1-5.  Resets LUT2. Delets
+ *                    all entries in LUT10 inserted by DSP.  Resets PA global
+ *                    config to default values
+ *      - EDMA3:      Disables DMA channels and clears the primary and secondary
+ *                    channel events.  Disables QDMA channels and clears primary
+ *                    and secondary events.  Disables interrupts and clears 
+ *                    pending events
+ *      - AIF2:       Resets AIF and powers down the AIF2 via the PSC
+ *      - TCP3D:      Powers down TCP3D A & B via the PSC
+ *      - BCP:        Powers down BCP via the PSC
+ *      - FFTC:       Powers down FFTC A & B via the PSC
+ *      - VCP:        Powers down the VCP via the PSC
+ *      - SA:         Clears the security context cache
+ *      - CIC:        Removes all CPINTC system to host interrupt mappings
+ *                    whose host interrupt is routed to the DSP.  Clears all
+ *                    pending CPINTC events.
+ *      - Timers:     Disables and resets timers.
+ *      - Semaphores: Soft resets semaphores
+ *
+ *   The fault_mgmt/device/[platform]/fm_device.c contains the FM global configuration
+ *   parameters and the exclusion list for the device.  The global config list
+ *   contains device peripheral information that could not be extracted from
+ *   CSL or externally-visible LLD APIs.  The exclusion list contains peripherals
+ *   resources that are in use by Linux.  These resources will not be halted or
+ *   cleaned up when the IO halt and cleanup APIs are called, respectively.
+ *
+ */
+
+/** @defgroup FAULT_MGMT_API   Fault Management
+ */
+
+#ifndef __FAULT_MGMT_H__
+#define __FAULT_MGMT_H__
+
+/* Standard includes */
+#include <stdint.h>
+
+/* CSL RL includes */
+#include <ti/csl/cslr_cpintc.h>
+#include <ti/csl/cslr_tmr.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+@defgroup FAULT_MGMT_SYMBOL                  Fault Management Defined Symbols
+@ingroup FAULT_MGMT_API
+*/
+/**
+@defgroup FAULT_MGMT_FUNCTION                Fault Management Functions
+@ingroup FAULT_MGMT_API
+*/
+/**
+@defgroup FAULT_MGMT_DATA_STRUCTURE          Fault Management Data Structures
+@ingroup FAULT_MGMT_API
+*/
+/**
+@defgroup FAULT_MGMT_OSAL_API                Fault Management OSAL API
+@ingroup FAULT_MGMT_API
+*/
+
+/** @addtogroup FAULT_MGMT_SYMBOL
+ @{ */
+
+/* FM return and error codes */
+/** FM successful return code */
+#define FM_OK                                        0
+
+#if (!defined(DEVICE_K2H) && !defined(DEVICE_K2K) && !defined(DEVICE_K2L) && !defined(DEVICE_K2E))
+/** FM fault cleanup successful return code */
+#define FM_FAULT_CLEANUP_OK                          1
+
+/** FM fault cleanup status base */
+#define FM_STATUS_BASE                               64
+/** FM fault cleanup process is being initialized */
+#define FM_STATUS_CLEANUP_INITIALIZATION             (FM_STATUS_BASE+1)
+/** FM fault cleanup process has entered CPDMA cleanup */
+#define FM_STATUS_CLEANUP_CPDMA                      (FM_STATUS_BASE+2)
+/** FM fault cleanup process has entered QMSS accumulator cleanup */
+#define FM_STATUS_CLEANUP_QMSS_ACCUM                 (FM_STATUS_BASE+3)
+/** FM fault cleanup process has entered PA cleanup */
+#define FM_STATUS_CLEANUP_PA                         (FM_STATUS_BASE+4)
+/** FM fault cleanup process has entered EDMA3 cleanup */
+#define FM_STATUS_CLEANUP_EDMA3                      (FM_STATUS_BASE+5)
+/** FM fault cleanup process has entered semaphore cleanup */
+#define FM_STATUS_CLEANUP_SEMAPHORE                  (FM_STATUS_BASE+6)
+/** FM fault cleanup process has entered QMSS queue cleanup */
+#define FM_STATUS_CLEANUP_QMSS_QUEUE                 (FM_STATUS_BASE+7)
+/** FM fault cleanup process has entered AIF2 cleanup */
+#define FM_STATUS_CLEANUP_AIF2                       (FM_STATUS_BASE+8)
+/** FM fault cleanup process has entered TCP3D cleanup */
+#define FM_STATUS_CLEANUP_TCP3D                      (FM_STATUS_BASE+9)
+/** FM fault cleanup process has entered BCP cleanup */
+#define FM_STATUS_CLEANUP_BCP                        (FM_STATUS_BASE+10)
+/** FM fault cleanup process has entered FFTC cleanup */
+#define FM_STATUS_CLEANUP_FFTC                       (FM_STATUS_BASE+11)
+/** FM fault cleanup process has entered VCP cleanup */
+#define FM_STATUS_CLEANUP_VCP                        (FM_STATUS_BASE+12)
+/** FM fault cleanup process has entered SA cleanup */
+#define FM_STATUS_CLEANUP_SA                         (FM_STATUS_BASE+13)
+/** FM fault cleanup process has entered CIC cleanup */
+#define FM_STATUS_CLEANUP_CIC                        (FM_STATUS_BASE+14)
+/** FM fault cleanup process has entered Timer cleanup */
+#define FM_STATUS_CLEANUP_TIMER                      (FM_STATUS_BASE+15)
+#endif /* !(K2H && K2K && K2L && K2E) */
+
+/** FM error base */
+#define FM_ERROR_BASE                                (-64)
+/** EDMA3 initialization failed during io halt initialization */
+#define FM_ERROR_EDMA3_INIT_FAILED                   (FM_ERROR_BASE-1)
+/** CPPI initialization failed during io halt or fault cleanup */
+#define FM_ERROR_CPPI_INIT_FAILED                    (FM_ERROR_BASE-2)
+/** QMSS initialization failed during io halt or fault cleanup */
+#define FM_ERROR_QMSS_INIT_FAILED                    (FM_ERROR_BASE-3)
+/** PA initialization failed during fault cleanup */
+#define FM_ERROR_PA_INIT_FAILED                      (FM_ERROR_BASE-4)
+/** An exclusion list entry's specified CPDMA type is incorrect based on 
+ *  fmGblCfgParams */
+#define FM_ERROR_INVALID_CPDMA_IN_EXCLUSION_LIST     (FM_ERROR_BASE-5)
+/** An exclusion list entry's specified EDMA3 CC number is incorrect based on 
+ *  fmGblCfgParams */
+#define FM_ERROR_INVALID_EDMA3_CC_IN_EXCLUSION_LIST  (FM_ERROR_BASE-6)
+/** An exclusion list entry's specified LUT number is incorrect based on 
+ *  fmGblCfgParams */
+#define FM_ERROR_INVALID_LUT_IN_EXCLUSION_LIST       (FM_ERROR_BASE-7)
+/** Could not continue with cleanup because cleanup initialization did not 
+ *  complete */
+#define FM_ERROR_CLEANUP_INIT_NOT_COMPLETE           (FM_ERROR_BASE-8)
+/** PA's command response indicated a LUT1 index could not be removed */
+#define FM_ERROR_LUT1_INDEX_NOT_REMOVED              (FM_ERROR_BASE-9)
+/** CPPI initialization failed during the PA cleanup process */
+#define FM_ERROR_CPPI_INIT_FAILED_DURING_PA_RECOV    (FM_ERROR_BASE-10)
+/** QMSS initialization failed during the PA cleanup process */
+#define FM_ERROR_QMSS_INIT_FAILED_DURING_PA_RECOV    (FM_ERROR_BASE-11)
+/** CPPI channel that is to be disabled is invalid */
+#define FM_ERROR_CPPI_TX_CHANNEL_INVALID             (FM_ERROR_BASE-13)
+/** Pa_control returned error when creating the command needed to reset
+ *  the PA global configuration to default values */
+#define FM_ERROR_PASS_SETTING_DEF_GLBL_CMD           (FM_ERROR_BASE-14)
+/** The command sent to PA to reset the global configuration failed */
+#define FM_ERROR_PASS_GBL_DEF_CFG_NOT_SET            (FM_ERROR_BASE-15)
+/** Pa_control returned error when creating the command needed to reset
+ *  the PA nat-t global configuration to default values */
+#define FM_ERROR_PASS_SETTING_DEF_NATT_CMD           (FM_ERROR_BASE-16)
+/** The command sent to PA to reset the nat-t global configuration failed */
+#define FM_ERROR_PASS_NATT_DEF_CFG_NOT_SET           (FM_ERROR_BASE-17)
+/** The monolithic descriptor buffer is not large enough to fit the 
+ *  LUT entry delete or reset global configuration commands sent to PA */
+#define FM_ERROR_DESC_BUF_TOO_SMALL                  (FM_ERROR_BASE-18)
+/** An exclusion list entry's specified CIC number is incorrect based on 
+ *  fmGblCfgParams */
+#define FM_ERROR_INVALID_CIC_IN_EXCLUSION_LIST       (FM_ERROR_BASE-19)
+/** An exclusion list entry's specified Timer range is incorrect based on 
+ *  fmGblCfgParams */
+#define FM_ERROR_INVALID_TIMER_IN_EXCLUSION_LIST     (FM_ERROR_BASE-20)
+/** Accumulator channel specified during INTD cleanup is not within the
+ *  highAccum or loAccum ranges defined within the fmGblCfgParams */
+#define FM_ERROR_INVALID_ACCUM_CH                    (FM_ERROR_BASE-21)
+
+/**
+ * @brief 
+ *  Size of data section used by fault management library to store coredump data that is to be 
+ *  sent to ARM.  The section size must be pre-defined at compile time since Linux Remoteproc
+ *  must know the FM's coredump region location and size at the time of DSP image download.
+ */
+#define FAULT_MGMT_DATA_SIZE                         1024
+
+/**
+@}
+*/
+
+/** @addtogroup FAULT_MGMT_DATA_STRUCTURE
+ @{ */
+
+/**********************************************************************
+ ****************** EXPORTED DATA STRUCTURES **************************
+ **********************************************************************/
+
+/**
+ * @brief 
+ *  This is the memory used by the fault management library to store any data that will be 
+ *  sent to the fault handling module. The region location must be pre-defined at compile time 
+ *  since the Linux DSP image downloader must know the FM's data dump region location and size 
+ *  at the time of download.
+ *
+ *  The fault_mgmt_data section is placed in the ".crash" data section.  The linker must place
+ *  ".crash" section in memory visible to the ARM. 
+ */
+extern uint8_t  fault_mgmt_data[FAULT_MGMT_DATA_SIZE];
+
+#if (!defined(DEVICE_K2H) && !defined(DEVICE_K2K) && !defined(DEVICE_K2L) && !defined(DEVICE_K2E))
+/**
+ * @brief
+ *  First 32-bit word is used by FM cleanup code to report cleanup status to Host
+ */
+extern int32_t  fmCleanupStatus[32];
+#endif /* !(K2H && K2K && K2L && K2E) */
+
+/**********************************************************************
+ **************************** EXPORTED API ****************************
+ **********************************************************************/
+
+/** 
+ * @brief Fault Management return code.
+ */
+typedef int32_t Fm_Result;
+
+/**
+ * @brief Accumulator channel range
+ */
+typedef struct {
+    /* Accumulator channel index start */
+    uint32_t start;
+    /* Accumulator channel index end */    
+    uint32_t end;
+} Fm_AccumChRange;
+
+/** 
+ * @brief CIC parameter structure containing information about each
+ *        CIC on the device.  A pointer to an array of these structures 
+ *        equal to the number of CICs on the device should be passed 
+ *        as part of the fmGlobalConfigParams structure.
+ */
+typedef struct {
+    /** Pointer to the CIC's register base address */
+    volatile CSL_CPINTCRegs *cicRegs;
+    /** Input system events or interrupts */
+    uint32_t                 maxNumSysInt;
+    /** Output host events or inputerrupts */
+    uint32_t                 maxNumHostInt;
+} Fm_CicParams;
+
+/** 
+ * @brief Timer parameter structure containing information about each
+ *        Timer on the device.  A pointer to an array of these structures 
+ *        equal to the number of Timers on the device should be passed 
+ *        as part of the fmGlobalConfigParams structure.
+ */
+typedef struct {
+    /** Pointer to the Timer's register base address */
+    volatile CSL_TmrRegs *timerRegs;
+} Fm_TimerParams;
+
+/** 
+ * @brief Fault Management global configuration structure
+ */
+typedef struct {
+    /** Number of device cores to notify on exception */
+    uint32_t        maxNumCores;
+    /** Number of EDMA3 CCs */
+    uint32_t        maxEdma3Cc;
+    /** Max number of AIF PE (TX) channels */
+    uint32_t        maxAifPeCh;
+    /** Max number of AIF PD (RX) channels */
+    uint32_t        maxAifPdCh;
+    /** Max number of QMSS accumulator channels */
+    uint32_t        maxQmssAccumCh;
+    /** High priority accumulator channels */
+    Fm_AccumChRange highAccum;
+    /** Low priority accumulator channels */
+    Fm_AccumChRange loAccum;
+    /** Max number of PA PDSPs */
+    uint32_t        maxPaPdsps;
+    /** Max number of PA LUT1 entries */
+    uint32_t        maxLut1Entries;
+    /** Number of CICs on device */
+    uint32_t        maxCic;
+    /** Pointer to list of CIC param structures.  One param structure
+     *  per CIC */
+    Fm_CicParams   *cicParams;
+    /** Number of Timers on device */
+    uint32_t        maxTimers;
+    /** Pointer to list of timer param structures.  One param structure
+     *  per timers */
+    Fm_TimerParams *timerParams;
+} Fm_GlobalConfigParams;
+
+/**
+ * @brief IO halt resource exclusion types
+ */
+typedef enum {
+    /** CPDMA RX channel */
+    Fm_res_CpdmaRxCh = 0,
+    /** CPDMA TX channel */
+    Fm_res_CpdmaTxCh,
+    /** CPDMA RX flow */
+    Fm_res_CpdmaRxFlow,
+    /** AIF PE (TX) channel */
+    Fm_res_AifPeCh,
+    /** AIF PD (RX) channel */
+    Fm_res_AifPdCh,
+    /** EDMA3 DMA channel */
+    Fm_res_Edma3DmaCh, 
+    /** EDMA3 QDMA channel */
+    Fm_res_Edma3QdmaCh, 
+    /** EDMA3 INT channel */
+    Fm_res_Edma3IntCh,
+    /** QMSS Accumulator channels */
+    Fm_res_QmssAccumCh,
+    /** QMSS Queues */
+    Fm_res_QmssQueue,
+    /** QMSS Memory Regions */
+    Fm_res_QmssMemRegion,
+    /** PA PDSPs */
+    Fm_res_PaPdsp,
+    /** PA LUT Entries */
+    Fm_res_PaLutEntry,
+    /** Chip Interrupt Controller Host interrupts */
+    Fm_res_CicHostInt,
+    /** Timers */
+    Fm_res_Timer,
+    /** End of exclusion array identifier */
+    Fm_res_END
+} Fm_ResType;
+
+/**
+ * @brief IO halt resource peripheral resource exclusion range
+ */
+typedef struct {
+    /** Range start for which exclusion will apply */
+    int32_t exStart;
+    /** Range end for which exclusion will apply */
+    int32_t exEnd;
+} Fm_ExRange;
+
+/**
+ * @brief Describes a resource range that will be excluded from 
+ *        the halt logic in the Fault_Mgmt_haltIoProcessing API
+ */
+typedef struct {
+    /** Defines the type of resource to be excluded */
+    Fm_ResType resType;
+    /** Peripheral resources exclusion range */
+    Fm_ExRange exRange;
+    /** Excluded resource's extra parsing info as described below:
+     *      #Fm_res_CpdmaRxCh
+     *      #Fm_res_CpdmaTxCh
+     *      #Fm_res_CpdmaRxFlow
+     *          - Maps to Cppi_CpDma type
+     *
+     *      #Fm_res_Edma3DmaCh
+     *      #Fm_res_Edma3QdmaCh
+     *      #Fm_res_Edma3IntCh
+     *          - Maps to CSL_InstNum EDMA3 Channel Controller (CC)
+     *
+     *      #Fm_res_AifPeCh
+     *      #Fm_res_AifPdCh
+     *      #Fm_res_QmssAccumCh
+     *      #Fm_res_QmssQueue
+     *      #Fm_res_QmssMemRegion
+     *      #Fm_res_PaPdsp
+     *      #Fm_res_Timer
+     *          - NULL
+     *
+     *      #Fm_res_PaLutEntry
+     *          - Maps to LUT 0, 1, or 2
+     *
+     *      #Fm_res_CicHostInt
+     *          - Maps to CIC number
+     */
+    uint32_t   exResInfo;
+} Fm_ExcludedResource;
+
+#if (!defined(DEVICE_K2H) && !defined(DEVICE_K2K) && !defined(DEVICE_K2L) && !defined(DEVICE_K2E))
+/**
+ * @brief
+ *  DSP fault cleanup configuration parameters.
+ */
+typedef struct {
+    /** Cleans CPDMA to PoR state if a non-zero value is written to this field */
+    int32_t              cleanCpdma;
+    /** Cleans QMSS to PoR state if a non-zero value is written to this field */
+    int32_t              cleanQmss;
+    /** Cleans PA to PoR state if a non-zero value is written to this field */
+    int32_t              cleanPa;
+    /** Cleans EDMA3 to PoR state if a non-zero value is written to this field */
+    int32_t              cleanEdma3;
+    /** Cleans AIF2 to PoR state if a non-zero value is written to this field */
+    int32_t              cleanAif2;
+    /** Powers down TCP3D if a non-zero value is written to this field */
+    int32_t              cleanTcp3d;
+    /** Powers down BCP if a non-zero value is written to this field */
+    int32_t              cleanBcp;
+    /** Powers down FFTC (A & B) if a non-zero value is written to this field */
+    int32_t              cleanFftc;
+    /** Powers down VCP if a non-zero value is written to this field */
+    int32_t              cleanVcp;
+    /** Cleans SA security context entries */
+    int32_t              cleanSa;
+    /** Cleans the Chip Interrupt Controllers (CIC) */
+    int32_t              cleanCics;
+    /** Cleans the device timers */
+    int32_t              cleanTimers;
+    /** List of resources to not reset when trying to cleanup from
+     *  a DSP fault.  Used to avoid resetting Linux kernel features, such 
+     *  as the network driver, that use may use CPDMA channels.
+     *
+     *  Pass NULL to reset all peripherals to their PoR state. */
+    Fm_ExcludedResource *excludedResources;
+} Fm_CleanupCfg;
+#endif /* !(K2H && K2K && K2L && K2E) */
+
+/**
+ * @brief
+ *  DSP subsystem halt configuration parameters.
+ */
+typedef struct {
+    /** Disables the AIF2 send and receive channels if a non-zero value is written to
+     *  this field */
+    int32_t              haltAif2;
+    /** Halts SGMII tx/rx logic if a non-zero value is written to this field */
+    int32_t              haltSGMII;
+    /** Halts EDMA3 channels if a non-zero value is written to this field */
+    int32_t              haltEdma3;
+    /** Halts CPDMA tx/rx channels if a non-zero value is written to this field */
+    int32_t              haltCpdma;
+    /** List of resources to exclude from IO halt feature.  Can be used
+     *  to avoid halting key Linux kernel features, such as the network driver, that
+     *  use may use CPDMA channels.
+     *
+     *  Pass NULL to disable all receive channels for all resource types. */
+    Fm_ExcludedResource *excludedResources;
+} Fm_HaltCfg;
+
+/**
+@}
+*/
+
+/** @addtogroup FAULT_MGMT_FUNCTION
+ @{ */
+
+#if (!defined(DEVICE_K2H) && !defined(DEVICE_K2K) && !defined(DEVICE_K2L) && !defined(DEVICE_K2E))
+/**
+ *  @b Description
+ *  @n  
+ *      The function is used to clean the DSP peripherals to their power on reset state
+ *      after a DSP crash occurs.  The reset can be augmented to ignore peripheral resources
+ *      in use by the ARM (specifically, Linux).  The peripherals that are supported in 
+ *      PoR cleanup are:
+ *          - CPPI
+ *          - QMSS
+ *          - PA
+ *          - EDMA3
+ *          - AIF2
+ *          - TCP3D
+ *          - BCP
+ *          - FFTC
+ *          - VCP
+ *          - SA
+ *          - CIC
+ *          - Timers
+ *          - Semaphores
+ *
+ *  @param[in]  *fmGblCfgParams
+ *      Pointer to the fault managment device specific global configuration parameters 
+ *  @param[in]  *cleanupCfg
+ *      Configuration structure that allows control over which peripheral's should be recovered
+ *      and which peripheral resources to avoid during cleanup.
+ *
+ *  @retval
+ *      Success - #FM_FAULT_CLEANUP_OK
+ *  @retval
+ *      Failure - return value <0
+ */
+extern Fm_Result Fault_Mgmt_faultCleanup(Fm_GlobalConfigParams *fmGblCfgParams, Fm_CleanupCfg *cleanupCfg);
+#endif /* !(K2H && K2K && K2L && K2E) */
+
+/**
+ *  @b Description
+ *  @n  
+ *      The function is used to halt IO processing when a crash occurs.  Currently disables:
+ *          - EDMA3 DMA, QDMA, and INT channels
+ *          - AIF PE/PD channels
+ *          - SGMII switch
+ *          - CPDMA tx/rx channels
+ *
+ *  @param[in]  *fmGblCfgParams
+ *      Pointer to the fault managment device specific global configuration parameters 
+ *  @param[in]  *haltCfg
+ *      Configuration structure that allows control over what portions of the system can be
+ *      disabled.
+ *
+ *  @retval
+ *      Success - #FM_OK
+ *  @retval
+ *      Failure - return value <0 
+ */
+extern Fm_Result Fault_Mgmt_haltIoProcessing(Fm_GlobalConfigParams *fmGblCfgParams, Fm_HaltCfg *haltCfg);
+
+/**
+ *  @b Description
+ *  @n  
+ *      The function is used to get the register status and store it in the fault management
+ *      data region.
+ *
+ *  @retval
+ *      Not Applicable    
+ */
+extern void Fault_Mgmt_getLastRegStatus(void);
+
+/**
+ *  @b Description
+ *  @n  
+ *      The function is used to notify ARM the DSP core has faulted. The fault 
+ *      information collected are read by the ARM from the relevant sections. 
+ *
+ *  @retval
+ *      Not Applicable
+ */
+extern void Fault_Mgmt_notify(void);
+
+/**
+ *  @b Description
+ *  @n  
+ *      The function is used to notify and manually fault a remote DSP core because
+ *      a fault has occurred on the on the local core.  The fault on the remote
+ *      core is generated by a NMI pulse to the GEM. The fault information collected 
+ *      is read by the ARM from the relevant sections. 
+ *
+ *  @retval
+ *      Not Applicable
+ */
+extern void Fault_Mgmt_notify_remote_core(uint32_t core_id);
+
+/**
+ *  @b Description
+ *  @n  
+ *      Returns the required size of the fault management data
+ *      region containing the crash dump data.
+ *
+ *  @retval
+ *      Required size of the fault management crash dump data region in bytes
+ */
+extern uint32_t Fault_Mgmt_getSizes(void);
+
+/**
+@}
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __FAULT_MGMT_H__ */
+
diff --git a/fault_mgmt_osal.h b/fault_mgmt_osal.h
new file mode 100644 (file)
index 0000000..f1112e0
--- /dev/null
@@ -0,0 +1,123 @@
+/**
+ *   @file  fault_mgmt_osal.h
+ *
+ *   @brief   
+ *      This is the sample OS Adaptation layer which is used by the fault management 
+ *      communicator module. The OSAL layer can be ported in either of the following 
+ *      manners to a native OS:
+ *
+ *      <b> Approach 1: </b>
+ *      @n  Use Prebuilt Libraries
+ *           - Ensure that the provide an implementation of all 
+ *             Osal_XXX API for their native OS.
+ *           - Link the prebuilt libraries with their application.
+ *           - Refer to the "example" directory for an example of this
+ *       @n <b> Pros: </b>
+ *           - Customers can reuse prebuilt TI provided libraries
+ *       @n <b> Cons: </b>
+ *           - Level of indirection in the API to get to the actual OS call
+ *              
+ *      <b> Approach 2: </b>
+ *      @n  Rebuilt Library 
+ *           - Create a copy of this file and modify it to directly 
+ *             inline the native OS calls
+ *           - Rebuild the Message communicator; ensure that the Include 
+ *             path points to the directory where the copy of this file 
+ *             has been provided.
+ *           - Please refer to the "test" directory for an example of this 
+ *       @n <b> Pros: </b>
+ *           - Optimizations can be done to remove the level of indirection
+ *       @n <b> Cons: </b>
+ *           - Message communicator Libraries need to be rebuilt by the customer.
+ *
+ *  \par
+ *  NOTE:
+ *      (C) Copyright 2012-2014 Texas Instruments, Inc.
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ifndef __FAULT_MGMT_OSAL_H__
+#define __FAULT_MGMT_OSAL_H__
+
+extern void  Osal_fault_mgmtEndMemAccess(void* ptr, uint32_t size);
+extern void  Osal_fault_mgmtLog (char *fmt, ... );
+
+/** @addtogroup FAULT_MGMT_OSAL_API
+ @{ */
+
+/**
+ * @brief   The macro is used by the Fault Management module to indicate that 
+ * the shared memory access is complete. If the memory block is cached then the 
+ * implementation should writeback the cache contents to ensure that 
+ * the cache and the memory are in sync with each other.
+ *
+ * <b> Prototype: </b>
+ *  The following is the C prototype for the expected OSAL API.
+ *
+ *  @verbatim
+       void  Osal_fault_mgmtEndMemAccess(void* ptr, uint32_t size)
+    @endverbatim
+ *
+ *  <b> Parameter </b>
+ *  @n  ptr  - Pointer to the memory 
+ *  @n  size - Size of the memory
+ *
+ *  <b> Return Value </b>
+ *  @n  None
+ */
+#define Fault_Mgmt_osalEndMemAccess       Osal_fault_mgmtEndMemAccess
+
+/**
+ * @brief   The macro is used by FM to log various 
+ *          messages. 
+ *
+ * <b> Prototype: </b>
+ *  The following is the C prototype for the expected OSAL API.
+ *
+ *  @verbatim
+       void Osal_fault_mgmtLog( char *fmt, ... ) 
+    @endverbatim
+ *
+ *  <b> Parameter </b>
+ *  @n  printf-style format string 
+ *
+ *  <b> Return Value </b>
+ *  @n  Not applicable.
+ */
+#define Fault_Mgmt_osalLog                Osal_fault_mgmtLog
+
+/**
+@}
+*/
+
+#endif /* __FAULT_MGMT_OSAL_H__ */
+
diff --git a/fault_mgmtlibver.h.xdt b/fault_mgmtlibver.h.xdt
new file mode 100644 (file)
index 0000000..cf23d6f
--- /dev/null
@@ -0,0 +1,100 @@
+%%{
+/*!
+ *  This template implements the fault_mgmtlibver.h
+ */  
+  /* Versioning */
+  var ver = this;
+  var ver1 = [00,00,00,00];
+  var ver2 = [00,00,00,00];
+  
+  for each(i=0;i<ver.length;i++)
+  {
+      if(String(ver[i]).length < 2)
+      {
+        ver1[i]="0"+ver[i];
+      }
+      else
+      {
+        ver1[i] = ver[i];
+      }
+      
+      ver2[i] = Number(ver[i]).toString(16).toUpperCase();
+      
+      if(String(ver2[i]).length < 2)
+      {
+        ver2[i]="0"+ver2[i];
+      }
+  }
+  
+  var versionStr = "\""+"Fault Management Lib Revision: "+ver1[0]+"."+ver1[1]+"."+ver1[2]+"."+ver1[3]+"\"";
+  var versionID = "(0x"+ver2[0]+ver2[1]+ver2[2]+ver2[3]+")";
+
+%%}
+#ifndef _FAULT_MGMTLIBVER_H
+#define _FAULT_MGMTLIBVER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ============================================================= */
+/**
+ *   @file  fault_mgmtlibver.h
+ *
+ *   path  ti/instrumentation/fault_mgmt/fault_mgmtlibver.h
+ *
+ *   @brief  Fault Management Library Version Definitions
+ *
+ *  ============================================================================
+ *  Copyright (c) Texas Instruments Incorporated 2009-2015
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+*/
+
+/**
+ * @brief   This is the FAULT MANAGEMENT LIB Version. Versions numbers are encoded in the following 
+ * format:
+ *  0xAABBCCDD -> Arch (AA); API Changes (BB); Major (CC); Minor (DD)
+ */
+#define FAULT_MGMTLIB_VERSION_ID                   `versionID`
+
+/**
+ * @brief   This is the version string which describes the FAULT MANAGEMENT LIB along with the
+ * date and build information.
+ */
+#define FAULT_MGMTLIB_VERSION_STR                  `versionStr`
+
+
+#ifdef __cplusplus
+}
+#endif
+  
+
+#endif  /* _FAULT_MGMTLIBVER_H */
diff --git a/include/Module.xs b/include/Module.xs
new file mode 100644 (file)
index 0000000..7670cfa
--- /dev/null
@@ -0,0 +1,29 @@
+/******************************************************************************
+ * FILE PURPOSE: Fault Management internal include files.
+ ******************************************************************************
+ * FILE NAME: module.xs
+ *
+ * DESCRIPTION: 
+ *  This file contains the module specification for FM include directory
+ *
+ * Copyright (C) 2014, Texas Instruments, Inc.
+ *****************************************************************************/
+
+/* Load the library utility. */
+var libUtility = xdc.loadCapsule ("../build/buildlib.xs");
+
+/**************************************************************************
+ * FUNCTION NAME : modBuild
+ **************************************************************************
+ * DESCRIPTION   :
+ *  The function is used to add all the header files in the include 
+ *  directory into the package.
+ **************************************************************************/
+function modBuild() 
+{
+    /* Add all the .h files to the release package. */
+    var testFiles = libUtility.listAllFiles (".h", "include", true);
+    for (var k = 0 ; k < testFiles.length; k++)
+        Pkg.otherFiles[Pkg.otherFiles.length++] = testFiles[k];
+}
+
diff --git a/include/fm_cleanloc.h b/include/fm_cleanloc.h
new file mode 100644 (file)
index 0000000..c063da1
--- /dev/null
@@ -0,0 +1,84 @@
+/*
+ *  file  fm_cleanloc.h
+ *
+ *  Internal prototypes and data structures for Fault Management fault 
+ *  cleanup.
+ *
+ *  ============================================================================
+ *      (C) Copyright 2014, Texas Instruments, Inc.
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  \par
+*/
+
+#ifndef FM_CLEANLOC_H_
+#define FM_CLEANLOC_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CSL Includes */
+#include <ti/csl/csl_cppi.h>
+
+/* FM external includes */
+#include <ti/instrumentation/fault_mgmt/fault_mgmt.h>
+
+uint32_t fmGetDmaMaxRxCh(Cppi_CpDma dmaNum);
+uint32_t fmGetDmaMaxTxCh(Cppi_CpDma dmaNum);
+
+Fm_Result fmCleanupInit(uint32_t fullInit);
+Fm_Result fmCleanCppi(Fm_ExcludedResource *excludedResList, uint32_t listSize);
+Fm_Result fmCleanQmssAccum(Fm_GlobalConfigParams *fmGblCfgParams, Fm_ExcludedResource *excludedResList,
+                           uint32_t listSize);
+Fm_Result fmCleanQmssQueue(Fm_GlobalConfigParams *fmGblCfgParams, Fm_ExcludedResource *excludedResList,
+                           uint32_t listSize);
+Fm_Result fmCleanPa(Fm_GlobalConfigParams *fmGblCfgParams, Fm_ExcludedResource *excludedResList, 
+                    uint32_t listSize);
+Fm_Result fmCleanSa(Fm_ExcludedResource *excludedResList, uint32_t listSize);
+Fm_Result fmCleanEdma3(Fm_GlobalConfigParams *fmGblCfgParams, Fm_ExcludedResource *excludedResList,
+                       uint32_t listSize, uint32_t provideStatus);
+Fm_Result fmCleanSemaphores(Fm_ExcludedResource *excludedResList, uint32_t listSize);
+Fm_Result fmCleanCics(Fm_GlobalConfigParams *fmGblCfgParams, Fm_ExcludedResource *excludedResList,
+                      uint32_t listSize);
+Fm_Result fmCleanTimers(Fm_GlobalConfigParams *fmGblCfgParams, Fm_ExcludedResource *excludedResList,
+                        uint32_t listSize);
+Fm_Result fmCleanAif2(void);
+Fm_Result fmCleanTcp3d(void);
+Fm_Result fmCleanBcp(void);
+Fm_Result fmCleanFftc(void);
+Fm_Result fmCleanVcp(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FM_CLEANLOC_H_ */
+
diff --git a/include/fm_exclusionloc.h b/include/fm_exclusionloc.h
new file mode 100644 (file)
index 0000000..3e7615f
--- /dev/null
@@ -0,0 +1,96 @@
+/*
+ *  file  fm_exclusionloc.h
+ *
+ *  Internal prototypes and data structures for Fault Management resource
+ *  exclusion from IO halt and fault recovery features.
+ *
+ *  ============================================================================
+ *      (C) Copyright 2014, Texas Instruments, Inc.
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  \par
+*/
+
+#ifndef FM_EXCLUSIONLOC_H_
+#define FM_EXCLUSIONLOC_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if (!defined(DEVICE_K2H) && !defined(DEVICE_K2K) && !defined(DEVICE_K2L) && !defined(DEVICE_K2E)) 
+/* CSL Includes */
+#include <ti/csl/csl_cppi.h>
+#else
+#include <ti/drv/cppi/cppi_drv.h>
+#endif
+
+/* FM external includes */
+#include <ti/instrumentation/fault_mgmt/fault_mgmt.h>
+
+typedef struct {
+    Cppi_CpDma dma;
+} Fm_ExclusionCpdmaParams;
+
+typedef struct {
+    CSL_InstNum edma3Num;
+} Fm_ExclusionEdma3Params;
+
+typedef struct {
+    int32_t lutInst;
+} Fm_ExclusionLutEntryParams;
+
+typedef struct {
+    int32_t cic;
+} Fm_ExclusionCicParams;
+
+typedef struct {
+    Fm_ResType           resType;
+    Fm_ExcludedResource *exclusionList;
+    uint32_t             numListEntries;
+    uint32_t             resourceNum;
+    union {
+        Fm_ExclusionCpdmaParams    cpdmaParams;
+        Fm_ExclusionEdma3Params    edma3Params;
+        Fm_ExclusionLutEntryParams lutParams;
+        Fm_ExclusionCicParams      cicParams;
+    } u;
+} Fm_ExclusionParams;
+
+uint32_t fmExclusionValidateList(Fm_GlobalConfigParams *fmGblCfgParams, Fm_ExcludedResource *exResList, 
+                                 int32_t *status);
+uint32_t fmExclusionIsExcluded(Fm_ExclusionParams *exParams);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FM_EXCLUSIONLOC_H_ */
+
diff --git a/include/fm_loc.h b/include/fm_loc.h
new file mode 100644 (file)
index 0000000..192964d
--- /dev/null
@@ -0,0 +1,68 @@
+/*
+ *  file  fm_loc.h
+ *
+ *  Internal prototypes and data structures for Fault Management.
+ *
+ *  ============================================================================
+ *      (C) Copyright 2014 - 2015, Texas Instruments, Inc.
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  \par
+*/
+
+#ifndef FM_LOC_H_
+#define FM_LOC_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if (!defined(DEVICE_K2H) && !defined(DEVICE_K2K) && \
+     !defined(DEVICE_K2L) && !defined(DEVICE_K2E))
+#include <ti/csl/csl_cppi.h>
+#else
+#include <ti/drv/cppi/cppi_drv.h>
+#endif
+
+#define FM_FALSE 0
+#define FM_TRUE  1
+
+/* Fault interrupt to Host is above the bits used by regular IPC. This is the
+ * offset to be used for setting the IPCGRH register bit */
+#define FM_HOST_IPCGR_OFFSET 8
+
+uint32_t fmIsWirelessPeriphPoweredOnForCpdma(Cppi_CpDma dmaNum);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FM_LOC_H_ */
+
diff --git a/package.bld b/package.bld
new file mode 100644 (file)
index 0000000..b6da10f
--- /dev/null
@@ -0,0 +1,179 @@
+/******************************************************************************
+ * FILE PURPOSE: Build description for the Fault Management
+ ******************************************************************************
+ * FILE NAME: package.bld
+ *
+ * DESCRIPTION: 
+ *  This file contains the build specification and description for the 
+ *  Packet Library
+ *  
+ *  The file takes the following parameters from the command line through the
+ *  XDCARGS variable.
+ *      XDCARGS[0] = Consumer Library Install Type 
+ *      Valid Values are "TAR" or "SETUP"
+ *      DEFAULT is "SETUP"
+ *
+ *  Example for a valid command:
+ *      xdc XDCARGS="SETUP" release   
+ *
+ * Copyright (C) 2012-2014 Texas Instruments, Inc.
+ *****************************************************************************/
+
+/* List of all subdirectories that combine to make the Fault Management Package. */
+var subDirectories = [ "src", "docs", "device", "test", "include", "util"];
+
+/* Determine if we need to create the InstallJammer Application or not? 
+ * Fault Management Deliverables be either of the following formats:
+ *  - TAR Ball Package
+ *  - Setup Executable 
+ * DEFAULT is a TAR Executable. */
+
+if ((arguments[0] != "TAR") && (arguments[0] != "SETUP"))
+    fault_mgmtlibInstallType = "TAR";
+else
+    fault_mgmtlibInstallType = arguments[0];
+
+/* Irrespective of the InstallType we always create a TAR Ball Package as a part
+ * of the RTSC Build. Here we determine the name of the TAR Ball Package
+ *  Format is as follows:
+ *      fault_mgmtlib_<version> */
+var fault_mgmtlibRTSCFileName = "fault_mgmtlib" + "_" + fault_mgmtlibPartNumber + "_" +
+                      fault_mgmtlibReleaseVersion[0] + "_" +  fault_mgmtlibReleaseVersion[1] + "_" + 
+                      fault_mgmtlibReleaseVersion[2]  + "_" + fault_mgmtlibReleaseVersion[3];
+
+/*****************************************************************
+ ************************ Release Banner *************************
+ *****************************************************************/
+
+print ("************* Fault Management Library Build Information *************");
+print ("Fault Management Lib Install : " + fault_mgmtlibInstallType);
+print ("Fault Management Lib Version : " + fault_mgmtlibReleaseVersion);
+print ("Tools Directory              : " + toolsBaseDir);
+print ("RTSC File Name              : " + fault_mgmtlibRTSCFileName);
+print ("Fault Management Lib Path    : " + fault_mgmtlibPath);
+print ("Coverity Analysis            : " + (coverityAnalysis == "ON" ? "ON" : "OFF"));
+print ("C66  LE opts                 : " + C66LE.ccOpts.prefix);
+print ("C66  BE opts                 : " + C66BE.ccOpts.prefix);
+print ("***********************************************************");
+
+/* Create the release package for the Fault Management Library */
+Pkg.defaultRelease = Pkg.addRelease (fault_mgmtlibRTSCFileName, {prefix: "./packages/"});
+
+/* Moving forward we need to set the Archiver of the package to be ZIP. This is currently
+ * not supported in the XDC tools being used. Currenly builds need to be done with the 
+ * following options:-
+ *   xdc MK_FIXLISTOPTS=-t release 
+ * ZIP is a better option as it works natively with INSTALL Jammer and we can remove the
+ * uncompression into a temporary directory. XDC Tools with xdc-rXX support the ZIP archiver. */
+//Pkg.attrs = {archiver : "zip"};
+
+/* Cycle through all the sub-directories and build all the files */
+for (var i = 0; i < subDirectories.length; i++) 
+{
+    /* Load the capsule in the sub directory. */
+    var caps = xdc.loadCapsule (subDirectories[i]+"/Module.xs");
+
+    print ("Building directory " + subDirectories[i]);
+
+    /* Build the capsule. */
+    caps.modBuild();
+
+    /* Package the module.xs files for building via package */
+    Pkg.otherFiles[Pkg.otherFiles.length++] = subDirectories[i]+"/Module.xs";
+}
+
+/* Package the remaining files */
+Pkg.otherFiles[Pkg.otherFiles.length++] = "config.bld";
+Pkg.otherFiles[Pkg.otherFiles.length++] = "package.bld";
+Pkg.otherFiles[Pkg.otherFiles.length++] = "package.xdc";
+Pkg.otherFiles[Pkg.otherFiles.length++] = "Settings.xdc";
+Pkg.otherFiles[Pkg.otherFiles.length++] = "fault_mgmt.h";
+Pkg.otherFiles[Pkg.otherFiles.length++] = "fault_mgmt_osal.h";
+Pkg.otherFiles[Pkg.otherFiles.length++] = "fault_mgmtlibver.h";
+Pkg.otherFiles[Pkg.otherFiles.length++] = "docs/Doxyfile";
+Pkg.otherFiles[Pkg.otherFiles.length++] = "build/buildlib.xs";
+Pkg.otherFiles[Pkg.otherFiles.length++] = "docs/ReleaseNotes_fault_mgmt.pdf";
+Pkg.otherFiles[Pkg.otherFiles.length++] = "makefile";
+
+/* Generate Users Manual Doxyfile */
+var tplt = xdc.loadTemplate("./docs/doxyfile.xdt");
+tplt.genFile("./docs/Doxyfile",fault_mgmtlibReleaseVersion); 
+
+/* Generate Settings.xdc */
+var tplt = xdc.loadTemplate("./Settings.xdc.xdt");
+tplt.genFile("./Settings.xdc",fault_mgmtlibReleaseVersion); 
+
+/* Generate fault_mgmtlibver.h */
+var tplt = xdc.loadTemplate("./fault_mgmtlibver.h.xdt");
+tplt.genFile("./fault_mgmtlibver.h",fault_mgmtlibReleaseVersion);      
+
+/* Check if we need to create the mini package? */
+var miniBuild = java.lang.System.getenv("MINI_PACKAGE");
+
+if (miniBuild == "ON")
+{
+    /***************************************************************************
+     ********************************* MINI Package ****************************
+     ***************************************************************************/
+    /* Create the MINI RTSC Package */
+    var libUtility = xdc.loadCapsule ("build/buildlib.xs");
+    libUtility.createMiniPkg(fault_mgmtlibRTSCFileName);
+}
+
+/********************************************************************* 
+ *********************** INSTALL-JAMMER Support **********************
+ * In order to create the InstallJammer Application; we need to UNTAR
+ * the package into a temporary directory. This is required because 
+ * currently the InstallJammer does not support the TAR Files and thus
+ * creating an UNTAR of the file. So to work-around the problem we will
+ * do the following in the EPILOGUE Section:-
+ *  (a) Create a temporary directory called 'tmp'
+ *  (b) UNTAR the package into 'tmp'
+ *  (c) Run the INSTALL Jammer on 'tmp'
+ *  (d) Remove the 'tmp' directory.
+ *
+ * This can be done only after the 'release' package has been created.
+ * Thus all of this work is being done in the EPILOGUE.
+ *********************************************************************/
+if (fault_mgmtlibInstallType == "SETUP")
+{
+    /* Create the Install Jammer Version Variable. This is used inside the 
+     * MPI File to create the Final executable. 
+     *  The format supported is as follows:-
+     *   - setupwin32_fault_mgmtlib-<part_number>-<version>.exe 
+     *      This is for Fault Management Libraries and Header files
+     */
+    var InstallJammerVersion = "-DVersion " + fault_mgmtlibPartNumber + "_" +
+                               fault_mgmtlibReleaseVersion[0] + "_" +  fault_mgmtlibReleaseVersion[1]  + "_" + 
+                               fault_mgmtlibReleaseVersion[2]  + "_" + fault_mgmtlibReleaseVersion[3];
+
+    /* This is the location where the tmp directory is located; this is used as 
+     * the input directory for the Install Jammer. */ 
+    var PackageBaseDir = " -DPackageBaseDir " + fault_mgmtlibPath + "./tmp";
+
+    /* This is the location where the Fault Management will be installed by default. */
+    var WinInstallDir = " -DWinInstallDir C:/Program Files/Texas Instruments/fault_mgmtlib" + "_" + 
+                            fault_mgmtlibPartNumber + "_" + 
+                            fault_mgmtlibReleaseVersion[0] + "_" + fault_mgmtlibReleaseVersion[1] + "_" +  
+                            fault_mgmtlibReleaseVersion[2]  + "_" + fault_mgmtlibReleaseVersion[3];
+
+    /* Create the actual EPILOGUE Section for the INSTALLER */
+    Pkg.makeEpilogue += "release: install_application\n";
+    Pkg.makeEpilogue += "install_application:\n";
+    Pkg.makeEpilogue += "\t @echo -------------------------------------------------------\n";
+    Pkg.makeEpilogue += "\t @echo Creating the Install\n";
+    Pkg.makeEpilogue += "\t @echo -------------------------------------------------------\n";
+    Pkg.makeEpilogue += "\t -$(MKDIR) tmp\n";
+    Pkg.makeEpilogue += "\t -$(MKDIR) tmp/packages\n";
+    Pkg.makeEpilogue += "\t -$(MKDIR) tmp/eclipse\n";
+    Pkg.makeEpilogue += "\t -$(CP) -R eclipse tmp\n";
+    Pkg.makeEpilogue += "\t tar -xf ./packages/" + fault_mgmtlibRTSCFileName + ".tar" + " -Ctmp/packages \n";
+    Pkg.makeEpilogue += "\t installjammer " + InstallJammerVersion + PackageBaseDir + WinInstallDir + 
+                        " --output-dir packages/ --build install/fault_mgmtlib.mpi\n";
+    Pkg.makeEpilogue += "\t -$(RMDIR) /S /Q tmp\n\n";
+
+/* We need to clean after ourselves; extend the 'clean' target to take care of this. */
+Pkg.makeEpilogue += "clean::\n";
+    Pkg.makeEpilogue += "\t -$(RM) packages/*.exe\n";
+    Pkg.makeEpilogue += "\t -$(RM) packages/*.bin\n";
+}
diff --git a/package.xdc b/package.xdc
new file mode 100644 (file)
index 0000000..0f465da
--- /dev/null
@@ -0,0 +1,15 @@
+/******************************************************************************
+ * FILE PURPOSE: Package specification file 
+ ******************************************************************************
+ * FILE NAME: package.xdc
+ *
+ * DESCRIPTION: 
+ *  This file contains the package specification for the Fault Management
+ *
+ * Copyright (C) 2012-2015 Texas Instruments, Inc.
+ *****************************************************************************/
+
+package ti.instrumentation.fault_mgmt[1, 0, 1, 2] {
+    module Settings;
+}
+
diff --git a/package.xs b/package.xs
new file mode 100644 (file)
index 0000000..1e36ef2
--- /dev/null
@@ -0,0 +1,74 @@
+/*
+ *  ======== package.xs ========
+ *
+ */
+
+
+/*
+ *  ======== Package.getLibs ========
+ *  This function is called when a program's configuration files are
+ *  being generated and it returns the name of a library appropriate
+ *  for the program's configuration.
+ */
+
+function getLibs(prog)
+{
+
+    var suffix = prog.build.target.suffix;
+
+    /* Default FM library */
+    var name = this.$name + ".a" + suffix;
+    /* Read LIBDIR variable */
+    var lib = java.lang.System.getenv("LIBDIR");
+
+    /* If NULL, default to "lib" folder */
+    if (lib == null)
+    {
+        lib = "./lib";
+    } else {
+        print ("\tSystem environment LIBDIR variable defined : " + lib);
+    }
+
+    /* Device types supported */
+    var deviceTypes = [
+                        'tci6614',    
+                        'k2k',
+                        'k2h',
+                        'k2l',
+                        'k2e',
+                      ];
+
+    /* Search for the supported devices (defined in config.bld) */
+    for each(var device in deviceTypes)
+    {
+        if (this.Settings.deviceType.equals(device))
+        {
+            lib = lib + "/" + device;
+            break;
+        }
+    }
+
+    /* Get target folder, if applicable */
+    if ( java.lang.String(suffix).contains('66') )
+        lib = lib + "/c66";
+
+    /* Get library name with path */
+    lib = lib + "/" + name;
+    if (java.io.File(this.packageBase + lib).exists()) {
+       print ("\tLinking with library " + this.$name + ":" + lib);
+       return lib;
+    }
+
+    /* Could not find any library, throw exception */
+    throw new Error("\tLibrary not found : " + name);
+}
+
+/*
+ *  ======== package.close ========
+ */
+function close()
+{    
+    if (xdc.om.$name != 'cfg') {
+        return;
+    }
+}
diff --git a/src/Module.xs b/src/Module.xs
new file mode 100644 (file)
index 0000000..4bc6c8d
--- /dev/null
@@ -0,0 +1,58 @@
+/******************************************************************************
+ * FILE PURPOSE: Fault Management Source module specification file.
+ ******************************************************************************
+ * FILE NAME: module.xs
+ *
+ * DESCRIPTION: 
+ *  This file contains the module specification for the Fault Management source directory.
+ *
+ * Copyright (C) 2012-2014 Texas Instruments, Inc.
+ *****************************************************************************/
+
+/* Load the library utility. */
+var libUtility = xdc.loadCapsule ("../build/buildlib.xs");
+
+var fault_mgmtLibFiles = [
+                    "src/fault_mgmt.c",
+                    "src/fm_clean.c",
+                    "src/fm_exclusion.c",
+                    ];
+
+/**************************************************************************
+ * FUNCTION NAME : modBuild
+ **************************************************************************
+ * DESCRIPTION   :
+ *  The function is used to build all the components of the Fault
+ *  Management library
+ **************************************************************************/
+function modBuild() 
+{
+    /* Build the libraries for all the targets specified. */
+    for (var device=0; device < devices.length; device++) 
+    {
+        /* Only build libraries within the specified SOC Family */
+        if (devicesSocFamily[device] == fault_mgmtlibSocFamily)
+        {
+            /* Build the libraries for all the targets specified. */
+            for (var targets=0; targets < Build.targets.length; targets++)
+            {
+                var libOptions = {
+                    copts: devicesCCOpt[device],
+                    incs: fault_mgmtlibIncludePath, 
+                };
+           
+                libUtility.buildLibrary (devices[device], libOptions, "ti.instrumentation.fault_mgmt", Build.targets[targets], fault_mgmtLibFiles);       
+            }
+        }
+    }
+
+    /* Add all the .c files to the release package. */
+    var testFiles = libUtility.listAllFiles (".c", "src", true);
+    for (var k = 0 ; k < testFiles.length; k++)
+        Pkg.otherFiles[Pkg.otherFiles.length++] = testFiles[k];
+
+    /* Add all the .h files to the release package. */
+    var testFiles = libUtility.listAllFiles (".h", "src", true);
+    for (var k = 0 ; k < testFiles.length; k++)
+        Pkg.otherFiles[Pkg.otherFiles.length++] = testFiles[k];        
+}
diff --git a/src/fault_mgmt.c b/src/fault_mgmt.c
new file mode 100644 (file)
index 0000000..a5fb8ad
--- /dev/null
@@ -0,0 +1,712 @@
+/**
+ *   @file  fault_mgmt.c
+ *
+ *   @brief   
+ *      The file implements the Fault Management library.
+ *
+ *  \par
+ *  NOTE:
+ *      (C) Copyright 2012-2015 Texas Instruments, Inc.
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/**************************************************************************
+ *************************** Include Files ********************************
+ **************************************************************************/
+
+/* Standard Include Files. */
+#include <string.h>
+#include <stdio.h>
+
+/* BIOS/XDC Include Files. */
+#include <ti/sysbios/family/c64p/Exception.h>
+
+/* CSL Include Files. */
+#include <ti/csl/csl_chip.h>
+#include <ti/csl/csl_cacheAux.h>
+#include <ti/csl/csl_ipcAux.h>
+#include <ti/csl/csl_cppi.h>
+#include <ti/csl/csl_cpsgmiiAux.h>
+#include <ti/csl/csl_edma3Aux.h>
+#include <ti/csl/csl_pscAux.h>
+
+/* LLD Includes */
+#include <ti/drv/cppi/cppi_drv.h>
+#include <ti/drv/aif2/aif2.h>
+
+/* FM API Include */
+#include <ti/instrumentation/fault_mgmt/fault_mgmt.h>
+
+/* FM Internal Include */
+#include <ti/instrumentation/fault_mgmt/include/fm_loc.h>
+#include <ti/instrumentation/fault_mgmt/include/fm_exclusionloc.h>
+#include <ti/instrumentation/fault_mgmt/include/fm_cleanloc.h>
+
+/* Fault Management OSAL File. */
+#include <fault_mgmt_osal.h>
+
+/**************************************************************************
+ ********************** Internal Data Structures **************************
+ **************************************************************************/
+
+/* Note section name length in bytes (chars). */
+#define NOTE_NAME_LEN 32
+
+/* Structure specifying the ELF program header Note section header.
+ *           ELF Note Section:
+ *
+ *           byte      +0        +1       +2        +3
+ *                  +--------+--------+---------+--------+
+ *           namesz | # bytes in name field excluding pad|    
+ *                  +--------+--------+---------+--------+
+ *           descsz | # bytes in desc field excluding pad|
+ *                  +--------+--------+---------+--------+
+ *           type   |      Not Used (should be zero)     |
+ *                  +--------+--------+---------+--------+
+ *           name   | char 0 | char 1 | char 2  | char 3 |
+ *                  +--------+--------+---------+--------+
+ *                  | char 4 |  ...   | char n  |  pad   |      
+ *                  +--------+--------+---------+--------+
+ *           desc   |              word 0                |   
+ *                  +--------+--------+---------+--------+
+ *                  |              word 1                |
+ *                  +--------+--------+---------+--------+
+ */
+typedef struct
+{
+    uint32_t namesz;
+    uint32_t descsz;
+    uint32_t type;
+} elfNoteHeader;
+
+/**********************************************************************
+ ************************** Globals ***********************************
+ **********************************************************************/
+
+#pragma DATA_ALIGN   (fault_mgmt_data, CACHE_L2_LINESIZE)
+#pragma DATA_SECTION (fault_mgmt_data, ".note");
+uint8_t          fault_mgmt_data[FAULT_MGMT_DATA_SIZE];
+
+#if (!defined(DEVICE_K2H) && !defined(DEVICE_K2K) && \
+     !defined(DEVICE_K2L) && !defined(DEVICE_K2E))
+/* Cache line aligned and padded */
+#pragma DATA_ALIGN   (fmCleanupStatus, CACHE_L2_LINESIZE)
+#pragma DATA_SECTION (fmCleanupStatus, ".fm_cleanup_status");
+int32_t          fmCleanupStatus[32];
+#endif /* !(K2H && K2K && K2L && K2E) */
+
+/* Heap needed to initialize CPPI prior to IO halt execution */
+uint8_t          tempCppiHeap[32000];
+
+/* AIF configuration object.  Defined as global because it's a large object
+ * that may cause overflow in smaller stacks */
+AIF_ConfigObj    localAifObj;
+
+/**********************************************************************
+ ******************** External Variables ******************************
+ **********************************************************************/
+
+/* CPPI Global configuration parameters */
+extern Cppi_GlobalConfigParams cppiGblCfgParams[];
+
+/**********************************************************************
+ ************************ Local Functions *****************************
+ **********************************************************************/
+
+/* FUNCTION PURPOSE: Disables a given CPDMA channel
+ ***********************************************************************
+ * DESCRIPTION: Opens then disables a specified CPDMA channel
+ */
+static void disableDmaCh(Cppi_Handle cppiHandle, int32_t dmaNum,
+                         int32_t chNum, uint32_t isRxCh)
+{
+    Cppi_RxChInitCfg rxChCfg;
+    Cppi_TxChInitCfg txChCfg;
+    Cppi_ChHnd       chHandle;
+    uint8_t          isAllocated;
+    Cppi_Result      cppiResult;
+
+    if (isRxCh) {
+        memset((void *) &rxChCfg, 0, sizeof(rxChCfg));
+        rxChCfg.channelNum = chNum;
+        
+        if (chHandle = Cppi_rxChannelOpen(cppiHandle, &rxChCfg, &isAllocated)) {
+            if(cppiResult = Cppi_channelDisable(chHandle) != CPPI_SOK) {
+                Fault_Mgmt_osalLog("IO Halt: Failed to disable cppi rx ch %d "
+                                   "with err %d\n", chNum, cppiResult);
+            }
+        } else {
+            Fault_Mgmt_osalLog("IO Halt: "
+                               "Failed to open DMA %d, RX channel %d\n",
+                               dmaNum, chNum);
+        }
+    } else {
+        memset((void *) &txChCfg, 0, sizeof(txChCfg));
+        txChCfg.channelNum = chNum;
+
+        if (chHandle = Cppi_txChannelOpenWithHwCfg(cppiHandle, &txChCfg,
+                                                   &isAllocated, 0)) {
+            if(cppiResult = Cppi_channelDisable(chHandle) != CPPI_SOK) {
+                Fault_Mgmt_osalLog("IO Halt: Failed to disable cppi tx ch %d "
+                                   "with err %d\n", chNum, cppiResult);
+            }
+        } else {
+            Fault_Mgmt_osalLog("IO Halt: "
+                               "Failed to open DMA %d, TX channel %d\n",
+                               dmaNum, chNum);
+        }
+    }
+}
+
+/* FUNCTION PURPOSE: Creates the note header
+ ***********************************************************************
+ * DESCRIPTION: Creates the note header.  Only the fault data region 
+ *              size if calculated if NULL is provided for the 
+ *              fault data region pointer.
+ */
+static uint32_t createNoteHeader(uint32_t **pFaultDataPtr)
+{
+    elfNoteHeader  noteHeader;
+    char           elfNoteName[NOTE_NAME_LEN];
+    uint32_t       totalBytes = 0;
+    uint32_t      *locPtr = NULL;
+
+    if (pFaultDataPtr) {
+        locPtr = *pFaultDataPtr;
+    }
+
+    memset((void *)&noteHeader, 0, sizeof(noteHeader));
+    totalBytes = sizeof(noteHeader);
+
+    sprintf(elfNoteName, "Core%d", DNUM);
+    noteHeader.namesz = strlen(elfNoteName) + 1;
+    totalBytes += noteHeader.namesz;
+    if (locPtr) {
+        *locPtr++ = noteHeader.namesz;
+    }
+    
+    /* Calculate size of desc section.  Subtract out size of pointer to
+     * Exception_Context structure since that structure is added in entirety.
+     * Add an additional uint32_t for PC value that is added.  The PC is not
+     * tracked by the Exception Status or Context*/
+    noteHeader.descsz = (sizeof(ti_sysbios_family_c64p_Exception_Status) -
+                         sizeof(ti_sysbios_family_c64p_Exception_Context *)) +
+                        sizeof (ti_sysbios_family_c64p_Exception_Context) +
+                        sizeof (uint32_t);
+    totalBytes += noteHeader.descsz;
+
+    /* noteHeader type should always be 0 */
+    noteHeader.type = 0;
+    if (locPtr) {
+        *locPtr++ = noteHeader.descsz;
+        *locPtr++ = noteHeader.type;
+    }
+
+    if (locPtr) {
+        memcpy ((void *)locPtr, (void *)&elfNoteName[0], noteHeader.namesz);
+        locPtr += (noteHeader.namesz/sizeof(noteHeader.namesz));
+    }
+    
+    /* Account for name padding */
+    if (noteHeader.namesz % sizeof(noteHeader.namesz)) {
+        totalBytes += (sizeof(noteHeader.namesz) -
+                       (noteHeader.namesz % sizeof(noteHeader.namesz)));
+        if (locPtr) {
+            locPtr++;
+        }
+    }
+
+    if (locPtr) {
+        *pFaultDataPtr = locPtr;
+    }
+    return(totalBytes);
+}
+
+/**********************************************************************
+ ********************** FM-Visible Functions **************************
+ **********************************************************************/
+
+/* FUNCTION PURPOSE: Checks if a wireless peripheral is powered on
+ ***********************************************************************
+ * DESCRIPTION: Checks if a wireless peripheral is powered on via the
+ *              PSC registers
+ */
+uint32_t fmIsWirelessPeriphPoweredOnForCpdma(Cppi_CpDma dmaNum)
+{
+#ifndef DEVICE_K2E
+    uint32_t pwrDmnNum;
+    uint32_t moduleNum;
+
+    switch (dmaNum) {
+#if (defined(DEVICE_K2H) || defined(DEVICE_K2K))
+        /* K2 devices */
+        case Cppi_CpDma_AIF_CPDMA:
+            pwrDmnNum = CSL_PSC_PD_AIF;
+            moduleNum = CSL_PSC_LPSC_AIF;
+            break;
+        case Cppi_CpDma_FFTC_A_CPDMA:
+            pwrDmnNum = CSL_PSC_PD_FFTC_01;
+            moduleNum = CSL_PSC_LPSC_FFTC_0;
+            break;
+        case Cppi_CpDma_FFTC_B_CPDMA:
+            pwrDmnNum = CSL_PSC_PD_FFTC_01;
+            moduleNum = CSL_PSC_LPSC_FFTC_1;
+            break;
+        case Cppi_CpDma_FFTC_C_CPDMA:
+            pwrDmnNum = CSL_PSC_PD_FFTC_2345;
+            moduleNum = CSL_PSC_LPSC_FFTC_2;
+            break;
+        case Cppi_CpDma_FFTC_D_CPDMA:
+            pwrDmnNum = CSL_PSC_PD_FFTC_2345;
+            moduleNum = CSL_PSC_LPSC_FFTC_3;
+            break;
+        case Cppi_CpDma_FFTC_E_CPDMA:
+            pwrDmnNum = CSL_PSC_PD_FFTC_2345;
+            moduleNum = CSL_PSC_LPSC_FFTC_4;
+            break;
+        case Cppi_CpDma_FFTC_F_CPDMA:
+            pwrDmnNum = CSL_PSC_PD_FFTC_2345;
+            moduleNum = CSL_PSC_LPSC_FFTC_5;
+            break;
+#elif (defined(DEVICE_K2L))
+        case Cppi_CpDma_FFTC_A_CPDMA:
+            pwrDmnNum = CSL_PSC_PD_FFTC_0;
+            moduleNum = CSL_PSC_LPSC_FFTC_0;
+            break;
+#elif (!defined(DEVICE_K2E))
+        /* Appleton */
+        case Cppi_CpDma_AIF_CPDMA:
+            pwrDmnNum = CSL_PSC_PD_AI;
+            moduleNum = CSL_PSC_LPSC_AI;
+            break;
+        case Cppi_CpDma_FFTC_A_CPDMA:
+        case Cppi_CpDma_FFTC_B_CPDMA:
+            pwrDmnNum = CSL_PSC_PD_FFTC_AB;
+            moduleNum = CSL_PSC_LPSC_FFTC_AB;
+            break;
+#endif
+        case Cppi_CpDma_BCP_CPDMA:
+            pwrDmnNum = CSL_PSC_PD_BCP;
+            moduleNum = CSL_PSC_LPSC_BCP;
+            break;
+        default:
+            return (FM_TRUE);
+    }
+
+    /* Get peripheral PSC status */
+    if ((CSL_PSC_getPowerDomainState(pwrDmnNum) == PSC_PDSTATE_ON) &&
+        (CSL_PSC_getModuleState (moduleNum) == PSC_MODSTATE_ENABLE)) {
+        /* On */
+        return (FM_TRUE);
+    } else {
+        /* Off */
+        return (FM_FALSE);
+    }
+#else
+    return (FM_TRUE);
+#endif
+}
+
+/**********************************************************************
+ ********************** Application Visible APIs **********************
+ **********************************************************************/
+
+#if (!defined(DEVICE_K2H) && !defined(DEVICE_K2K) && \
+     !defined(DEVICE_K2L) && !defined(DEVICE_K2E))
+/* FUNCTION PURPOSE: Resets system peripherals to their power on reset state
+ ***********************************************************************
+ * DESCRIPTION: Can be called to reset system peripherals to their power on
+ *              reset state.  After a DSP local reset an application that
+ *              uses system peripherals can be loaded without fear of a 
+ *              corrupted peripheral state.
+ */
+Fm_Result Fault_Mgmt_faultCleanup(Fm_GlobalConfigParams *fmGblCfgParams,
+                                  Fm_CleanupCfg *cleanupCfg)
+{
+    uint32_t  numEntries;
+    int32_t   validateStatus;
+    uint32_t  fullInit = FM_TRUE;
+    Fm_Result retVal = FM_FAULT_CLEANUP_OK;
+
+    /* Writeback status so that Host can view it */
+    fmCleanupStatus[0] = FM_OK;
+    Fault_Mgmt_osalEndMemAccess(&fmCleanupStatus[0], sizeof(fmCleanupStatus));
+
+    /* Validate exclusion entries and return number of entries */
+    numEntries = fmExclusionValidateList(fmGblCfgParams,
+                                         cleanupCfg->excludedResources,
+                                         &validateStatus);
+    if (validateStatus < 0) {
+        Fault_Mgmt_osalLog("Fault Cleanup: Failed because entry %d (base 0) "
+                           "of exclusion list has invalid exResInfo field\n",
+                           numEntries);
+        retVal = validateStatus;
+        goto errorExit;
+    }
+
+    /* Do not do full initializtion of peripherals if there are excluded
+     * resources.  This means the peripherals have already been configured */
+    if (numEntries) {
+        fullInit = FM_FALSE;
+    }
+
+    /* Clean sems first since they may be used in LLD OSAL layers */
+    if ((retVal = fmCleanSemaphores(cleanupCfg->excludedResources,
+                                    numEntries)) != FM_FAULT_CLEANUP_OK) {
+        goto errorExit;
+    }
+    /* Stop all timers */
+    if ((retVal = fmCleanTimers(fmGblCfgParams, cleanupCfg->excludedResources,
+                                numEntries)) != FM_FAULT_CLEANUP_OK) {
+        goto errorExit;
+    }
+
+    /* Init CPPI, QMSS, etc data structures for cleanup */
+    if ((retVal = fmCleanupInit(fullInit)) != FM_FAULT_CLEANUP_OK) {
+        goto errorExit;
+    }
+
+    /* Shut down all the wireless peripherals first (Expectation is any app
+     * using them will power them on at init) AIF gets cleaned first since it
+     * is the heartbeat for all wireless peripherals.  The wireless peripherals
+     * will be in an "idle" state after the AIF is cleaned */
+    if (cleanupCfg->cleanAif2) {
+        if ((retVal = fmCleanAif2()) != FM_FAULT_CLEANUP_OK) {
+            goto errorExit;
+        }
+    }
+    if (cleanupCfg->cleanTcp3d) {
+        if ((retVal = fmCleanTcp3d()) != FM_FAULT_CLEANUP_OK) {
+            goto errorExit;
+        }
+    }
+    if (cleanupCfg->cleanBcp) {
+        if ((retVal = fmCleanBcp()) != FM_FAULT_CLEANUP_OK) {
+            goto errorExit;
+        }
+    }
+    if (cleanupCfg->cleanFftc) {
+        if ((retVal = fmCleanFftc()) != FM_FAULT_CLEANUP_OK) {
+            goto errorExit;
+        }
+    }
+    if (cleanupCfg->cleanVcp) {
+        if ((retVal = fmCleanVcp()) != FM_FAULT_CLEANUP_OK) {
+            goto errorExit;
+        }
+    }
+
+    if (cleanupCfg->cleanCpdma) {
+        if ((retVal = fmCleanCppi(cleanupCfg->excludedResources,
+                                  numEntries)) != FM_FAULT_CLEANUP_OK) {
+            goto errorExit;
+        }
+    }
+    if (cleanupCfg->cleanEdma3) {
+        if ((retVal = fmCleanEdma3(fmGblCfgParams,
+                                   cleanupCfg->excludedResources,
+                                   numEntries,
+                                   FM_TRUE)) != FM_FAULT_CLEANUP_OK) {
+            goto errorExit;
+        }
+    }
+    if (cleanupCfg->cleanQmss) {
+        if ((retVal = fmCleanQmssQueue(fmGblCfgParams,
+                                       cleanupCfg->excludedResources,
+                                       numEntries)) != FM_FAULT_CLEANUP_OK) {
+            goto errorExit;
+        }
+    }
+    if (cleanupCfg->cleanPa) {
+        if ((retVal = fmCleanPa(fmGblCfgParams,
+                                cleanupCfg->excludedResources,
+                                numEntries)) != FM_FAULT_CLEANUP_OK) {
+            goto errorExit;
+        }
+    }
+    if (cleanupCfg->cleanSa) {
+        if ((retVal = fmCleanSa(cleanupCfg->excludedResources,
+                                numEntries)) != FM_FAULT_CLEANUP_OK) {
+            goto errorExit;
+        }
+    }
+    /* Clean QMSS again in case of descriptor leakage during PA and SA
+     * cleanup */
+    if (cleanupCfg->cleanQmss) {
+        if ((retVal = fmCleanQmssQueue(fmGblCfgParams,
+                                       cleanupCfg->excludedResources,
+                                       numEntries)) != FM_FAULT_CLEANUP_OK) {
+            goto errorExit;
+        }
+    }
+    if (cleanupCfg->cleanQmss) {
+        if ((retVal = fmCleanQmssAccum(fmGblCfgParams,
+                                       cleanupCfg->excludedResources,
+                                       numEntries)) != FM_FAULT_CLEANUP_OK) {
+            goto errorExit;
+        }
+    }
+    /* Clean out all the CIC mappings after everything has been disabled */
+    if ((retVal = fmCleanCics(fmGblCfgParams, cleanupCfg->excludedResources,
+                              numEntries)) != FM_FAULT_CLEANUP_OK) {
+        goto errorExit;
+    }
+    /* Clean sems again at end to wipe fresh for application restart */
+    if ((retVal = fmCleanSemaphores(cleanupCfg->excludedResources,
+                                    numEntries)) != FM_FAULT_CLEANUP_OK) {
+        goto errorExit;
+    }
+
+errorExit:
+    /* Writeback status so that Host can view it */
+    fmCleanupStatus[0] = retVal;
+    Fault_Mgmt_osalEndMemAccess(&fmCleanupStatus[0], sizeof(fmCleanupStatus));
+
+    return(retVal);
+}
+#endif /* !(K2H && K2K && K2L && K2E) */
+
+/* FUNCTION PURPOSE: Halts certain IO processing mechanisms
+ ***********************************************************************
+ * DESCRIPTION: Stops hardware processing in the following IO:
+ *                  - EMDA3 DMA, QDMA, and INT channels
+ *                  - AIF PE/PD channels
+ *                  - SGMII switch
+ *                  - CPDMA tx/rx channels
+ */
+Fm_Result Fault_Mgmt_haltIoProcessing(Fm_GlobalConfigParams *fmGblCfgParams,
+                                      Fm_HaltCfg *haltCfg)
+{
+    uint32_t           numEntries;
+    int32_t            validateStatus;
+    Fm_ExclusionParams exclusionParams;  
+    int32_t            i, j;
+    Cppi_Result        cppiResult;
+    uint32_t           heapSize;
+    Cppi_InitCfg       cppiInitCfg;
+    Cppi_CpDmaInitCfg  dmaCfg;
+    Cppi_Handle        cppiHandle;
+
+    /* Validate exclusion entries and return number of entries */
+    numEntries = fmExclusionValidateList(fmGblCfgParams, 
+                                         haltCfg->excludedResources,
+                                         &validateStatus);
+    if (validateStatus < 0) {
+        Fault_Mgmt_osalLog("IO Halt: Failed because entry %d (base 0) of "
+                           "exclusion list has invalid exResInfo field\n",
+                           numEntries);
+        return(validateStatus);
+    }
+
+    memset(&exclusionParams, 0, sizeof(exclusionParams));
+    exclusionParams.exclusionList = haltCfg->excludedResources;
+    exclusionParams.numListEntries = numEntries;
+
+    if (haltCfg->haltEdma3) {
+        /* Reuse recovery function */
+        fmCleanEdma3(fmGblCfgParams, haltCfg->excludedResources, numEntries,
+                     FM_FALSE);
+    }
+
+    if (haltCfg->haltAif2) {
+#if (!defined(DEVICE_K2L) && !defined(DEVICE_K2E))
+        /* Halts AIF2 peripheral resources.  Resources in the exclusion
+         * list will not be reset */
+
+        /* Disable all the AIF2 PE (TX) and PD (RX) channels. */
+        exclusionParams.resType = Fm_res_AifPeCh;
+        for (i = 0; i < fmGblCfgParams->maxAifPeCh; i++) {
+            exclusionParams.resourceNum = i;
+            if (!fmExclusionIsExcluded(&exclusionParams)) {
+                AIF_disablePeCh(&localAifObj, i);
+            }
+        }
+        exclusionParams.resType = Fm_res_AifPdCh;
+        for (i = 0; i < fmGblCfgParams->maxAifPdCh; i++) {
+            exclusionParams.resourceNum = i;
+            if (!fmExclusionIsExcluded(&exclusionParams)) {
+                AIF_disablePdCh(&localAifObj, i);
+            }
+        }
+
+        /* Reset the AIF2 timers */
+        AIF_resetFsync(&localAifObj);
+#endif /* !(K2L && K2E) */
+    }
+
+    if (haltCfg->haltSGMII) {
+        /* Halt the RX/TX transmit logic by starting soft reset but not
+         * completing it */
+        CSL_SGMII_startRxTxSoftReset(0);
+        CSL_SGMII_startRxTxSoftReset(1);
+    }
+
+    if (haltCfg->haltCpdma) {
+        /* Setup CPPI */
+        cppiResult = Cppi_getHeapReq(cppiGblCfgParams, &heapSize);
+        if (sizeof(tempCppiHeap) < heapSize) {
+            Fault_Mgmt_osalLog("IO Halt: Temp heap needed to initalize CPPI is "
+                               "too small");
+        }
+        cppiInitCfg.heapParams.staticHeapBase = &tempCppiHeap[0];
+        cppiInitCfg.heapParams.staticHeapSize = heapSize;
+        cppiInitCfg.heapParams.heapAlignPow2  = 8;
+        cppiInitCfg.heapParams.dynamicHeapBlockSize = -1;
+
+        cppiResult = Cppi_initCfg(cppiGblCfgParams, &cppiInitCfg);
+        if (cppiResult != CPPI_SOK) {
+            Fault_Mgmt_osalLog("IO Halt: Failed CPPI init\n");
+            return(FM_ERROR_CPPI_INIT_FAILED);
+        }
+
+        memset(&exclusionParams, 0, sizeof(exclusionParams));
+        exclusionParams.exclusionList = haltCfg->excludedResources;
+        exclusionParams.numListEntries = numEntries;
+        
+        /* Disable CPPI channels */
+        for (i = 0; i < CPPI_MAX_CPDMA; i++) {
+            if (fmIsWirelessPeriphPoweredOnForCpdma((Cppi_CpDma) i)) {
+                memset ((void *) &dmaCfg, 0, sizeof(dmaCfg));
+                dmaCfg.dmaNum = (Cppi_CpDma) i;
+
+                if (cppiHandle = Cppi_open(&dmaCfg)) {
+                    exclusionParams.u.cpdmaParams.dma = dmaCfg.dmaNum;
+                    exclusionParams.resType = Fm_res_CpdmaRxCh;
+                    for (j = 0; j < fmGetDmaMaxRxCh(dmaCfg.dmaNum); j++) {
+                        exclusionParams.resourceNum = j;
+                        if (!fmExclusionIsExcluded(&exclusionParams)) {
+                            disableDmaCh(cppiHandle, i, j, 1);
+                        }
+                    }
+
+                    exclusionParams.resType = Fm_res_CpdmaTxCh;
+                    for (j = 0; j < fmGetDmaMaxTxCh(dmaCfg.dmaNum); j++) {
+                        exclusionParams.resourceNum = j;
+                        if (!fmExclusionIsExcluded(&exclusionParams)) {
+                            disableDmaCh(cppiHandle, i, j, 0);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return(FM_OK);
+}
+
+/* FUNCTION PURPOSE: Gets and stores the system register status
+ ***********************************************************************
+ * DESCRIPTION: Gets the system register status and stores it in the
+ *              fault management data region.
+ */
+void Fault_Mgmt_getLastRegStatus(void)
+{
+    Exception_Status  status;
+    uint32_t         *faultDataPtr = (uint32_t *)&fault_mgmt_data[0];
+
+    /* Make sure note section fits within the provided fault data region */
+    if (Fault_Mgmt_getSizes() > FAULT_MGMT_DATA_SIZE) {
+        Fault_Mgmt_osalLog("Get Last Reg Status: Failed - ELF Note data "
+                           "section is %d bytes.  Need %d bytes.\n",
+                           FAULT_MGMT_DATA_SIZE, Fault_Mgmt_getSizes());
+        return;
+    }
+
+    memset((void *)faultDataPtr, 0, FAULT_MGMT_DATA_SIZE);
+
+    createNoteHeader(&faultDataPtr);
+
+    /* Get the register status for the core dump. */
+    Exception_getLastStatus (&status);
+
+    /* Copy the execution context to fault management data memory and update
+     * number of bytes in the Note section. */
+
+    /* The very first data value in the "desc" field is the PC for the crash
+     * dump.  The PC value should correspond to the NMI return pointer that was
+     * stored in the NRP register when the DSP exception triggered the
+     * exception handler which runs in the NMI context */
+    *faultDataPtr++ = status.nrp;
+
+    *faultDataPtr++ = status.efr;
+    *faultDataPtr++ = status.nrp;
+    *faultDataPtr++ = status.ntsr;
+    /* Copy IERR from exception context to the status value.  According to the
+     * exception module it's tracked in two places.  However, it is only
+     * updated in one of them.  To avoid confusion on the host side when the
+     * fault is reported the valid value in the exception context is copied to
+     * the invalid value in the status context */
+    status.ierr = (uint32_t) status.excContext->IERR;
+    *faultDataPtr++ = status.ierr;
+    memcpy((void *)faultDataPtr, (void *)status.excContext,
+           sizeof(ti_sysbios_family_c64p_Exception_Context));
+
+    Fault_Mgmt_osalEndMemAccess(&fault_mgmt_data[0], FAULT_MGMT_DATA_SIZE);
+
+    return;
+}
+
+/* FUNCTION PURPOSE: Notifies Host of DSP fault
+ ***********************************************************************
+ * DESCRIPTION: Sends a notification to the Host via the IPC registers
+ *              that a certain DSP has encountered an exception.
+ */
+void Fault_Mgmt_notify(void)
+{
+    CSL_IPC_genHostInterrupt(FM_HOST_IPCGR_OFFSET + DNUM);
+    return;
+}
+
+/* FUNCTION PURPOSE: Notifies remote DSP core of DSP fault
+ ***********************************************************************
+ * DESCRIPTION: Sends a notification to a remote DSP core via the IPC
+ *              registers that a certain DSP has encountered an exception.
+ */
+void Fault_Mgmt_notify_remote_core(uint32_t core_id)
+{
+    CSL_IPC_genNMIEvent(core_id);
+    return;
+}
+
+/* FUNCTION PURPOSE: Returns the required fault management data region size
+ ***********************************************************************
+ * DESCRIPTION: Returns the required size of the fault management data
+ *              region containing the crash dump data.
+ */
+uint32_t Fault_Mgmt_getSizes(void)
+{
+    return(createNoteHeader(NULL));
+}
+
+/**
+@}
+*/
diff --git a/src/fm_clean.c b/src/fm_clean.c
new file mode 100644 (file)
index 0000000..d1d966e
--- /dev/null
@@ -0,0 +1,2012 @@
+/**
+ *   @file  fm_clean.c
+ *
+ *   @brief   
+ *      Fault Management fault cleanup source
+ *
+ *  \par
+ *  ============================================================================
+ *  @n   (C) Copyright 2014, Texas Instruments, Inc.
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  \par
+*/
+
+#include <c6x.h>
+
+/* Standard Include Files. */
+#include <string.h>
+
+/* CSL Includes */
+#include <ti/csl/csl_sem.h>
+#include <ti/csl/csl_qm_queue.h>
+#include <ti/csl/csl_pscAux.h>
+#include <ti/csl/csl_chipAux.h>
+#include <ti/csl/csl_edma3Aux.h>
+
+#include <ti/csl/cslr.h>
+#include <ti/csl/cslr_device.h>
+#include <ti/csl/cslr_pa_ss.h>
+#include <ti/csl/cslr_cp_ace.h>
+#include <ti/csl/cslr_cpintc.h>
+#include <ti/csl/cslr_tmr.h>
+
+/* LLD Includes */
+#include <ti/drv/cppi/cppi_drv.h>
+#include <ti/drv/cppi/cppi_desc.h>
+#include <ti/drv/qmss/qmss_drv.h>
+#include <ti/drv/qmss/qmss_acc.h>
+#include <ti/drv/qmss/qmss_qm.h>
+#include <ti/drv/pa/pa.h>
+#include <ti/drv/pa/pasahost.h>
+#include <ti/drv/pa/fw/pafw.h>
+#include <ti/drv/aif2/aif2.h>
+
+/* FM API Include */
+#include <ti/instrumentation/fault_mgmt/fault_mgmt.h>
+
+/* FM Internal Includes */
+#include <ti/instrumentation/fault_mgmt/include/fm_loc.h>
+#include <ti/instrumentation/fault_mgmt/include/fm_cleanloc.h>
+#include <ti/instrumentation/fault_mgmt/include/fm_exclusionloc.h>
+
+/* OSAL Includes */
+#include <ti/instrumentation/fault_mgmt/fault_mgmt_osal.h>
+
+#if (!defined(DEVICE_K2H) && !defined(DEVICE_K2K) && !defined(DEVICE_K2L) && !defined(DEVICE_K2E))
+
+#define NUM_MONO_DESC          32
+#define SIZE_MONO_DESC         128
+#define MONO_DESC_DATA_OFFSET  36
+
+#define PA_INST_SIZE           128 /* Required size = 84 */
+#define PA_MAX_NUM_L2_HANDLES  64
+#define PA_L2_TABLE_SIZE       (PA_MAX_NUM_L2_HANDLES * 32) /* Requires 32 bytes per entry */
+#define PA_MAX_NUM_L3_HANDLES  128
+#define PA_L3_TABLE_SIZE       (PA_MAX_NUM_L3_HANDLES * 72) /* Requires 72 bytes per entry */
+
+#define PA_MAX_NUM_CPPI_TX_CH  9
+                                         
+#if defined(_LITTLE_ENDIAN)
+  #define SWIZ(x)  (sizeof((x)) == 1 ? (x) : (sizeof((x)) == 2 ? swiz16((x)) : (sizeof((x)) == 4 ? swiz32((x)) : 0)))
+#else
+  #define SWIZ(x)  (x)
+#endif
+
+/**********************************************************************
+ ********************** Cleanup Globals *******************************
+ **********************************************************************/
+
+/* Tracks whether LLDs have been initialized during the cleanup process */
+uint32_t      initComplete = FM_FALSE;
+
+#pragma DATA_ALIGN (monoDesc, 128)
+uint8_t       monoDesc[SIZE_MONO_DESC * NUM_MONO_DESC];
+
+/* Array used to store Queues that cannot be used by DSP until
+ * they can be closed.  Must be global to memory corruption
+ * when initializing the array since it may potentially be 
+ * larger than the stack*/
+Qmss_QueueHnd invalidQs[QMSS_MAX_GENERAL_PURPOSE_QUEUE];
+
+/* PA memory */
+#pragma DATA_ALIGN (paMemPaInst, 8)
+uint8_t       paMemPaInst[PA_INST_SIZE];
+#pragma DATA_ALIGN (paMemL2Ram, 8)
+uint8_t       paMemL2Ram[PA_L2_TABLE_SIZE];
+#pragma DATA_ALIGN(paMemL3Ram, 8);
+uint8_t       paMemL3Ram[PA_L3_TABLE_SIZE];
+
+/* PASS Tx Queues */
+Qmss_QueueHnd paTxQs[PA_MAX_NUM_CPPI_TX_CH];
+#endif /* !(K2H && K2K && K2L && K2E) */
+
+/* EDMA3 object - global to avoid overflowing stack */
+CSL_Edma3Obj  edmaObjCC;
+
+#if (!defined(DEVICE_K2H) && !defined(DEVICE_K2K) && !defined(DEVICE_K2L) && !defined(DEVICE_K2E))
+/* AIF2 object - Global to avoid overflowing stack */
+AIF_ConfigObj    locAifObj;
+
+/**********************************************************************
+ ******************** External Variables ******************************
+ **********************************************************************/
+
+/* Location in memory where cleanup status is written */
+extern int32_t                 fmCleanupStatus[32];
+
+/* Heap needed to initialize CPPI prior to IO halt execution */
+extern uint8_t                 tempCppiHeap[];
+#endif /* !(K2H && K2K && K2L && K2E) */
+
+/* CPPI Global configuration parameters */
+#if (!defined(DEVICE_K2H) && !defined(DEVICE_K2K) && !defined(DEVICE_K2L) && !defined(DEVICE_K2E))
+extern Cppi_GlobalConfigParams cppiGblCfgParams[];
+#else
+extern Cppi_GlobalConfigParams cppiGblCfgParams;
+#endif
+
+#if (!defined(DEVICE_K2H) && !defined(DEVICE_K2K) && !defined(DEVICE_K2L) && !defined(DEVICE_K2E))
+/* QMSS Global configuration parameters */
+extern Qmss_GlobalConfigParams qmssGblCfgParams;
+
+/**********************************************************************
+ ********************* Local Cleanup Functions ************************
+ **********************************************************************/
+
+/* START: PA API hardcoded here until it can be added to PA LLD */
+#if defined(_LITTLE_ENDIAN)
+/*********************************************************************
+ * FUNCTION PURPOSE: Swizzling
+ *********************************************************************
+ * DESCRIPTION: The PA sub-system requires all multi-byte fields in
+ *              big endian format.
+ *********************************************************************/
+static inline uint16_t swiz16(uint16_t x)
+{
+  return ((x >> 8) | (x << 8));
+}
+
+static inline uint32_t swiz32 (uint32_t x)
+{
+  return (((x) >> 24) | (((x) >> 8) & 0xff00L) | (((x) << 8) & 0xff0000L) | ((x) << 24));
+}
+#endif
+
+/* Hardcode here until API added to PA to remove entries with minimal
+ * overhead.  This define maps to PAFRM_CONFIG_COMMAND_DEL_LUT1 (in src/pafrm.h) */
+#define temp_PAFRM_CONFIG_COMMAND_DEL_LUT1 2
+
+/* Hardcode here until API added to PA to remove entries with minimal
+ * overhead.  This define maps to PAFRM_CONFIG_COMMAND_SEC_BYTE (in src/pafrm.h) */
+#define temp_PAFRM_CONFIG_COMMAND_SEC_BYTE 0xce
+
+/* Hardcode here until API added to PA to remove entries with minimal
+ * overhead.  This define maps to PAFRM_DEST_PKTDMA (in src/pafrm.h) */
+#define temp_PAFRM_DEST_PKTDMA 6
+/* Hardcode here until API added to PA to remove entries with minimal
+ * overhead.  This define maps to PAFRM_DEST_DISCARD (in src/pafrm.h) */
+#define temp_PAFRM_DEST_DISCARD 10
+
+/* Commands to PA - Hardcode here until API added to PA to remove entries with minimal
+ *                  overhead.  This structure maps to pafrmCommand_t (in src/pafrm.h) */
+typedef struct {
+    uint32_t commandResult; /* Returned to the host, ignored on entry to the PASS                         */
+    uint8_t  command;       /* Command value                                                              */
+    uint8_t  magic;         /* Magic value                                                                */
+    uint16_t comId;         /* Used by the host to identify command results                               */
+    uint32_t retContext;    /* Returned in swInfo to identify packet as a command                         */
+    uint16_t replyQueue;    /* Specifies the queue number for the message reply. 0xffff to toss the reply */
+    uint8_t  replyDest;     /* Reply destination (host0, host1, discard are the only valid values)        */
+    uint8_t  flowId;        /* Flow ID used to assign packet at reply                                     */
+    uint32_t cmd;           /* First word of the command */
+} tempPaCmd;
+
+/* Delete entry from LUT1 - Hardcode here until API added to PA to remove entries with minimal
+ *                          overhead.  This structure maps to pafrmCommandDelLut1_t (in src/pafrm.h) */
+typedef struct {
+    uint8_t index;        /*  LUT1 index */
+} tempPaCmdDelLut1;
+
+/*************************************************************************
+ * FUNCTION PURPOSE: Format Firmware Command Header
+ ************************************************************************* 
+ * DESCRIPTION: Clear and construct the firmware command header
+ *              Returns pointer to the firmware command
+ *************************************************************************/
+static tempPaCmd *pa_format_fcmd(void *pCmd, paCmdReply_t *reply, uint8_t lutIndex)
+{
+    tempPaCmd        *fcmd = (tempPaCmd *) pCmd;
+    uint16_t          csize = sizeof(tempPaCmd)+sizeof(tempPaCmdDelLut1)-sizeof(uint32_t);
+    tempPaCmdDelLut1 *del;
+    uint8_t           lut = temp_PAFRM_CONFIG_COMMAND_DEL_LUT1;
+
+    memset(fcmd, 0, csize);
+
+    fcmd->command       = SWIZ(lut);
+    fcmd->magic         = temp_PAFRM_CONFIG_COMMAND_SEC_BYTE;
+    fcmd->comId         = 0;
+    fcmd->retContext    = SWIZ(reply->replyId);
+    fcmd->replyQueue    = SWIZ(reply->queue);
+    fcmd->flowId        = SWIZ(reply->flowId);
+
+    /* Validity of the destination was already checked (HOST), so no other cases 
+    * must be considered */
+    if (reply->dest == pa_DEST_HOST)
+    fcmd->replyDest = temp_PAFRM_DEST_PKTDMA;
+    else
+    fcmd->replyDest = temp_PAFRM_DEST_DISCARD;
+
+    del = (tempPaCmdDelLut1 *)&(fcmd->cmd);
+
+    del->index = lutIndex;
+    del->index = SWIZ(del->index);
+
+    return(fcmd);
+}
+/* END: PA API hardcoded here until it can be added to PA LLD */
+
+/* FUNCTION PURPOSE: Converts L2 addresses to global
+ ***********************************************************************
+ * DESCRIPTION: Converts local l2 addresses to their global address
+ */
+static uint32_t l2_global_address (uint32_t addr)
+{
+    /* Compute the global address. */
+    return (addr + (0x10000000 + (DNUM * 0x1000000)));
+}
+
+/* FUNCTION PURPOSE: Cycle Delay
+ ***********************************************************************
+ * DESCRIPTION: Delays for the specified amount of cycles
+ */
+static void cycleDelay(int count, int initTSCL)
+{
+    uint32_t TSCLin = TSCL;
+
+    if (initTSCL) {
+        CSL_chipWriteTSCL(0);
+    }
+    else {
+        if (count <= 0)
+            return;
+
+        while ((TSCL - TSCLin) < (uint32_t)count);
+    }
+}
+
+/* FUNCTION PURPOSE: Resets a specified CPDMA channel or flow
+ ***********************************************************************
+ * DESCRIPTION: Resets the specified CPDMA channel or flow
+ */
+static void resetDmaCh(Cppi_Handle cppiHandle, int32_t dmaNum, int32_t chNum, Fm_ResType resType)
+{
+    Cppi_RxChInitCfg rxChCfg;
+    Cppi_TxChInitCfg txChCfg;
+    Cppi_ChHnd       chHandle;
+    Cppi_RxFlowCfg   rxFlowCfg;
+    Cppi_FlowHnd     flowHandle;     
+    uint8_t          isAllocated; 
+    Cppi_Result      cppiResult;    
+
+    if (resType == Fm_res_CpdmaRxCh) {
+        memset((void *) &rxChCfg, 0, sizeof(rxChCfg));
+        rxChCfg.channelNum = chNum;
+        
+        if (chHandle = Cppi_rxChannelOpen(cppiHandle, &rxChCfg, &isAllocated)) {
+            if(cppiResult = Cppi_channelDisable(chHandle) != CPPI_SOK) {
+                Fault_Mgmt_osalLog("Failed to disable cppi DMA %d rx ch %d with err %d\n", dmaNum, chNum, cppiResult);
+            }
+            if(cppiResult = Cppi_channelClose(chHandle) != CPPI_SOK) {
+                Fault_Mgmt_osalLog("Failed to close cppi DMA %d rx ch %d with err %d\n", dmaNum, chNum, cppiResult);
+            }
+        }
+        else {
+            Fault_Mgmt_osalLog("DMA %d, RX channel %d failed to open\n", dmaNum, chNum);
+        }
+    }
+    else if (resType == Fm_res_CpdmaTxCh) {
+        memset((void *) &txChCfg, 0, sizeof(txChCfg));
+        txChCfg.channelNum = chNum;
+        
+        if (chHandle = Cppi_txChannelOpen(cppiHandle, &txChCfg, &isAllocated)) {
+            if(cppiResult = Cppi_channelDisable(chHandle) != CPPI_SOK) {
+                Fault_Mgmt_osalLog("Failed to disable cppi DMA %d tx ch %d with err %d\n", dmaNum, chNum, cppiResult);
+            }
+            if(cppiResult = Cppi_channelClose(chHandle) != CPPI_SOK) {
+                Fault_Mgmt_osalLog("Failed to close cppiDMA %d tx ch %d with err %d\n", dmaNum, chNum, cppiResult);
+            }                        
+        }
+        else {
+            Fault_Mgmt_osalLog("DMA %d, TX channel %d failed to open\n", dmaNum, chNum);
+        } 
+    }
+    else if (resType == Fm_res_CpdmaRxFlow) {
+        memset((void *) &rxFlowCfg, 0, sizeof(rxFlowCfg));
+        rxFlowCfg.flowIdNum = chNum;
+        
+        if (flowHandle = Cppi_configureRxFlow(cppiHandle, &rxFlowCfg, &isAllocated)) {
+            if(cppiResult = Cppi_closeRxFlow(flowHandle) != CPPI_SOK) {
+                Fault_Mgmt_osalLog("Failed to disable cppi DMA %d rx flow %d with err %d\n", dmaNum, chNum, cppiResult);
+            }                       
+        }
+        else {
+            Fault_Mgmt_osalLog("DMA %d, RX flow %d failed to open\n", dmaNum, chNum);
+        } 
+    }  
+}
+
+/* FUNCTION PURPOSE: Gets the max CPPI rx flows for a CPDMA
+ ***********************************************************************
+ * DESCRIPTION: Returns the maximum number of rx flows for the
+ *              given CPDMA
+ *
+ * CPPI API hardcoded here until it can be added to CPPI LLD 
+ */
+static uint32_t getDmaMaxRxFlow(Cppi_CpDma dmaNum)
+{
+    uint32_t     maxRxFlow;
+
+    maxRxFlow = cppiGblCfgParams[dmaNum].maxRxFlow;
+    return (uint32_t) maxRxFlow;
+}
+
+/* FUNCTION PURPOSE: Enables a CPPI tx channel
+ ***********************************************************************
+ * DESCRIPTION: Directly accesses the CPPI registers to Enable
+ *              the specified transmit channel
+ *
+ * CPPI API hardcoded here until it can be added to CPPI LLD 
+ */
+static Cppi_Result txChannelExpressEnable (Cppi_CpDma dmaNum, uint32_t channelNum)
+{
+    uint32_t     value = 0;    
+    Cppi_Result  retVal = CPPI_SOK;
+
+    if (channelNum > cppiGblCfgParams[dmaNum].maxTxCh) {
+        retVal =  FM_ERROR_CPPI_TX_CHANNEL_INVALID;
+        goto exitCs;
+    }
+    
+    CSL_FINS (value, CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_A_TX_ENABLE, (uint32_t) 1);
+    cppiGblCfgParams[dmaNum].txChRegs->TX_CHANNEL_GLOBAL_CONFIG[channelNum].TX_CHANNEL_GLOBAL_CONFIG_REG_A = value;
+
+exitCs:
+    return retVal;
+}
+
+/* FUNCTION PURPOSE: Disables a CPPI tx channel
+ ***********************************************************************
+ * DESCRIPTION: Directly accesses the CPPI registers to disable
+ *              the specified transmit channel
+ *
+ * CPPI API hardcoded here until it can be added to CPPI LLD 
+ */
+static Cppi_Result txChannelExpressDisable (Cppi_CpDma dmaNum, uint32_t channelNum)
+{
+    Cppi_Result  retVal = CPPI_SOK;
+
+    if (channelNum > cppiGblCfgParams[dmaNum].maxTxCh) {
+        retVal =  FM_ERROR_CPPI_TX_CHANNEL_INVALID;
+        goto exitCs;
+    }
+
+    cppiGblCfgParams[dmaNum].txChRegs->TX_CHANNEL_GLOBAL_CONFIG[channelNum].TX_CHANNEL_GLOBAL_CONFIG_REG_A = 0;
+  
+exitCs:
+    return retVal;
+}
+
+/* FUNCTION PURPOSE: Disable TX DMAs used by Linux
+ ***********************************************************************
+ * DESCRIPTION: Disables the PASS and QMSS TX DMAs that are owned and
+ *              operated by Linux.
+ */
+static void linuxTxDmaDisable(Fm_ExcludedResource *excludedResList, uint32_t listSize)
+{
+    Fm_ExclusionParams exclusionParams;
+    int32_t            i;   
+    
+    /* Disable all PASS & QMSS TX DMAs owned by Linux */
+    memset(&exclusionParams, 0, sizeof(exclusionParams));
+    exclusionParams.exclusionList = excludedResList;
+    exclusionParams.numListEntries = listSize;
+    
+    exclusionParams.resType = Fm_res_CpdmaTxCh;
+    exclusionParams.u.cpdmaParams.dma = Cppi_CpDma_PASS_CPDMA;
+    for (i = 0; i < fmGetDmaMaxTxCh(Cppi_CpDma_PASS_CPDMA); i++) {
+        exclusionParams.resourceNum = i;
+        if (fmExclusionIsExcluded(&exclusionParams)) {
+            txChannelExpressDisable(Cppi_CpDma_PASS_CPDMA, i);
+        }
+    }
+    exclusionParams.u.cpdmaParams.dma = Cppi_CpDma_QMSS_CPDMA;
+    for (i = 0; i < fmGetDmaMaxTxCh(Cppi_CpDma_QMSS_CPDMA); i++) {
+        exclusionParams.resourceNum = i;
+        if (fmExclusionIsExcluded(&exclusionParams)) {
+            txChannelExpressDisable(Cppi_CpDma_QMSS_CPDMA, i);
+        }
+    }  
+}
+
+/* FUNCTION PURPOSE: Enable TX DMAs used by Linux
+ ***********************************************************************
+ * DESCRIPTION: Enables the PASS and QMSS TX DMAs that are owned and
+ *              operated by Linux.
+ */
+static void linuxTxDmaEnable(Fm_ExcludedResource *excludedResList, uint32_t listSize)
+{
+    Fm_ExclusionParams exclusionParams;
+    int32_t            i;   
+
+    memset(&exclusionParams, 0, sizeof(exclusionParams));
+    exclusionParams.exclusionList = excludedResList;
+    exclusionParams.numListEntries = listSize;
+
+    /* Enable the Linux TX CPDMAs */
+    exclusionParams.resType = Fm_res_CpdmaTxCh;
+    exclusionParams.u.cpdmaParams.dma = Cppi_CpDma_PASS_CPDMA;
+    for (i = 0; i < fmGetDmaMaxTxCh(Cppi_CpDma_PASS_CPDMA); i++) {
+        exclusionParams.resourceNum = i;
+        if (fmExclusionIsExcluded(&exclusionParams)) {
+            txChannelExpressEnable(Cppi_CpDma_PASS_CPDMA, i);        
+        }
+    }
+    exclusionParams.u.cpdmaParams.dma = Cppi_CpDma_QMSS_CPDMA;
+    for (i = 0; i < fmGetDmaMaxTxCh(Cppi_CpDma_QMSS_CPDMA); i++) {
+        exclusionParams.resourceNum = i;
+        if (fmExclusionIsExcluded(&exclusionParams)) {
+            txChannelExpressEnable(Cppi_CpDma_QMSS_CPDMA, i); 
+        }
+    }
+}
+
+/* FUNCTION PURPOSE: Disables a QMSS accumulator channel
+ ***********************************************************************
+ * DESCRIPTION: Disables a QMSS accumulator channel the same as the
+ *              Qmss_disableAccumulator API except a timeout is added
+ *              when waiting for response from the PDSP firmware.
+ *
+ * QMSS API hardcoded here until it can be added to QMSS LLD 
+ */
+static Qmss_Result disableAccumChWithTimeout(Qmss_PdspId pdspId, uint8_t channel)
+{
+    Qmss_AccCmd        cmd;
+    volatile uint32_t *cmdPtr, *reg;
+    uint32_t           index;
+    uint8_t            result;
+    void              *key;
+    uint32_t           gotResponse = FM_FALSE;
+    uint32_t           timeoutCnt;
+
+    /* Begin Critical Section before accessing shared resources. */
+    key = Qmss_osalCsEnter ();
+
+    while(!gotResponse) {
+        memset ((void *) &cmd, 0, sizeof (Qmss_AccCmd));
+        CSL_FINSR (cmd.word0, 7, 0, channel);
+        CSL_FINSR (cmd.word0, 15, 8, Qmss_AccCmd_DISABLE_CHANNEL);
+
+        /* Point to the accumulator command register's last word */
+        reg = (uint32_t *) ((uint8_t *) qmssGblCfgParams.qmPdspCmdReg[pdspId] + 4 * 4);
+
+        /* Write command word last */
+        cmdPtr = ((uint32_t *) &cmd) + 4;
+
+        for (index = 0; index < 5; index++)
+            *reg-- = *cmdPtr--;
+
+        /* Wait for the command to clear */
+        reg++;
+        timeoutCnt = 0;
+        do
+        {
+            result = CSL_FEXTR (*reg, 15, 8);
+
+            if (result != 0) {
+                gotResponse = FM_TRUE;
+            }
+            else {
+                cycleDelay(1000, FM_FALSE);
+                timeoutCnt += 1000;
+                if (timeoutCnt >= 1000000000) {
+                    /* Resend the command */
+                    break;
+                }
+            }
+        } while (result != 0);
+    }
+
+    /* End Critical Section */
+    Qmss_osalCsExit (key);
+    
+    return (Qmss_Result) (CSL_FEXTR (*reg, 31, 24));
+}
+
+
+/* FUNCTION PURPOSE: Resets a QMSS memory region
+ ***********************************************************************
+ * DESCRIPTION: Directly accesses the QMSS descriptor registers
+ *              to reset a specified memory region
+ *
+ * QMSS API hardcoded here until it can be added to QMSS LLD 
+ */
+static Qmss_Result expressResetMemoryRegion (Qmss_MemRegion memRegion)
+{
+    int32_t index = (int32_t) memRegion;
+    
+    if (memRegion == Qmss_MemRegion_MEMORY_REGION_NOT_SPECIFIED)
+        return QMSS_MEMREGION_INVALID_INDEX;
+
+    qmssGblCfgParams.qmDescReg->MEMORY_REGION_BASE_ADDRESS_GROUP[index].MEMORY_REGION_BASE_ADDRESS_REG = (uint32_t)0;
+    qmssGblCfgParams.qmDescReg->MEMORY_REGION_BASE_ADDRESS_GROUP[index].MEMORY_REGION_START_INDEX_REG = (uint32_t)0;
+    qmssGblCfgParams.qmDescReg->MEMORY_REGION_BASE_ADDRESS_GROUP[index].MEMORY_REGION_DESCRIPTOR_SETUP_REG = 0; 
+        
+    return QMSS_SOK;
+}
+
+/* FUNCTION PURPOSE: Gets a Memory Region Base Address
+ ***********************************************************************
+ * DESCRIPTION: Directly accesses the QMSS descriptor registers
+ *              to get the region base address.  A return of NULL
+ *              means memory region is not in use.  The physical
+ *              base address can not be NULL if it is in use.
+ *
+ * QMSS API hardcoded here until it can be added to QMSS LLD 
+ */
+static uint32_t getMemoryRegionBaseAddr (Qmss_MemRegion memRegion)
+{
+    int32_t index = (int32_t) memRegion;
+    
+    return (qmssGblCfgParams.qmDescReg->MEMORY_REGION_BASE_ADDRESS_GROUP[index].MEMORY_REGION_BASE_ADDRESS_REG);
+}
+
+/* FUNCTION PURPOSE: Gets a Memory Region Descriptor Block Size
+ ***********************************************************************
+ * DESCRIPTION: Directly accesses the QMSS descriptor registers
+ *              to get the descriptor block size for the region
+ *
+ * QMSS API hardcoded here until it can be added to QMSS LLD 
+ */
+static uint32_t getMemoryRegionDescBlockSize (Qmss_MemRegion memRegion)
+{
+    int32_t  index = (int32_t) memRegion;
+    uint32_t descSizeBytes = 0;
+    uint32_t powRegSize = 0;
+    uint32_t numDesc = 0;
+    
+    descSizeBytes = (uint32_t) CSL_FEXT (qmssGblCfgParams.qmDescReg->MEMORY_REGION_BASE_ADDRESS_GROUP[index].MEMORY_REGION_DESCRIPTOR_SETUP_REG,
+                                         QM_DESCRIPTOR_REGION_CONFIG_MEMORY_REGION_DESCRIPTOR_SETUP_REG_DESC_SIZE);
+    /* Value stored as multiplier minus 1 that needs to be applied to 16 to get descriptor size */
+    descSizeBytes = (descSizeBytes + 1) * 16;
+    
+    powRegSize = (uint32_t) CSL_FEXT (qmssGblCfgParams.qmDescReg->MEMORY_REGION_BASE_ADDRESS_GROUP[index].MEMORY_REGION_DESCRIPTOR_SETUP_REG,
+                                      QM_DESCRIPTOR_REGION_CONFIG_MEMORY_REGION_DESCRIPTOR_SETUP_REG_REG_SIZE);
+    /* Value stored as 2^(5+stored_value) = number of descriptors */
+    numDesc = (32UL << powRegSize);
+
+    return (numDesc * descSizeBytes);
+}
+
+/* FUNCTION PURPOSE: Cleans QMSS queues
+ ***********************************************************************
+ * DESCRIPTION: QMSS queues cleaned.  The steps taken to clean the
+ *              queues differs based on whether the queue is part of
+ *              the provided exclusion list.  Queues not in the
+ *              exclusion list will be emptied of all descriptors
+ *              Queues in the exclusion list will be cleaned 
+ *              using the following process:
+ *
+ * Queue cleanup process
+ *  - Disable all PASS DMA TX channels that are owned by Linux
+ *  - Pause QoS (if supported - not currently supported)
+ *  - Wipe all QMSS queues that are DSP owned
+ *  - Read QMSS memory region registers for Linux inserted regions to get addresses associated
+ *    with Linux pushed descriptors
+ *  - For each queue that may be used by Linux
+ *      - Allocate a scratch queue and a cleanup queue from the list of wiped QMSS queues
+ *      - Divert all descriptors in Linux owned queue to scratch queue
+ *      - Pop descriptors off scratch queue
+ *          - Discard if descriptor not in Linux memory region
+ *          - Push onto cleanup queue if descript in Linux memory region
+ *      - Divert descriptors in cleanup queue back to original queue
+ *  - Enable PASS DMA TX channels
+ */
+static int32_t cleanQmssQueues(Fm_ExcludedResource *excludedResList, uint32_t listSize)
+{
+    Fm_ExclusionParams exclusionParams;
+    uint8_t            isAllocated;
+    int32_t            i, j;   
+    Qmss_QueueHnd      scratchQ = NULL;
+    Qmss_QueueHnd      cleanQ = NULL;
+    uint32_t           desc;
+    uint32_t           memRegStart;
+    uint32_t           memRegEnd;
+    Fm_Result          retVal = FM_FAULT_CLEANUP_OK;
+
+    /* Stop flow of descriptors while cleaning QM */
+    linuxTxDmaDisable(excludedResList, listSize);  
+
+    /* Cleanup QMSS queues */
+    
+    memset(&exclusionParams, 0, sizeof(exclusionParams));
+    exclusionParams.exclusionList = excludedResList;
+    exclusionParams.numListEntries = listSize;
+
+    /* Empty all queues not owned by Linux first */
+    exclusionParams.resType = Fm_res_QmssQueue;
+    for (i = 0; i < QMSS_MAX_QUEUES; i++) {
+        exclusionParams.resourceNum = i;
+        if (!fmExclusionIsExcluded(&exclusionParams)) {
+            Qmss_queueEmpty((Qmss_QueueHnd) i);
+        }
+    }
+
+    /* Clean all Linux-owned queues of DSP-based descriptors second */
+
+    /* Allocate a scratchQ for temporarily storing the descriptor contents of a queue being swept of
+     * DSP descriptors */
+    memset(&invalidQs[0], 0, sizeof(invalidQs));
+    i = 0;
+    while (scratchQ == NULL) {
+        scratchQ = Qmss_queueOpen(Qmss_QueueType_GENERAL_PURPOSE_QUEUE, QMSS_PARAM_NOT_SPECIFIED, &isAllocated);
+        exclusionParams.resourceNum = scratchQ;
+        if (fmExclusionIsExcluded(&exclusionParams)) {
+            /* Store the queues that can't be used until after both the scratchQ and cleanQ have been found. */
+            invalidQs[i++] = scratchQ;
+            scratchQ = NULL;
+        }
+    }
+    /* Allocate a cleanQ to temporarily store the linux-based descriptors filtered from a Linux-based queue. */
+    while (cleanQ == NULL) {
+        cleanQ = Qmss_queueOpen(Qmss_QueueType_GENERAL_PURPOSE_QUEUE, QMSS_PARAM_NOT_SPECIFIED, &isAllocated);
+        exclusionParams.resourceNum = cleanQ;
+        if (fmExclusionIsExcluded(&exclusionParams)) {
+            /* Store the queues that can't be used until after both the scratchQ and cleanQ have been found. */
+            invalidQs[i++] = cleanQ;
+            cleanQ = NULL;
+        }
+    }   
+    /* Free any invalidQs */
+    for (j = 0; j < i; j++) {
+        Qmss_queueClose(invalidQs[j]);
+    }
+    
+    /* Need to check allocated queue against those owned by linux */    
+    for (i = 0; i < QMSS_MAX_QUEUES; i++) {
+        exclusionParams.resType = Fm_res_QmssQueue;
+        exclusionParams.resourceNum = i;
+        if (fmExclusionIsExcluded(&exclusionParams)) {
+            /* In K2 will need to open twice the scratch and clean queues (one from each QM) */
+            Qmss_queueDivert(i, scratchQ, Qmss_Location_TAIL);
+
+            /* Pop each decriptor from the queue being swept.  if the descriptor lies within
+             * the range of a Linux-owned memory region it is saved via a push onto a clean Q.  Otherwise,
+             * the descriptor is dropped. */
+            while (desc = (uint32_t)Qmss_queuePop(scratchQ)) {
+                for (j = 0; j < QMSS_MAX_MEM_REGIONS; j++) {
+                    if (memRegStart = getMemoryRegionBaseAddr((Qmss_MemRegion)j)) {
+                        memRegEnd = memRegStart + getMemoryRegionDescBlockSize((Qmss_MemRegion)j);
+                        if ((desc >= memRegStart) && (desc < memRegEnd)) {
+                            /* Save descriptor */
+                            Qmss_queuePushDesc(cleanQ, (void *)desc);
+                            break;
+                        }
+                    }
+                }
+            }
+            /* Move Linux-based descriptors in the cleanQ back into the original queue.  The descriptors are
+             * diverted to the HEAD in case any descriptors were pushed into the original queue during the 
+             * sweep process.  Pushing to HEAD will guarantee the original descriptors are handled prior to the
+             * new ones */
+            Qmss_queueDivert(cleanQ, i, Qmss_Location_HEAD); 
+        }
+    }
+
+    /* Restart flow of descriptors */
+    linuxTxDmaEnable(excludedResList, listSize);
+
+    /* Leave DMA handles hanging since it can't be closed without closing all the channels.  Channels
+     * can't be closed without wiping Linux configuration */
+    return (retVal);
+}
+
+/* FUNCTION PURPOSE: Resets PA PDSPs and LUTs
+ ***********************************************************************
+ * DESCRIPTION: Resets PA PDSPs and LUTs based on the provided
+ *              exclusion list.
+ *
+ *              TAKEN FROM pa.c (Pa_resetControl).  Replace this code 
+ *              with call to modified Pa_resetControl when it doesn't
+ *              automatically reset all PDSPs.  Until then use this 
+ *              modified function
+ *
+ * To reset portions of PA used by DSP
+ *  - Disable DSP owned PDSPs
+ *  - Clear LUT2 if completely owned by DSP
+ *  - Redownload DSP owned PDSPs
+ *  - Reenable DSP owned PDSPs
+ */
+static paReturn_t resetPaPdspsAndLuts(Pa_Handle paHandle, uint32_t numPdsps, 
+                                      Fm_ExcludedResource *excludedResList, uint32_t listSize)
+{
+    CSL_Pa_ssRegs      *passRegs;
+    Fm_ExclusionParams  exclusionParams;
+    uint32_t            i;
+    uint32_t            resetLut2 = FM_TRUE;
+    paReturn_t          paRet = pa_OK;
+
+    if (listSize) {
+        /* A present exclusion list signifies another core (typically ARM Linux) is in
+         * control of PA.  As a result, the firmware download and reset must be selective */
+
+        /* Initialize the exclusion parameters */
+        memset(&exclusionParams, 0, sizeof(exclusionParams));
+        exclusionParams.exclusionList = excludedResList;
+        exclusionParams.numListEntries = listSize;    
+
+        passRegs = (CSL_Pa_ssRegs *)CSL_PA_SS_CFG_REGS;
+
+        /* Put each of the PDSPs into reset (PC = 0)*/
+        exclusionParams.resType = Fm_res_PaPdsp;
+        for (i = 0; i < numPdsps; i++) {
+            exclusionParams.resourceNum = i;
+            if (!fmExclusionIsExcluded(&exclusionParams)) {
+                passRegs->PDSP_CTLSTAT[i].PDSP_CONTROL = 0;
+            }
+        }
+
+        /* Reset LUT2 if applicable */
+        for (i = 0; i < listSize; i++) {
+            if ((excludedResList[i].resType == Fm_res_PaLutEntry) &&
+                (excludedResList[i].exResInfo == 2)) {
+                resetLut2 = FM_FALSE;
+                break;
+            }
+        }
+
+        if (resetLut2) {
+            passRegs->LUT2.LUT2_SOFT_RESET = 1;
+        }
+
+        exclusionParams.resType = Fm_res_PaPdsp;
+        /* PDPSs 0-2 use image c1 */
+        for (i = 0; i < 3; i++) {
+            exclusionParams.resourceNum = i;
+            if (!fmExclusionIsExcluded(&exclusionParams)) {
+                paRet = Pa_downloadImage (paHandle, i, (Ptr)c1, c1Size);
+                if (paRet != pa_OK) {
+                    goto errorExit;
+                }
+            }
+        }
+        /* PDSP 3 uses image c2 */
+        exclusionParams.resourceNum = 3;
+        if (!fmExclusionIsExcluded(&exclusionParams)) {
+            paRet = Pa_downloadImage (paHandle, 3, (Ptr)c2, c2Size);
+            if (paRet != pa_OK) {
+                goto errorExit;
+            }        
+        }
+        /* PDSPs 4-5 use image m */
+        for (i = 4; i < numPdsps; i++) {
+            exclusionParams.resourceNum = i;
+            if (!fmExclusionIsExcluded(&exclusionParams)) {
+                paRet = Pa_downloadImage (paHandle, i, (Ptr)m, mSize);
+                if (paRet != pa_OK) {
+                    goto errorExit;
+                }            
+            }
+        }
+
+        /* Should be able to use PA's PDSP enable API since an active PDSP will not be
+         * modified */
+        paRet = Pa_resetControl(paHandle, pa_STATE_ENABLE);
+        if (paRet == pa_STATE_ENABLE) {
+            paRet = pa_OK;
+        }
+    }
+    else {
+        /* Perform full firmware download and reset since another core is not
+         * in control of PA */
+         
+        Pa_resetControl (paHandle, pa_STATE_RESET);
+        
+        /* PDPSs 0-2 use image c1 */
+        for (i = 0; i < 3; i++)
+          Pa_downloadImage (paHandle, i, (Ptr)c1, c1Size);
+        
+        /* PDSP 3 uses image c2 */
+        Pa_downloadImage (paHandle, 3, (Ptr)c2, c2Size);
+        
+        /* PDSPs 4-5 use image m */
+        for (i = 4; i < 6; i++)
+          Pa_downloadImage (paHandle, i, (Ptr)m, mSize);
+        
+        paRet = Pa_resetControl (paHandle, pa_STATE_ENABLE);
+        
+        if (paRet == pa_STATE_ENABLE) {
+            paRet = pa_OK;
+        }
+    }
+
+errorExit:
+    return (paRet);
+}
+
+/* FUNCTION PURPOSE: Check if NetCp (PA & SA) subsystem is powered up
+ ***************************************************************************************
+ * DESCRIPTION: This function checks the power status of the NetCp (PA & SA) subsystem domains
+ */
+static uint32_t isNetCpPoweredUp (void)
+{
+    /* Get peripheral PSC status */
+    if ((CSL_PSC_getPowerDomainState(CSL_PSC_PD_PASS) == PSC_PDSTATE_ON) &&
+        (CSL_PSC_getModuleState (CSL_PSC_LPSC_PKTPROC) == PSC_MODSTATE_ENABLE) &&
+        (CSL_PSC_getModuleState (CSL_PSC_LPSC_CPGMAC) == PSC_MODSTATE_ENABLE) &&
+        (CSL_PSC_getModuleState (CSL_PSC_LPSC_Crypto) == PSC_MODSTATE_ENABLE)) {
+        /* On */
+        return (FM_TRUE);
+    }
+    else {
+        return (FM_FALSE);
+    }
+}
+
+/* FUNCTION PURPOSE: Resets and Initializes PA
+ ***********************************************************************
+ * DESCRIPTION: Resets and intializes PA.  Certain steps
+ *              will be skipped if an exclusion list
+ *              is provided.  This signifies another
+ *              entity (typically ARM Linux) has already setup
+ *              portions of PA which should not be reset
+ */
+static Pa_Handle resetAndInitPa(uint32_t numPdsps, Fm_ExcludedResource *excludedResList, uint32_t listSize)
+{
+    paSizeInfo_t  paSize;
+    paConfig_t    paCfg;
+    paReturn_t    paRet;
+    int           bufSizes[pa_N_BUFS];
+    int           bufAligns[pa_N_BUFS];
+    void         *bufBases[pa_N_BUFS];
+    Pa_Handle     paHandle = NULL;
+
+    /* Stop flow of descriptors while resetting the PA PDSPs */
+    linuxTxDmaDisable(excludedResList, listSize);
+    /* Delay so PDSPs can finish processing any queued descriptors (commands) */
+    cycleDelay(5000, FM_FALSE);
+    
+    /* The maximum number of handles that can exists are 32 for L2, and 64 for L3. */
+    memset(&paSize, 0, sizeof(paSizeInfo_t));
+    memset(&paCfg, 0, sizeof(paConfig_t));
+    memset(bufBases, 0, sizeof(bufBases));
+    paSize.nMaxL2 = PA_MAX_NUM_L2_HANDLES;
+    paSize.nMaxL3 = PA_MAX_NUM_L3_HANDLES;
+    paSize.nUsrStats = 0;
+    paSize.nVlnkMax = 0;
+    paRet = Pa_getBufferReq(&paSize, bufSizes, bufAligns);
+
+    if (paRet != pa_OK) {
+        goto errorExit;
+    }
+    
+    /* The first buffer is used as the instance buffer */
+    if (((Uint32)paMemPaInst & (bufAligns[0] - 1)) ||
+        (sizeof(paMemPaInst) < bufSizes[0])) {
+        goto errorExit;
+    }
+    bufBases[0] = (void *)paMemPaInst;
+
+    /* The second buffer is the L2 table */
+    if (((Uint32)paMemL2Ram & (bufAligns[1] - 1)) ||
+        (sizeof(paMemL2Ram) < bufSizes[1])) {
+        goto errorExit;
+    }
+    bufBases[1] = (void *)paMemL2Ram;
+
+    /* The third buffer is the L3 table */
+    if (((Uint32)paMemL3Ram & (bufAligns[2] - 1)) ||
+        (sizeof(paMemL3Ram) < bufSizes[2])) {
+        goto errorExit;
+    }
+    bufBases[2] = (void *)paMemL3Ram;
+
+    paCfg.initTable = TRUE;
+    if (excludedResList) {
+        paCfg.initDefaultRoute = FALSE;
+    }
+    else {
+        paCfg.initDefaultRoute = TRUE;
+    }
+    paCfg.baseAddr = CSL_PA_SS_CFG_REGS;
+    paCfg.sizeCfg = &paSize;
+
+    paRet = Pa_create(&paCfg, bufBases, &paHandle);
+    if (paRet != pa_OK) {
+        goto errorExit;
+    }
+
+    /* Reset the portions of PA that are used by the DSP.  Avoid resetting
+     * anything used by Linux */
+    paRet = resetPaPdspsAndLuts(paHandle, numPdsps, excludedResList, listSize);
+    if (paRet != pa_OK) {
+        paHandle = NULL;
+    }
+
+    /* Restart DMAs */
+    linuxTxDmaEnable(excludedResList, listSize);
+
+errorExit:
+    return (paHandle);
+}
+
+/* FUNCTION PURPOSE: Resets the PA Global Config
+ ***********************************************************************
+ * DESCRIPTION: The PASS global configuration stored in the PA
+ *              scratch memory is reset to default values
+ */
+static Fm_Result paSetDefaultGblCfg(Pa_Handle passHandle, Qmss_QueueHnd cmdRespQ, Qmss_QueueHnd freeQ, int16_t flowId)
+{
+    paSysConfig_t            paDefGlobalCfg;
+    Cppi_Desc               *monolithicDesc;
+    paCmdReply_t             paReply;
+    uint8_t                 *descBuf;
+    uint32_t                 cmdLen;
+    int                      cmdDest;
+    uint32_t                 psCmd;
+    tempPaCmd               *paRespCmd;
+    uint32_t                 paRespCmdLen;    
+    paReturn_t               paRet;
+    Fm_Result                retVal = FM_FAULT_CLEANUP_OK;
+    paCtrlInfo_t             ctrlInfo;
+    /* Set the default values, taken from pa.h */
+    paProtocolLimit_t        paDefProtocolLimit = {
+        pa_PROTOCOL_LIMIT_NUM_VLANS_DEF,      /* Number of VLANs */
+        pa_PROTOCOL_LIMIT_NUM_IP_DEF,         /* Number of IPs */
+        pa_PROTOCOL_LIMIT_NUM_GRE_DEF         /* Number of GREs */
+    };
+    paCmdSetConfig_t         paDefCmdSetCfg = {
+        64      /* Number of command sets */
+    };
+    paUsrStatsConfig_t       paDefUsrStatsCfg = {
+        (pa_USR_STATS_MAX_COUNTERS - pa_USR_STATS_MAX_COUNTERS),          /* Number of user stats   */
+        (pa_USR_STATS_MAX_64B_COUNTERS - pa_USR_STATS_MAX_64B_COUNTERS)   /* Number of 64-bit user stats */
+    };
+
+    paQueueDivertConfig_t    paDefQueueDivertCfg = {
+        0,    /* Monitoring Queue */
+        0     /* flow Id */
+    };
+    paPacketControlConfig_t  paDefPktCtrlCfg = {
+        pa_PKT_CTRL_HDR_VERIFY_IP,  /* ctrlBitMap */
+        0,                          /* rxPaddingErrStatsIndex */
+        0                           /* txPaddingStatsIndex */
+    };
+    paIpReassmConfig_t       paDefReassmConfig = {
+        0,  /* numTrafficFlow */
+        0,  /* destFlowId */
+        0   /* destQueue */
+    };
+    paIpsecNatTConfig_t      paDefNatTCfg = {
+        0,    /* ctrlBitMap */
+        0     /* UDP port number */
+    };    
+
+    paDefGlobalCfg.pCmdSetConfig       = &paDefCmdSetCfg;
+    paDefGlobalCfg.pInIpReassmConfig   = &paDefReassmConfig;
+    paDefGlobalCfg.pOutIpReassmConfig  = &paDefReassmConfig;
+    paDefGlobalCfg.pPktControl         = &paDefPktCtrlCfg;
+    paDefGlobalCfg.pProtoLimit         = &paDefProtocolLimit;
+    paDefGlobalCfg.pQueueDivertConfig  = &paDefQueueDivertCfg;
+    paDefGlobalCfg.pUsrStatsConfig     = &paDefUsrStatsCfg;
+
+    memset(&paReply, 0, sizeof(paReply));
+    paReply.dest = pa_DEST_HOST;
+    paReply.queue = Qmss_getQIDFromHandle(cmdRespQ);
+    paReply.flowId = flowId;
+
+    /* Set system global default configuration */
+    ctrlInfo.code = pa_CONTROL_SYS_CONFIG;
+    ctrlInfo.params.sysCfg = paDefGlobalCfg;
+        
+    monolithicDesc = (Cppi_Desc *) QMSS_DESC_PTR(Qmss_queuePop(freeQ));
+    Cppi_getData(Cppi_DescType_MONOLITHIC, monolithicDesc, &descBuf, &cmdLen);
+    cmdLen = SIZE_MONO_DESC - Cppi_getDataOffset(Cppi_DescType_MONOLITHIC, monolithicDesc);
+    paRet = Pa_control(passHandle, &ctrlInfo, (paCmd_t)descBuf, (uint16_t *)&cmdLen, &paReply, &cmdDest);
+    if (paRet != pa_OK) {
+        if (paRet == pa_INSUFFICIENT_CMD_BUFFER_SIZE) {
+            retVal = FM_ERROR_DESC_BUF_TOO_SMALL;
+        }
+        else {
+            retVal = FM_ERROR_PASS_SETTING_DEF_GLBL_CMD;
+        }
+        goto cleanupQueue;
+    }
+    
+    psCmd = PASAHO_PACFG_CMD;
+    Cppi_setPSData (Cppi_DescType_MONOLITHIC, monolithicDesc, (uint8_t *)&psCmd, 4);
+    Cppi_setPacketLen(Cppi_DescType_MONOLITHIC, monolithicDesc, cmdLen);
+    Qmss_queuePushDescSize(paTxQs[cmdDest - pa_CMD_TX_DEST_0], (uint32_t *)monolithicDesc, SIZE_MONO_DESC);
+    
+    /* Wait for response from PA */
+    while (Qmss_getQueueEntryCount(cmdRespQ) == 0){};
+    monolithicDesc = (Cppi_Desc *) QMSS_DESC_PTR(Qmss_queuePop(cmdRespQ));
+    Cppi_getData(Cppi_DescType_MONOLITHIC, monolithicDesc,(uint8_t **)&paRespCmd, &paRespCmdLen);
+    
+    if (paRespCmd->commandResult) {
+        retVal = FM_ERROR_PASS_GBL_DEF_CFG_NOT_SET;
+        goto cleanupQueue;
+    }
+    Qmss_queuePushDescSize(freeQ, monolithicDesc, SIZE_MONO_DESC);
+
+    /* Set nat-t global default configuration */
+    ctrlInfo.code = pa_CONTROL_IPSEC_NAT_T_CONFIG;
+    ctrlInfo.params.ipsecNatTDetCfg = paDefNatTCfg;
+    ctrlInfo.params.ipsecNatTDetCfg.ctrlBitMap = 0;
+
+    monolithicDesc = (Cppi_Desc *) QMSS_DESC_PTR(Qmss_queuePop(freeQ));
+    Cppi_getData(Cppi_DescType_MONOLITHIC, monolithicDesc, &descBuf, &cmdLen);
+    cmdLen = SIZE_MONO_DESC - Cppi_getDataOffset(Cppi_DescType_MONOLITHIC, monolithicDesc);
+    paRet = Pa_control(passHandle, &ctrlInfo, (paCmd_t)descBuf, (uint16_t *)&cmdLen, &paReply, &cmdDest);
+    if (paRet != pa_OK) {
+        if (paRet == pa_INSUFFICIENT_CMD_BUFFER_SIZE) {
+            retVal = FM_ERROR_DESC_BUF_TOO_SMALL;
+        }
+        else {        
+            retVal = FM_ERROR_PASS_SETTING_DEF_NATT_CMD;
+        }
+        goto cleanupQueue;
+    }
+    
+    psCmd = PASAHO_PACFG_CMD;
+    Cppi_setPSData (Cppi_DescType_MONOLITHIC, monolithicDesc, (uint8_t *)&psCmd, 4);
+    Cppi_setPacketLen(Cppi_DescType_MONOLITHIC, monolithicDesc, cmdLen);
+    Qmss_queuePushDescSize(paTxQs[cmdDest - pa_CMD_TX_DEST_0], (uint32_t *)monolithicDesc, SIZE_MONO_DESC);
+    
+    /* Wait for response from PA */
+    while (Qmss_getQueueEntryCount(cmdRespQ) == 0){};
+    monolithicDesc = (Cppi_Desc *) QMSS_DESC_PTR(Qmss_queuePop(cmdRespQ));
+    Cppi_getData(Cppi_DescType_MONOLITHIC, monolithicDesc,(uint8_t **)&paRespCmd, &paRespCmdLen);
+    
+    if (paRespCmd->commandResult) {
+        retVal = FM_ERROR_PASS_NATT_DEF_CFG_NOT_SET;
+    }
+    
+cleanupQueue:
+    Qmss_queuePushDescSize(freeQ, monolithicDesc, SIZE_MONO_DESC);
+
+    return (retVal);    
+}
+
+/* FUNCTION PURPOSE: Powers down a peripheral
+ ***********************************************************************
+ * DESCRIPTION: Powers down the peripheral for a given power
+ *              domain number if the peripheral is currently on.
+ */
+static void periphPowerDown(uint32_t pwrDmnNum)
+{
+    if ((CSL_PSC_getPowerDomainState(pwrDmnNum) == PSC_PDSTATE_ON)) {
+        /* Peripheral is ON */  
+
+        /* Power OFF */
+
+        //Wait for any previous transitions to complete
+        while (!CSL_PSC_isStateTransitionDone (pwrDmnNum));
+        //Write Switch input into the corresponding PDCTL register
+        CSL_PSC_disablePowerDomain (pwrDmnNum);
+        //Write PTCMD to start the transition
+        CSL_PSC_startStateTransition (pwrDmnNum);
+        //Wait for the transition to complete
+        while (!CSL_PSC_isStateTransitionDone (pwrDmnNum));  
+    }
+}
+
+/**********************************************************************
+ **************************** Cleanup APIs ****************************
+ **********************************************************************/
+
+/* FUNCTION PURPOSE: Cleanup peripheral init code
+ ***********************************************************************
+ * DESCRIPTION: Initializes some peripherals via their LLDs so that
+ *              API calls used to reset their peripheral resources
+ *              will succeed.  QMSS init, CPPI init, etc.
+ */
+Fm_Result fmCleanupInit(uint32_t fullInit)
+{
+    Qmss_InitCfg qmssInitCfg;
+    Qmss_Result  qmssResult;    
+    uint32_t     heapSize;
+    Cppi_InitCfg cppiInitCfg;
+    Cppi_Result  cppiResult;
+    Fm_Result    retVal = FM_FAULT_CLEANUP_OK;
+
+    Fault_Mgmt_osalLog("Fault Cleanup: LLD Initialization\n");
+    /* Writeback status so that Host can view it */
+    fmCleanupStatus[0] = FM_STATUS_CLEANUP_INITIALIZATION;
+    Fault_Mgmt_osalEndMemAccess(&fmCleanupStatus[0], sizeof(fmCleanupStatus));
+
+    /* Init TSCL */
+    cycleDelay(0, FM_TRUE);
+
+    /* Init QMSS */
+    memset ((void *) &qmssInitCfg, 0, sizeof(qmssInitCfg));
+    if (fullInit) {
+        /* Set up the linking RAM. Use internal Linking RAM.  */
+        qmssInitCfg.linkingRAM0Base = 0;
+        qmssInitCfg.linkingRAM0Size = 0;
+        qmssInitCfg.linkingRAM1Base = 0x0;
+        qmssInitCfg.maxDescNum      = 0x3fff;
+    }
+    else {
+        qmssInitCfg.qmssHwStatus = QMSS_HW_INIT_COMPLETE;
+    }
+    qmssInitCfg.maxDescNum = NUM_MONO_DESC;
+    qmssResult = Qmss_init(&qmssInitCfg, &qmssGblCfgParams);
+    if (qmssResult != QMSS_SOK) {  
+        Fault_Mgmt_osalLog("Fault Cleanup: Failed to Init QMSS LLD\n");
+        retVal = FM_ERROR_QMSS_INIT_FAILED;
+        goto errorExit;
+    }
+
+    qmssResult = Qmss_start ();
+    if (qmssResult != QMSS_SOK) {  
+        Fault_Mgmt_osalLog("Fault Cleanup: Failed to Start QMSS LLD\n");
+        retVal = FM_ERROR_QMSS_INIT_FAILED;
+        goto errorExit;
+    }
+
+    /* Init CPPI */
+    cppiResult = Cppi_getHeapReq(cppiGblCfgParams, &heapSize);
+    cppiInitCfg.heapParams.staticHeapBase = &tempCppiHeap[0];
+    cppiInitCfg.heapParams.staticHeapSize = heapSize;
+    cppiInitCfg.heapParams.heapAlignPow2  = 8;
+    cppiInitCfg.heapParams.dynamicHeapBlockSize = -1;
+    
+    cppiResult = Cppi_initCfg(cppiGblCfgParams, &cppiInitCfg);
+    if (cppiResult != CPPI_SOK) {
+        Fault_Mgmt_osalLog("Fault Cleanup: Failed to Init CPPI LLD\n");
+        retVal =  FM_ERROR_CPPI_INIT_FAILED;
+        goto errorExit;
+    }
+
+    initComplete = FM_TRUE;
+
+errorExit:
+    return (retVal);
+}
+
+/* FUNCTION PURPOSE: Resets CPPI peripheral resources
+ ***********************************************************************
+ * DESCRIPTION: Resets CPPI peripheral resources to their PoR
+ *              state.  Resources in the exclusion list will
+ *              not be reset.
+ */
+Fm_Result fmCleanCppi(Fm_ExcludedResource *excludedResList, uint32_t listSize)
+{
+    Fm_ExclusionParams exclusionParams;    
+    Cppi_CpDmaInitCfg  dmaCfg;
+    Cppi_Handle        cppiHandle;   
+    int32_t            i, j;
+
+    if (!initComplete) {
+        return (FM_ERROR_CLEANUP_INIT_NOT_COMPLETE);
+    }   
+
+    Fault_Mgmt_osalLog("Fault Cleanup: CPPI\n");
+    /* Writeback status so that Host can view it */
+    fmCleanupStatus[0] = FM_STATUS_CLEANUP_CPDMA;
+    Fault_Mgmt_osalEndMemAccess(&fmCleanupStatus[0], sizeof(fmCleanupStatus));
+    
+    /* CPPI PoR reset process - Reset all DMA rx/tx channels and flows except 
+     *                          those owned by Linux */
+
+    memset(&exclusionParams, 0, sizeof(exclusionParams));
+    exclusionParams.exclusionList = excludedResList;
+    exclusionParams.numListEntries = listSize;
+    
+    /* Reset CPPI channels and flows */
+    for (i = 0; i < CPPI_MAX_CPDMA; i++) {
+        if (fmIsWirelessPeriphPoweredOnForCpdma((Cppi_CpDma) i)) {
+            memset ((void *) &dmaCfg, 0, sizeof(dmaCfg));
+            dmaCfg.dmaNum = (Cppi_CpDma) i;
+
+            if (cppiHandle = Cppi_open(&dmaCfg)) {
+                exclusionParams.u.cpdmaParams.dma = dmaCfg.dmaNum;
+                
+                exclusionParams.resType = Fm_res_CpdmaRxCh;
+                for (j = 0; j < fmGetDmaMaxRxCh(dmaCfg.dmaNum); j++) {
+                    exclusionParams.resourceNum = j;
+                    if (!fmExclusionIsExcluded(&exclusionParams)) {
+                        resetDmaCh(cppiHandle, i, j, Fm_res_CpdmaRxCh);
+                    }
+                }
+        
+                exclusionParams.resType = Fm_res_CpdmaTxCh;
+                for (j = 0; j < fmGetDmaMaxTxCh(dmaCfg.dmaNum); j++) {
+                    exclusionParams.resourceNum = j;
+                    if (!fmExclusionIsExcluded(&exclusionParams)) {
+                        resetDmaCh(cppiHandle, i, j, Fm_res_CpdmaTxCh);
+                    }
+                }   
+
+                exclusionParams.resType = Fm_res_CpdmaRxFlow;
+                for (j = 0; j < getDmaMaxRxFlow(dmaCfg.dmaNum); j++) {
+                    exclusionParams.resourceNum = j;
+                    if (!fmExclusionIsExcluded(&exclusionParams)) {
+                        resetDmaCh(cppiHandle, i, j, Fm_res_CpdmaRxFlow);
+                    }
+                }              
+            }         
+            else {
+                Fault_Mgmt_osalLog("Fault Cleanup: Failed to open CPDMA with index %d\n", i);
+            }
+        }
+    }
+
+    return (FM_FAULT_CLEANUP_OK);
+}
+
+/* FUNCTION PURPOSE: Resets QMSS accumulator peripheral resources
+ ***********************************************************************
+ * DESCRIPTION: Resets QMSS accumulator peripheral resources to
+ *              their PoR state.  Resources in the exclusion list will
+ *              not be reset. 
+ *
+ *              NOTE: This API should be called before queues
+ *                    are cleaned.
+ */
+Fm_Result fmCleanQmssAccum(Fm_GlobalConfigParams *fmGblCfgParams, Fm_ExcludedResource *excludedResList, 
+                           uint32_t listSize)
+{
+    Qmss_Result            qmssResult;   
+    int32_t                i;
+    Fm_ExclusionParams     exclusionParams;
+    Qmss_IntdInterruptType intdType;
+
+    if (!initComplete) {
+        return (FM_ERROR_CLEANUP_INIT_NOT_COMPLETE);
+    }  
+
+    Fault_Mgmt_osalLog("Fault Cleanup: QMSS Accumulator\n");
+    /* Writeback status so that Host can view it */
+    fmCleanupStatus[0] = FM_STATUS_CLEANUP_QMSS_ACCUM;
+    Fault_Mgmt_osalEndMemAccess(&fmCleanupStatus[0], sizeof(fmCleanupStatus));
+
+    /* QMSS cleanup - Disable all the accumulator channels except those owned by Linux */
+    memset(&exclusionParams, 0, sizeof(exclusionParams));
+    exclusionParams.exclusionList = excludedResList;
+    exclusionParams.numListEntries = listSize;
+
+    if (listSize) {
+        /* Only clean up accumulator channels if another processor is maintaining the
+         * QM PDSPs.  Another processor is in play if the exclusion list is populated */
+        exclusionParams.resType = Fm_res_QmssAccumCh;
+        for (i = 0; i < fmGblCfgParams->maxQmssAccumCh; i++) {
+            exclusionParams.resourceNum = i;
+            if (!fmExclusionIsExcluded(&exclusionParams)) {
+                /* Clear channel's pending interrupts */
+                if ((i >= fmGblCfgParams->highAccum.start) && (i <= fmGblCfgParams->highAccum.end)) {
+                    intdType = Qmss_IntdInterruptType_HIGH;
+                }
+                else if ((i >= fmGblCfgParams->loAccum.start) && (i <= fmGblCfgParams->loAccum.end)) {
+                    intdType = Qmss_IntdInterruptType_LOW;
+                }
+                else {
+                    return (FM_ERROR_INVALID_ACCUM_CH);
+                }
+                
+                while (qmssGblCfgParams.qmQueIntdReg->INTCNT_REG[i]) {
+                    Qmss_ackInterrupt(i, 1);
+                    Qmss_setEoiVector(intdType, i);
+                }
+
+                qmssResult = disableAccumChWithTimeout(Qmss_PdspId_PDSP1, i);
+                if (qmssResult < 0) {
+                    Fault_Mgmt_osalLog("Failed to disable PDSP1 accum ch %d with err %d\n", i, qmssResult);
+                }  
+            }
+        }  
+    }
+
+    return (FM_FAULT_CLEANUP_OK);
+}
+
+/* FUNCTION PURPOSE: Resets QMSS peripheral queue resources
+ ***********************************************************************
+ * DESCRIPTION: Resets QMSS peripheral queue resources to their PoR
+ *              state.  Resources in the exclusion list will
+ *              not be reset.
+ *
+ *              NOTE: This API should be called after accumulator
+ *                    channels are disabled. 
+ */
+Fm_Result fmCleanQmssQueue(Fm_GlobalConfigParams *fmGblCfgParams, Fm_ExcludedResource *excludedResList, 
+                           uint32_t listSize)
+{  
+    int32_t            i;
+    Fm_ExclusionParams exclusionParams;
+
+    if (!initComplete) {
+        return (FM_ERROR_CLEANUP_INIT_NOT_COMPLETE);
+    }  
+
+    Fault_Mgmt_osalLog("Fault Cleanup: QMSS Queues\n");
+    /* Writeback status so that Host can view it */
+    fmCleanupStatus[0] = FM_STATUS_CLEANUP_QMSS_QUEUE;
+    Fault_Mgmt_osalEndMemAccess(&fmCleanupStatus[0], sizeof(fmCleanupStatus));
+
+    /* QMSS cleanup - Don't touch QoS clusters (using different firmware downloaded by Linux kernel)
+     *              - Sweep QMSS queues of all DSP-based descriptors
+     *              - Clear all memory region registers not inserted by Linux */
+    memset(&exclusionParams, 0, sizeof(exclusionParams));
+    exclusionParams.exclusionList = excludedResList;
+    exclusionParams.numListEntries = listSize;
+
+    /* Cleanup the QMSS queues of DSP-based descriptors */
+    cleanQmssQueues(excludedResList, listSize);
+
+    exclusionParams.resType = Fm_res_QmssMemRegion;
+    for (i = 0; i < QMSS_MAX_MEM_REGIONS; i++) {
+        exclusionParams.resourceNum = i;
+        if (!fmExclusionIsExcluded(&exclusionParams)) {
+            expressResetMemoryRegion((Qmss_MemRegion)i); 
+        }
+    }
+
+    return (FM_FAULT_CLEANUP_OK);
+}
+
+/* FUNCTION PURPOSE: Resets PA peripheral resources
+ ***********************************************************************
+ * DESCRIPTION: Resets PA peripheral resources to their PoR
+ *              state.  Resources in the exclusion list will
+ *              not be reset.
+ */
+Fm_Result fmCleanPa(Fm_GlobalConfigParams *fmGblCfgParams, Fm_ExcludedResource *excludedResList, 
+                    uint32_t listSize)
+{
+    Pa_Handle           passHandle;
+    Qmss_MemRegInfo     memInfo;
+    Cppi_CpDmaInitCfg   dmaCfg;
+    Cppi_TxChInitCfg    txChCfg;
+    Cppi_RxChInitCfg    rxChCfg;
+    Cppi_RxFlowCfg      rxFlowCfg;
+    Cppi_Handle         cppiHandle;
+    Cppi_ChHnd          paTxCh;
+    Cppi_ChHnd          paRxCh;
+    Cppi_FlowHnd        rxFlowHnd = NULL;
+    Qmss_QueueHnd       freeQ = NULL;
+    Qmss_QueueHnd       cmdRespQ = NULL;    
+    Cppi_DescCfg        descCfg;
+    Qmss_Queue          queInfo;
+    uint8_t             isAllocated;
+    uint32_t            numAllocated;
+    int32_t             i, j;
+    Fm_ExclusionParams  exclusionParams;
+    Cppi_Desc          *monolithicDesc;
+    paCmdReply_t        paReply;
+    tempPaCmd           paDelCmd;
+    tempPaCmd          *paRespCmd;
+    uint32_t            paRespCmdLen;
+    uint32_t            psCmd;
+    Cppi_Result         cppiResult;
+    Fm_Result           retVal = FM_FAULT_CLEANUP_OK;
+
+    if (!initComplete) {
+        retVal = FM_ERROR_CLEANUP_INIT_NOT_COMPLETE;
+        goto errorExit;
+    }
+
+    Fault_Mgmt_osalLog("Fault Cleanup: PA\n");
+    /* Writeback status so that Host can view it */
+    fmCleanupStatus[0] = FM_STATUS_CLEANUP_PA;
+    Fault_Mgmt_osalEndMemAccess(&fmCleanupStatus[0], sizeof(fmCleanupStatus));
+
+    /* Only cleanup if NetCp is on */
+    if (isNetCpPoweredUp()) {
+        /* Init PA and reset PDSPs 1-5 */
+        if ((passHandle = resetAndInitPa(fmGblCfgParams->maxPaPdsps, excludedResList, listSize)) == NULL) {
+            retVal = FM_ERROR_PA_INIT_FAILED;
+            goto errorExit;
+        }
+             
+        /* Allocate QMSS and CPPI resources needed to send commands to PA */
+        
+        /* Initialize the exclusion parameters */
+        memset(&exclusionParams, 0, sizeof(exclusionParams));
+        exclusionParams.exclusionList = excludedResList;
+        exclusionParams.numListEntries = listSize;
+
+        /* Make sure descriptor can fit delete command */
+        if ((SIZE_MONO_DESC - MONO_DESC_DATA_OFFSET) < sizeof(paDelCmd)) {
+            retVal = FM_ERROR_DESC_BUF_TOO_SMALL;
+            goto errorExit;
+        }
+
+        /* Setup memory region for monolithic descriptors */
+        memset(&memInfo, 0, sizeof(memInfo));
+        memset ((void *) monoDesc, 0, SIZE_MONO_DESC * NUM_MONO_DESC);
+        memInfo.descBase = (uint32_t *) l2_global_address ((uint32_t) monoDesc);
+        memInfo.descSize = SIZE_MONO_DESC;
+        memInfo.descNum = NUM_MONO_DESC;
+        memInfo.manageDescFlag = Qmss_ManageDesc_MANAGE_DESCRIPTOR;
+        memInfo.startIndex = 0;
+        /* Find a memory region not used by Linux */
+        exclusionParams.resType = Fm_res_QmssMemRegion;
+        for (i = 0; i < QMSS_MAX_MEM_REGIONS; i++) {
+            exclusionParams.resourceNum = i;
+            if (!fmExclusionIsExcluded(&exclusionParams)) {
+                memInfo.memRegion = (Qmss_MemRegion)i;
+                break;
+            }        
+        }
+
+        if (Qmss_insertMemoryRegion(&memInfo) < QMSS_SOK) {
+            retVal = FM_ERROR_QMSS_INIT_FAILED_DURING_PA_RECOV;
+            goto cleanupMemRegion;
+        }
+
+        /* Open queues required to send commands to PA:
+         * - freeQ    (GP)       - contains unused descriptors
+         * - cmdSendQ (NetCP TX) - used to send commands to PA
+         * - cmdRespQ (GP)       - used to receive command responses from PA */
+        memset(&invalidQs[0], 0, sizeof(invalidQs));
+        exclusionParams.resType = Fm_res_QmssQueue;
+        i = 0;
+        while (freeQ == NULL) {
+            freeQ = Qmss_queueOpen(Qmss_QueueType_GENERAL_PURPOSE_QUEUE, QMSS_PARAM_NOT_SPECIFIED, &isAllocated);
+            exclusionParams.resourceNum = Qmss_getQIDFromHandle(freeQ);
+            if (fmExclusionIsExcluded(&exclusionParams)) {
+                /* Store the queues that can't be used until after all queues have been found. */
+                invalidQs[i++] = freeQ;
+                freeQ = NULL;
+            }
+        }
+        while (cmdRespQ == NULL) {
+            cmdRespQ = Qmss_queueOpen(Qmss_QueueType_GENERAL_PURPOSE_QUEUE, QMSS_PARAM_NOT_SPECIFIED, &isAllocated);
+            exclusionParams.resourceNum = Qmss_getQIDFromHandle(cmdRespQ);
+            if (fmExclusionIsExcluded(&exclusionParams)) {
+                /* Store the queues that can't be used until after all queues have been found. */
+                invalidQs[i++] = cmdRespQ;
+                cmdRespQ = NULL;
+            }
+        }      
+        /* Free any invalidQs */
+        for (j = 0; j < i; j++) {
+            Qmss_queueClose(invalidQs[j]);
+        }
+
+        /* Open all PASS tx queues.  It's okay if already opened by Linux.  Just need the interface
+         * to PA PDSPs */
+        for (i = 0; i < PA_MAX_NUM_CPPI_TX_CH; i++) {
+            paTxQs[i] = Qmss_queueOpen(Qmss_QueueType_PASS_QUEUE, QMSS_PARAM_NOT_SPECIFIED, &isAllocated);
+        }
+
+        /* Setup the descriptors for freeQ */
+        memset(&descCfg, 0, sizeof(descCfg));
+        descCfg.memRegion = memInfo.memRegion;
+        descCfg.descNum = NUM_MONO_DESC;
+        descCfg.destQueueNum = Qmss_getQIDFromHandle(freeQ);
+        descCfg.queueType = Qmss_QueueType_STARVATION_COUNTER_QUEUE;
+        descCfg.initDesc = Cppi_InitDesc_INIT_DESCRIPTOR;
+        descCfg.descType = Cppi_DescType_MONOLITHIC;
+        descCfg.epibPresent = Cppi_EPIB_NO_EPIB_PRESENT;
+        descCfg.cfg.mono.dataOffset = MONO_DESC_DATA_OFFSET;
+        /* Descriptor should be recycled back to freeQ */
+        queInfo = Qmss_getQueueNumber(freeQ);
+        descCfg.returnQueue.qMgr = queInfo.qMgr;
+        descCfg.returnQueue.qNum = queInfo.qNum;
+
+        /* Initialize the descriptors and push to free Queue */
+        if (Cppi_initDescriptor(&descCfg, &numAllocated) < CPPI_SOK) {
+            retVal = FM_ERROR_CPPI_INIT_FAILED_DURING_PA_RECOV;
+            goto cleanupResources;
+        }
+        /* Writeback changes to the monolithic descriptors */
+        Fault_Mgmt_osalEndMemAccess(&monoDesc[0], sizeof(monoDesc));
+
+        /* Open PASS DMA to send commands to and receive responses from PA */
+        memset ((void *)&dmaCfg, 0, sizeof(dmaCfg));
+        dmaCfg.dmaNum = Cppi_CpDma_PASS_CPDMA;
+        cppiHandle = Cppi_open(&dmaCfg);
+
+        /* Open PASS rxChs - Doesn't matter if already used by Linux */
+        memset(&rxChCfg, 0, sizeof(rxChCfg));
+        for (i = 0; i < fmGetDmaMaxRxCh(Cppi_CpDma_PASS_CPDMA); i++) {
+            rxChCfg.channelNum = i;
+            rxChCfg.rxEnable = Cppi_ChState_CHANNEL_DISABLE;
+            paRxCh = Cppi_rxChannelOpen(cppiHandle, &rxChCfg, &isAllocated);
+            Cppi_channelEnable(paRxCh);
+        }
+
+        /* Open all cppi tx channels to go with the queues - don't need to save handle */
+        for (i = 0; i < PA_MAX_NUM_CPPI_TX_CH; i ++) {
+            memset(&txChCfg, 0, sizeof(txChCfg));
+            txChCfg.txEnable = Cppi_ChState_CHANNEL_DISABLE;
+            txChCfg.channelNum = Qmss_getQIDFromHandle(paTxQs[i]) - QMSS_PASS_QUEUE_BASE;
+            paTxCh = Cppi_txChannelOpenWithHwCfg(cppiHandle, &txChCfg, &isAllocated, 0);
+            Cppi_channelEnable(paTxCh);
+        }
+
+        /* Open a PASS rxFlow */
+        memset(&rxFlowCfg, 0, sizeof(rxFlowCfg));
+        exclusionParams.resType = Fm_res_CpdmaRxFlow;
+        exclusionParams.u.cpdmaParams.dma = Cppi_CpDma_PASS_CPDMA;
+        for (i = 0; i < getDmaMaxRxFlow(Cppi_CpDma_PASS_CPDMA); i++) {
+            exclusionParams.resourceNum = i;
+            if (!fmExclusionIsExcluded(&exclusionParams)) {
+                rxFlowCfg.flowIdNum = i;
+                break;
+            }        
+        }
+        rxFlowCfg.rx_ps_location = Cppi_PSLoc_PS_IN_DESC;
+        rxFlowCfg.rx_desc_type = Cppi_DescType_MONOLITHIC;
+        rxFlowCfg.rx_sop_offset = MONO_DESC_DATA_OFFSET;
+        queInfo = Qmss_getQueueNumber(freeQ);
+        rxFlowCfg.rx_fdq0_sz0_qnum = queInfo.qNum;
+        rxFlowCfg.rx_fdq0_sz0_qmgr = queInfo.qMgr;
+        rxFlowHnd = Cppi_configureRxFlow(cppiHandle, &rxFlowCfg, &isAllocated);
+
+        if (listSize) {
+            /* A present exclusion list signifies another core (typically ARM Linux) is in
+             * control of PA.  As a result, LUT1 entry deletion must take place and be selective.  If
+             * listSize is 0 the resetPaPdspsAndLuts function will have reset all PDSPs cleaning out 
+             * all LUT entries. */        
+            exclusionParams.resType = Fm_res_PaLutEntry;
+            exclusionParams.u.lutParams.lutInst = 1;
+            for (i = 0; i < fmGblCfgParams->maxLut1Entries; i++) {
+                exclusionParams.resourceNum = i;
+                if (!fmExclusionIsExcluded(&exclusionParams)) {
+                    memset(&paReply, 0, sizeof(paReply));
+                    paReply.dest = pa_DEST_HOST;
+                    paReply.queue = Qmss_getQIDFromHandle(cmdRespQ);
+                    paReply.flowId = rxFlowCfg.flowIdNum;
+                    pa_format_fcmd((void *) &paDelCmd, &paReply, (uint8_t) i);
+                        
+                    monolithicDesc = (Cppi_Desc *) QMSS_DESC_PTR(Qmss_queuePop(freeQ));
+                    Cppi_setData(Cppi_DescType_MONOLITHIC, monolithicDesc, (uint8_t *)&paDelCmd, sizeof(paDelCmd));
+                    psCmd = PASAHO_PACFG_CMD;
+                    Cppi_setPSData (Cppi_DescType_MONOLITHIC, monolithicDesc, (uint8_t *)&psCmd, 4);
+                    Cppi_setPacketLen(Cppi_DescType_MONOLITHIC, monolithicDesc, sizeof(paDelCmd));
+                    /* LUT entry delete commands sent to PDSP 0 (Queue 640) */
+                    Qmss_queuePushDescSize(paTxQs[pa_CMD_TX_DEST_0], (uint32_t *)monolithicDesc, SIZE_MONO_DESC);
+
+                    /* Wait for response from PA */
+                    while (Qmss_getQueueEntryCount(cmdRespQ) == 0){};
+                    monolithicDesc = (Cppi_Desc *) QMSS_DESC_PTR(Qmss_queuePop(cmdRespQ));
+                    Cppi_getData(Cppi_DescType_MONOLITHIC, monolithicDesc,(uint8_t **)&paRespCmd, &paRespCmdLen);
+
+                    if (paRespCmd->commandResult) {
+                        retVal = FM_ERROR_LUT1_INDEX_NOT_REMOVED;
+                        Qmss_queuePushDescSize(freeQ, monolithicDesc, SIZE_MONO_DESC);
+                        goto cleanupResources;
+                    }
+                    Qmss_queuePushDescSize(freeQ, monolithicDesc, SIZE_MONO_DESC);
+                }     
+            }
+        }
+
+        if ((retVal = paSetDefaultGblCfg(passHandle, cmdRespQ, freeQ, rxFlowCfg.flowIdNum)) != FM_FAULT_CLEANUP_OK) {
+            goto cleanupResources;
+        }
+
+cleanupResources:
+        if ((cppiResult = Cppi_closeRxFlow(rxFlowHnd)) != CPPI_SOK) {
+            Fault_Mgmt_osalLog("Failed to disable PASS rx flow %d with err %d\n", rxFlowCfg.flowIdNum, cppiResult);
+        }      
+        
+        /* All descriptors should be in freeQ */
+        Qmss_queueEmpty(freeQ);
+        Qmss_queueEmpty(cmdRespQ);
+
+cleanupMemRegion:        
+        expressResetMemoryRegion(memInfo.memRegion); 
+    }
+errorExit:
+    return (retVal);
+}
+
+/* FUNCTION PURPOSE: Cleans SA security context
+ ***********************************************************************
+ * DESCRIPTION: Evicts and tears down the SA security contexts
+ *              so that IPsec traffic can be reestablished
+ */
+Fm_Result fmCleanSa(Fm_ExcludedResource *excludedResList, uint32_t listSize)
+{
+    CSL_Cp_aceRegs *pSaRegs = (CSL_Cp_aceRegs *)CSL_PA_SS_CFG_CP_ACE_CFG_REGS;;        
+    int             i;
+    uint32_t        ctxCachCtrl;
+    Fm_Result       retVal = FM_FAULT_CLEANUP_OK;
+
+    Fault_Mgmt_osalLog("Fault Cleanup: SA\n");
+    /* Writeback status so that Host can view it */
+    fmCleanupStatus[0] = FM_STATUS_CLEANUP_SA;
+    Fault_Mgmt_osalEndMemAccess(&fmCleanupStatus[0], sizeof(fmCleanupStatus));
+
+    /* Only cleanup if context cache is enabled */
+    if ((pSaRegs->MMR.CMD_STATUS & CSL_CP_ACE_CMD_STATUS_CTXCACH_EN_MASK)) {
+
+        /* Stop flow of descriptors while resetting SA */
+        linuxTxDmaDisable(excludedResList, listSize);
+        
+
+        /* Clear the security context cache - Allows IPsec tunnels to be recreated
+         * from scratch after cleanup */
+        ctxCachCtrl = pSaRegs->MMR.CTXCACH_CTRL;
+        ctxCachCtrl |= CSL_CP_ACE_CTXCACH_CTRL_CLR_CACHE_TABLE_MASK;
+        pSaRegs->MMR.CTXCACH_CTRL = ctxCachCtrl;
+
+        /* Wait for bit to clear for completion */
+        do {                           
+            for (i = 0; i < 100; i++) {
+                asm (" nop ");
+            }
+        } while (pSaRegs->MMR.CTXCACH_CTRL & CSL_CP_ACE_CTXCACH_CTRL_CLR_CACHE_TABLE_MASK);
+
+        /* Restart DMAs */
+        linuxTxDmaEnable(excludedResList, listSize);        
+    }
+
+    return (retVal);
+}
+
+/* FUNCTION PURPOSE: Resets Semaphore peripheral resources
+ ***********************************************************************
+ * DESCRIPTION: Resets Semaphore peripheral resources to their PoR
+ *              state.  Resources in the exclusion list will
+ *              not be reset.
+ */
+Fm_Result fmCleanSemaphores(Fm_ExcludedResource *excludedResList, uint32_t listSize)
+{
+    Fault_Mgmt_osalLog("Fault Cleanup: Semaphore\n");
+    /* Writeback status so that Host can view it */
+    fmCleanupStatus[0] = FM_STATUS_CLEANUP_SEMAPHORE;
+    Fault_Mgmt_osalEndMemAccess(&fmCleanupStatus[0], sizeof(fmCleanupStatus));
+    
+    /* Soft reset semaphores through the SEM_RST_RUN register */
+    CSL_FINS(hSEM->SEM_RST_RUN, SEM_SEM_RST_RUN_RESET, 1);
+
+    return (FM_FAULT_CLEANUP_OK);
+}
+
+/* FUNCTION PURPOSE: Resets the CICs
+ ***********************************************************************
+ * DESCRIPTION: Clears a CIC of all system interrupt to host interrupt
+ *              mappings except those routed to Linux
+ */
+Fm_Result fmCleanCics(Fm_GlobalConfigParams *fmGblCfgParams, Fm_ExcludedResource *excludedResList,
+                      uint32_t listSize)
+{
+    int32_t                  i, j, k;
+    volatile CSL_CPINTCRegs *regs;
+    uint32_t                 numSysInt;
+    uint32_t                 numHostInt;
+    Fm_ExclusionParams       exclusionParams;
+    uint32_t                 entireCicDisable;
+    Fm_Result                retVal = FM_FAULT_CLEANUP_OK;
+
+    Fault_Mgmt_osalLog("Fault Cleanup: CIC\n");
+    /* Writeback status so that Host can view it */
+    fmCleanupStatus[0] = FM_STATUS_CLEANUP_CIC;
+    Fault_Mgmt_osalEndMemAccess(&fmCleanupStatus[0], sizeof(fmCleanupStatus));
+
+    memset(&exclusionParams, 0, sizeof(exclusionParams));
+    exclusionParams.exclusionList = excludedResList;
+    exclusionParams.numListEntries = listSize;
+    exclusionParams.resType = Fm_res_CicHostInt;
+
+    for (i = 0; i < fmGblCfgParams->maxCic; i++) {
+        exclusionParams.u.cicParams.cic = i;
+        
+        /* Get CIC params */
+        regs = fmGblCfgParams->cicParams[i].cicRegs;
+        numSysInt = fmGblCfgParams->cicParams[i].maxNumSysInt;
+        numHostInt = fmGblCfgParams->cicParams[i].maxNumHostInt;
+        entireCicDisable = FM_TRUE;
+
+        /* Unmap and disable all host interrupts not in exclusion list */
+        for (j = 0; j < numHostInt; j++) {
+            exclusionParams.resourceNum = j;
+            if (!fmExclusionIsExcluded(&exclusionParams)) {
+                /* Disable the host interrupt */
+                regs->HINT_ENABLE_CLR_INDEX_REG = CSL_FMK(CPINTC_HINT_ENABLE_CLR_INDEX_REG_HINT_ENABLE_CLR_INDEX, j);
+                
+                for (k = 0; k < numSysInt; k++) {
+                    /* Clear system int channel map routed to host int */
+                    if (regs->CH_MAP[k] == j) {
+                        regs->CH_MAP[k] = 0;
+
+                        /* Disable sys int since not routed anymore */
+                        regs->ENABLE_CLR_INDEX_REG = CSL_FMK(CPINTC_ENABLE_CLR_INDEX_REG_ENABLE_CLR_INDEX, k);
+
+                        /* Clear any pending interrupts */
+                        regs->STATUS_CLR_INDEX_REG = CSL_FMK(CPINTC_STATUS_CLR_INDEX_REG_STATUS_CLR_INDEX, k);
+                    }
+                }
+            }
+            else {
+                /* At least one host interrupt in this CIC is excluded.  Don't
+                 * perform global disable of host interrupts for this CIC */
+                entireCicDisable = FM_FALSE;
+            }
+        }
+
+        /* Global disable of host interrupts if none excluded */
+        if (entireCicDisable) {
+            regs->GLOBAL_ENABLE_HINT_REG = CSL_FMK(CPINTC_GLOBAL_ENABLE_HINT_REG_ENABLE_HINT_ANY, 0);
+        }
+    }
+    
+    return (retVal);
+}
+
+/* FUNCTION PURPOSE: Resets Timers
+ ***********************************************************************
+ * DESCRIPTION: Disables and resets all device timers except 
+ *              those used by Linux
+ */
+Fm_Result fmCleanTimers(Fm_GlobalConfigParams *fmGblCfgParams, Fm_ExcludedResource *excludedResList,
+                        uint32_t listSize)
+{
+    volatile CSL_TmrRegs *regs;
+    int32_t               i;
+    Uint32                tmpReg;    
+    Fm_ExclusionParams    exclusionParams;    
+    Fm_Result             retVal = FM_FAULT_CLEANUP_OK;    
+
+    Fault_Mgmt_osalLog("Fault Cleanup: Timers\n");
+    /* Writeback status so that Host can view it */
+    fmCleanupStatus[0] = FM_STATUS_CLEANUP_TIMER;
+    Fault_Mgmt_osalEndMemAccess(&fmCleanupStatus[0], sizeof(fmCleanupStatus));
+
+    memset(&exclusionParams, 0, sizeof(exclusionParams));
+    exclusionParams.exclusionList = excludedResList;
+    exclusionParams.numListEntries = listSize;
+    exclusionParams.resType = Fm_res_Timer;
+
+    for (i = 0; i < fmGblCfgParams->maxTimers; i++) {
+        exclusionParams.resourceNum = i;
+        if (!fmExclusionIsExcluded(&exclusionParams)) {        
+            regs = fmGblCfgParams->timerParams[i].timerRegs;
+
+            /* Disable the LOW and HIGH Timers. */
+            tmpReg = regs->TCR;
+            CSL_FINST(tmpReg, TMR_TCR_ENAMODE_LO, DISABLE);
+            CSL_FINST(tmpReg, TMR_TCR_ENAMODE_HI, DISABLE);
+            regs->TCR = tmpReg;
+
+            /* Reset after disable */
+            tmpReg = regs->TGCR;
+            CSL_FINST(tmpReg, TMR_TGCR_TIMLORS, RESET_ON);
+            CSL_FINST(tmpReg, TMR_TGCR_TIMHIRS, RESET_ON);
+            regs->TGCR = tmpReg;
+        }
+    }
+    
+    return (retVal);
+}
+
+/* FUNCTION PURPOSE: Resets AIF2
+ ***********************************************************************
+ * DESCRIPTION: Resets the AIF2 peripheral and then powers it down
+ */
+Fm_Result fmCleanAif2(void)
+{
+    Fault_Mgmt_osalLog("Fault Cleanup: AIF2\n");
+    /* Writeback status so that Host can view it */
+    fmCleanupStatus[0] = FM_STATUS_CLEANUP_AIF2;
+    Fault_Mgmt_osalEndMemAccess(&fmCleanupStatus[0], sizeof(fmCleanupStatus));
+
+    if ((CSL_PSC_getPowerDomainState(CSL_PSC_PD_AI) == PSC_PDSTATE_ON)) {
+        /* On */
+        memset(&locAifObj, 0, sizeof(locAifObj));
+        AIF_resetAif(&locAifObj);
+
+#if 0 /* K2 only - Add back when K2 support is added */
+        /* Reset SERDES separately */
+        /* Link 0 to Link 3*/
+        CSL_AIF2SerdesShutdown(CSL_AIF2_SERDES_B8_CFG_REGS);
+        /* Link 4 to Link 5*/
+        CSL_AIF2SerdesShutdown(CSL_AIF2_SERDES_B4_CFG_REGS);
+#endif        
+    }
+    periphPowerDown(CSL_PSC_PD_AI);
+
+    return (FM_FAULT_CLEANUP_OK);
+}
+
+/* FUNCTION PURPOSE: Resets TCP3D
+ ***********************************************************************
+ * DESCRIPTION: Powers down the TCP3D peripheral
+ */
+Fm_Result fmCleanTcp3d(void)
+{
+    Fault_Mgmt_osalLog("Fault Cleanup: TCP3D\n");
+    /* Writeback status so that Host can view it */
+    fmCleanupStatus[0] = FM_STATUS_CLEANUP_TCP3D;
+    Fault_Mgmt_osalEndMemAccess(&fmCleanupStatus[0], sizeof(fmCleanupStatus));
+
+    periphPowerDown(CSL_PSC_PD_TCP3D_A);
+    periphPowerDown(CSL_PSC_PD_TCP3D_B);
+    
+    return (FM_FAULT_CLEANUP_OK);
+}
+
+/* FUNCTION PURPOSE: Resets BCP
+ ***********************************************************************
+ * DESCRIPTION: Powers down the BCP peripheral
+ */
+Fm_Result fmCleanBcp(void)
+{
+    Fault_Mgmt_osalLog("Fault Cleanup: BCP\n");
+    /* Writeback status so that Host can view it */
+    fmCleanupStatus[0] = FM_STATUS_CLEANUP_BCP;
+    Fault_Mgmt_osalEndMemAccess(&fmCleanupStatus[0], sizeof(fmCleanupStatus));
+
+    periphPowerDown(CSL_PSC_PD_BCP);
+
+    return (FM_FAULT_CLEANUP_OK);
+}
+
+/* FUNCTION PURPOSE: Resets FFTC
+ ***********************************************************************
+ * DESCRIPTION: Powers down the FFTC peripheral
+ */
+Fm_Result fmCleanFftc(void)
+{
+    Fault_Mgmt_osalLog("Fault Cleanup: FFTC (A & B)\n");
+    /* Writeback status so that Host can view it */
+    fmCleanupStatus[0] = FM_STATUS_CLEANUP_FFTC;
+    Fault_Mgmt_osalEndMemAccess(&fmCleanupStatus[0], sizeof(fmCleanupStatus));
+
+    periphPowerDown(CSL_PSC_PD_FFTC_AB);
+
+    return (FM_FAULT_CLEANUP_OK);
+}
+
+/* FUNCTION PURPOSE: Resets VCP
+ ***********************************************************************
+ * DESCRIPTION: Powers down the VCP peripheral
+ */
+Fm_Result fmCleanVcp(void)
+{
+    Fault_Mgmt_osalLog("Fault Cleanup: VCP\n");
+    /* Writeback status so that Host can view it */
+    fmCleanupStatus[0] = FM_STATUS_CLEANUP_VCP;
+    Fault_Mgmt_osalEndMemAccess(&fmCleanupStatus[0], sizeof(fmCleanupStatus));
+
+    periphPowerDown(CSL_PSC_PD_PD_VCP_BCD);
+
+    return (FM_FAULT_CLEANUP_OK);
+}
+#endif /* !(K2H && K2K && K2L && K2E) */
+
+/* FUNCTION PURPOSE: Resets EDMA3 peripheral resources
+ ***********************************************************************
+ * DESCRIPTION: Resets EDMA3 peripheral resources to their PoR
+ *              state.  Resources in the exclusion list will
+ *              not be reset.
+ */
+Fm_Result fmCleanEdma3(Fm_GlobalConfigParams *fmGblCfgParams, Fm_ExcludedResource *excludedResList, 
+                       uint32_t listSize, uint32_t provideStatus)
+{
+    CSL_Edma3Handle    edmaCCModule;    
+    int32_t            i, j, k;
+    CSL_Status         status;
+    Fm_ExclusionParams exclusionParams;
+
+    if (provideStatus) {
+#if (!defined(DEVICE_K2H) && !defined(DEVICE_K2K) && !defined(DEVICE_K2L) && !defined(DEVICE_K2E))        
+        Fault_Mgmt_osalLog("Fault Cleanup: EDMA3\n");
+        /* Writeback status so that Host can view it */
+        fmCleanupStatus[0] = FM_STATUS_CLEANUP_EDMA3;
+        Fault_Mgmt_osalEndMemAccess(&fmCleanupStatus[0], sizeof(fmCleanupStatus));
+#endif /* !(K2H && K2K && K2L && K2E) */        
+    }
+    
+    memset(&exclusionParams, 0, sizeof(exclusionParams));
+    exclusionParams.exclusionList = excludedResList;
+    exclusionParams.numListEntries = listSize;
+
+    for (i = 0; i < fmGblCfgParams->maxEdma3Cc; i++) {
+        /* Module Level Open */
+        memset((void *)&edmaCCModule, 0, sizeof(edmaCCModule));
+        memset((void *)&edmaObjCC, 0, sizeof(edmaObjCC));
+        edmaCCModule = CSL_edma3Open(&edmaObjCC, i, NULL, &status);
+        if ((edmaCCModule == NULL) || (status != CSL_SOK)) {
+            return(FM_ERROR_EDMA3_INIT_FAILED);
+        }
+        
+        exclusionParams.u.edma3Params.edma3Num = i;
+
+        /* Disable CC channels */
+        exclusionParams.resType = Fm_res_Edma3DmaCh;
+        for (j = 0; j < edmaObjCC.cfgInfo.numDMAChannel; j++) {
+            exclusionParams.resourceNum = j;
+            if (!fmExclusionIsExcluded(&exclusionParams)) {            
+                CSL_edma3DMAChannelDisable(edmaCCModule, CSL_EDMA3_REGION_GLOBAL, j);
+                CSL_edma3ClearDMAChannelEvent(edmaCCModule, CSL_EDMA3_REGION_GLOBAL, j);
+                for (k = 0; k < edmaObjCC.cfgInfo.numRegions; k++) {
+                    CSL_edma3DMAChannelDisable(edmaCCModule, k, j);
+                    CSL_edma3ClearDMAChannelEvent(edmaCCModule, k, j);
+                }
+                CSL_edma3ClearDMAChannelSecondaryEvents(edmaCCModule, j);
+            }
+        }     
+
+        exclusionParams.resType = Fm_res_Edma3QdmaCh;
+        for (j = 0; j < edmaObjCC.cfgInfo.numQDMAChannel; j++) {
+            exclusionParams.resourceNum = j;
+            if (!fmExclusionIsExcluded(&exclusionParams)) {            
+                CSL_edma3QDMAChannelDisable(edmaCCModule, CSL_EDMA3_REGION_GLOBAL, j);
+                CSL_edma3ClearQDMAChannelSecondaryEvents(edmaCCModule, j);
+            }
+        }
+
+        exclusionParams.resType = Fm_res_Edma3IntCh;
+        for (j = 0; j < edmaObjCC.cfgInfo.numINTChannel; j++) {
+            exclusionParams.resourceNum = j;
+            if (!fmExclusionIsExcluded(&exclusionParams)) {
+                if (j < 32) {
+                    CSL_edma3InterruptLoDisable(edmaCCModule, CSL_EDMA3_REGION_GLOBAL, j);                        
+                    CSL_edma3ClearLoPendingInterrupts (edmaCCModule, CSL_EDMA3_REGION_GLOBAL, j);
+                }
+                else {
+                    CSL_edma3InterruptHiDisable(edmaCCModule, CSL_EDMA3_REGION_GLOBAL, j);  
+                    CSL_edma3ClearHiPendingInterrupts (edmaCCModule, CSL_EDMA3_REGION_GLOBAL, j);
+                }
+            }
+        }   
+    }    
+
+#if (!defined(DEVICE_K2H) && !defined(DEVICE_K2K) && !defined(DEVICE_K2L) && !defined(DEVICE_K2E)) 
+    return (FM_FAULT_CLEANUP_OK);
+#else
+    return (0);
+#endif
+}
+
+/* FUNCTION PURPOSE: Gets the max CPPI tx ch for a CPDMA
+ ***********************************************************************
+ * DESCRIPTION: Returns the maximum number of tx ch for the
+ *              given CPDMA
+ *
+ * CPPI API hardcoded here until it can be added to CPPI LLD 
+ */
+uint32_t fmGetDmaMaxTxCh(Cppi_CpDma dmaNum)
+{
+    uint32_t maxTxCh;
+
+#if (!defined(DEVICE_K2H) && !defined(DEVICE_K2K) && !defined(DEVICE_K2L) && !defined(DEVICE_K2E))
+    maxTxCh = cppiGblCfgParams[dmaNum].maxTxCh;
+#else
+    maxTxCh = cppiGblCfgParams.cpDmaCfgs[dmaNum].maxTxCh;
+#endif
+    return (uint32_t) maxTxCh;
+}
+
+/* FUNCTION PURPOSE: Gets the max CPPI rx ch for a CPDMA
+ ***********************************************************************
+ * DESCRIPTION: Returns the maximum number of rx ch for the
+ *              given CPDMA
+ *
+ * CPPI API hardcoded here until it can be added to CPPI LLD 
+ */
+uint32_t fmGetDmaMaxRxCh(Cppi_CpDma dmaNum)
+{
+    uint32_t maxRxCh;
+
+#if (!defined(DEVICE_K2H) && !defined(DEVICE_K2K) && !defined(DEVICE_K2L) && !defined(DEVICE_K2E))    
+    maxRxCh = cppiGblCfgParams[dmaNum].maxRxCh;
+#else
+    maxRxCh = cppiGblCfgParams.cpDmaCfgs[dmaNum].maxRxCh;
+#endif
+    return (uint32_t) maxRxCh;
+}
diff --git a/src/fm_exclusion.c b/src/fm_exclusion.c
new file mode 100644 (file)
index 0000000..105d64b
--- /dev/null
@@ -0,0 +1,307 @@
+/**
+ *   @file  fm_exclusion.c
+ *
+ *   @brief   
+ *      Fault Management exclusion list source
+ *
+ *  \par
+ *  ============================================================================
+ *  @n   (C) Copyright 2014, Texas Instruments, Inc.
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  \par
+*/
+
+/* CSL Includes */
+#include <ti/csl/csl_sem.h>
+#include <ti/csl/cslr.h>
+
+/* FM API Include */
+#include <ti/instrumentation/fault_mgmt/fault_mgmt.h>
+
+/* FM Internal Includes */
+#include <ti/instrumentation/fault_mgmt/include/fm_loc.h>
+#include <ti/instrumentation/fault_mgmt/include/fm_exclusionloc.h>
+
+/**********************************************************************
+ ********************* Exclusion Globals ******************************
+ **********************************************************************/
+
+
+/**********************************************************************
+ ******************** External Variables ******************************
+ **********************************************************************/
+
+
+/**********************************************************************
+ ******************* Local Exclusion Functions ***********************
+ **********************************************************************/
+
+/* FUNCTION PURPOSE: Generic check if a resource is in exclusion list
+ ***********************************************************************
+ * DESCRIPTION: Compares input resource with the list of resources
+ *              in the supplied exclusion list
+ */
+static uint32_t isExcludedGenericResource(Fm_ExclusionParams *exParams)
+{
+   int i;
+  
+   if (exParams->exclusionList) {
+       for (i = 0; i < exParams->numListEntries; i++) {
+           if (exParams->exclusionList[i].resType == exParams->resType) {
+               if ((exParams->resourceNum >= exParams->exclusionList[i].exRange.exStart) && 
+                   (exParams->resourceNum <= exParams->exclusionList[i].exRange.exEnd)) {
+                   return (FM_TRUE);
+               }
+           }
+       }
+   }
+  
+   return (FM_FALSE);
+}
+
+/* FUNCTION PURPOSE: Checks if CPDMA channel is in exclusion list
+ ***********************************************************************
+ * DESCRIPTION: Compares input channel/flow of a given CPDMA with the
+ *              list of CPDMA channels in the supplied exclusion list
+ */
+static uint32_t isExcludedCpdmaResource(Fm_ExclusionParams *exParams)
+{
+   Fm_ExclusionCpdmaParams *cpdmaParams = &(exParams->u.cpdmaParams);
+   int                      i;
+  
+   if (exParams->exclusionList) {
+       for (i = 0; i < exParams->numListEntries; i++) {
+           if (exParams->exclusionList[i].resType == exParams->resType) {
+               if ((cpdmaParams->dma == exParams->exclusionList[i].exResInfo) &&
+                   (exParams->resourceNum >= exParams->exclusionList[i].exRange.exStart) && 
+                   (exParams->resourceNum <= exParams->exclusionList[i].exRange.exEnd)) {
+                   return (FM_TRUE);
+               }
+           }
+       }
+   }
+  
+   return (FM_FALSE);
+}
+
+/* FUNCTION PURPOSE: Checks if EDMA3 channel is in exclusion list
+ ***********************************************************************
+ * DESCRIPTION: Compares input channel with the list of EDMA3 channels
+ *              in the supplied exclusion list
+ */
+static uint32_t isExcludedEdma3Resource(Fm_ExclusionParams *exParams)
+{
+   Fm_ExclusionEdma3Params *edma3Params = &(exParams->u.edma3Params);
+   int                      i;
+  
+   if (exParams->exclusionList) {
+       for (i = 0; i < exParams->numListEntries; i++) {
+           if (exParams->exclusionList[i].resType == exParams->resType) {
+               if ((edma3Params->edma3Num == exParams->exclusionList[i].exResInfo) &&
+                   (exParams->resourceNum >= exParams->exclusionList[i].exRange.exStart) && 
+                   (exParams->resourceNum <= exParams->exclusionList[i].exRange.exEnd)) {
+                   return (FM_TRUE);
+               }
+           }
+       }
+   }
+  
+   return (FM_FALSE);
+}
+
+/* FUNCTION PURPOSE: Checks if LUT entry is in exclusion list
+ ***********************************************************************
+ * DESCRIPTION: Compares input LUT entry with the list of LUT entries
+ *              in the supplied exclusion list
+ */
+static uint32_t isExcludedLutEntry(Fm_ExclusionParams *exParams)
+{
+    Fm_ExclusionLutEntryParams *lutParams = &(exParams->u.lutParams);
+    int                         i;
+    
+    if (exParams->exclusionList) {
+        for (i = 0; i < exParams->numListEntries; i++) {
+            if (exParams->exclusionList[i].resType == exParams->resType) {
+                if ((lutParams->lutInst == exParams->exclusionList[i].exResInfo) &&
+                    (exParams->resourceNum >= exParams->exclusionList[i].exRange.exStart) && 
+                    (exParams->resourceNum <= exParams->exclusionList[i].exRange.exEnd)) {
+                    return (FM_TRUE);
+                }
+            }
+        }
+    }
+    
+    return (FM_FALSE);
+}
+
+/* FUNCTION PURPOSE: Checks if CIC host interrupt is in exclusion list
+ ***********************************************************************
+ * DESCRIPTION: Compares input CIC host interrupt with the list of 
+ *              CIC host interrupts in the supplied exclusion list
+ */
+static uint32_t isExcludedCicResource(Fm_ExclusionParams *exParams)
+{
+    Fm_ExclusionCicParams *cicParams = &(exParams->u.cicParams);
+    int                    i;
+    
+    if (exParams->exclusionList) {
+        for (i = 0; i < exParams->numListEntries; i++) {
+            if (exParams->exclusionList[i].resType == exParams->resType) {
+                if ((cicParams->cic == exParams->exclusionList[i].exResInfo) &&
+                    (exParams->resourceNum >= exParams->exclusionList[i].exRange.exStart) && 
+                    (exParams->resourceNum <= exParams->exclusionList[i].exRange.exEnd)) {
+                    return (FM_TRUE);
+                }
+            }
+        }
+    }
+    
+    return (FM_FALSE);
+}
+
+/**********************************************************************
+ ************************** Exclusion APIs ****************************
+ **********************************************************************/
+
+/* FUNCTION PURPOSE: Validates the excluded resource list passed by the app
+ ***********************************************************************
+ * DESCRIPTION: Validates the exResInfo field for the different possible
+ *              exclusion types that can be passed in.  Will return a -1
+ *              and the exclusion list entry that failed if the exResInfo
+ *              does not match what is expected.  Otherwise, returns 0 in the
+ *              status field and the number of exclusion entries
+ *              as the return value.
+ */
+uint32_t fmExclusionValidateList(Fm_GlobalConfigParams *fmGblCfgParams, Fm_ExcludedResource *exResList, 
+                                 int32_t *status)
+{
+    int32_t exEntries = 0;
+
+    *status  = FM_OK;
+
+    if (exResList) {
+        while(exResList[exEntries].resType != Fm_res_END) {
+            switch(exResList[exEntries].resType) {
+                case Fm_res_CpdmaRxCh:
+                case Fm_res_CpdmaTxCh:
+                case Fm_res_CpdmaRxFlow:
+                    if (exResList[exEntries].exResInfo > CPPI_MAX_CPDMA) {
+                        *status = FM_ERROR_INVALID_CPDMA_IN_EXCLUSION_LIST;
+                        return(exEntries);
+                    }
+                    break;
+                case Fm_res_Edma3DmaCh:
+                case Fm_res_Edma3QdmaCh:
+                case Fm_res_Edma3IntCh:
+                    if (exResList[exEntries].exResInfo > fmGblCfgParams->maxEdma3Cc) {
+                        *status = FM_ERROR_INVALID_EDMA3_CC_IN_EXCLUSION_LIST;
+                        return(exEntries);
+                    }
+                    break;
+                case Fm_res_PaLutEntry:
+                    if (exResList[exEntries].exResInfo > 2) {
+                        *status = FM_ERROR_INVALID_LUT_IN_EXCLUSION_LIST;
+                        return(exEntries);
+                    }
+                    break;
+                case Fm_res_CicHostInt:                    
+                    if (exResList[exEntries].exResInfo >= fmGblCfgParams->maxCic) {
+                        *status = FM_ERROR_INVALID_CIC_IN_EXCLUSION_LIST;
+                        return(exEntries);
+                    }
+                    break;
+                case Fm_res_Timer:
+                    if ((exResList[exEntries].exRange.exStart < 0) ||
+                        (exResList[exEntries].exRange.exStart >= fmGblCfgParams->maxTimers) ||
+                        (exResList[exEntries].exRange.exEnd < 0) ||
+                        (exResList[exEntries].exRange.exEnd >= fmGblCfgParams->maxTimers)) {
+                        *status = FM_ERROR_INVALID_TIMER_IN_EXCLUSION_LIST;
+                        return(exEntries);
+                    }
+                    break;
+                case Fm_res_AifPeCh:
+                case Fm_res_AifPdCh:
+                case Fm_res_QmssAccumCh:
+                case Fm_res_QmssQueue:
+                case Fm_res_QmssMemRegion:
+                default:
+                    break;
+            }
+            exEntries++;
+        }
+    }
+
+    return(exEntries);
+}
+
+/* FUNCTION PURPOSE: Gets the exclusion result for a resource
+ ***********************************************************************
+ * DESCRIPTION: Returns the exclusion result for the provided resource
+ */
+uint32_t fmExclusionIsExcluded(Fm_ExclusionParams *exParams)
+{
+    uint32_t isExcluded = FM_TRUE;
+    
+    switch(exParams->resType) {
+        case Fm_res_CpdmaRxCh:
+        case Fm_res_CpdmaTxCh:
+        case Fm_res_CpdmaRxFlow:
+            isExcluded = isExcludedCpdmaResource(exParams);
+            break;
+        case Fm_res_Edma3DmaCh:
+        case Fm_res_Edma3QdmaCh:
+        case Fm_res_Edma3IntCh:
+            isExcluded = isExcludedEdma3Resource(exParams);
+            break;
+        case Fm_res_PaLutEntry:
+            isExcluded = isExcludedLutEntry(exParams);
+            break;
+        case Fm_res_CicHostInt:
+            isExcluded = isExcludedCicResource(exParams);
+            break;
+        case Fm_res_QmssAccumCh:
+        case Fm_res_QmssQueue:
+        case Fm_res_QmssMemRegion:
+        case Fm_res_AifPeCh:
+        case Fm_res_AifPdCh:
+        case Fm_res_PaPdsp:
+        case Fm_res_Timer:
+            isExcluded = isExcludedGenericResource(exParams);
+            break;
+        case Fm_res_END:
+        default:
+            /* Exclude an invalid peripheral */
+            break;
+    }
+
+    return (isExcluded);
+}
+
diff --git a/test/Module.xs b/test/Module.xs
new file mode 100644 (file)
index 0000000..02e7790
--- /dev/null
@@ -0,0 +1,55 @@
+/******************************************************************************
+ * FILE PURPOSE: Fault Management Test files.
+ ******************************************************************************
+ * FILE NAME: module.xs
+ *
+ * DESCRIPTION: 
+ *  This file contains the module specification for Fault Management Test
+ *  Files
+ *
+ * Copyright (C) 2012-2014 Texas Instruments, Inc.
+ *****************************************************************************/
+
+/* Load the library utility. */
+var libUtility = xdc.loadCapsule ("../build/buildlib.xs");
+
+/**************************************************************************
+ * FUNCTION NAME : modBuild
+ **************************************************************************
+ * DESCRIPTION   :
+ *  The function is used to add all the source files in the test 
+ *  directory into the package.
+ **************************************************************************/
+function modBuild() 
+{
+    /* Add all the .c files to the release package. */
+    var testFiles = libUtility.listAllFiles (".c", "test");
+    for (var k = 0 ; k < testFiles.length; k++)
+        Pkg.otherFiles[Pkg.otherFiles.length++] = testFiles[k];
+
+    /* Add all the .h files to the release package. */
+    var testFiles = libUtility.listAllFiles (".h", "test");
+    for (var k = 0 ; k < testFiles.length; k++)
+        Pkg.otherFiles[Pkg.otherFiles.length++] = testFiles[k];
+
+    /* Add all the .cfg files to the release package. */
+    var testFiles = libUtility.listAllFiles (".cfg", "test");
+    for (var k = 0 ; k < testFiles.length; k++)
+        Pkg.otherFiles[Pkg.otherFiles.length++] = testFiles[k];
+
+    /* Add all the .cmd files to the release package. */
+    var testFiles = libUtility.listAllFiles (".cmd", "test");
+    for (var k = 0 ; k < testFiles.length; k++)
+        Pkg.otherFiles[Pkg.otherFiles.length++] = testFiles[k];
+
+    /* Add the README files to the release package. */
+    var testFiles = libUtility.listAllFiles ("README.txt", "test");
+    for (var k = 0 ; k < testFiles.length; k++)
+        Pkg.otherFiles[Pkg.otherFiles.length++] = testFiles[k];
+        
+    /* Add the .txt to the package */
+    var testFiles = libUtility.listAllFiles (".txt", "test", true);
+    for (var k = 0 ; k < testFiles.length; k++)
+        Pkg.otherFiles[Pkg.otherFiles.length++] = testFiles[k];        
+}
+
diff --git a/test/README.txt b/test/README.txt
new file mode 100644 (file)
index 0000000..0aaa985
--- /dev/null
@@ -0,0 +1,55 @@
+Fault Management Library Example
+
+
+
+A simple example demonstrating how to use the Fault Management module to send the DSP core dump to the Host processor when a DSP exception occurs.
+
+
+
+Steps to build the benchmark example:
+
+
+
+1. Import the CCS faultManagementTestProject from instrumentation\fault_mgmt\test directory. (in CCSv5.1, File->Import... Select Existing CCS/CCE Eclipse Projects)
+
+
+2. Clean the faultManagementTestProject project, delete the Debug and Release directories, and re-build the project.  After the build is complete, faultManagementTestProject.out and faultManagementTestProject.map will be generated under instrumentation\fault_mgmt\test\Debug (or \Release depending on the build configuration) directory.
+
+
+
+Steps to run faultManagementTestProject in CCSv5.1:
+
+
+
+1. Be sure to set the boot mode dip switch to no boot/EMIF16 boot mode on the EVM.
+
+
+2. Connect to Core 0.
+3. Load instrumentation\fault_mgmt\test\Debug\faultManagementTestProject.out on core 0
+
+
+4. Run the project.  A DSP exception should occur.
+5. Open a new Memory Browser (View->Memory Browser) and type the symbol name "fault_mgmt_data" (minus quotes) into the memory window.  The data collected by the fault management library upon exception is located here.  Alternatively, one can open the faultManagementTestProject.map file and search for the fault_mgmt_data symbol and its associated placement address.  Then type that address into the Memory Browser.
+6. The output located at the address input in the memory browser should follow the below format for ELF note sections and contain the DSP core dump information (i.e. registers A0/B0 through A31/B31 and NTSR, ITSR, IRP, SSR, AMR, RILC, and ILC should all be in the fault_mgmt_data section:
+
+ELF Note Section:
+
+byte            +0        +1       +2        +3
+            +--------+--------+---------+--------+
+namesz | # bytes in name field excluding pad|    Should contain number of bytes in the name field
+            +--------+--------+---------+--------+
+descsz   | # bytes in desc field excluding pad|     Should contain number of byes in the desc field
+            +--------+--------+---------+--------+
+type      |      Not Used (should be zero)     |
+            +--------+--------+---------+--------+
+name    | char 0 | char 1 | char 2  | char 3 |
+            +--------+--------+---------+--------+
+            | char 4 |  ...   | char n  |  pad   |      
+            +--------+--------+---------+--------+
+ desc    |              word 0                |   
+            +--------+--------+---------+--------+
+            |              word 1                |
+            +--------+--------+---------+--------+
+
+7. Open a new Memory Browser and input the address of the device's IPCGRH register.  Use the device's Data Manual to find the address for this register.
+8. The SRCSx bit, where x is the DSP core number that the example project was loaded on, should be set.
diff --git a/test/k2e/c66/bios/fmCoredump_K2ETestInstrumentationProject.txt b/test/k2e/c66/bios/fmCoredump_K2ETestInstrumentationProject.txt
new file mode 100644 (file)
index 0000000..9d2db05
--- /dev/null
@@ -0,0 +1,8 @@
+-ccs.linkFile "PDK_INSTALL_PATH/ti/drv/cppi/device/k2e/src/cppi_device.c"
+-ccs.linkFile "PDK_INSTALL_PATH/ti/instrumentation/fault_mgmt/device/k2e/src/fm_device.c"
+-ccs.linkFile "PDK_INSTALL_PATH/ti/instrumentation/fault_mgmt/test/src/k2/fm_coredump_test.c"
+-ccs.linkFile "PDK_INSTALL_PATH/ti/instrumentation/fault_mgmt/test/src/k2/fm_coredump_osal.c" 
+-ccs.linkFile "PDK_INSTALL_PATH/ti/instrumentation/fault_mgmt/test/k2e/c66/bios/fm_coredump_test.cfg" 
+-ccs.setCompilerOptions "-mv64+ -g -DDEVICE_K2E --diag_warning=225 -I${PDK_INSTALL_PATH}/ti/drv/cppi -I${PDK_INSTALL_PATH}/ti/instrumentation/fault_mgmt"  
+-ccs.setLinkerOptions "--ram_model"
+-rtsc.enableRtsc
diff --git a/test/k2e/c66/bios/fm_coredump_test.cfg b/test/k2e/c66/bios/fm_coredump_test.cfg
new file mode 100644 (file)
index 0000000..50051e2
--- /dev/null
@@ -0,0 +1,61 @@
+/*
+ *  Copyright 2012-2014 by Texas Instruments Incorporated.
+ *
+ *  All rights reserved. Property of Texas Instruments Incorporated.
+ *  Restricted rights to use, duplicate or disclose this code are
+ *  granted through contract.
+ *
+ */
+
+var devType = "k2e";
+
+/* Load and use the various BIOS modules. */
+var BIOS    = xdc.useModule('ti.sysbios.BIOS');
+var Task    = xdc.useModule('ti.sysbios.knl.Task');
+
+/* Load and use the CSL package */
+var Csl = xdc.useModule('ti.csl.Settings');
+Csl.deviceType = devType;
+
+/* Load and use LLDs */
+var Cppi = xdc.loadPackage('ti.drv.cppi'); 
+var Aif2 = xdc.loadPackage('ti.drv.aif2');
+
+/* Load and use the Fault Management package */
+var Fault_mgmt = xdc.useModule('ti.instrumentation.fault_mgmt.Settings')
+Fault_mgmt.deviceType = devType;
+
+/* Enable BIOS Task Scheduler */
+BIOS.taskEnabled                       =   true;
+
+/*
+ * The SysMin used here vs StdMin, as trace buffer address is required for
+ * Linux trace debug driver, plus provides better performance.
+ */
+Program.global.sysMinBufSize = 0x8000;
+var System = xdc.useModule('xdc.runtime.System');
+var SysMin = xdc.useModule('xdc.runtime.SysMin');
+System.SupportProxy = SysMin;
+SysMin.bufSize = Program.global.sysMinBufSize;
+
+/* Load the Exception and register a exception hook */
+var Exception = xdc.useModule('ti.sysbios.family.c64p.Exception');
+Exception.exceptionHook = '&myExceptionHook';
+Exception.enablePrint = true;
+
+/* Add note section for coredump */
+Program.sectMap[".note"] = new Program.SectionSpec();
+Program.sectMap[".note"] = Program.platform.dataMemory;
+Program.sectMap[".note"].loadAlign = 128;
+
+/* Configure resource table for trace only.
+   Note that, it traceOnly parameter should not
+   be set if application is using MessageQ based IPC
+   to communicate between cores
+ */
+var Resource = xdc.useModule('ti.ipc.remoteproc.Resource');
+Resource.loadSegment = Program.platform.dataMemory;
+Resource.traceOnly = true;
+
+/* Memory map */
+Program.sectMap[".cppi"] = "L2SRAM";
diff --git a/test/k2h/c66/bios/fmCoredump_K2HTestInstrumentationProject.txt b/test/k2h/c66/bios/fmCoredump_K2HTestInstrumentationProject.txt
new file mode 100644 (file)
index 0000000..36558ed
--- /dev/null
@@ -0,0 +1,8 @@
+-ccs.linkFile "PDK_INSTALL_PATH/ti/drv/cppi/device/k2h/src/cppi_device.c"
+-ccs.linkFile "PDK_INSTALL_PATH/ti/instrumentation/fault_mgmt/device/k2h/src/fm_device.c"
+-ccs.linkFile "PDK_INSTALL_PATH/ti/instrumentation/fault_mgmt/test/src/k2/fm_coredump_test.c"
+-ccs.linkFile "PDK_INSTALL_PATH/ti/instrumentation/fault_mgmt/test/src/k2/fm_coredump_osal.c" 
+-ccs.linkFile "PDK_INSTALL_PATH/ti/instrumentation/fault_mgmt/test/k2h/c66/bios/fm_coredump_test.cfg" 
+-ccs.setCompilerOptions "-mv64+ -g -DDEVICE_K2H --diag_warning=225 -I${PDK_INSTALL_PATH}/ti/drv/cppi -I${PDK_INSTALL_PATH}/ti/instrumentation/fault_mgmt"  
+-ccs.setLinkerOptions "--ram_model"
+-rtsc.enableRtsc
diff --git a/test/k2h/c66/bios/fm_coredump_test.cfg b/test/k2h/c66/bios/fm_coredump_test.cfg
new file mode 100644 (file)
index 0000000..1167646
--- /dev/null
@@ -0,0 +1,61 @@
+/*
+ *  Copyright 2012-2014 by Texas Instruments Incorporated.
+ *
+ *  All rights reserved. Property of Texas Instruments Incorporated.
+ *  Restricted rights to use, duplicate or disclose this code are
+ *  granted through contract.
+ *
+ */
+
+var devType = "k2h";
+
+/* Load and use the various BIOS modules. */
+var BIOS    = xdc.useModule('ti.sysbios.BIOS');
+var Task    = xdc.useModule('ti.sysbios.knl.Task');
+
+/* Load and use the CSL package */
+var Csl = xdc.useModule('ti.csl.Settings');
+Csl.deviceType = devType;
+
+/* Load and use LLDs */
+var Cppi = xdc.loadPackage('ti.drv.cppi'); 
+var Aif2 = xdc.loadPackage('ti.drv.aif2');
+
+/* Load and use the Fault Management package */
+var Fault_mgmt = xdc.useModule('ti.instrumentation.fault_mgmt.Settings')
+Fault_mgmt.deviceType = devType;
+
+/* Enable BIOS Task Scheduler */
+BIOS.taskEnabled                       =   true;
+
+/*
+ * The SysMin used here vs StdMin, as trace buffer address is required for
+ * Linux trace debug driver, plus provides better performance.
+ */
+Program.global.sysMinBufSize = 0x8000;
+var System = xdc.useModule('xdc.runtime.System');
+var SysMin = xdc.useModule('xdc.runtime.SysMin');
+System.SupportProxy = SysMin;
+SysMin.bufSize = Program.global.sysMinBufSize;
+
+/* Load the Exception and register a exception hook */
+var Exception = xdc.useModule('ti.sysbios.family.c64p.Exception');
+Exception.exceptionHook = '&myExceptionHook';
+Exception.enablePrint = true;
+
+/* Add note section for coredump */
+Program.sectMap[".note"] = new Program.SectionSpec();
+Program.sectMap[".note"] = Program.platform.dataMemory;
+Program.sectMap[".note"].loadAlign = 128;
+
+/* Configure resource table for trace only.
+   Note that, it traceOnly parameter should not
+   be set if application is using MessageQ based IPC
+   to communicate between cores
+ */
+var Resource = xdc.useModule('ti.ipc.remoteproc.Resource');
+Resource.loadSegment = Program.platform.dataMemory;
+Resource.traceOnly = true;
+
+/* Memory map */
+Program.sectMap[".cppi"] = "L2SRAM";
diff --git a/test/k2k/c66/bios/fmCoredump_K2KTestInstrumentationProject.txt b/test/k2k/c66/bios/fmCoredump_K2KTestInstrumentationProject.txt
new file mode 100644 (file)
index 0000000..560a27e
--- /dev/null
@@ -0,0 +1,8 @@
+-ccs.linkFile "PDK_INSTALL_PATH/ti/drv/cppi/device/k2k/src/cppi_device.c"
+-ccs.linkFile "PDK_INSTALL_PATH/ti/instrumentation/fault_mgmt/device/k2k/src/fm_device.c"
+-ccs.linkFile "PDK_INSTALL_PATH/ti/instrumentation/fault_mgmt/test/src/k2/fm_coredump_test.c"
+-ccs.linkFile "PDK_INSTALL_PATH/ti/instrumentation/fault_mgmt/test/src/k2/fm_coredump_osal.c" 
+-ccs.linkFile "PDK_INSTALL_PATH/ti/instrumentation/fault_mgmt/test/k2k/c66/bios/fm_coredump_test.cfg" 
+-ccs.setCompilerOptions "-mv64+ -g -DDEVICE_K2K --diag_warning=225 -I${PDK_INSTALL_PATH}/ti/drv/cppi -I${PDK_INSTALL_PATH}/ti/instrumentation/fault_mgmt"  
+-ccs.setLinkerOptions "--ram_model"
+-rtsc.enableRtsc
diff --git a/test/k2k/c66/bios/fm_coredump_test.cfg b/test/k2k/c66/bios/fm_coredump_test.cfg
new file mode 100644 (file)
index 0000000..103bb19
--- /dev/null
@@ -0,0 +1,61 @@
+/*
+ *  Copyright 2012-2014 by Texas Instruments Incorporated.
+ *
+ *  All rights reserved. Property of Texas Instruments Incorporated.
+ *  Restricted rights to use, duplicate or disclose this code are
+ *  granted through contract.
+ *
+ */
+
+var devType = "k2k";
+
+/* Load and use the various BIOS modules. */
+var BIOS    = xdc.useModule('ti.sysbios.BIOS');
+var Task    = xdc.useModule('ti.sysbios.knl.Task');
+
+/* Load and use the CSL package */
+var Csl = xdc.useModule('ti.csl.Settings');
+Csl.deviceType = devType;
+
+/* Load and use LLDs */
+var Cppi = xdc.loadPackage('ti.drv.cppi'); 
+var Aif2 = xdc.loadPackage('ti.drv.aif2');
+
+/* Load and use the Fault Management package */
+var Fault_mgmt = xdc.useModule('ti.instrumentation.fault_mgmt.Settings')
+Fault_mgmt.deviceType = devType;
+
+/* Enable BIOS Task Scheduler */
+BIOS.taskEnabled                       =   true;
+
+/*
+ * The SysMin used here vs StdMin, as trace buffer address is required for
+ * Linux trace debug driver, plus provides better performance.
+ */
+Program.global.sysMinBufSize = 0x8000;
+var System = xdc.useModule('xdc.runtime.System');
+var SysMin = xdc.useModule('xdc.runtime.SysMin');
+System.SupportProxy = SysMin;
+SysMin.bufSize = Program.global.sysMinBufSize;
+
+/* Load the Exception and register a exception hook */
+var Exception = xdc.useModule('ti.sysbios.family.c64p.Exception');
+Exception.exceptionHook = '&myExceptionHook';
+Exception.enablePrint = true;
+
+/* Add note section for coredump */
+Program.sectMap[".note"] = new Program.SectionSpec();
+Program.sectMap[".note"] = Program.platform.dataMemory;
+Program.sectMap[".note"].loadAlign = 128;
+
+/* Configure resource table for trace only.
+   Note that, it traceOnly parameter should not
+   be set if application is using MessageQ based IPC
+   to communicate between cores
+ */
+var Resource = xdc.useModule('ti.ipc.remoteproc.Resource');
+Resource.loadSegment = Program.platform.dataMemory;
+Resource.traceOnly = true;
+
+/* Memory map */
+Program.sectMap[".cppi"] = "L2SRAM";
diff --git a/test/k2l/c66/bios/fmCoredump_K2LTestInstrumentationProject.txt b/test/k2l/c66/bios/fmCoredump_K2LTestInstrumentationProject.txt
new file mode 100644 (file)
index 0000000..58d6819
--- /dev/null
@@ -0,0 +1,8 @@
+-ccs.linkFile "PDK_INSTALL_PATH/ti/drv/cppi/device/k2l/src/cppi_device.c"
+-ccs.linkFile "PDK_INSTALL_PATH/ti/instrumentation/fault_mgmt/device/k2l/src/fm_device.c"
+-ccs.linkFile "PDK_INSTALL_PATH/ti/instrumentation/fault_mgmt/test/src/k2/fm_coredump_test.c"
+-ccs.linkFile "PDK_INSTALL_PATH/ti/instrumentation/fault_mgmt/test/src/k2/fm_coredump_osal.c" 
+-ccs.linkFile "PDK_INSTALL_PATH/ti/instrumentation/fault_mgmt/test/k2l/c66/bios/fm_coredump_test.cfg" 
+-ccs.setCompilerOptions "-mv64+ -g -DDEVICE_K2L --diag_warning=225 -I${PDK_INSTALL_PATH}/ti/drv/cppi -I${PDK_INSTALL_PATH}/ti/instrumentation/fault_mgmt"  
+-ccs.setLinkerOptions "--ram_model"
+-rtsc.enableRtsc
diff --git a/test/k2l/c66/bios/fm_coredump_test.cfg b/test/k2l/c66/bios/fm_coredump_test.cfg
new file mode 100644 (file)
index 0000000..666a02e
--- /dev/null
@@ -0,0 +1,61 @@
+/*
+ *  Copyright 2012-2014 by Texas Instruments Incorporated.
+ *
+ *  All rights reserved. Property of Texas Instruments Incorporated.
+ *  Restricted rights to use, duplicate or disclose this code are
+ *  granted through contract.
+ *
+ */
+
+var devType = "k2l";
+
+/* Load and use the various BIOS modules. */
+var BIOS    = xdc.useModule('ti.sysbios.BIOS');
+var Task    = xdc.useModule('ti.sysbios.knl.Task');
+
+/* Load and use the CSL package */
+var Csl = xdc.useModule('ti.csl.Settings');
+Csl.deviceType = devType;
+
+/* Load and use LLDs */
+var Cppi = xdc.loadPackage('ti.drv.cppi'); 
+var Aif2 = xdc.loadPackage('ti.drv.aif2');
+
+/* Load and use the Fault Management package */
+var Fault_mgmt = xdc.useModule('ti.instrumentation.fault_mgmt.Settings')
+Fault_mgmt.deviceType = devType;
+
+/* Enable BIOS Task Scheduler */
+BIOS.taskEnabled                       =   true;
+
+/*
+ * The SysMin used here vs StdMin, as trace buffer address is required for
+ * Linux trace debug driver, plus provides better performance.
+ */
+Program.global.sysMinBufSize = 0x8000;
+var System = xdc.useModule('xdc.runtime.System');
+var SysMin = xdc.useModule('xdc.runtime.SysMin');
+System.SupportProxy = SysMin;
+SysMin.bufSize = Program.global.sysMinBufSize;
+
+/* Load the Exception and register a exception hook */
+var Exception = xdc.useModule('ti.sysbios.family.c64p.Exception');
+Exception.exceptionHook = '&myExceptionHook';
+Exception.enablePrint = true;
+
+/* Add note section for coredump */
+Program.sectMap[".note"] = new Program.SectionSpec();
+Program.sectMap[".note"] = Program.platform.dataMemory;
+Program.sectMap[".note"].loadAlign = 128;
+
+/* Configure resource table for trace only.
+   Note that, it traceOnly parameter should not
+   be set if application is using MessageQ based IPC
+   to communicate between cores
+ */
+var Resource = xdc.useModule('ti.ipc.remoteproc.Resource');
+Resource.loadSegment = Program.platform.dataMemory;
+Resource.traceOnly = true;
+
+/* Memory map */
+Program.sectMap[".cppi"] = "L2SRAM";
diff --git a/test/src/k2/fm_coredump_osal.c b/test/src/k2/fm_coredump_osal.c
new file mode 100644 (file)
index 0000000..7614a0c
--- /dev/null
@@ -0,0 +1,246 @@
+/**
+ *   @file  fm_coredump_osal.c
+ *
+ *   @brief   
+ *      This is the OS abstraction layer 
+ *
+ *  \par
+ *  ============================================================================
+ *  @n   (C) Copyright 2012-2014, Texas Instruments, Inc.
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/* Standard Includes */
+#include <stdarg.h>
+
+/* XDC Includes */
+#include <xdc/std.h>
+#include <xdc/runtime/System.h>
+#include <ti/sysbios/family/c64p/Hwi.h>
+
+/* CSL Include Files */
+#include <ti/csl/csl_cacheAux.h>
+
+/**********************************************************************
+ ************************** Local Definitions *************************
+ **********************************************************************/
+
+/* Define this option during DEBUG and it can be turned off during final release
+ * as it can help debug cache misaligned buffers */
+#undef CACHE_ALIGNMENT_CHECK
+
+
+/**********************************************************************
+ *************************** OSAL Functions ***************************
+ **********************************************************************/
+
+/**
+ *  @b Description
+ *  @n
+ *      The function is used to indicate that the block of memory has
+ *      finished being accessed. If the memory block is cached then the
+ *      application would need to ensure that the contents of the cache
+ *      are updated immediately to the actual memory.
+ *
+ *  @param[in]  ptr
+ *       Address of memory block
+ *  @param[in]  size
+ *       Size of memory block
+ *  @param[in]  checkAlign
+ *       Flags that enables checks for address cache line alignment
+ *
+ *  @retval
+ *      Not Applicable
+ */
+static void Osal_endMemAccess (void *ptr, uint32_t size, uint32_t checkAlign)
+{
+       UInt  key;
+
+#ifdef CACHE_ALIGNMENT_CHECK
+    /* Validate the address only if required to do so. */
+    if (checkAlign == 1)
+    {
+               /* Check if DDR3 address is 128 byte aligned */
+               if ((((int)ptr & 0x80000000) == 0x80000000) && (((int)ptr % 0x80) != 0))
+                       asm (" swbp 0");
+
+               /* Check if MSMC address is 64 byte aligned */
+               if ((((int)ptr & 0x0C000000) == 0x0C000000) && (((int)ptr % 0x40) != 0))
+                       asm (" swbp 0");
+       }
+#endif /* CACHE_ALIGNMENT_CHECK */
+
+       /* Disable Interrupts */
+       key = Hwi_disable();
+
+       /* Writeback the contents of the cache. */
+       CACHE_wbL1d (ptr, size, CACHE_FENCE_WAIT);
+
+       asm      (" nop 4");
+       asm      (" nop 4");
+       asm      (" nop 4");
+       asm      (" nop 4");
+
+       /* Reenable Interrupts. */
+       Hwi_restore(key);
+}
+
+/**
+ *  @b Description
+ *  @n  
+ *      The function is used by the Fault Management module to writeback the cache.
+ *
+ *  @param[in]  ptr
+ *      Pointer to the buffer to be written back
+ *  @param[in]  size
+ *      Size of the buffer to be written back
+ *
+ *  @retval
+ *      None
+ */
+void Osal_fault_mgmtEndMemAccess(void* ptr, uint32_t size)
+{
+       Osal_endMemAccess(ptr, size, 1);
+}
+
+/* FUNCTION PURPOSE: Prints a variable list
+ ***********************************************************************
+ * DESCRIPTION: The function is used to print a string to the console
+ */
+void Osal_fault_mgmtLog (char *fmt, ... )
+{
+    VaList ap;
+    
+    va_start(ap, fmt);
+    System_vprintf(fmt, ap);
+    va_end(ap);
+}
+
+void *Osal_cppiMalloc(uint32_t num_bytes)
+{
+    return(NULL);
+}
+
+void Osal_cppiFree(void *ptr, uint32_t size)
+{
+}
+
+/**
+ * ============================================================================
+ *  @n@b Osal_cppiCsEnter
+ *
+ *  @b  brief
+ *  @n  This API ensures multi-core and multi-threaded
+ *      synchronization to the caller.
+ *
+ *      This is a BLOCKING API.
+ *
+ *      This API ensures multi-core synchronization between
+ *      multiple processes trying to access CPPI shared
+ *      library at the same time.
+ *
+ *  @param[in]  
+ *  @n  None
+ *
+ *  @return     
+ *  @n  Handle used to lock critical section
+ * =============================================================================
+ */
+Ptr Osal_cppiCsEnter (Void)
+{
+    return (NULL);
+}
+
+/**
+ * ============================================================================
+ *  @n@b Osal_cppiCsExit
+ *
+ *  @b  brief
+ *  @n  This API needs to be called to exit a previously
+ *      acquired critical section lock using @a Osal_cppiCsEnter ()
+ *      API. It resets the multi-core and multi-threaded lock,
+ *      enabling another process/core to grab CPPI access.
+ *
+ *  @param[in]  CsHandle
+ *      Handle for unlocking critical section.
+ *
+ *  @return     None
+ * =============================================================================
+ */
+Void Osal_cppiCsExit (Ptr CsHandle)
+{
+
+}
+
+/**
+ *  @b Description
+ *  @n  
+ *      The function is used to indicate that a block of memory is 
+ *      about to be accessed. If the memory block is cached then this 
+ *      indicates that the application would need to ensure that the 
+ *      cache is updated with the data from the actual memory.
+ *
+ *  @param[in]  blockPtr
+ *       Address of the block which is to be invalidated
+ *
+ *  @param[in]  size
+ *       Size of the block to be invalidated
+
+ *  @retval
+ *      Not Applicable
+ */
+void Osal_cppiBeginMemAccess (void *blockPtr, uint32_t size)
+{    
+
+}
+
+/**
+ *  @b Description
+ *  @n  
+ *      The function is used to indicate that the block of memory has 
+ *      finished being accessed. If the memory block is cached then the 
+ *      application would need to ensure that the contents of the cache 
+ *      are updated immediately to the actual memory. 
+ *
+ *  @param[in]  blockPtr
+ *       Address of the block which is to be written back
+ *
+ *  @param[in]  size
+ *       Size of the block to be written back
+
+ *  @retval
+ *      Not Applicable
+ */
+void Osal_cppiEndMemAccess (void *blockPtr, uint32_t size)
+{
+
+}
+
diff --git a/test/src/k2/fm_coredump_test.c b/test/src/k2/fm_coredump_test.c
new file mode 100644 (file)
index 0000000..2b4c10d
--- /dev/null
@@ -0,0 +1,198 @@
+/**
+ *   @file  fm_coredump_test.c
+ *
+ *   @brief   
+ *      Test Code to test the Fault Management library coredump APIs
+ *      on K2 devices
+ *
+ *  \par
+ *  NOTE:
+ *      (C) Copyright 2012-2014 Texas Instruments, Inc.
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+
+/* BIOS/XDC Include Files. */
+#include <xdc/std.h>
+#include <xdc/cfg/global.h>
+#include <xdc/runtime/System.h>
+#include <xdc/runtime/SysMin.h>
+#include <ti/sysbios/BIOS.h>
+#include <ti/sysbios/knl/Task.h>
+
+/* CSL Include Files */
+#include <ti/csl/csl_chip.h>
+#include <ti/csl/csl_cacheAux.h>
+#include <ti/csl/csl_chipAux.h>
+
+/* Fault Management Include File */
+#include <ti/instrumentation/fault_mgmt/fault_mgmt.h>
+
+/* Exclude Linux CPDMA resources from being disabled during IO halt */
+#define EXCLUDE_LINUX_RESOURCES_FROM_HALT 1
+
+/**********************************************************************
+ ************************** External Variables ************************
+ **********************************************************************/
+
+extern Fm_GlobalConfigParams fmGblCfgParams;
+extern Fm_ExcludedResource   linuxResources[];
+
+/**********************************************************************
+ ************************* Unit Test Functions ************************
+ **********************************************************************/
+
+Void myExceptionHook(Void)
+{
+    uint32_t   i;
+    Fm_HaltCfg haltCfg;
+    uint32_t   efr_val;
+    
+    /* Copy register status into fault management data region for Host */
+    Fault_Mgmt_getLastRegStatus();
+
+    memset(&haltCfg, 0, sizeof(haltCfg));
+    efr_val = CSL_chipReadEFR();
+
+    /* If triggered exception originates from another core through
+     * NMI exception don't need to halt processing and notify other cores 
+     * since the parent core where the exception originally triggered via 
+     * event would notify them.  This eliminates recursive exceptions */
+       if (!(efr_val & 0x80000000)) {
+        /* Halt all processing - Only need to be done on one core */
+        haltCfg.haltAif2 = 1;
+        haltCfg.haltCpdma = 1;
+        haltCfg.haltEdma3 = 1;
+#if EXCLUDE_LINUX_RESOURCES_FROM_HALT
+        haltCfg.haltSGMII = 0;
+        haltCfg.excludedResources = &linuxResources[0];
+#else
+        haltCfg.haltSGMII = 1; 
+        haltCfg.excludedResources = NULL;
+#endif
+
+        Fault_Mgmt_haltIoProcessing(&fmGblCfgParams, &haltCfg);
+        
+        for (i = 0; i < fmGblCfgParams.maxNumCores; i++) {
+            /* Notify remote DSP cores of exception - WARNING: This will generate NMI
+             * pulse to the remote DSP cores */
+            if (i != CSL_chipReadDNUM()) {
+                Fault_Mgmt_notify_remote_core(i);
+            }
+        }      
+    }
+    
+    /* Notify Host of crash */
+    Fault_Mgmt_notify();
+}
+
+/* Exception inducing function */
+void exceptionFunc (void)
+{
+       System_printf ("Causing exception\n");
+
+       /* Attempt to use B0 twice in the same execution stage.  This will
+        * cause a resource sharing exception to occur */
+    asm(" \n \
+               mvk 1, a1; \n \
+               mvk 1, a0; \n \
+         [a1]  mvk 0, b0; \n \
+       ||[a0]  mv a0, b0; \n \
+    ");
+
+    /* The crash dump should show NRP as corresponding to this printf.
+     * NRP is used as the PC in the crash dump since that is the return
+     * address from the non-maskable interrupt generated by the
+     * exception */
+    System_printf ("Print after causing the exception\n");
+}
+
+/* Second function in test call stack. */
+void testFunc1 (void)
+{
+       System_printf ("In testFunc1\n");
+
+       /* Call the function which will cause the exception */
+       exceptionFunc();
+}
+
+/* Task which causes DSP exception.  Need to create a call stack first for
+ * crash dump analysis testing purposes. */
+void testTask ()
+{
+       uint32_t coreId;
+       System_printf ("In testTask\n");
+       coreId = CSL_chipReadDNUM();
+
+       if (coreId == 0) {
+
+         /* Call first function in call stack */
+         testFunc1();
+       }
+       else
+       {
+               /* No operations for other cores */
+               while(1);
+       }
+}
+
+int32_t main(int32_t argc, char* argv[])
+{
+    Task_Params         taskParams;
+
+    System_printf ("**********************************************\n");
+    System_printf ("******* Fault Management Coredump Test *******\n");
+    System_printf ("**********************************************\n");
+
+    /* Enable the caches. */
+       CACHE_setL1DSize (CACHE_L1_32KCACHE);
+       CACHE_setL1PSize (CACHE_L1_32KCACHE);
+
+    /* Check that proper size has been allocated for coredump note header */
+    if (FAULT_MGMT_DATA_SIZE < Fault_Mgmt_getSizes()) {
+        System_printf ("Error: Section allocated for coredump is too small\n");
+        System_printf ("       Allocated: %d\n", FAULT_MGMT_DATA_SIZE);
+        System_printf ("       Required : %d\n", Fault_Mgmt_getSizes());
+    }
+    else {
+        /* Initialize the Task Parameters. */
+        Task_Params_init(&taskParams);
+
+        /* Create a task that causes an exception */
+        Task_create((Task_FuncPtr)testTask, &taskParams, NULL);
+
+        BIOS_start();
+    }
+    return 0;
+}
+
diff --git a/test/src/tci6614/cleanup_test/fm_cleanup_test.c b/test/src/tci6614/cleanup_test/fm_cleanup_test.c
new file mode 100644 (file)
index 0000000..b87f773
--- /dev/null
@@ -0,0 +1,250 @@
+/**
+ *   @file  fm_cleanup_test.c
+ *
+ *   @brief   
+ *      Test code to test IPs then crash a DSP.  Used to test the
+ *      FM DSP cleanup and recovery code.
+ *
+ *  \par
+ *  NOTE:
+ *      (C) Copyright 2013-2014 Texas Instruments, Inc.
+ * 
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions 
+ *  are met:
+ *
+ *    Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ *    Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the   
+ *    distribution.
+ *
+ *    Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+
+/* BIOS/XDC Include Files. */
+#include <xdc/std.h>
+#include <xdc/cfg/global.h>
+#include <xdc/runtime/System.h>
+#include <xdc/runtime/SysMin.h>
+#include <ti/sysbios/BIOS.h>
+#include <ti/sysbios/knl/Task.h>
+
+/* CSL Include Files */
+#include <ti/csl/csl_chip.h>
+#include <ti/csl/csl_cacheAux.h>
+#include <ti/csl/csl_chipAux.h>
+
+/* Platform Include Files */
+#include <ti/platform/platform.h>
+
+/* Remoteproc include file */
+#include <ti/instrumentation/remoteproc/remoteproc.h>
+
+/* Fault Management Include File */
+#include <ti/instrumentation/fault_mgmt/fault_mgmt.h>
+
+/* Test code headers */
+#include "nav_test.h"
+#include "paExample.h"
+#include "tcp3d_demo.h"
+#include "vcp2_test.h"
+
+/* Defines the core number responsible for system initialization. */
+#define CORE_SYS_INIT               0
+
+/* Global Variable which keeps track of the core number executing the
+ * application. */
+uint32_t coreNum = 0xFFFF;
+
+/* Add trace buffer information to the resource table */
+extern char * xdc_runtime_SysMin_Module_State_0_outbuf__A;
+#define TRACEBUFADDR (uint32_t)&xdc_runtime_SysMin_Module_State_0_outbuf__A
+#define TRACEBUFSIZE sysMinBufSize
+#pragma DATA_SECTION(resources, ".resource_table")
+#pragma DATA_ALIGN(resources, 4096)
+struct rproc_resource resources[] = {
+ {TYPE_TRACE, 0, TRACEBUFADDR,0,0,0, TRACEBUFSIZE, 0,
+   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"trace:appleton"},
+ {TYPE_COREDUMP_NOTE, 0, (uint32_t) &fault_mgmt_data[0],0,0,0, FAULT_MGMT_DATA_SIZE, 0,
+   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"exception_trace_dump"},
+};
+
+/**********************************************************************
+ ************************* Extern Definitions *************************
+ **********************************************************************/
+
+extern Fm_GlobalConfigParams fmGblCfgParams;
+
+/**********************************************************************
+ ************************* Unit Test Functions ************************
+ **********************************************************************/
+
+Void myExceptionHook(Void)
+{
+    uint32_t   i, my_core_id, efr_val;
+    /* Copy register status into fault management data region for Host */
+    Fault_Mgmt_getLastRegStatus();
+       
+       my_core_id = CSL_chipReadDNUM();
+
+       efr_val    = CSL_chipReadEFR();
+       if (efr_val & 0x80000000)
+       {
+               /* Exception is triggered to be assumed by other core for NMI exceptions
+                * so, don't need to notify other cores since the parent core where the
+                * exception has triggered by an event would notify them, thus eliminating
+                * the recursive exceptions */
+
+               /* Notify Host of crash and return */
+           Fault_Mgmt_notify();
+           return;
+       }
+
+    for (i = 0; i < fmGblCfgParams.maxNumCores; i++)
+       {
+       /* Skip the notification if it is same core */
+          if (i == my_core_id)
+              continue;
+                  
+          /* Notify remote DSP cores for exception - WARNING: This will generate NMI
+           pulse to the remote DSP cores */
+       Fault_Mgmt_notify_remote_core(i);
+       }       
+    /* Notify Host of crash */
+    Fault_Mgmt_notify();
+}
+
+/* Exception inducing function */
+void exceptionFunc (void)
+{
+       System_printf ("Causing exception\n");
+
+       /* Attempt to use B0 twice in the same execution stage.  This will
+        * cause a resource sharing exception to occur */
+    asm(" \n \
+               mvk 1, a1; \n \
+               mvk 1, a0; \n \
+         [a1]  mvk 0, b0; \n \
+       ||[a0]  mv a0, b0; \n \
+    ");
+
+    /* The crash dump should show NRP as corresponding to this printf.
+     * NRP is used as the PC in the crash dump since that is the return
+     * address from the non-maskable interrupt generated by the
+     * exception */
+    System_printf ("Print after causing the exception\n");
+}
+
+/* Task which causes DSP exception.  Need to create a call stack first for
+ * crash dump analysis testing purposes. */
+void testTask ()
+{
+    volatile uint32_t j;
+    uint32_t          k;
+
+    if (coreNum == CORE_SYS_INIT) {
+        /* Initialize peripherals for tests */
+        nav_test_setup();
+#if !RUNNING_WITH_LINUX         
+        Netcp_SetUp();
+#endif
+#ifdef _BIG_ENDIAN
+        tcp3d_init();
+#endif
+        vcp2Init(coreNum); // Init VCP2_A
+
+        /* run peripheral tests */
+        nav_test_run();
+#if !RUNNING_WITH_LINUX 
+        Netcp_Test();
+#endif
+#ifdef _BIG_ENDIAN        
+        tcp3d_test();
+#endif
+        runVcp2Test(coreNum);
+
+        System_printf("\nCore %d: Completed IP tests.\n", coreNum);
+
+        /* Call function to cause DSP exception */
+           exceptionFunc();
+    }
+    else {
+        /* Slave cores processing loop */
+        while(1) {
+            j=0;
+            for(k=0; k<500000;k++) {
+                j++;
+            }
+        }
+    }
+}
+
+int32_t main(int32_t argc, char* argv[])
+{
+    platform_init_flags  init_flags;
+    platform_init_config init_config;    
+    Task_Params          taskParams;
+
+    System_printf ("**********************************************\n");
+    System_printf ("*************** FM Cleanup Test **************\n");
+    System_printf ("**********************************************\n");
+
+    /* Get the core number. */
+    coreNum = CSL_chipReadReg (CSL_CHIP_DNUM);
+
+    if (coreNum == CORE_SYS_INIT) {
+        /* Turn on all the platform initialize flags */
+        memset(&init_config, 0, sizeof(platform_init_config));
+        memset(&init_flags, 0x01, sizeof(platform_init_flags));
+
+        init_flags.ddr = 0;
+        init_flags.pll = 0;
+        init_flags.phy = 0;
+        init_flags.ecc = 0;
+    }
+    else {
+        memset(&init_config, 0, sizeof(platform_init_config));
+        memset(&init_flags, 0x00, sizeof(platform_init_flags));
+    }
+
+    /* Initialize the platform */
+    platform_init(&init_flags, &init_config);
+
+    /* Enable the caches. */
+    CACHE_setL2Size(CACHE_256KCACHE);
+
+    System_printf ("\nPrint resource table value to avoid compiler optimizing out table: %d\n", 
+                   resources[0].type);
+
+    /* Initialize the Task Parameters. */
+    Task_Params_init(&taskParams);
+
+    /* Create a task that causes an exception */
+    Task_create((Task_FuncPtr)testTask, &taskParams, NULL);
+
+    BIOS_start();
+    return 0;
+}
+
diff --git a/test/src/tci6614/cleanup_test/fm_cleanup_test.cfg b/test/src/tci6614/cleanup_test/fm_cleanup_test.cfg
new file mode 100644 (file)
index 0000000..deea45e
--- /dev/null
@@ -0,0 +1,81 @@
+/*
+ *  Copyright 2012-2014 by Texas Instruments Incorporated.
+ *
+ *  All rights reserved. Property of Texas Instruments Incorporated.
+ *  Restricted rights to use, duplicate or disclose this code are
+ *  granted through contract.
+ *
+ */
+
+/* Load and use the various BIOS modules. */
+var BIOS    = xdc.useModule('ti.sysbios.BIOS');
+var Task    = xdc.useModule('ti.sysbios.knl.Task');
+
+/* Load and use the CSL package */
+var Csl = xdc.loadPackage('ti.csl');
+
+/* Use the CSL module and indicate that INTC library will be used. */
+/* note that this is only used by the qos sched drop sched test */
+var cslSettings = xdc.useModule ('ti.csl.Settings');
+cslSettings.useCSLIntcLib = true;
+
+/* Load and use the IP packages */
+var Rm = xdc.loadPackage('ti.drv.rm');
+var Cppi = xdc.loadPackage('ti.drv.cppi'); 
+var&nb