diff --git a/CMSIS/DoxyGen/Pack/src/pack_check.txt b/CMSIS/DoxyGen/Pack/src/pack_check.txt
index 6fade7e..2c4628e 100644
--- a/CMSIS/DoxyGen/Pack/src/pack_check.txt
+++ b/CMSIS/DoxyGen/Pack/src/pack_check.txt
@@ -102,19 +102,71 @@
 
 \section packChkMessages Error and Warning Messages
 
-[SVDConv.exe]: ../../SVD/html/svd_SVDConv_pg.html
+The following table explains the categories for the output messages issued by packChk utility. Sections below list the errors and warnings and contain recommendations on how to resolve them.
 
-The following table shows the errors and warnings issued by packChk.
+\b Categories
+\n
+Code  | Category            | Description
+:---:|:---------------------|:--------------------
+M0xx | Info messages        | Help and Progress messages.\n No action required.
+M1xx | \ref packchk_internal_msgs "Internal errors"   | Internal execution errors
+M2xx | \ref packchk_invoc_msgs "Invocation Errors"    | Errors in the command line input.
+M3xx\n M4xx | \ref packchk_valid_msgs "Validation Messages"  | Errors and Warnings from the pack validation.
+M5xx | \ref packchk_model_msgs "Model Errors"         | Errors in RTE model creation
 
-Invocation Errors
+\anchor packchk_internal_msgs 
+Internal Errors
 -----------------
+The errors in this category are issued because of an internal error in the PackChk utility. 
 
-<table class="cmtable" summary="packChk Invocation Msgs">
+<table class="cmtable" summary="packChk Internal Msgs">
   <tr>
     <th>Message Number</th>
     <th>Type</th>
     <th>Description</th>
-    <th>Action</th>
+    <th>Details and Actions</th>
+  </tr>
+<tr><td>M100</td> <td>ERROR</td> <td>GetModuleHandle failed</td>
+  <td>Contact Arm for clarifications</td>
+</tr>
+<tr><td>M101</td> <td>ERROR</td> <td>Unknown error!</td>
+  <td>Contact Arm for clarifications</td>
+</tr>
+<tr><td>M102</td> <td>ERROR</td> <td>MFC initialization failed</td>
+  <td>Contact Arm for clarifications</td>
+</tr>
+<tr><td>M103</td> <td>ERROR</td> <td>Internal Error: \em 'REF'</td>
+  <td>Contact Arm for clarifications</td>
+</tr>
+<tr><td>M104</td> <td>ERROR</td> <td>Path empty when searching for other PDSC files</td>
+  <td>Execute the check in verbose mode and try to identify the PDSC file intended for use. Correct the PDSC.</td>
+</tr>
+<tr><td>M107</td> <td>WARNING</td> <td>\em 'FEATURE' is not supported by current version of \em 'OS' PackChk.</td>
+  <td>Some PackChk functionalities are available only on certain OS platforms. For example SVD check is supported only on Windows.
+  <br>Do not use listed \em 'FEATURE' or change operating system.</td>
+</tr>
+<tr><td>M108</td> <td>TEXT</td> <td>Reading PDSC File failed!</td>
+  <td>XML parsing of the PDSC file failed.
+  <br>Verify syntax of the PDSC file.</td>
+</tr>
+<tr><td>M109</td> <td>TEXT</td> <td>Constructing Model failed!</td>
+  <td>Contact Arm for clarifications</td>
+</tr>
+<tr><td>M110</td> <td>TEXT</td> <td>Verifying Model failed</td>
+  <td>Contact Arm for clarifications</td>
+</tr>
+</table>
+
+\anchor packchk_invoc_msgs 
+Invocation Errors
+-----------------
+The errors in this category are issued because of an incorrect command-line input that prevents the packChk execution.
+<table class="cmtable" summary="packChk Invocation Msgs">
+  <tr>
+    <th>Message Number</th>
+    <th>Type</th>
+    <th>Message Text</th>
+    <th>Details and Actions</th>
   </tr>
 <tr><td>M200</td> <td>ERROR</td> <td>Invalid arguments!</td>
   <td>At least one argument is wrong. Correct the argument.</td>
@@ -123,11 +175,10 @@
   <td>The list of arguments is too long. Verify if you have used one argument twice.</td>
 </tr>
 <tr><td>M202</td> <td>ERROR</td> <td>No PDSC input file specified</td>
-  <td>Correct the command line. \b packChk expects a *.pdsc file name as input.</td>
+  <td>Correct the command line. \b packChk expects a \ref packFormat "*.pdsc" file name as input.</td>
 </tr>
 <tr><td>M203</td> <td>ERROR</td> <td>Error reading PDSC file  \em 'PATH/FILENAME'!</td>
-  <td>Verify the PDSC file for consistency. 
-  </td>
+  <td>Verify the PDSC file for consistency.</td>
 </tr>
 <tr><td>M204</td> <td>ERROR</td> <td>File not found: \em 'PATH'</td>
   <td>The specified PDSC file could not be found in the \em PATH displayed in the message. Correct the path or the filename.</td>
@@ -144,79 +195,109 @@
   <td>The PDSC file expected has not been found. Rename or exchange the PDSC file.</td>
 </tr>
 <tr><td>M208</td> <td>ERROR</td> <td>Error calling SVDConv:  \em 'PATH'</td>
-  <td>SVDConv.exe was not found. Copy the executable into the directory of \b packChk or enter the path where \b SVDConv is located. Default is \token{CMSIS\\Utilities}.</td>
+  <td><a href="../../SVD/html/svd_SVDConv_pg">SVDConv utility</a> could not be executed. 
+     <br>Verify the permissions. Correct the path name.</td>
 </tr>
 <tr><td>M209</td> <td>ERROR</td> <td>Unknown Option: \em 'OPT'</td>
-  <td>The command line option entered is not known or invalid.</td>
+  <td>The command line option \em 'OPT' is not known or invalid.</td>
 </tr>
 <tr><td>M210</td> <td>ERROR</td> <td>Only one input file to be checked is allowed.</td>
   <td>You can only check one PDSC file at a time.</td>
 </tr>
+<tr><td>M211</td> <td>ERROR</td> <td>Cannot find SVDConv.exe: \em 'CMDLINE'</td>
+  <td><a href="../../SVD/html/svd_SVDConv_pg">SVDConv utility</a> was not found in specified \em 'CMDLINE'.
+   <br>Copy the \b SVDConv.exe into the directory of \b packChk. Default is \token{CMSIS\\Utilities}.</td>
+</tr>
 </table>
 
 \anchor packchk_valid_msgs
 Validation Messages
 --------------------
+The messages in this category are issued by packChk during package validation. This can be for example incorrect use of the pack schema in the PDSC file, missing files, broken dependancies and others. \em ERROR messages must be resolved to ensure that the package is compliant to the CMSIS-format. \em WARNING messages should be checked and are strongly recommended to be resolved. 
 
 <table class="cmtable" summary="packChk Validation Msgs">
   <tr>
     <th>Message Number</th>
     <th>Type</th>
-    <th>Description</th>
-    <th>Action</th>
+    <th>Message Text</th>
+    <th>Details and Actions</th>
   </tr>
-<tr><td>M300</td> <td>ERROR</td> <td>The following files are listed in PDSC but not part of the package: \n
+<!--
+  <tr><td>M300</td> <td>ERROR</td> <td>The following files are listed in PDSC but not part of the package: \n
                                                    \em 'PATH': \n
                                                    \em 'FILES'</td>
-  <td>The files listed should be part of the package. However, these files could not be added to the package. Verify whether the files exist. Verify the file permissions.</td>
+  <td>The files listed in the PDSC file shall be part of the package. However, these files could not be added to the package.
+  <br>Verify whether the listed files exist. Verify the file permissions.</td>
 </tr>
-<tr><td>M301</td> <td>ERROR</td> <td>Checking Pack URL of PDSC file failed: \n
+-->
+<tr><td>M301</td> <td>ERROR</td><td>Checking Pack URL of PDSC file failed: \n
                                                   Expected URL :  \em 'URL1'   \n
                                                   Package  URL :  \em 'URL2'</td>
-  <td>The URL entered in the package does not match the value entered for comparison. Change the URL in the package. Check for possible misspellings of \em URL1.</td>
+  <td>The URL specified in the package does not match the value entered for comparison in option \c -u.
+  <br>Check for possible misspellings in both URLs. Refer to \ref package_url "/package/url".</td>
 </tr>
 <tr><td>M302</td> <td>ERROR</td><td>No vendor tag found in the PDSC file! Add the \<vendor> tag and provide the vendor name. For example: <code>\<vendor>Keil\</vendor></code>.</td>
-  <td>No vendor entered in the PDSC file. Enter the tag \token{\<vendor>} and add the vendor name.  Refer to \ref element_package.</td>
+  <td>Vendor name is mandatory required in the package description but was not found in the \ref element_package element in the PDSC file.
+  <br>Within the parent \token{\<package>} element enter the tag \token{\<vendor>} and add the vendor name. For example: <code>\<vendor>Keil\</vendor></code>. Refer to \ref package_vendor "/package/vendor".</td>
 </tr>
 <tr><td>M303</td> <td>ERROR</td><td>No package name found in the PDSC file! Add the \<name> tag and provide the package name. For example: <code>\<name>MCU-Name_DFP\</name></code>.</td>
-  <td>No package name found in the PDSC file. Enter the tag \token{\<name>} and add the package name. For example \token{\<name>MCU-Name_DFP\</name>}. The package name is mandatory to create the package.  Refer to \ref element_package.</td>
+  <td>Package name is mandatory required in the package description but was not found in the \ref element_package element in the PDSC file.
+  <br>Within the parent \token{\<package>} element enter the tag  \token{\<name>} and add the package name. For example <code>\<name>MCU-Name_DFP\</name></code>. Refer to \ref package_name "/package/name".</td>
 </tr>
-<tr><td>M304</td> <td>ERROR</td> <td>No package URL (\<url>-tag and/or value) found in PDSC file!</td>
-  <td>Add the tag \token{\<url>} and enter a URL in the PDSC file. The URL points to the web page from which users can download the package.  Refer to \ref element_package.</td>
+<tr><td>M304</td> <td>WARNING</td> <td>No package URL (\<url>-tag and/or value) found in PDSC file!</td>
+  <td>Package URL is mandatory required in the package description but was not found in the \ref element_package element in the PDSC file.
+  <br>Within the parent \token{\<package>} element enter the tag \token{\<url>} and add the URL that should be used to download the package. Refer to \ref package_url "/package/url".</td>
 </tr>
-<tr><td>M305</td> <td>ERROR</td><td>No package version (\"version\"-attribute in a \<release>-tag) found in PDSC file!</td>
-  <td>No version or release information found in the PDSC file. Add the attribute \token{version} to the tag \token{\<release>} and enter the version number. Refer to \ref element_release.</td>
+<tr><td>M305</td> <td>ERROR</td><td>No releases ("\<release>" elements in a \<releases>-tag) found in PDSC file!"</td>
+  <td>At least one package release shall be specified in the PDSC file, but none  was not found.
+  <br>Use \token{\<release>} tag to specify release information in \token{\<releases>} element. Refer to \ref element_release.</td>
 </tr>
 <tr><td>M306</td> <td>ERROR</td><td>No package description found in the PDSC file. Add the \<description>-tag and provide a descriptive text.</td>
-  <td>No package description was found in the PDSC file. Enter the tag \token{\<description>} and briefly describe the package content. Refer to \ref element_package.</td>
+  <td>Package description is mandatory required in the package description but was not found in the \ref element_package element in the PDSC file. 
+  <br>Within the parent \token{\<package>} element add the tag \token{\<description>} and briefly describe the package content. Refer to \ref package_description "/package/description".</td>
 </tr>
 <tr><td>M307</td> <td>ERROR</td> <td>Checking SVD file  \em 'PATH' failed!</td>
   <td>Verify the consistency of the *.SVD file. Refer to <a href="../../SVD/html/svd_validate_file_pg.html">SVD File Validation</a>.</td>
 </tr>
+<!--  
 <tr><td>M308</td> <td>ERROR</td> <td>SVD file \em 'PATH' not found. Add the SVD file or correct the PDSC entry.</td>
-  <td>The *.SVD file was not found in the path specified in the message. Add the SVD file or correct the entry in the *.pdsc file.</td>
+  <td>The *.SVD file was not found in the specified \em 'PATH'.
+  <br>Add the path to the SVD file or correct the entry in the PDSC file. Refer to the \token{svd} attribute in \ref element_debug.</td>
 </tr>
+-->
+<!--
 <tr><td>M309</td> <td>ERROR</td> <td>Cannot read file information: \em 'PATH'.</td>
-  <td>Access to the file specified failed. Verify permissions and spelling.</td>
+  <td>Access to the file specified in \em 'PATH' failed.
+  <br>Verify permissions and spelling.</td>
 </tr>
+-->
 <tr><td>M310</td> <td>ERROR</td> <td>Filename mismatch (case sensitive):\n
                      PDSC name : \em 'PDSC_FILENAME' \n
                      Filename  : \em 'SYSTEM'   </td>
   <td>Filenames are case sensitive. Correct spelling.</td>
 </tr>
-<tr><td>M323</td> <td>ERROR</td> <td>File/Path not found: \em 'PATH' </td>
-  <td>The file or path entered in the PDSC file could not be found. Verify the path information.</td>
+<tr><td>M315</td> <td>ERROR</td> <td>Invalid URL / Paths to Drives are not allowed in Package URL: \em 'URL' </td>
+  <td>Correct package URL \em 'URL'. Refer to \ref package_url "/package/url".</td>
 </tr>
-<tr><td>M324</td> <td>ERROR</td> <td>Board referenced in Example \em 'EXAMPLE' is undefined: \em 'VENDOR' : \em 'BOARD' </td>
-  <td>The board referenced in the example application could not be found. Define the board (\ref element_board) or correct the reference information (\ref element_example_board).</td>
+<tr><td>M316</td> <td>WARNING</td> <td>URL must end with slash '/': 'URL' </td>
+  <td>Correct package URL \em 'URL'. Refer to \ref package_url "/package/url".</td>
+</tr>
+<tr><td>M323</td> <td>ERROR</td> <td>File/Path not found: \em 'PATH' </td>
+  <td>The file or path \em 'PATH' entered in the PDSC file could not be found.
+  <br>Verify the path information.</td>
+</tr>
+<tr><td>M324</td> <td>WARNING</td> <td>Board referenced in Example \em 'EXAMPLE' is undefined: \em 'VENDOR' : \em 'BOARD' </td>
+  <td>The definition of the board referenced in the example application could not be found.
+  <br>Define the board (\ref element_board) or correct the reference information (\ref element_example_board).</td>
 </tr>
 <tr><td>M325</td> <td>ERROR</td> <td>Board \em 'NAME' redefined, already defined in Line \em 'LINE': \em 'PATH'</td>
-  <td>This board has been defined already in the line \em 'LINE' of the file \em 'PATH'.  Verify and remove one of the board definitions.</td>
+  <td>This board has been defined already in the line \em 'LINE' of the file \em 'PATH'.
+  <br>Verify and remove one of the board definitions. Refer to \ref element_board.</td>
 </tr>
 <tr><td>M326</td> <td>ERROR</td> <td>Path is not conformant: \em 'PATH':  Absolute Paths or Drive references are not allowed, use Paths relative to PDSC file.</td>
   <td>The path needs to be relative to the PDSC file so that a dependency of a certain file system does not occur.</td>
 </tr>
-<tr><td>M327</td> <td>ERROR</td> <td>Path is not conformant: \em 'PATH':  Backslashes are not recommended, use forward slashes.</td>
+<tr><td>M327</td> <td>WARNING</td> <td>Path is not conformant: \em 'PATH':  Backslashes are not recommended, use forward slashes.</td>
   <td>Paths to files should adhere to the POSIX standard using forward slashes (/).</td>
 </tr>
 <tr><td>M328</td> <td>ERROR</td> <td>Version not set for Release Information \em 'DESCR'</td>
@@ -226,49 +307,62 @@
   <td>The release defined through the version \em 'VER' needs a description. Refer to \ref element_release.</td>
 </tr>
 <tr><td>M330</td> <td>ERROR</td> <td>Condition redefined: \em 'COND', already defined in Line \em 'LINE'</td>
-  <td>The condition has been defined already in a previous line. Correct the condition name, or remove the duplicate.</td>
+  <td>The condition has been defined already in a previous line. 
+  <br>Correct the condition name, or remove the duplicate. Refer to \ref element_condition.</td>
 </tr>
 <tr><td>M331</td> <td>WARNING</td> <td>Condition unused: \em 'COND'</td>
-  <td>The condition has been defined but not used further. Remove the condition or add condition rules. Refer to \ref element_condition.</td>
+  <td>The condition has been defined but not used further. 
+  <br>Remove the condition or add condition rules. Refer to \ref element_condition.</td>
 </tr>
 <tr><td>M332</td> <td>ERROR</td> <td>Condition undefined: \em 'COND'</td>
-  <td>A condition has been used but not defined. Correct the name of the condition or define the missing condition. Refer to \ref element_condition.</td>
+  <td>A condition has been used but not defined. 
+  <br>Correct the name of the condition or define the missing condition. Refer to \ref element_condition.</td>
 </tr>
 <tr><td>M333</td> <td>WARNING</td> <td>Component has no condition: Cclass= \em 'CCLASS', Cgroup= \em 'CGROUP', \em Csub='CSUB', \em Cversion= 'CVER'</td>
   <td>The component defined has no condition. If the component has restrictions, then add a condition to the component definition. Refer to \ref element_component.</td>
 </tr>
 <tr><td>M334</td> <td>WARNING</td> <td>Config File has no version: \em 'PATH'</td>
-  <td>Add version information to the configuration file.</td>
+  <td>Specified file 'PATH' does not contain version information. It is recommended to specify versions for configuration files. 
+  <br>Add attribute \token{version} with the file version in the \token{\<file>} tag that defines the \em 'PATH' file in the PDSC. Refer to \ref element_file.</td>
 </tr>
 <tr><td>M335</td> <td>WARNING</td> <td>Component declared as 'Board Support' has no ref to a device: Cclass= \em 'CCLASS', Cgroup= \em 'CGROUP', Cversion= \em 'CVER'</td>
-  <td>A component defined as 'board support' needs a reference to a device. Add a device or correct the component definition. Refer to attribute \em Cclass of \ref element_component and \ref element_board_mountedDevice.</td>
+  <td>A component defined as 'board support' needs a reference to a device.
+  <br>Add a device or correct the component definition. Refer to attribute \em Cclass of \ref element_component and \ref element_board_mountedDevice.</td>
 </tr>
 <tr><td>M336</td> <td>WARNING</td> <td>No reference to a device or device not found: Cclass= \em 'CCLASS', Cgroup= \em 'CGROUP', Cversion= \em 'CVER'</td>
   <td>Define the device \ref element_device or correct the information about the device in the reference.</td>
 </tr>
 <tr><td>M337</td> <td>WARNING</td> <td>File with category \em 'CAT' has wrong extension \em 'EXT': \em 'PATH'</td>
-  <td>The extension of the file does not match the file category. Verify the extension to match the category. Refer to \ref element_file.</td>
+  <td>The extension of the file does not match the file category \em 'CAT' specified in the \token{category} attribute.
+  <br>Verify the extension to match the category. Refer to \ref element_file.</td>
 </tr>
 <tr><td>M338</td> <td>WARNING</td> <td>No releases found.</td>
-  <td>The PDSC file is missing release information. Add \token{\<release>} information to the file. Refer to \ref element_releases.</td>
+  <td>The PDSC file is missing release information.
+  <br>Add \token{\<release>} information to the file. Refer to \ref element_releases.</td>
 </tr>
 <tr><td>M339</td> <td>WARNING</td> <td>Include Path \em 'PATH' must not be a file!</td>
-  <td>The path specified contains a filename. Correct the path infomation and remove the filename.</td>
+  <td>The path specified contains a filename.
+  <br>Correct the path infomation and remove the filename. Refer to \ref element_file.</td>
 </tr>
 <tr><td>M340</td> <td>WARNING</td> <td>Include Path \em 'PATH' must end with '/' or '\\'</td>
-  <td>Include paths must end with a slash or backslash. Verify and correct the path name.</td>
+  <td>Include paths must end with a slash or backslash.
+  <br>Verify and correct the path name. Refer to \ref element_file.</td>
 </tr>
 <tr><td>M341</td> <td>WARNING</td> <td>File with \em 'COMP' dependency must have extension \em 'EXT' : \em 'PATH'</td>
-  <td>A file defining component dependencies must have the extension mentioned in the message. Verify the settings and correct the file extension.</td>
+  <td>The file \em 'PATH' with dependency on component \em 'COMP' must have a specific extension \em 'EXT'.
+  <br>Verify the dependency and correct the file extension. Refer to \ref element_file.</td>
 </tr>
 <tr><td>M342</td> <td>WARNING</td> <td>File with attribute \em 'ATTR' must not have category \em 'CAT':  \em 'PATH'</td>
-  <td>A file with the attribute mentioned in the message must not have the category specified. Correct the attribute or the category.Refer to \ref element_file.</td>
+  <td>File \em 'PATH' is defined with the attribute \token{attr} set to \em 'ATTR'. This conflicts with the file category \em 'CAT' specified in \token{category} attribute. For example \token{attr=config} and \token{category=include} are not allowed for the same file.
+  <br>Correct the file attribute or the file category. Refer to \ref element_file.</td>
 </tr>
 <tr><td>M343</td> <td>WARNING</td> <td>File with attribute \em 'ATTR' requires \em 'ATTR2' attribute: \em 'PATH'</td>
-  <td>A file with the attribute \em 'ATTR' requires another attribute \em 'ATTR2'. Add the required attribute or correct attribute \em 'ATTR'. Refer to \ref element_file.</td>
+  <td>File \em 'PATH' is defined with the attribute \em 'ATTR' that requires presense of attribute \em 'ATTR2' as well, but such attribute was not found. For example, \token{attr=template} requires that attribute \token{select} is defined.
+  <br> Add the required attribute \em 'ATTR2' or correct the attribute \em 'ATTR' in the \token{\<file>} element. Refer to \ref element_file.</td>
 </tr>
 <tr><td>M344</td> <td>WARNING</td> <td>File shall have condition containing \em 'COND': \em 'PATH'</td>
-  <td>The file should have a condition. Define a condition in the file specified in the message.</td>
+  <td>File definition for \em 'PATH' shall contain a condition \em 'COND'.
+  <br>Add attribute \token{condition} with the \em 'COND' in the \token{\<file>} tag that defines the \em 'PATH' file. Refer to \ref element_file..</td>
 </tr>
 <tr><td>M345</td> <td>WARNING</td> <td>URL not found : \em 'URL' </td>
   <td>The specified URL could not be found. Correct the URL. Refer to \ref element_package.</td>
@@ -286,7 +380,8 @@
   <td>Example projects have been found for a board that was not defined. Correct the entry for the examples (\ref element_example_board) or define the board (\ref element_board).</td>
 </tr>
 <tr><td>M350</td> <td>WARNING</td> <td>No \em 'COMP' found for \em 'VENDOR' : \em 'MCU' (\em 'COMPILER')</td>
-  <td>The package (\ref element_package) defines a Vendor-MCU combination for which no component was defined. Define a component (\ref element_component) or verify the \em 'VENDOR' - \em 'MCU' settings.</td>
+  <td>The package (\ref element_package) defines a Vendor-MCU combination for which no component was defined. 
+  <br>Define a component (\ref element_component) or verify the \em 'VENDOR' - \em 'MCU' settings.</td>
 </tr>
 <tr><td>M351</td> <td>WARNING</td> <td>Component \em 'COMP' (\em 'COMPID') error for \em 'VENDOR': \em 'MCU' ( \em 'COMPILER'): \em 'MSG'</td>
   <td>An unspecified error was found for the component. The message might give detailed information about the error.</td>
@@ -303,9 +398,12 @@
 <tr><td>M355</td> <td>WARNING</td> <td>No \em 'FILECAT' Directory found for Component \em 'COMP' (\em 'COMPID') for \em 'VENDOR' : \em 'MCU' (\em 'COMPILER')</td>
   <td>The directory specified for the file category was not found. Correct the information in the component settings (\ref element_component).
 </tr>
+<!-- /* not used */
 <tr><td>M356</td> <td>WARNING</td> <td>Multiple \em 'FILECAT' Directories found for Component \em 'COMP' (\em 'COMPID') for \em 'VENDOR' : \em 'MCU' (\em 'COMPILER')</td>
-  <td>Multiple directories were found for the same file category in the specified component. Remove obsolete information or correct the component settings.</td>
+  <td>Multiple directories were found for the same file category in the specified component. 
+  <br>Remove obsolete information or correct the component settings.</td>
 </tr>
+-->
 <tr><td>M358</td> <td>WARNING</td> <td>Header File \em 'HFILE' for \em 'CFILE' missing for Component \em 'COMP' (\em 'COMPID') for \em 'VENDOR' : \em 'MCU' (\em 'COMPILER')</td>
   <td>The header file defined for the component could not be found. Verify the header file settings (\ref element_file) or whether the file exists.</td>
 </tr>
@@ -327,16 +425,22 @@
 <tr><td>M364</td> <td>WARNING</td> <td>No Devices for Condition \em 'COND' available.</td>
   <td>The specified condition refers to a device that does not exist. Define the device (\ref element_device) or correct the information for the condition (\ref element_condition).</td>
 </tr>
-<tr><td>M365</td> <td>ERROR</td> <td>Redefined DEVTYPE \em 'MCU' found, see Line \em LINE</td>
-  <td>Remove duplicate device/variant entries.</td>
+<tr><td>M365</td> <td>ERROR</td> <td>Redefined \em 'DEVTYPE' \em 'MCU' found, see Line \em LINE</td>
+  <td>Remove duplicate device/variant entries. Refer to \ref element_device.</td>
 </tr>
-<tr><td>M366</td> <td>ERROR</td> <td>Redefined DEVTYPEEXIST as DEVTYPE \em 'MCU' found, see Line \em LINE</td>
-  <td>Device has been redefined as variant or vice versa. Remove duplicate device/variant entries.</td>
+<tr><td>M366</td> <td>ERROR</td> <td>Redefined \em 'DEVTYPEEXIST' as \em 'DEVTYPE' \em 'MCU' found, see Line \em LINE</td>
+  <td>Device has been redefined as variant or vice versa.
+   <br>Remove duplicate device/variant entries. Refer to \ref element_device.</td>
 </tr>
-<tr><td>M368</td> <td>INFO</td> <td>Redefined TYPEEXISTING as TYPE \em 'NAME' found, see Line \em LINE</td>
+<tr><td>M367</td> <td>ERROR</td> <td>Redefined \em 'TYPE' \em 'NAME' found, see Line \em 'LINE'</td>
+  <td>Remove duplicate device/variant entries. Refer to \ref element_device.</td>
+</tr>
+<!-- /* not used */
+<tr><td>M368</td> <td>ERROR</td> <td>Redefined \em 'TYPEEXISTING' as \em 'TYPE' \em 'NAME' found, see Line \em LINE</td>
   <td>Family/subfamily/device/variant has been redefined as different type.</td>
 </tr>
-<tr><td>M369</td> <td>INFO</td> <td>Feature is already defined for \em 'DEVICE' and will be added, see Line \em 'LINE': \em 'FEATURE'.</td>
+-->
+<tr><td>M369</td> <td>WARNING</td> <td>Feature is already defined for \em 'DEVICE' and will be added, see Line \em 'LINE': \em 'FEATURE'.</td>
   <td>This feature \em 'FEATURE' has been defined already on a higher level and as such it gets added to this \em 'DEVICE'. This is usually done when some devices have a higher number of basic features. Correct the feature (\ref element_feature) if this is a typo.</td>
 </tr>
 <tr><td>M370</td> <td>WARNING</td> <td>URL is not conformant: \em 'URL':\n  Backslashes are not allowed in URL, use forward slashes.</td>
@@ -358,79 +462,123 @@
   <td>If a board element does not contain a \<mountedDevice\> element, then the examples for this board are not shown and example projects may not appear in the development tools. Refer to \ref element_board_mountedDevice of \ref element_boards.</td>
 </tr>
 <tr><td>M376</td> <td>ERROR</td> <td>Schema Version not set!</td>
-  <td>Set a valid schema version in the PDSC file.</td>
+  <td>Set a valid schema version in the PDSC file. Refer to \token{schemaVersion} attribute in the \ref element_package.</td>
 </tr>
-<tr><td>M377</td> <td>INFO</td> <td>File \em 'NAME' \em TYPE must have \em 'attr="config"'</td>
+<tr><td>M377</td> <td>WARNING</td> <td>File \em 'NAME' \em 'TYPE' must have \em 'attr="config"'</td>
+  <td>The category \em 'TYPE' of the file \em 'NAME' requires it to be defined as a configuration file.
+  <br>Add the attribute \token{attr="config"} to the \token{\<file>} element that defines the file. Refer to \ref element_file.</td>
+<tr><td>M378</td> <td>WARNING</td> <td>Component Cclass=\em 'CCLASS, Cgroup=\em 'CGROUP, Csub=\em 'CSUB', Cversion=\em 'CVER', implements the API defined in \em 'NAME' but does not attribute 'Capiversion' specifying the version it implements.</td>
+  <td>Add attribute \token{Capiversion} specifying the API version that is implemented in the component described in the message. Refer to \ref element_component.</td>
+</tr>
+<tr><td>M379</td> <td>WARNING</td> <td>No example(s) found for Board '[\em 'VENDOR'] \em 'BOARD'.</td>
+  <td>There are no examples found for the board \em 'BOARD'.
+  <br>Provide examples. Refer to \ref element_example.</td>
+</tr>
+<!-- /* not used*/
+<tr><td>M380</td> <td>WARNING</td> <td>No description found for [\em 'VENDOR'] 'MCU'</td>
+  <td> </td>
+</tr>
+-->
+<tr><td>M381</td> <td>WARNING</td> <td>Vendor names are not equal: '[\em 'VENDOR'] \em 'MCU', MCU '[\em 'VENDOR2'] \em 'MCU2', see Line \em 'LINE'</td>
+  <td>Vendor name specified in the \token{Dvendor} attribute for the \token{\<mountedDevice>} tag does not match the actual device vendor name.
+  <br>Verify and correct vendor name. Refer to \ref element_board_mountedDevice.</td>
+</tr>
+<tr><td>M382</td> <td>WARNING</td> <td>Requirement \<\em 'TAG'> '[\em 'VENDOR'] \em 'NAME' \em 'VER' could not be resolved.\em 'MSG'</td>
+  <td>The package requires a package with name \em 'NAME' and version \em 'VER' from vendor \em 'VENDOR'. That package was not found.
+  <br>Verify the requirement. Use option \c -i to point to the required package. Refer to \ref element_packages.</td>
+</tr>
+<tr><td>M383</td> <td>ERROR</td> <td>\em 'TAG' \em 'NAME' is not conformant to the pattern \"\em 'CHAR'\"</td>
+  <td>Unsupported characters are found in the \em 'NAME' for the tag/attribute \em 'TAG'.
+  <br>Specify the name using only supported characters from \em 'CHAR'.</td>
+</tr>
+<tr><td>M384</td> <td>ERROR</td> <td>Condition \em 'NAME': Direct or indirect recursion detected. Skipping condition while searching for \em 'NAME2'</td>
+  <td>Resolve recursion in condition \em 'NAME'.</td>
+</tr>
+<tr><td>M385</td> <td>INFO</td> <td>Release date is empty.</td>
+  <td>In the \token{\<release>} tag add attribute \token{date} with the release date. Refer to \ref element_release.</td>
+</tr>
+<tr><td>M386</td> <td>WARNING</td> <td>Release date is in future: \em 'RELEASEDATE' (today: \em 'TODAYDATE')</td>
+  <td>Set the \token{date} to the future. Refer to \ref element_release.</td>
+</tr>
+<!-- /* not used */
+<tr><td>M389</td> <td>WARNING</td> <td>Condition \em 'NAME': Direct or indirect recursion detected. Skipping condition while searching for \em 'NAME2'</td>
+  <td> </td>
+</tr>
+-->
+<!--
+<tr><td>M390</td> <td>WARNING</td> <td>Condition \em 'NAME': Direct or indirect recursion detected. Skipping condition while searching for \em 'NAME2'</td>
   <td>This file has to be configurable. Add the required attribute to achieve this.</td>
 </tr>
-</table>
-
-XML Reader Errors
----------------
-
-<table class="cmtable" summary="packChk XML Reader Msgs">
-  <tr>
-    <th>Message Number</th>
-    <th>Type</th>  <th>Description</th>
-    <th>Action</th>
-  </tr>
-<tr><td>M401</td> <td>INFO</td> <td>Did you mean \em 'TAG'?</td>
-  <td>Specify the tag to be used.</td>
+-->
+<tr><td>M391</td> <td>WARNING</td> <td>Redefined Item \em 'NAME': \em 'MSG</td>
+  <td>Multiple defitions of item \em 'NAME' are found.
+  <br>Use unique names for the items listed in the message \em 'MSG'.</td>
 </tr>
-<tr><td>M410</td> <td>WARNING</td> <td>Lost xml file stream.</td>
-  <td>File corrupted.</td>
+<tr><td>M392</td> <td>ERROR</td> <td>Redefined Device or Variant \em 'NAME': \em 'MSG'</td>
+  <td>Multiple defitions of device or variant \em 'NAME' are found.
+  <br>Use unique names for the devices listed in the message \em 'MSG'. Refer to \ref element_device and \ref element_variant</td>
 </tr>
-<tr><td>M411</td> <td>WARNING</td> <td>Preamble for \em 'UTF' should not be used, specify via '<?xml'   </td>
-  <td>Specify encoding as UTF-8 only, without BOM.</td>
+<tr><td>M393</td> <td>WARNING</td> <td>Package has development version \em 'RELEASEVER'</td>
+  <td>The package has development version specified in the \token{version} attribute.
+  <br>For release use only MAJOR, MINOR and PATCH sections as described in the \ref VersionType "CMSIS-pack version semantics". Also refer to \ref element_release.</td>
 </tr>
-<tr><td>M412</td> <td>WARNING</td> <td>Unsupported format or extra characters found before '<?xml': \em 'TEXT'  </td>
-  <td>Correct the XML file.</td>
+<tr><td>M394</td> <td>ERROR</td> <td>Not Semantic Versioning: \em 'RELEASEVER'</td>
+  <td>Package version does not follow expected \ref VersionType "semantic versioning".
+  <br>Correct the value specified for the \token{version} attribute using correct semantic. Refer to \ref element_release.</td>
 </tr>
-<tr><td>M413</td> <td>WARNING</td> <td>UTF Format not supported: \em 'UTF'  </td>
-  <td>Select another UTF format.</td>
+<tr><td>M395</td> <td>WARNING</td> <td>Release date attribute is not set for release version: \em 'RELEASEVER'</td>
+  <td>Specify release date in the attribute \token{date} for the returned release version \em 'RELEASEVER'. Refer to \ref element_release.</td>
 </tr>
-<tr><td>M414</td> <td>ERROR</td> <td>Cannot decode XML special character: \em 'SPECIALCHAR'. </td>
-  <td>Correct the XML file.</td>
+<tr><td>M396</td> <td>WARNING</td> <td>Release \em 'TAG' not consecutive (newest first): \em 'RELEASEVER', \em 'RELEASEDATE' (prev.: \em 'LATESTVER', \em 'LATESTDATE', see Line \em 'LINE')</td>
+  <td>Package releases shall be entered in consecutive way: newest release version and latest date first.
+  <br>Rearrange the releases in the list or correct values for the returned 'TAG' attributes (\token{version} or \token{date}). Refer to \ref element_release.</td>
 </tr>
-<tr><td>M415</td> <td>ERROR</td> <td>'<--' found, should this be a comment '\<!--' ?</td>
-  <td>Looks like a misspelled comment.</td>
+<tr><td>M397</td> <td>WARNING</td> <td>File extension '.pdsc' must be lowercase: \em 'PATH'</td>
+  <td>The PDSC file shall have lowercase extension .pdsc
+  <>Correct extension of the PDSC file \em 'PATH'.</td>
 </tr>
-<tr><td>M416</td> <td>ERROR</td> <td>Begin Tag seems to end with a Single Tag. Is this a typo?</td>
-  <td>Correct the XML file.</td>
+<tr><td>M398</td> <td>ERROR</td> <td>Attribute 'Dname' missing in expression using 'Pname=\"\em 'NAME'\"</td>
+  <td>When using attribute \token{Pname} in the \token{\<condition>} element the \token{Dname} attribue shall be present as well.
+  <br>Add attribute token{Dname} specifying the device name. Refer to \ref element_condition.</td>
 </tr>
-<tr><td>M417</td> <td>ERROR</td> <td>Inconsistent XML Structure </td>
-  <td>Correct the XML file.</td>
+<tr><td>M399</td> <td>WARNING</td> <td>Attribute \em 'TAG' is ignored, because \em 'TAG2' + \em 'TAG3' is specified</td>
+  <td>Deprecated attribute \em 'TAG' is ignored because newer attributes are found. Triggered for \token{id} attribute in the \ref element_memory element when \token{name} or \token{access} attributes are present as well.
+  <br>remove deprecated attribute \em 'TAG'</td>
+<tr><td>M400</td> <td>ERROR</td> <td>Either attribute \em 'TAG' or \em 'TAG2' + \em 'TAG3' must be specified for 'memory'</td>
+  <td>\token{\<memory>} element requires that either attribute \token{id} or attributes \token{name} and \token{access} are specified, but none of those were found.
+  <br>Specify the expected attributes. Refer to \ref element_memory.</td>
 </tr>
-<tr><td>M418</td> <td>ERROR</td> <td>XML Stack deeper than 30 Items! Giving up.</td>
-  <td>Reduce the nested nodes.</td>
+<tr><td>M401</td> <td>ERROR</td> <td>Attribute \em 'TAG' missing on \em 'TAG2'</td>
+  <td>Element \em 'TAG2' requires attribute \em 'TAG', but it was not found.
+  <br>Add missing attribute.</td>
 </tr>
-<tr><td>M419</td> <td>ERROR</td> <td>Begin Tag follows Text. Missing End Tag?</td>
-  <td>Correct the XML file.</td>
+<tr><td>M402</td> <td>ERROR</td> <td>Attribute \em 'TAG' missing on \em 'TAG2' (when \em 'TAG3' is specified)</td>
+  <td>Add missing attribute \em 'TAG' or remove the attribute \em 'TAG3' in the element \em 'TAG2'.</td>
 </tr>
-<tr><td>M420</td> <td>ERROR</td> <td>Missing quotes (\") in Attributes: \em 'ATTRLINE'</td>
-  <td>Correct the XML file. Enclose values in \token{\" \"}.</td>
+<tr><td>M403</td> <td>ERROR</td> <td>Redefinition of \em 'TAG' : \em 'NAME', see Line \em 'LINE'</td>
+  <td>Remove the redefinition of element \em 'TAG' with name \em 'NAME'.</td>
 </tr>
-<tr><td>M421</td> <td>ERROR</td> <td>XML Hierarchy Error: Missing End Tags.</td>
-  <td>Correct the XML file. Verify for enclosing or nested tags.</td>
-</tr>
-<tr><td>M422</td> <td>ERROR</td> <td>Error reading file \em 'NAME'</td>
-  <td>File could not be read.</td>
+<tr><td>M404</td> <td>WARNING</td> <td>No \em 'TAG' found for device \em 'NAME'</td>
+  <td>Element \em 'TAG' is missing for device \em 'NAME'.
+  <br>Add missing element.</td>
 </tr>
 </table>
 
+\anchor packchk_model_msgs
 Model Errors
 ---------------
 
 <table class="cmtable" summary="packChk Model Msgs">
   <tr>
     <th>Message Number</th>
-    <th>Type</th>  <th>Description</th>
+    <th>Type</th>
+	<th>Message Text</th>
     <th>Action</th>
   </tr>
-<tr><td>M500</td> <td>TEXT</td> <td>RTE Model reports: \em MSG</td>
+<tr><td>M500</td> <td>TEXT</td> <td>RTE Model reports: \em 'MSG'</td>
   <td>Error while preparing data. See massage for more details.</td>
 </tr>
-<tr><td>M502</td> <td>TEXT</td> <td>RTE Model reports: \#error \em NUM: \em NAME : \em MSG</td>
+<tr><td>M502</td> <td>TEXT</td> <td>RTE Model reports: \#error \em 'NUM': \em 'NAME' : \em 'MSG'</td>
   <td>Additional software components required.</td>
 </tr>
 <tr><td>M504</td> <td>TEXT</td> <td>RTE Model reports: MISSING: -- \em SPACE \em NAME</td>
diff --git a/CMSIS/DoxyGen/Pack/src/pdsc_format.txt b/CMSIS/DoxyGen/Pack/src/pdsc_format.txt
index 907ef50..71b0062 100644
--- a/CMSIS/DoxyGen/Pack/src/pdsc_format.txt
+++ b/CMSIS/DoxyGen/Pack/src/pdsc_format.txt
@@ -195,24 +195,28 @@
     <th>Type</th>
     <th>Occurrence</th>
   </tr>
+  \anchor package_name
   <tr>
     <td>name</td>
     <td>Name of the \ref cp_SWComponents "Software Pack". Could be displayed by an installer.</td>
     <td>xs:string </td>
     <td>1..1 </td>
   </tr>
+  \anchor package_vendor
   <tr>
     <td>vendor</td>
     <td>Name of the supplier or vendor of the \ref cp_SWComponents "Software Pack".</td>
     <td>xs:string </td>
     <td>1..1 </td>
   </tr>
+  \anchor package_description  
   <tr>
     <td>description</td>
     <td>Brief description of the \ref cp_SWComponents "Software Pack".</td>
     <td>xs:string </td>
     <td>1..1 </td>
   </tr>
+  \anchor package_url
   <tr>
     <td>url</td>
     <td><a href="https://en.wikipedia.org/wiki/Uniform_resource_locator" target="_blank">HTTP URL</a> 
@@ -222,12 +226,14 @@
     <td>xs:anyURI </td>
     <td>1..1 </td>
   </tr>
+  \anchor package_supportContact
   <tr>
     <td>supportContact</td>
     <td>HTTP URL or e-mail address for users to get support for the content of the Pack</td>
     <td>xs:string</td>
     <td>0..1 </td>
   </tr>
+  \anchor package_url
   <tr>
     <td>license</td>
     <td>Path to a license document.</td>
