diff mbox

[03/10] Keystone2: Add prebuilt OpenEM helper libraries

Message ID 1397476530-20816-4-git-send-email-taras.kondratiuk@linaro.org
State Superseded
Headers show

Commit Message

Taras Kondratiuk April 14, 2014, 11:55 a.m. UTC 
Add headers, prebuilt libraries and kernel module for C6638.
Pack static libraries content into libodp.a

Signed-off-by: Taras Kondratiuk <taras.kondratiuk@linaro.org>
---
 platform/linux-keystone2/Makefile                  |   25 +-
 .../prebuilts/openem/c6638/arm-linux/em_mod.ko     |  Bin 0 -> 161344 bytes
 .../openem/c6638/arm-linux/libopenem_osal.a        |  Bin 0 -> 39708 bytes
 .../openem/c6638/arm-linux/libopenem_rh.a          |  Bin 0 -> 22128 bytes
 .../prebuilts/openem/include/event_machine.h       |  256 ++++
 .../openem/include/event_machine_core_mask.h       |  434 ++++++
 .../openem/include/event_machine_functions.h       |  885 ++++++++++++
 .../prebuilts/openem/include/event_machine_group.h |  292 ++++
 .../openem/include/event_machine_helper.h          |  142 ++
 .../prebuilts/openem/include/event_machine_hw.h    |   57 +
 .../openem/include/event_machine_hw_config.h       |  104 ++
 .../openem/include/event_machine_hw_functions.h    |   94 ++
 .../openem/include/event_machine_hw_macros.h       |  212 +++
 .../prebuilts/openem/include/event_machine_hw_ti.h |   54 +
 .../openem/include/event_machine_hw_ti_functions.h | 1467 ++++++++++++++++++++
 .../openem/include/event_machine_hw_ti_macros.h    |  570 ++++++++
 .../openem/include/event_machine_hw_ti_types.h     |  792 +++++++++++
 .../openem/include/event_machine_hw_types.h        |  338 +++++
 .../openem/include/event_machine_macros.h          |  514 +++++++
 .../prebuilts/openem/include/event_machine_sw.h    |   54 +
 .../openem/include/event_machine_sw_config.h       |  155 +++
 .../prebuilts/openem/include/event_machine_sw_ti.h |   52 +
 .../openem/include/event_machine_sw_ti_config.h    |   49 +
 .../prebuilts/openem/include/event_machine_types.h |  549 ++++++++
 .../openem/include/linux/keystone2/ti_em_hw_cppi.h | 1288 +++++++++++++++++
 .../openem/include/linux/keystone2/ti_em_hw_csl.h  | 1146 +++++++++++++++
 .../include/linux/keystone2/ti_em_hw_functions.h   |  105 ++
 .../openem/include/linux/keystone2/ti_em_hw_mach.h |  166 +++
 .../openem/include/linux/keystone2/ti_em_hw_qmss.h |  633 +++++++++
 .../openem/include/linux/osal/ti_em_osal.h         |  131 ++
 .../openem/include/linux/osal/ti_em_osal_cma.h     |   61 +
 .../openem/include/linux/osal/ti_em_osal_core.h    |  133 ++
 .../openem/include/linux/osal/ti_em_osal_cppi.h    |   73 +
 .../openem/include/linux/osal/ti_em_osal_event.h   |   65 +
 .../include/linux/osal/ti_em_osal_firmware.h       |   43 +
 .../openem/include/linux/osal/ti_em_osal_queue.h   |   84 ++
 .../openem/include/linux/osal/ti_em_osal_shm.h     |   57 +
 .../openem/include/linux/osal/ti_em_osal_uaccess.h |  119 ++
 .../openem/include/linux/osal/ti_em_osal_xge.h     |   69 +
 .../prebuilts/openem/include/linux/rh/ti_em_rh.h   |  139 ++
 .../openem/include/src/event_machine_hwpform.h     |   51 +
 41 files changed, 11455 insertions(+), 3 deletions(-)
 create mode 100644 platform/linux-keystone2/prebuilts/openem/c6638/arm-linux/em_mod.ko
 create mode 100644 platform/linux-keystone2/prebuilts/openem/c6638/arm-linux/libopenem_osal.a
 create mode 100644 platform/linux-keystone2/prebuilts/openem/c6638/arm-linux/libopenem_rh.a
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_core_mask.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_functions.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_group.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_helper.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_hw.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_config.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_functions.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_macros.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_ti.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_ti_functions.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_ti_macros.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_ti_types.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_types.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_macros.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_sw.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_sw_config.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_sw_ti.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_sw_ti_config.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/event_machine_types.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_cppi.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_csl.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_functions.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_mach.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_qmss.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_cma.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_core.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_cppi.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_event.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_firmware.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_queue.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_shm.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_uaccess.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_xge.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/linux/rh/ti_em_rh.h
 create mode 100644 platform/linux-keystone2/prebuilts/openem/include/src/event_machine_hwpform.h

Comments

Maxim Uvarov April 14, 2014, 2:41 p.m. UTC | #1 
On 04/14/2014 03:55 PM, Taras Kondratiuk wrote:
> #ifndef EVENT_MACHINE_CORE_MASK_H_
> +#define EVENT_MACHINE_CORE_MASK_H_
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +#include <event_machine_macros.h>
> +#include <event_machine_types.h>
> +
> +
> +
> +
<4 empty lines>
> +#if EM_CORE_MASK_SIZE != 64
> +#error Core mask functions support only 64 bit mask size
> +#endif
> +
> +
> +
<3 empty lines>
> +#ifdef EM_64_BIT
> +/*
> + *
> + * 64 bit versions.
> + * --------------------------------------------
> + */
> +
> +
< 2 empty lines>
> +/**
> + * @ingroup DOC_api_generic
> + *
> + * Zero the whole mask.
> + *
> + * @param mask      Core mask
> + */
> +static inline void em_core_mask_zero(em_core_mask_t* mask)
> +{
> +  mask->u64[0] = 0;
> +}
> +
> +
> +/**
> + * @ingroup DOC_api_generic
> + *
Taras Kondratiuk April 14, 2014, 9:17 p.m. UTC | #2 
On 04/14/2014 05:41 PM, Maxim Uvarov wrote:
> On 04/14/2014 03:55 PM, Taras Kondratiuk wrote:
>> #ifndef EVENT_MACHINE_CORE_MASK_H_
>> +#define EVENT_MACHINE_CORE_MASK_H_
>> +
>> +#ifdef __cplusplus
>> +extern "C" {
>> +#endif
>> +
>> +#include <event_machine_macros.h>
>> +#include <event_machine_types.h>
>> +
>> +
>> +
>> +
> <4 empty lines>
>> +#if EM_CORE_MASK_SIZE != 64
>> +#error Core mask functions support only 64 bit mask size
>> +#endif
>> +
>> +
>> +
> <3 empty lines>

Thanks. I'll fix it in other patches.
Regarding this patch. It is a copy of headers from an external library.
This patch will generate a lot of coding style warnings. If you don't
mind I won't fix them.

What if I'll skip this patch entirely and just point to an external
location from Makefile?
David Nyström April 15, 2014, 8:45 a.m. UTC | #3 
On 2014-04-14 13:55, Taras Kondratiuk wrote:
> Add headers, prebuilt libraries and kernel module for C6638.
> Pack static libraries content into libodp.a
>
> Signed-off-by: Taras Kondratiuk <taras.kondratiuk@linaro.org>
> ---
>   platform/linux-keystone2/Makefile                  |   25 +-
>   .../prebuilts/openem/c6638/arm-linux/em_mod.ko     |  Bin 0 -> 161344 bytes

This is kernel dependency, and usable only to some, since module 
vermagic probably points to your kernel version.

>   .../openem/c6638/arm-linux/libopenem_osal.a        |  Bin 0 -> 39708 bytes
>   .../openem/c6638/arm-linux/libopenem_rh.a          |  Bin 0 -> 22128 bytes

OpenEM dependency.

>   .../prebuilts/openem/include/event_machine.h       |  256 ++++
>   .../openem/include/event_machine_core_mask.h       |  434 ++++++
>   .../openem/include/event_machine_functions.h       |  885 ++++++++++++
>   .../prebuilts/openem/include/event_machine_group.h |  292 ++++
>   .../openem/include/event_machine_helper.h          |  142 ++
>   .../prebuilts/openem/include/event_machine_hw.h    |   57 +
>   .../openem/include/event_machine_hw_config.h       |  104 ++
>   .../openem/include/event_machine_hw_functions.h    |   94 ++
>   .../openem/include/event_machine_hw_macros.h       |  212 +++
>   .../prebuilts/openem/include/event_machine_hw_ti.h |   54 +
>   .../openem/include/event_machine_hw_ti_functions.h | 1467 ++++++++++++++++++++
>   .../openem/include/event_machine_hw_ti_macros.h    |  570 ++++++++
>   .../openem/include/event_machine_hw_ti_types.h     |  792 +++++++++++
>   .../openem/include/event_machine_hw_types.h        |  338 +++++
>   .../openem/include/event_machine_macros.h          |  514 +++++++
>   .../prebuilts/openem/include/event_machine_sw.h    |   54 +
>   .../openem/include/event_machine_sw_config.h       |  155 +++
>   .../prebuilts/openem/include/event_machine_sw_ti.h |   52 +
>   .../openem/include/event_machine_sw_ti_config.h    |   49 +
>   .../prebuilts/openem/include/event_machine_types.h |  549 ++++++++
>   .../openem/include/linux/keystone2/ti_em_hw_cppi.h | 1288 +++++++++++++++++
>   .../openem/include/linux/keystone2/ti_em_hw_csl.h  | 1146 +++++++++++++++
>   .../include/linux/keystone2/ti_em_hw_functions.h   |  105 ++
>   .../openem/include/linux/keystone2/ti_em_hw_mach.h |  166 +++
>   .../openem/include/linux/keystone2/ti_em_hw_qmss.h |  633 +++++++++
>   .../openem/include/linux/osal/ti_em_osal.h         |  131 ++
>   .../openem/include/linux/osal/ti_em_osal_cma.h     |   61 +
>   .../openem/include/linux/osal/ti_em_osal_core.h    |  133 ++
>   .../openem/include/linux/osal/ti_em_osal_cppi.h    |   73 +
>   .../openem/include/linux/osal/ti_em_osal_event.h   |   65 +
>   .../include/linux/osal/ti_em_osal_firmware.h       |   43 +
>   .../openem/include/linux/osal/ti_em_osal_queue.h   |   84 ++
>   .../openem/include/linux/osal/ti_em_osal_shm.h     |   57 +
>   .../openem/include/linux/osal/ti_em_osal_uaccess.h |  119 ++
>   .../openem/include/linux/osal/ti_em_osal_xge.h     |   69 +
>   .../prebuilts/openem/include/linux/rh/ti_em_rh.h   |  139 ++
>   .../openem/include/src/event_machine_hwpform.h     |   51 +
>   41 files changed, 11455 insertions(+), 3 deletions(-)


Adding other software packages into ODP breaks the rule of modularity. 
ref: http://www.faqs.org/docs/artu/ch01s06.html#id2877537

This rule is assumed by other FOSS software, and it is maintenance heavy 
to break it.
Example: How would this be packaged and versioned in OpenEmbedded ?

Br,
David
Taras Kondratiuk April 15, 2014, 9:20 a.m. UTC | #4 
On 04/15/2014 11:45 AM, David Nyström wrote:
> On 2014-04-14 13:55, Taras Kondratiuk wrote:
>> Add headers, prebuilt libraries and kernel module for C6638.
>> Pack static libraries content into libodp.a
>>
>> Signed-off-by: Taras Kondratiuk <taras.kondratiuk@linaro.org>
>> ---
>>   platform/linux-keystone2/Makefile                  |   25 +-
>>   .../prebuilts/openem/c6638/arm-linux/em_mod.ko     |  Bin 0 ->
>> 161344 bytes
>
> This is kernel dependency, and usable only to some, since module
> vermagic probably points to your kernel version.
>
>>   .../openem/c6638/arm-linux/libopenem_osal.a        |  Bin 0 -> 39708
>> bytes
>>   .../openem/c6638/arm-linux/libopenem_rh.a          |  Bin 0 -> 22128
>> bytes
>
> OpenEM dependency.
>
>>   .../prebuilts/openem/include/event_machine.h       |  256 ++++
>>   .../openem/include/event_machine_core_mask.h       |  434 ++++++
>>   .../openem/include/event_machine_functions.h       |  885 ++++++++++++
>>   .../prebuilts/openem/include/event_machine_group.h |  292 ++++
>>   .../openem/include/event_machine_helper.h          |  142 ++
>>   .../prebuilts/openem/include/event_machine_hw.h    |   57 +
>>   .../openem/include/event_machine_hw_config.h       |  104 ++
>>   .../openem/include/event_machine_hw_functions.h    |   94 ++
>>   .../openem/include/event_machine_hw_macros.h       |  212 +++
>>   .../prebuilts/openem/include/event_machine_hw_ti.h |   54 +
>>   .../openem/include/event_machine_hw_ti_functions.h | 1467
>> ++++++++++++++++++++
>>   .../openem/include/event_machine_hw_ti_macros.h    |  570 ++++++++
>>   .../openem/include/event_machine_hw_ti_types.h     |  792 +++++++++++
>>   .../openem/include/event_machine_hw_types.h        |  338 +++++
>>   .../openem/include/event_machine_macros.h          |  514 +++++++
>>   .../prebuilts/openem/include/event_machine_sw.h    |   54 +
>>   .../openem/include/event_machine_sw_config.h       |  155 +++
>>   .../prebuilts/openem/include/event_machine_sw_ti.h |   52 +
>>   .../openem/include/event_machine_sw_ti_config.h    |   49 +
>>   .../prebuilts/openem/include/event_machine_types.h |  549 ++++++++
>>   .../openem/include/linux/keystone2/ti_em_hw_cppi.h | 1288
>> +++++++++++++++++
>>   .../openem/include/linux/keystone2/ti_em_hw_csl.h  | 1146
>> +++++++++++++++
>>   .../include/linux/keystone2/ti_em_hw_functions.h   |  105 ++
>>   .../openem/include/linux/keystone2/ti_em_hw_mach.h |  166 +++
>>   .../openem/include/linux/keystone2/ti_em_hw_qmss.h |  633 +++++++++
>>   .../openem/include/linux/osal/ti_em_osal.h         |  131 ++
>>   .../openem/include/linux/osal/ti_em_osal_cma.h     |   61 +
>>   .../openem/include/linux/osal/ti_em_osal_core.h    |  133 ++
>>   .../openem/include/linux/osal/ti_em_osal_cppi.h    |   73 +
>>   .../openem/include/linux/osal/ti_em_osal_event.h   |   65 +
>>   .../include/linux/osal/ti_em_osal_firmware.h       |   43 +
>>   .../openem/include/linux/osal/ti_em_osal_queue.h   |   84 ++
>>   .../openem/include/linux/osal/ti_em_osal_shm.h     |   57 +
>>   .../openem/include/linux/osal/ti_em_osal_uaccess.h |  119 ++
>>   .../openem/include/linux/osal/ti_em_osal_xge.h     |   69 +
>>   .../prebuilts/openem/include/linux/rh/ti_em_rh.h   |  139 ++
>>   .../openem/include/src/event_machine_hwpform.h     |   51 +
>>   41 files changed, 11455 insertions(+), 3 deletions(-)
>
>
> Adding other software packages into ODP breaks the rule of modularity.
> ref: http://www.faqs.org/docs/artu/ch01s06.html#id2877537
>
> This rule is assumed by other FOSS software, and it is maintenance heavy
> to break it.
> Example: How would this be packaged and versioned in OpenEmbedded ?

As I've mentioned to Max yesterday, I'll remove this patch from the
series and keep OpenEM as a separate git repo.
David Nyström April 15, 2014, 9:26 a.m. UTC | #5 
On 2014-04-15 11:20, Taras Kondratiuk wrote:
> On 04/15/2014 11:45 AM, David Nyström wrote:
>> On 2014-04-14 13:55, Taras Kondratiuk wrote:
>>> Add headers, prebuilt libraries and kernel module for C6638.
>>> Pack static libraries content into libodp.a
>>>
>>> Signed-off-by: Taras Kondratiuk <taras.kondratiuk@linaro.org>
>>> ---
>>>   platform/linux-keystone2/Makefile                  |   25 +-
>>>   .../prebuilts/openem/c6638/arm-linux/em_mod.ko     |  Bin 0 ->
>>> 161344 bytes
>>
>> This is kernel dependency, and usable only to some, since module
>> vermagic probably points to your kernel version.
>>
>>>   .../openem/c6638/arm-linux/libopenem_osal.a        |  Bin 0 -> 39708
>>> bytes
>>>   .../openem/c6638/arm-linux/libopenem_rh.a          |  Bin 0 -> 22128
>>> bytes
>>
>> OpenEM dependency.
>>
>>>   .../prebuilts/openem/include/event_machine.h       |  256 ++++
>>>   .../openem/include/event_machine_core_mask.h       |  434 ++++++
>>>   .../openem/include/event_machine_functions.h       |  885 ++++++++++++
>>>   .../prebuilts/openem/include/event_machine_group.h |  292 ++++
>>>   .../openem/include/event_machine_helper.h          |  142 ++
>>>   .../prebuilts/openem/include/event_machine_hw.h    |   57 +
>>>   .../openem/include/event_machine_hw_config.h       |  104 ++
>>>   .../openem/include/event_machine_hw_functions.h    |   94 ++
>>>   .../openem/include/event_machine_hw_macros.h       |  212 +++
>>>   .../prebuilts/openem/include/event_machine_hw_ti.h |   54 +
>>>   .../openem/include/event_machine_hw_ti_functions.h | 1467
>>> ++++++++++++++++++++
>>>   .../openem/include/event_machine_hw_ti_macros.h    |  570 ++++++++
>>>   .../openem/include/event_machine_hw_ti_types.h     |  792 +++++++++++
>>>   .../openem/include/event_machine_hw_types.h        |  338 +++++
>>>   .../openem/include/event_machine_macros.h          |  514 +++++++
>>>   .../prebuilts/openem/include/event_machine_sw.h    |   54 +
>>>   .../openem/include/event_machine_sw_config.h       |  155 +++
>>>   .../prebuilts/openem/include/event_machine_sw_ti.h |   52 +
>>>   .../openem/include/event_machine_sw_ti_config.h    |   49 +
>>>   .../prebuilts/openem/include/event_machine_types.h |  549 ++++++++
>>>   .../openem/include/linux/keystone2/ti_em_hw_cppi.h | 1288
>>> +++++++++++++++++
>>>   .../openem/include/linux/keystone2/ti_em_hw_csl.h  | 1146
>>> +++++++++++++++
>>>   .../include/linux/keystone2/ti_em_hw_functions.h   |  105 ++
>>>   .../openem/include/linux/keystone2/ti_em_hw_mach.h |  166 +++
>>>   .../openem/include/linux/keystone2/ti_em_hw_qmss.h |  633 +++++++++
>>>   .../openem/include/linux/osal/ti_em_osal.h         |  131 ++
>>>   .../openem/include/linux/osal/ti_em_osal_cma.h     |   61 +
>>>   .../openem/include/linux/osal/ti_em_osal_core.h    |  133 ++
>>>   .../openem/include/linux/osal/ti_em_osal_cppi.h    |   73 +
>>>   .../openem/include/linux/osal/ti_em_osal_event.h   |   65 +
>>>   .../include/linux/osal/ti_em_osal_firmware.h       |   43 +
>>>   .../openem/include/linux/osal/ti_em_osal_queue.h   |   84 ++
>>>   .../openem/include/linux/osal/ti_em_osal_shm.h     |   57 +
>>>   .../openem/include/linux/osal/ti_em_osal_uaccess.h |  119 ++
>>>   .../openem/include/linux/osal/ti_em_osal_xge.h     |   69 +
>>>   .../prebuilts/openem/include/linux/rh/ti_em_rh.h   |  139 ++
>>>   .../openem/include/src/event_machine_hwpform.h     |   51 +
>>>   41 files changed, 11455 insertions(+), 3 deletions(-)
>>
>>
>> Adding other software packages into ODP breaks the rule of modularity.
>> ref: http://www.faqs.org/docs/artu/ch01s06.html#id2877537
>>
>> This rule is assumed by other FOSS software, and it is maintenance heavy
>> to break it.
>> Example: How would this be packaged and versioned in OpenEmbedded ?
>
> As I've mentioned to Max yesterday, I'll remove this patch from the
> series and keep OpenEM as a separate git repo.

Sorry, did not see that comment.

Thanks Taras.

//DD
diff mbox

Patch

diff --git a/platform/linux-keystone2/Makefile b/platform/linux-keystone2/Makefile
index 15e2a2c..036f7d5 100644
--- a/platform/linux-keystone2/Makefile
+++ b/platform/linux-keystone2/Makefile
@@ -32,10 +32,24 @@  ODP_ROOT = ../..
 LIB_DIR  = ./lib
 DOC_DIR  = ./doc
 
+MY_PLATFORM = DEVICE_K2K
+OPENEM_PREBUILTS_DIR=./prebuilts/openem/c6638/arm-linux
+
+PLAT_CFLAGS  = -D$(MY_PLATFORM)
+PLAT_CFLAGS += -D_GNU_SOURCE -DEM_32_BIT -DTI_EM_CENTRAL_SCHED
+PLAT_CFLAGS += -DTI_EM_TRACE_LEVEL=3 -DEM_CHECK_LEVEL=1
+PLAT_CFLAGS += -DTI_EM_LINUX -DTI_EM_GCC -DTI_EM_ARM_A15 -DTI_EM_C6638
+PLAT_CFLAGS += -D_LITTLE_ENDIAN -DTI_EM_USE_MSM -DTI_EM_XGE_LOOPBACK
+PLAT_CFLAGS += -DTI_ODP
+
+EXTRA_CFLAGS  += $(PLAT_CFLAGS)
 EXTRA_CFLAGS  += -I$(ODP_ROOT)/include
 EXTRA_CFLAGS  += -I./include
 EXTRA_CFLAGS  += -I./include/api
-EXTRA_CFLAGS  += -fPIC
+EXTRA_CFLAGS  += -I./prebuilts/openem/include
+EXTRA_CFLAGS  += -I./prebuilts/openem/include/linux/keystone2
+EXTRA_CFLAGS  += -I./prebuilts/openem/include/linux/osal
+EXTRA_CFLAGS  += -I./prebuilts/openem/include/linux/rh
 
 ifeq ($(ODP_HAVE_NETMAP),yes)
 EXTRA_CFLAGS  += -DODP_HAVE_NETMAP
@@ -100,8 +114,8 @@  $(OBJ_DIR)/%.o: ./source/%.c
 #
 # Lib rule
 #
-$(STATIC_LIB): $(OBJS)
-	$(AR) -cr $@ $(OBJS)
+$(STATIC_LIB): $(OBJS) extract_prebuilt_libs
+	$(AR) -cr $@ $(OBJ_DIR)/*.o
 
 clean:
 	$(RMDIR) $(OBJ_DIR)
@@ -124,6 +138,11 @@  docs_install: docs
 pdf: docs
 	make --directory doc/latex refman.pdf 1> /dev/null
 
+.PHONY: extract_prebuilt_libs
+extract_prebuilt_libs: $(OBJ_DIR)
+	(cd $(OBJ_DIR) && $(AR) x ../$(OPENEM_PREBUILTS_DIR)/libopenem_osal.a)
+	(cd $(OBJ_DIR) && $(AR) x ../$(OPENEM_PREBUILTS_DIR)/libopenem_rh.a)
+
 .PHONY: libs
 libs: $(OBJ_DIR) $(LIB_DIR) $(STATIC_LIB)
 
diff --git a/platform/linux-keystone2/prebuilts/openem/c6638/arm-linux/em_mod.ko b/platform/linux-keystone2/prebuilts/openem/c6638/arm-linux/em_mod.ko
new file mode 100644
index 0000000000000000000000000000000000000000..9112ec5102579e8f58f017ed760e265c01713b38
GIT binary patch
literal 161344
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

literal 0
HcmV?d00001

diff --git a/platform/linux-keystone2/prebuilts/openem/c6638/arm-linux/libopenem_osal.a b/platform/linux-keystone2/prebuilts/openem/c6638/arm-linux/libopenem_osal.a
new file mode 100644
index 0000000000000000000000000000000000000000..c64299e04a3049da641b8c1bca2efa5e18d95a99
GIT binary patch
literal 39708
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
UB_a4wuOCnXcuo(vpjh_&Kj>$}uK)l5

literal 0
HcmV?d00001

diff --git a/platform/linux-keystone2/prebuilts/openem/c6638/arm-linux/libopenem_rh.a b/platform/linux-keystone2/prebuilts/openem/c6638/arm-linux/libopenem_rh.a
new file mode 100644
index 0000000000000000000000000000000000000000..015214ca5d8f9d718a4541d66f1475eb7360108f
GIT binary patch
literal 22128
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
VAr$e3f~Qsftik~ba}pMc{|0<^B}V`N

literal 0
HcmV?d00001

diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine.h
new file mode 100644
index 0000000..4987577
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine.h
@@ -0,0 +1,256 @@ 
+/*
+ *   Copyright (c) 2012, Nokia Siemens Networks
+ *   All rights reserved.
+ *
+ *   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 Nokia Siemens Networks 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.
+ */
+
+
+/**
+ *
+ * Contributors
+ *
+ * The initial developer of the original code is Nokia Siemens Networks.
+ *  The following contributors have made changes to 
+ *  the original code as described below.
+ * 
+ *----------------------------------------------------------------------------------------------
+ * Copyright (c) 2012, Texas Instruments Incorporated. All Rights Reserved. - http://www.ti.com/
+ * 
+ * Changes were done on the original NSN header files in order to avoid 
+ * circular dependencies when called in the TI implementation files.
+ *
+ * From the original event_machine.h, the list of changes are:
+ *   - Functions definitions are now located in:
+ *     - openem/event_machine_functions.h
+ *   - Doxygen tags are added for API documentation generation.
+ *
+ * The event_machine.h is now just an aggregator of include files. It will
+ * be called by the Open Event Machine user. 
+ *
+ * Finally, the Open Event Machine is a RTSC component.
+ * See http://rtsc.eclipse.org/docs-tip/Main_Page for details.
+ *
+ *----------------------------------------------------------------------------------------------
+ */
+
+
+/**
+ * @file : event_machine.h
+ *
+ * @brief
+ * Open Event Machine API v1.0
+ *
+ */
+  
+#ifndef EVENT_MACHINE_H
+#define EVENT_MACHINE_H
+/**
+ * @mainpage
+ *
+ * This document contains information about the Texas Instruments implementation of the Open Event Machine.
+ *
+ * The file event_machine.h represents the interface of the event machine library.
+ * It includes all the specifications needed to use the library.
+ * It shall be included as follows to access the event machine functionality.
+ * @code #include <event_machine.h>
+ * @endcode
+ * 
+ * The file event_machine_firmware.h contains the binary of the micro risc controller implementing the event machine scheduler.
+ * The binary shall be loaded in the micro risc controller when initializing the QMSS.
+ * This file shall be included as follows.
+ * @code #include <firmware/event_machine_firmware.h>
+ * @endcode
+
+ * Limitations of the Texas Instruments implementation of the Open Event Machine are listed in the release notes document.
+ *
+ * @n This document is divided into the following sections:
+ *
+ * - @subpage DOC_intro
+ *
+ * - @subpage DOC_error
+ *
+ * - @subpage DOC_trace
+ *
+ * - @subpage DOC_api_generic
+ *
+ * - @subpage DOC_api_specific
+ */
+
+
+
+#define EM_API_VERSION_MAJOR 1     /**< Major API version number. Step if not backwards compatible  */
+#define EM_API_VERSION_MINOR 0     /**< Minor API version number. Updates and additions             */
+
+
+/** 
+ *
+ * @page DOC_intro Introduction
+ * @section section_1 General
+ * Event Machine (EM) is an architectural abstraction and framework of an event driven
+ * multicore optimized processing concept originally developed for networking data plane.
+ * It offers an easy programming concept for scalable and dynamically load balanced
+ * multicore applications with a very low overhead run-to-completion principle.
+ *
+ * Main elements in the concept are events, queues, scheduler, dispatcher and the
+ * execution objects (EO). Event is an application specific piece of data (like a message
+ * or a network packet) describing work, something to do. Any processing in EM must be
+ * triggered by an event. Events are sent to asynchronous application specific queues.
+ * A single thread on all cores of an EM instance runs a dispatcher loop (a "core" is
+ * used here to refer to a core or one HW thread on multi-threaded cores). Dispatcher
+ * interfaces with the scheduler and asks for an event. Scheduler evaluates the state
+ * of all queues and gives the highest priority event to the dispatcher, which forwards
+ * it to the EO mapped to the queue the event came from by calling the registered receive
+ * function. As the event is handled and receive function returns, the next event is
+ * received from the scheduler and again forwarded to the mapped EO. This happens in
+ * parallel on all cores included. Everything is highly efficient run to completion
+ * single thread, no context switching nor pre-emption (priorities are handled by the
+ * scheduler).
+ * EM can run on bare metal for best performance or under an operating system with special
+ * arrangements (e.g. one thread per core with thread affinity).
+ *
+ * The concept and this API are made to be easy to implement for multiple general purpose or
+ * networking oriented multicore packet processing systems on chip, which typically also
+ * contain accelerators for packet processing needs. Efficient integration with modern HW
+ * accelerators has been a major driver in EM concept.
+ *
+ * One general principle of this API is that all calls are multicore safe, i.e.
+ * no data structure gets broken, if calls are simultaneously made by multiple cores, but
+ * unless explicitly documented per API call, the application also needs to take the parallel
+ * world into consideration. For example if one core asks for a queue mode and another one
+ * changes the mode at the same time, the returned mode may be invalid (valid data, but the old
+ * or the new!). Thus modifications should be done under atomic context (if load balancing is
+ * used) or otherwise synchronized by the application. One simple way of achieving this is to use
+ * one EO with an atomic queue to do all the management functionality. That guarantees
+ * synchronized operations (but also serializes them limiting performance)
+ *
+ * EM_64_BIT or EM_32_BIT (needs to be defined at makefile) defines whether (most of)
+ * the types used in the API are 32 or 64 bits wide. NOTE, that this is a major decision,
+ * since it may limit value passing between different systems using the defined types directly.
+ * Using 64-bits may allow more efficient underlying implementation, as more data can be coded
+ * in 64-bit identifiers for instance.
+ *
+ * @section section_2 Some principles
+ * - This API attempts to guide towards a portable application architecture, but is not defined
+ *  for portability by re-compilation. Many things are system specific giving more possibilities
+ *  for efficient use of HW resources.
+ * - EM does not define event content (one exception, see em_alloc()). This is a choice made for
+ * performance, since most HW devices use proprietary descriptors. This API enables to use those directly.
+ * - EM does not define detailed queue scheduling disciplines or API to set those up (or actually
+ * anything to configure a system). The priority value in this API is a (mapped) system specific
+ * QoS class label only
+ * - In general EM does not implement full SW platform or middleware solution, it implements a sub-
+ * set of such, a driver level part. For best performance it can be used directly from applications.
+ *
+ */
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @defgroup DOC_api_generic Generic API
+ * @brief Generic declarations.
+ */
+/**
+ * @defgroup DOC_api_specific TI specific API
+ * @brief Implementation specific declarations.
+ * @attention Unless otherwise specified values of symbolic constants cannot be changed.
+ */
+
+/** 
+ *
+ * @page DOC_error Error
+ * @section section_101 mechanism
+ * 
+ * The error handler prototype to be provided by the application to the OpenEM when activating the error mecanism shall comply with the following prototype:
+ * 
+ * 
+ * em_status_t (*em_error_handler_t)(em_eo_t eo, em_status_t error, em_escope_t escope, va_list args)
+ * 
+ * 
+ * In the current implementation, the OpenEM does not consider using other parameters other than the 
+ * execution object (eo), the error code (error) and the error scope (escope). 
+ * 
+ * @see em_error_handler_t(), em_register_error_handler(), em_unregister_error_handler, em_eo_register_error_handler, em_eo_unregister_error_handler()
+ * 
+ */
+
+/** 
+ *
+ * @page DOC_trace Trace
+ * @section section_201 mechanism
+ * 
+ * The trace handler prototype to be provided by the application to the OpenEM when activating the trace mechanism shall comply with the following prototype:
+ * 
+ * 
+ * em_status_t (*ti_em_trace_handler_t)(ti_em_tscope_t tscope, ...)
+ * 
+ * 
+ * In the curent implementation, the OpenEM assumes the trace of the following APIs to be associated to the following set of input parameters:
+ * 
+ * - void ti_em_preschedule(void)                                                          -> TI_EM_TSCOPE_PRESCHEDULE
+ * 
+ * - em_status_t ti_em_dispatch_once (void)                                                -> TI_EM_TSCOPE_DISPATCH
+ * 
+ * - void* ti_em_claim_local (void)                                                        -> TI_EM_TSCOPE_CLAIM_LOCAL, (void*)(buffer_ptr)
+ * 
+ * - em_event_t em_alloc(size_t size, em_event_type_t type, em_pool_id_t pool_id)          -> TI_EM_TSCOPE_ALLOC, (em_event_t)(event), (uint32_t)(size), (em_event_type_t)(type), (em_pool_id_t)(pool_id)
+ * 
+ * - void em_atomic_processing_end(void)                                                   -> TI_EM_TSCOPE_ATOMIC_PROCESSING_END
+ * 
+ * - void em_free(em_event_t event)                                                        -> TI_EM_TSCOPE_FREE, (em_event_t)(event)
+ * 
+ * - em_status_t em_send(em_event_t event, em_queue_t queue)                               -> TI_EM_TSCOPE_SEND, (em_event_t)(event), (em_queue_t)(queue)
+ * 
+ * - em_status_t em_send_group(em_event_t event, em_queue_t queue, em_event_group_t group) -> TI_EM_TSCOPE_SEND, (em_event_t)(event), (em_queue_t)(queue), (em_event_group_t)(eventGroup)
+ * 
+ * 
+ * @see ti_em_trace_handler_t(), ti_em_register_trace_handler(), ti_em_unregister_trace_handler() 
+ * 
+ */
+
+/* Basic EM types and HW configuration */
+#include <event_machine_macros.h>
+#include <event_machine_types.h>
+#include <event_machine_functions.h>
+#include <event_machine_group.h>
+#include <event_machine_core_mask.h>
+#include <event_machine_helper.h>
+
+/* EM HW */
+#include <event_machine_hw.h>
+
+/* EM SW */
+#include <event_machine_sw.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* EVENT_MACHINE_H */
+
+
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_core_mask.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_core_mask.h
new file mode 100644
index 0000000..9326c88
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_core_mask.h
@@ -0,0 +1,434 @@ 
+/*
+ *   Copyright (c) 2012, Nokia Siemens Networks
+ *   All rights reserved.
+ *
+ *   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 Nokia Siemens Networks 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.
+ */
+ 
+
+/**
+ *
+ * Contributors
+ *
+ * The initial developer of the original code is Nokia Siemens Networks.
+ *  The following contributors have made changes to 
+ *  the original code as described below.
+ * 
+ *----------------------------------------------------------------------------------------------
+ * Copyright (c) 2012, Texas Instruments Incorporated. All Rights Reserved. - http://www.ti.com/
+ * 
+ * Changes were done on the original NSN header files in order to avoid 
+ * circular dependencies when called in the TI implementation files.
+ *
+ * From the original event_machine_helper.h, the list of changes are:
+ *   - The included files are now event_machine_types.h and event_machine_macros.h
+ *   - Doxygen tags are added for API documentation generation.
+ *       - Doxygen comments were copied from the 64-BIT implementation to the 32-BIT section
+ *         since the TI implementation only support 32-BIT section.
+ *----------------------------------------------------------------------------------------------
+ *
+ */
+
+
+/**
+ * @file: event_machine_core_mask.h
+ *
+ * @brief
+ *    Event Machine core mask functions. This implementation is generic C - non HW optimized. 
+ *
+ */
+
+#ifndef EVENT_MACHINE_CORE_MASK_H_
+#define EVENT_MACHINE_CORE_MASK_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <event_machine_macros.h>
+#include <event_machine_types.h>
+
+
+
+
+#if EM_CORE_MASK_SIZE != 64
+#error Core mask functions support only 64 bit mask size
+#endif
+
+
+
+#ifdef EM_64_BIT
+/*
+ *
+ * 64 bit versions.
+ * --------------------------------------------
+ */
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Zero the whole mask.
+ *
+ * @param mask      Core mask
+ */
+static inline void em_core_mask_zero(em_core_mask_t* mask)
+{
+  mask->u64[0] = 0;
+}
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Set a bit in the mask.
+ *
+ * @param core      Core id
+ * @param mask      Core mask
+ */
+static inline void em_core_mask_set(int core, em_core_mask_t* mask)
+{
+  mask->u64[0] |= ((uint64_t)1 << core);
+}
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Clear a bit in the mask.
+ *
+ * @param core      Core id
+ * @param mask      Core mask
+ */
+static inline void em_core_mask_clr(int core, em_core_mask_t* mask)
+{
+  mask->u64[0] &= ~((uint64_t)1 << core);
+}
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Test if a bit is set in the mask.
+ *
+ * @param core      Core id
+ * @param mask      Core mask
+ *
+ * @return Non-zero if core id is set in the mask
+ */
+static inline int em_core_mask_isset(int core, const em_core_mask_t* mask)
+{
+  return (mask->u64[0] & ((uint64_t)1 << core));
+}
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Test if the mask is all zero.
+ *
+ * @param mask      Core mask
+ *
+ * @return Non-zero if the mask is all zero
+ */
+static inline int em_core_mask_iszero(const em_core_mask_t* mask)
+{
+  return (mask->u64[0] == 0);
+}
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Test if two masks are equal
+ *
+ * @param mask1     First core mask
+ * @param mask2     Second core mask
+ *
+ * @return Non-zero if the two masks are equal
+ */
+static inline int em_core_mask_equal(const em_core_mask_t* mask1, const em_core_mask_t* mask2)
+{
+  return (mask1->u64[0] == mask2->u64[0]);
+}
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Set a range (0...count-1) of bits in the mask.
+ * 
+ * @param count     Number of bits to set
+ * @param mask      Core mask
+ */
+static inline void em_core_mask_set_count(int count, em_core_mask_t* mask)
+{
+  mask->u64[0] |= (((uint64_t)1 << count) - 1);
+}
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Copy core mask
+ *
+ * @param dest      Destination core mask
+ * @param src       Source core mask
+ */
+static inline void em_core_mask_copy(em_core_mask_t* dest, const em_core_mask_t* src)
+{
+  dest->u64[0] = src->u64[0];
+}
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Count the number of bits set in the mask.
+ *
+ * @param mask      Core mask
+ *
+ * @return Number of bits set
+ */
+static inline int em_core_mask_count(const em_core_mask_t* mask)
+{
+  uint64_t n = mask->u64[0];
+  int      cnt;
+  
+
+  for(cnt = 0; n; cnt++)
+  {
+    n &= (n - 1); // Clear the least significant bit set
+  }
+  
+  return cnt;
+}
+
+
+
+
+#elif defined(EM_32_BIT)
+/*
+ *
+ * 32 bit versions.
+ * --------------------------------------------
+ */
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Zero the whole mask.
+ *
+ * @param mask      Core mask
+ */
+static inline void em_core_mask_zero(em_core_mask_t* mask)
+{
+  mask->u32[0] = 0;
+  mask->u32[1] = 0;
+}
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Set a bit in the mask.
+ *
+ * @param core      Core id
+ * @param mask      Core mask
+ */
+static inline void em_core_mask_set(int core, em_core_mask_t* mask)
+{
+  if(core < 32)
+  {
+    mask->u32[1] |= ((uint32_t)1 << core);
+  }
+  else
+  {
+    mask->u32[0] |= ((uint32_t)1 << (core - 32) );
+  }
+}
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Clear a bit in the mask.
+ *
+ * @param core      Core id
+ * @param mask      Core mask
+ */
+static inline void em_core_mask_clr(int core, em_core_mask_t* mask)
+{
+  if(core < 32)
+  {
+    mask->u32[1] &= ~((uint32_t)1 << core);
+  }
+  else
+  {
+    mask->u32[0] &= ~((uint32_t)1 << (core - 32) );
+  }
+}
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Test if a bit is set in the mask.
+ *
+ * @param core      Core id
+ * @param mask      Core mask
+ *
+ * @return Non-zero if core id is set in the mask
+ */
+static inline int em_core_mask_isset(int core, const em_core_mask_t* mask)
+{
+  if(core < 32)
+  {
+    return (mask->u32[1] & ((uint32_t)1 << core));
+  }
+  else
+  {
+    return (mask->u32[0] & ((uint32_t)1 << (core - 32)));
+  }
+}
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Test if the mask is all zero.
+ *
+ * @param mask      Core mask
+ *
+ * @return Non-zero if the mask is all zero
+ */
+static inline int em_core_mask_iszero(const em_core_mask_t* mask)
+{
+  return ((mask->u32[0] == 0) && (mask->u32[1] == 0));
+}
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Test if two masks are equal
+ *
+ * @param mask1     First core mask
+ * @param mask2     Second core mask
+ *
+ * @return Non-zero if the two masks are equal
+ */
+static inline int em_core_mask_equal(const em_core_mask_t* mask1, const em_core_mask_t* mask2)
+{
+  return ((mask1->u32[0] == mask2->u32[0]) && (mask1->u32[1] == mask2->u32[1]));
+}
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Set a range (0...count-1) of bits in the mask.
+ * 
+ * @param count     Number of bits to set
+ * @param mask      Core mask
+ */
+static inline void em_core_mask_set_count(int count, em_core_mask_t* mask)
+{
+  if(count <= 32)
+  {
+    mask->u32[1] |= (((uint32_t)1 << count) - 1);
+  }
+  else
+  {
+    mask->u32[1] |= 0xffffffff;
+    mask->u32[0] |= (((uint32_t)1 << (count - 32)) - 1);
+  }
+}
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Copy core mask
+ *
+ * @param dest      Destination core mask
+ * @param src       Source core mask
+ */
+static inline void em_core_mask_copy(em_core_mask_t* dest, const em_core_mask_t* src)
+{
+  dest->u32[0] = src->u32[0];
+  dest->u32[1] = src->u32[1];
+}
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Count the number of bits set in the mask.
+ *
+ * @param mask      Core mask
+ *
+ * @return Number of bits set
+ */
+static inline int em_core_mask_count(const em_core_mask_t* mask)
+{
+  uint32_t n;
+  int      cnt, i;
+  
+  for(i = 0, cnt = 0; i < 2; i++)
+  {
+    n = mask->u32[i];
+    
+    for(; n; cnt++) {
+      n &= (n - 1); // clear the least significant bit set
+    }
+  }
+  
+  return cnt;
+}
+
+#endif
+
+
+
+
+/*
+ *  These mask functions could be added also
+ *
+ *  void em_core_mask_and(em_core_mask_t* dest, const em_core_mask_t* src1, const em_core_mask_t* src2);
+ *  void em_core_mask_or(em_core_mask_t* dest, const em_core_mask_t* src1, const em_core_mask_t* src2);
+ *  void em_core_mask_xor(em_core_mask_t* dest, const em_core_mask_t* src1, const em_core_mask_t* src2);
+ *
+ */
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* EVENT_MACHINE_CORE_MASK_H_ */
+
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_functions.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_functions.h
new file mode 100644
index 0000000..eec71b8
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_functions.h
@@ -0,0 +1,885 @@ 
+/*
+ *   Copyright (c) 2012, Nokia Siemens Networks
+ *   All rights reserved.
+ *
+ *   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 Nokia Siemens Networks 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.
+ */
+
+
+/**
+ *
+ * Contributors
+ *
+ * The initial developer of the original code is Nokia Siemens Networks.
+ *  The following contributors have made changes to 
+ *  the original code as described below.
+ * 
+ *----------------------------------------------------------------------------------------------
+ * Copyright (c) 2012, Texas Instruments Incorporated. All Rights Reserved. - http://www.ti.com/
+ * 
+ * Changes were done on the original NSN header files in order to avoid 
+ * circular dependencies when called in the TI implementation files.
+ *
+ * From the original event_machine.h, openem/event_machine_functions.h was
+ * created with:
+ *   - Functions definitions.
+ *   - Doxygen tags are added for API documentation generation.
+ *
+ *----------------------------------------------------------------------------------------------
+ */
+
+
+/**
+ * @file : event_machine_functions.h
+ *
+ * @brief
+ *    Open Event Machine public functions
+ *
+ */
+  
+#ifndef EVENT_MACHINE_FUNCTIONS_H
+#define EVENT_MACHINE_FUNCTIONS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#include <stdlib.h>
+
+/*
+ *
+ * From application to Event Machine interface
+ * ----------------------------------------------------------------------------
+ *
+ */
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Create a new queue with a dynamic queue id.
+ *
+ * The given name string is copied to EM internal data structure. The maximum
+ * string length is EM_QUEUE_NAME_LEN. 
+ *
+ * @param name          Queue name for debugging purposes (optional, NULL ok)
+ * @param type          Queue scheduling type
+ * @param prio          Queue priority
+ * @param group         Queue group for this queue
+ *
+ * @return New queue id or EM_QUEUE_UNDEF on an error
+ *
+ * @see em_queue_group_create(), em_queue_delete()
+ */
+em_queue_t em_queue_create(const char* name, em_queue_type_t type, em_queue_prio_t prio, em_queue_group_t group);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Create a new queue with a static queue id.
+ *
+ * Note, that system may have limited amount of static identifiers,
+ * so unless really needed use dynamic queues instead.
+ * The range of static identifiers is system dependent, but macros
+ * EM_QUEUE_STATIC_MIN and EM_QUEUE_STATIC_MAX can be used to abstract,
+ * i.e. use EM_QUEUE_STATIC_MIN+x for the application.
+ *
+ * The given name string is copied to EM internal data structure. The maximum
+ * string length is EM_QUEUE_NAME_LEN.
+ *
+ * @param name          Queue name for debugging purposes (optional, NULL ok)
+ * @param type          Queue scheduling type
+ * @param prio          Queue priority
+ * @param group         Queue group for this queue
+ * @param queue         Requested queue id from the static range
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_queue_group_create(), em_queue_delete()
+ */
+em_status_t em_queue_create_static(const char* name, em_queue_type_t type, em_queue_prio_t prio, em_queue_group_t group, em_queue_t queue);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Delete a queue.
+ *
+ * Unallocates the queue id.
+ * NOTE: this is an immediate deletion and can *only*
+ * be done after the queue has been removed from scheduling
+ * using em_eo_remove_queue() !
+ *
+ * @param queue         Queue id to delete
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_eo_remove_queue(), em_queue_create(), em_queue_create_static()
+ */
+em_status_t em_queue_delete(em_queue_t queue);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Enable event scheduling for the queue.
+ *
+ * All events sent to a non-enabled queue may get discarded or held
+ * depending on the system. Queue enable/disable is not meant to be used
+ * for additional scheduling nor used frequently. Main purpose is to
+ * synchronize startup or recovery actions.
+ *
+ * @param queue         Queue to enable
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_eo_start(), em_queue_enable_all(), em_queue_disable()
+ */
+em_status_t em_queue_enable(em_queue_t queue);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Enable event scheduling for all the EO's queues.
+ * 
+ * Otherwise identical to em_queue_enable().
+ *
+ * @param eo            EO id 
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_queue_enable(), em_queue_disable_all()
+ */
+em_status_t em_queue_enable_all(em_eo_t eo);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Disable scheduling for the queue.
+ *
+ * Note, that this might be an asynchronous operation and actually complete later as
+ * other cores may still be handling existing events. If application needs to
+ * know exactly when all processing is completed, it can use the notification
+ * arguments - the given notification(s) are sent after all cores have completed.
+ *
+ * Implicit disable is done for all queues, that are mapped to an EO when
+ * it's stop-function is called (via em_eo_stop()).
+ *
+ * All events sent to a non-enabled queue may get discarded or held
+ * depending on the system. Queue enable/disable is not meant to be used
+ * for additional scheduling nor used frequently. Main purpose is to
+ * synchronize startup or recovery actions.
+ *
+ * @param queue         Queue to disable
+ * @param num_notif     Number of entries in notif_tbl, use 0 for no notification
+ * @param notif_tbl     Notification events to send
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_eo_stop(), em_queue_disable_all(), em_queue_enable()
+ */
+em_status_t em_queue_disable(em_queue_t queue, int num_notif, const em_notif_t* notif_tbl);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Disable scheduling for all the EO's queues.
+ *
+ * Otherwise identical to em_queue_disable().
+ *
+ * @param eo            EO id
+ * @param num_notif     Number of entries in notif_tbl, use 0 for no notification
+ * @param notif_tbl     Notification events to send
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_eo_stop(), em_queue_disable(), em_queue_enable_all()
+ */
+em_status_t em_queue_disable_all(em_eo_t eo, int num_notif, const em_notif_t* notif_tbl);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Set queue specific (application) context.
+ * 
+ * This is just a single pointer associated with a queue. Application can use it
+ * to access some context data quickly (without a lookup). The context is given
+ * as argument for the receive function. EM does not use the value, it just
+ * passes it.
+ *                        
+ * @param queue         Queue to which associate the context
+ * @param context       Context pointer
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_receive_func_t(), em_queue_get_context()
+ */
+em_status_t em_queue_set_context(em_queue_t queue, const void* context);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Get queue specific (application) context.
+ *
+ * Returns the value application has earlier set with em_queue_set_context().
+ *
+ * @param queue         Queue which context is requested
+ *
+ * @return Queue specific context pointer or NULL on an error
+ *
+ * @see em_queue_set_context()
+ */
+void* em_queue_get_context(em_queue_t queue);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Get queue name.
+ *
+ * Returns the name given to a queue when it was created.
+ * A copy of the queue name string (up to 'maxlen' characters) is
+ * written to the user given buffer.
+ * String is always null terminated even if the given buffer length
+ * is less than the name length.
+ *
+ * If the queue has no name, function returns 0 and writes empty string.
+ *
+ * This is only for debugging purposes.
+ *
+ * @param queue         Queue id
+ * @param name          Destination buffer
+ * @param maxlen        Maximum length (including the terminating '0')
+ *
+ * @return Number of characters written (excludes the terminating '0').
+ * 
+ * @see em_queue_create()
+ */
+size_t em_queue_get_name(em_queue_t queue, char* name, size_t maxlen);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Get queue priority.
+ *
+ * @param  queue        Queue identifier
+ *
+ * @return Priority class or EM_QUEUE_PRIO_UNDEF on an error
+ *
+ * @see em_queue_create()
+ */
+em_queue_prio_t em_queue_get_priority(em_queue_t queue);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Get queue type (scheduling mode).
+ *
+ * @param  queue        Queue identifier
+ *
+ * @return Queue type or EM_QUEUE_TYPE_UNDEF on an error
+ *
+ * @see em_queue_create()
+ */
+em_queue_type_t em_queue_get_type(em_queue_t queue);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Get queue's queue group
+ *
+ * @param  queue        Queue identifier 
+ *
+ * @return Queue group or EM_QUEUE_GROUP_UNDEF on error.
+ * 
+ * @see em_queue_create(), em_queue_group_create(), em_queue_group_modify()
+ */
+em_queue_group_t em_queue_get_group(em_queue_t queue);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Create a new queue group to control queue to core mapping.
+ *
+ * Allocates a new queue group identifier with a given core mask. The group name
+ * can have max EM_QUEUE_GROUP_NAME_LEN characters and must be unique 
+ * since it's used to identify the group. Cores added to the queue group can be 
+ * changed later with em_queue_group_modify().
+ *
+ * This operation may be asynchronous, i.e. the creation may complete well
+ * after this function has returned. Provide notification events, if
+ * application cares about the actual completion time. EM will
+ * send notifications when the operation has completed.
+ *
+ * The core mask is visible through em_queue_group_mask() only after the create
+ * operation is complete. 
+ * 
+ * Note, that depending on the system, the operation can also happen one core at a time, so
+ * an intermediate mask may be active momentarily.
+ *
+ * Only manipulate the core mask with the access macros defined in event_machine_core_mask.h
+ * as the implementation underneath may change.
+ *
+ * EM has a default group (EM_QUEUE_GROUP_DEFAULT) containing 
+ * all cores. It's named "default", otherwise naming scheme is system specific.
+ *
+ * Note, some systems may have a low number of queue groups available.
+ *
+ * @attention  Only call em_queue_enable() after em_queue_group_create() has completed - use
+ *             notifications to synchronize.
+ *
+ * @param name          Queue group name. Unique name for identifying the group. 
+ * @param mask          Core mask for the queue group
+ * @param num_notif     Number of entries in notif_tbl (use 0 for no notification)
+ * @param notif_tbl     Array of notifications to send to signal completion of operation
+ *
+ * @return Queue group or EM_QUEUE_GROUP_UNDEF on error.
+ *
+ * @see em_queue_group_find(), em_queue_group_modify(), em_queue_group_delete()
+ */
+em_queue_group_t em_queue_group_create(const char* name, const em_core_mask_t* mask, int num_notif, const em_notif_t* notif_tbl);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Delete the queue group.
+ * 
+ * Removes all cores from the queue group and free's the identifier for re-use. 
+ * All queues in the group must be deleted with em_queue_delete() before
+ * deleting the group.
+ *
+ * @param group         Queue group to delete
+ * @param num_notif     Number of entries in notif_tbl (use 0 for no notification)
+ * @param notif_tbl     Array of notifications to send to signal completion of operation
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_queue_group_create(), em_queue_group_modify(), em_queue_delete()
+ */
+em_status_t em_queue_group_delete(em_queue_group_t group, int num_notif, const em_notif_t* notif_tbl);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Modify core mask of an existing queue group.
+ *
+ * The function compares the new core mask to the current mask and changes the 
+ * queue group to core mapping accordingly. 
+ *
+ * This operation may be asynchronous, i.e. the change may complete well
+ * after this function has returned. Provide notification events, if
+ * application cares about the actual completion time. EM will
+ * send notifications when the operation has completed.
+ *
+ * The new core mask is visible through em_queue_group_mask() only after the modify
+ * operation is complete. 
+ * 
+ * Note, that depending on the system, the change can also happen one core at a time, so
+ * an intermediate mask may be active momentarily.
+ *
+ * Only manipulate core mask with the access macros defined in event_machine_core_mask.h
+ * as the implementation underneath may change.
+ *
+ * @param group         Queue group to modify
+ * @param new_mask      New core mask 
+ * @param num_notif     Number of entries in notif_tbl (use 0 for no notification)
+ * @param notif_tbl     Array of notifications to send
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_queue_group_create(), em_queue_group_find(), em_queue_group_delete(), em_queue_group_mask()
+ */
+em_status_t em_queue_group_modify(em_queue_group_t group, const em_core_mask_t* new_mask, int num_notif, const em_notif_t* notif_tbl);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Finds queue group by name.
+ *
+ * This returns the situation at the moment of the inquiry. If another core is modifying the group
+ * at the same time the result may not be up-to-date. Application may need to synchronize group modifications. 
+ *
+ * @param name          Name of the queue qroup to find
+ *
+ * @return  Queue group or EM_QUEUE_GROUP_UNDEF on an error
+ *
+ * @see em_queue_group_create(), em_queue_group_modify()
+ *
+ */
+em_queue_group_t em_queue_group_find(const char* name);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Get current core mask for a queue group.
+ *
+ * This returns the situation at the moment of the inquiry. If another core is modifying the group
+ * at the same time the result may not be up-to-date. Application may need to synchronize group modifications.
+ *
+ * @param group         Queue group
+ * @param mask          Core mask for the queue group
+ *
+ * @return EM_OK if successful.
+ * 
+ * @see em_queue_group_create(), em_queue_group_modify()
+ */
+em_status_t em_queue_group_mask(em_queue_group_t group, em_core_mask_t* mask);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Create Execution Object (EO).
+ * 
+ * This will allocate identifier and initialize internal data for a new EO.
+ * It is left in a non-active state, i.e. no events are dispatched before
+ * em_eo_start() has called. Start, stop and receive callback function
+ * pointers are mandatory parameters.
+ *
+ * The name given is copied to EO internal data and can be used e.g. for debugging.
+ * The maximum length stored is EM_EO_NAME_LEN.
+ *
+ * @param name          Name of the EO (NULL if no name)
+ * @param start         Start function
+ * @param local_start   Core local start function (NULL if no local start)
+ * @param stop          Stop function
+ * @param local_stop    Core local stop function (NULL if no local stop)
+ * @param receive       Receive function
+ * @param eo_ctx        User defined EO context data, EM just passes the pointer (NULL if not context)
+ *
+ * @return New EO id if successful, otherwise EM_EO_UNDEF
+ *
+ * @see em_eo_start(), em_eo_delete(), em_queue_create(), em_eo_add_queue()
+ * @see em_start_func_t(), em_stop_func_t(), em_receive_func_t()
+ */
+em_eo_t em_eo_create(const char* name,
+                     em_start_func_t start,
+                     em_start_local_func_t local_start,
+                     em_stop_func_t stop,
+                     em_stop_local_func_t local_stop,
+                     em_receive_func_t receive,
+                     const void* eo_ctx);
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Delete Execution Object (EO).
+ *
+ * This will immediately delete the given EO and free the identifier.
+ *
+ * NOTE, that EO can only be deleted after it has been stopped using
+ * em_eo_stop(), otherwise another core might still access the EO data!
+ * Deletion will fail, if the EO is not stopped.
+ *
+ * This will delete all possibly remaining queues.
+ *
+ * @param eo            EO id to delete
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_eo_stop(), em_eo_create()
+ */
+em_status_t em_eo_delete(em_eo_t eo);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Returns the name given to the EO when it was created.
+ *
+ * A copy of the name string (up to 'maxlen' characters) is
+ * written to the user buffer 'name'.
+ * String is always null terminated even if the given buffer length
+ * is less than the name length.
+ *
+ * If the EO has no name, function returns 0 and writes empty string. 
+ *
+ * This is only for debugging purposes.
+ *
+ * @param eo            EO id
+ * @param name          Destination buffer
+ * @param maxlen        Maximum length (including the terminating '0')
+ *
+ * @return Number of characters written (excludes the terminating '0')
+ *
+ * @see em_eo_create() 
+ */
+size_t em_eo_get_name(em_eo_t eo, char* name, size_t maxlen);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Add a queue to an EO.
+ *
+ * Note, that this does not enable the queue. Although queues added in
+ * (or before) the start function will be enabled automatically.
+ *
+ * @param eo            EO id
+ * @param queue         Queue id
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_queue_create(), em_eo_create(), em_queue_enable(), em_eo_remove_queue()
+ */
+em_status_t em_eo_add_queue(em_eo_t eo, em_queue_t queue);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Removes a queue from an EO.
+ * 
+ * Function disables scheduling of the queue and removes the queue from the
+ * EO. The operation is asynchronous, to quarantee that all cores have completed
+ * processing of events from the queue (i.e. there's no cores in middle of the
+ * receive function) before removing it.
+ *
+ * If the caller needs to know when the context deletion actually occurred,
+ * the num_notif and notif_tbl can be used. The given notification event(s)
+ * will be sent to given queue(s), when the removal has completed.
+ * If such notification is not needed, use 0 as num_notif.
+ *
+ * If the queue to be removed is still enabled, it will first be disabled.
+ *
+ * @param eo            EO id
+ * @param queue         Queue id to remove
+ * @param num_notif     How many notification events given, 0 for no notification
+ * @param notif_tbl     Array of pairs of event and queue identifiers
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_eo_add_queue(), em_queue_disable(), em_queue_delete()
+ */
+em_status_t em_eo_remove_queue(em_eo_t eo, em_queue_t queue, int num_notif, const em_notif_t* notif_tbl);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Register EO specific error handler.
+ *
+ * The EO specific error handler is called if error is noticed or em_error() is 
+ * called in the context of the EO. Note, the function will override any previously 
+ * registered error hanler.
+ *
+ * @param eo            EO id
+ * @param handler       New error handler.
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_register_error_handler(), em_error_handler_t()
+ */
+em_status_t em_eo_register_error_handler(em_eo_t eo, em_error_handler_t handler);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Unregister EO specific error handler.
+ *
+ * Removes previously registered EO specific error handler.
+ *
+ * @param eo            EO id
+ *
+ * @return EM_OK if successful.
+ */
+em_status_t em_eo_unregister_error_handler(em_eo_t eo);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Start Execution Object (EO).
+ *
+ * Calls global EO start function. If that returns EM_OK,
+ * an internal event to trigger local start is sent to all cores belonging to
+ * the queue group of this EO.
+ * If the global start function does not return EM_OK the local start is
+ * not called and event dispatching is not enabled for this EO.
+ *
+ * If the caller needs to know when the EO start was actually completed
+ * on all cores, the num_notif and notif_tbl can be used. The given
+ * notification event(s) will be sent to given queue(s), when the
+ * start is completed on all cores.
+ * If local start does not exist the notification(s) are sent as the global
+ * start returns.
+ * If such notification is not needed, use 0 as num_notif.
+ *
+ * @param eo            EO id
+ * @param result        Optional pointer to em_status_t, which gets updated to the
+ *                      return value of the actual EO global start function
+ *
+ * @param num_notif     If not 0, defines the number of events to send as all cores
+ *                      have returned from the start function (in notif_tbl).
+ *
+ * @param notif_tbl     Array of em_notif_t, the optional notification events (data copied)
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_start_func_t(), em_start_local_func_t(), em_eo_stop()
+ *
+ * @todo Way to read core local start value or status?
+ */
+em_status_t em_eo_start(em_eo_t eo, em_status_t *result, int num_notif, const em_notif_t* notif_tbl);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Stop Execution Object (EO).
+ *
+ * Disables event dispatch from all related queues, calls core local stop
+ * on all cores and finally calls the global stop function of the EO,
+ * when all cores have returned from the (optional) core local stop.
+ * Call to the global EO stop is asynchronous and only done, when all cores
+ * have completed processing of the receive function and/or core local stop.
+ * This guarantees no core is accessing EO data during EO global stop function.
+ *
+ * This function returns immediately.
+ *
+ * If the caller needs to know when the EO stop was actually completed,
+ * the num_notif and notif_tbl can be used. The given notification event(s)
+ * will be sent to given queue(s), when the stop actually completes.
+ * If such notification is not needed, use 0 as num_notif.
+ *
+ * @param eo            EO id
+ * @param num_notif     How many notification events given, 0 for no notification
+ * @param notif_tbl     Array of pairs of event and queue identifiers
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_stop_func_t(), em_stop_local_func_t(), em_eo_start()
+ *
+ * @todo Method for the application to get the final stop status
+ */
+em_status_t em_eo_stop(em_eo_t eo, int num_notif, const em_notif_t* notif_tbl);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Logical core id.
+ *
+ * Returns the logical id of the current core.
+ * EM enumerates cores (or HW threads) to always start from 0 and be contiguous,
+ * i.e. valid core identifiers are 0...em_core_count()-1
+ *
+ * @return Current logical core id
+ *
+ * @see em_core_count()
+ */
+int em_core_id(void);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * The number of cores running within the same EM instance (sharing the EM state).
+ *
+ * @return Number of EM cores (or HW threads)
+ *
+ * @see em_core_id()
+ *
+ * @todo CPU hot plugging support
+ */
+int em_core_count(void);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Allocate an event.
+ *
+ * Memory address of the allocated event is system specific and
+ * can depend on given pool id, event size and type. Returned 
+ * event (handle) may refer to a memory buffer or a HW specific 
+ * descriptor, i.e. the event structure is system specific. 
+ *
+ * Use em_event_pointer() to convert an event (handle) to a pointer to 
+ * the event structure. 
+ *
+ * EM_EVENT_TYPE_SW with minor type 0 is reserved for direct portability.
+ * It is always guaranteed to return a 64-bit aligned contiguous 
+ * data buffer, that can directly be used by the application up to
+ * the given size (no HW specific descriptors etc are visible).
+ *
+ * EM_POOL_DEFAULT can be used as pool id if there's no need to 
+ * use any specific memory pool.
+ *
+ * Additionally it is guaranteed, that two separate buffers
+ * never share a cache line to avoid false sharing.
+ *
+ * @param size          Event size in octets
+ * @param type          Event type to allocate
+ * @param pool_id       Event pool id 
+ *
+ * @return the allocated event or EM_EVENT_UNDEF on an error
+ *
+ * @see em_free(), em_send(), em_event_pointer(), em_receive_func_t()
+ */
+em_event_t em_alloc(size_t size, em_event_type_t type, em_pool_id_t pool_id);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Free an event.
+ *
+ * It is assumed the implementation can detect from which
+ * memory area/pool the event was originally allocated from.
+ *
+ * Free transfers the ownership of the event to the system and
+ * application must not touch the event (or related memory buffers)
+ * after calling it.
+ *
+ * Application must only free events it owns. For example, sender must
+ * not free an event after sending it. 
+ * 
+ * @param event         Event to be freed
+ *
+ * @see em_alloc(), em_receive_func_t()
+ *
+ * @todo OK or not to free EM_EVENT_UNDEF?
+ */
+void em_free(em_event_t event); 
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Send an event to a queue.
+ *
+ * Event must have been allocated with em_alloc(), or
+ * received via receive-function. Sender must not touch the
+ * event after calling em_send as the ownership is moved to system
+ * and then to the receiver. If return status is *not* EM_OK, the ownership
+ * has not moved and the application is still responsible for the event (e.g. 
+ * may free it).
+ *
+ * EM does not define guaranteed event delivery, i.e. EM_OK return value only
+ * means the event was accepted for delivery. It could still be lost during
+ * the delivery (e.g. due to disabled/removed queue, queue or system 
+ * congestion, etc).
+ *
+ * @param event         Event to be sent
+ * @param queue         Destination queue
+ *
+ * @return EM_OK if successful (accepted for delivery).
+ * 
+ * @see em_alloc()
+ */
+em_status_t em_send(em_event_t event, em_queue_t queue) ;
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Get pointer to event structure
+ *
+ * Returns pointer to the event structure or NULL. Event structure is
+ * implementation and event type specific. It may be a directly 
+ * accessible buffer of memory, a descriptor containing a list of 
+ * buffer pointers, a descriptor of a packet buffer, etc.
+ *
+ * @param event         Event from receive/alloc
+ *
+ * @return              Event pointer or NULL
+ * 
+ */
+void* em_event_pointer(const em_event_t event);
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Release atomic processing context.
+ *
+ * When an event was received from an atomic queue, the function can be used to 
+ * release the atomic context before receive function return. After the call,
+ * scheduler is allowed to schedule another event from the same queue
+ * to another core. This increases parallelism and may improve performance - 
+ * however the exclusive processing and ordering (!) might be lost after the call.
+ *
+ * Can only be called from within the event receive function!
+ *
+ * The call is ignored, if current event was not received from an atomic queue.
+ *
+ * Pseudo-code example:
+ * @code
+ *  receive_func(void* eo_ctx, em_event_t event, em_event_type_t type, em_queue_t queue, void* q_ctx);
+ *  {
+ *      if(is_my_atomic_queue(q_ctx))
+ *      {
+ *          update_sequence_number(event);  // this needs to be done atomically
+ *          em_atomic_processing_end();
+ *          ...                             // do other processing (potentially) in parallel
+ *      }
+ *   }
+ * @endcode
+ *
+ * @see em_receive_func_t()
+ */
+void em_atomic_processing_end(void);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Register the global error handler.
+ *
+ * The global error handler is called on errors (or em_error() calls)  
+ * outside of any EO context or if there's no EO specific error 
+ * handler registered. Note, the function will override any previously 
+ * registered global error handler.
+ *
+ * @param handler       Error handler.
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_eo_register_error_handler(), em_unregister_error_handler(), em_error_handler_t()
+ */
+em_status_t em_register_error_handler(em_error_handler_t handler);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Unregister the global error handler.
+ *
+ * Removes previously registered global error handler.
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_register_error_handler()
+ */
+em_status_t em_unregister_error_handler(void);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Report an error.
+ *
+ * Reported errors are handled by the appropriate (EO specific or the global) error handler.
+ *
+ * Depending on the error/scope/implementation, the function call may not return.
+ * 
+ * @param error         Error code
+ * @param escope        Error scope. Identifies the scope for interpreting the error code and variable arguments.
+ * @param ...           Variable number and type of arguments
+ * 
+ * @see em_register_error_handler(), em_error_handler_t()
+ */
+void em_error(em_status_t error, em_escope_t escope, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* EVENT_MACHINE_FUNCTIONS_H */
+
+
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_group.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_group.h
new file mode 100644
index 0000000..79796f3
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_group.h
@@ -0,0 +1,292 @@ 
+/*
+ *   Copyright (c) 2012, Nokia Siemens Networks
+ *   All rights reserved.
+ *
+ *   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 Nokia Siemens Networks 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.
+ */
+ 
+
+/**
+ *
+ * Contributors
+ *
+ * The initial developer of the original code is Nokia Siemens Networks.
+ *  The following contributors have made changes to 
+ *  the original code as described below.
+ * 
+ *----------------------------------------------------------------------------------------------
+ * Copyright (c) 2012, Texas Instruments Incorporated. All Rights Reserved. - http://www.ti.com/
+ * 
+ * Changes were done on the original NSN header files in order to avoid 
+ * circular dependencies when called in the TI implementation files.
+ *
+ * From the original event_machine_group.h, the list of changes are:
+ *   - Doxygen tags are added for API documentation generation.
+ *   - Comments have been added for EM_EVENT_GROUP_UNDEF, PRI_EGRP.
+ *   - The included file is now event_machine_types.h 
+ *----------------------------------------------------------------------------------------------
+ *
+ */
+
+
+/**
+ * @file : event_machine_group.h
+ *
+ * @brief
+ *     Open Event Machine public event group functions
+ */
+
+/**
+ * @page DOC_intro Introduction
+ * @section section_3 Open Event Machine optional fork-join helper.
+ *
+ * An event group can be used to trigger join of parallel operations.
+ * The number of parallel operations need to be known by the event group
+ * creator, but the separate events handlers don't need to know anything
+ * about the other related events.
+ *
+ * 1. a group is created with em_event_group_create()
+ *
+ * 2. the number of parallel events is set with em_event_group_apply()
+ *
+ * 3. the parallel events are sent normally, but using em_send_group() instead
+ *    of em_send()
+ *
+ * 4. as the receive function of the last event is completed, the given notification
+ *    event(s) are sent automatically and can trigger the next operation
+ *
+ * 5. the sequence continues from step 2. for new set of events (if the group is reused)
+ *
+ * So here the original initiator only needs to know how the task is split into
+ * parallel events, the event handlers and the one continuing the work (join)
+ * are not involved (assuming the task itself can be separately processed)
+ *
+ * Note, that this only works with events targeted to an EO, i.e. SW events
+ *
+ *
+ *
+ * @todo specify exact operation to cancel an aborted fork-join
+ *       em_status_t em_event_group_cancel(em_event_group_t group, ...);
+ *
+ */
+#ifndef EVENT_MACHINE_GROUP_H
+#define EVENT_MACHINE_GROUP_H
+
+#include <inttypes.h>
+#include <event_machine_types.h>
+#include <event_machine_hw_macros.h>
+#include <event_machine_hw_types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*
+ * Optimize EM for 64 bit architecture
+ * =====================================
+ */
+#ifdef EM_64_BIT
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Event group id. This is used for fork-join event handling.
+ *
+ * @see em_event_group_create()
+ */
+typedef uint64_t               em_event_group_t;
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ */
+#define EM_EVENT_GROUP_UNDEF   EM_UNDEF_U64      /**< Invalid event group */
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ */
+#define PRI_EGRP               PRIu64            /**< em_event_group_t printf format */
+
+
+/*
+ * Optimize EM for 32 bit architecture
+ * =====================================
+ */
+#elif defined(EM_32_BIT)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Event group id. This is used for fork-join event handling.
+ *
+ * @see em_event_group_create()
+ */
+typedef uint32_t               em_event_group_t;
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ */
+#define EM_EVENT_GROUP_UNDEF   EM_UNDEF_U32      /**< Invalid event group id */
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ */
+#define PRI_EGRP               PRIu32            /**< em_event_group_t printf format */
+
+#else
+  #error Missing architecture definition. Define EM_64_BIT or EM_32_BIT!   
+
+   /* @page page_version 64/32 bit version not selected */
+
+  /**
+   *
+   * @page DOC_intro Introduction
+   * @section page_version 64/32 bit version not selected
+   * This is documentation has not selected between 64/32 bit version of Event Machine API.
+   * Some types might be missing. Define EM_64_BIT or EM_32_BIT to select between 64 and 32 bit versions.
+   *
+   */
+   
+#endif
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Create new event group id for fork-join.
+ *
+ * @return New event group id or EM_EVENT_GROUP_UNDEF
+ *
+ * @see em_event_group_delete(), em_event_group_apply()
+ */
+em_event_group_t em_event_group_create(void);
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Delete (unallocate) an event group id
+ *
+ * An event group must not be deleted before it has been
+ * completed (notifications sent) or canceled.
+ *
+ * @param event_group  Event group to delete
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_event_group_create()
+ */
+em_status_t em_event_group_delete(em_event_group_t event_group);
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Apply event group configuration.
+ *
+ * The function sets (or resets) the event count and notification parameters
+ * for the event group. After it returns events sent to the group are counted
+ * against the (updated) count. Notification events are sent when all (counted)
+ * events have been processed. A new apply call is needed to reset the event
+ * group (counting).
+ *
+ * @param group        Group id
+ * @param count        Number of events in the group
+ * @param num_notif    Number of noticifation events to send
+ * @param notif_tbl    Table of notifications (events and target queues)
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_event_group_create(), em_send_group()
+ */
+em_status_t em_event_group_apply(em_event_group_t group, int count, int num_notif, const em_notif_t* notif_tbl);
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Increment event group count
+ * 
+ * Increments event count of the current event group. Enables sending new events into 
+ * the current group. Must be called before sending. Note that event count cannot be decremented.
+ *
+ * @param count        Number of events to add in the group
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_send_group()
+ */
+em_status_t em_event_group_increment(int count);
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Current event group
+ *
+ * Returns the event group of the currently received event or EM_EVENT_GROUP_UNDEF 
+ * if the current event does not belong into any event group. Current group is needed 
+ * when sending new events into the group.
+ *
+ * @return Current event group id or EM_EVENT_GROUP_UNDEF
+ *
+ * @see em_event_group_create()
+ */
+em_event_group_t em_event_group_current(void);
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Send event with group number.
+ *
+ * Any valid event and destination queue parameters can be used. Event group id
+ * indicates which event group the event belongs to. Event group has to be first
+ * created and applied.
+ *
+ * @param event    Event to send
+ * @param queue    Destination queue
+ * @param group    Event group
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_send(), em_event_group_create(), em_event_group_apply(), em_event_group_increment()
+ */
+em_status_t em_send_group(em_event_t event, em_queue_t queue, em_event_group_t group);
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif
+
+
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_helper.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_helper.h
new file mode 100644
index 0000000..bb40fd4
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_helper.h
@@ -0,0 +1,142 @@ 
+/*
+ *   Copyright (c) 2012, Nokia Siemens Networks
+ *   All rights reserved.
+ *
+ *   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 Nokia Siemens Networks 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.
+ */
+ 
+
+/**
+ *
+ * Contributors
+ *
+ * The initial developer of the original code is Nokia Siemens Networks.
+ *  The following contributors have made changes to 
+ *  the original code as described below.
+ * 
+ *----------------------------------------------------------------------------------------------
+ * Copyright (c) 2012, Texas Instruments Incorporated. All Rights Reserved. - http://www.ti.com/
+ * 
+ * Changes were done on the original NSN header files in order to avoid 
+ * circular dependencies when called in the TI implementation files.
+ *
+ * From the original event_machine_helper.h, the list of changes are:
+ *   - The included files are now event_machine_types.h, event_machine_core_mask.h and event_machine_macros.h
+ *   - em_get_type_major and em_get_type_minor implementation has been changed.
+ *   - Doxygen tags are added for API documentation generation.
+ *       - Doxygen comments were copied from the 64-BIT implementation to the 32-BIT section
+ *         since the TI implementation only support 32-BIT section.
+ *----------------------------------------------------------------------------------------------
+ *
+ */
+
+
+/**
+ * @file: event_machine_helper.h
+ *
+ * @brief
+ *    Open Event Machine helper functions and macros
+ *
+ */
+
+#ifndef EVENT_MACHINE_HELPER_H_
+#define EVENT_MACHINE_HELPER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Format error string
+ *
+ * Creates an implementation dependent error report string from EM 
+ * internal errors.
+ *
+ * @param str       Output string pointer
+ * @param size      Maximum string lenght in characters
+ * @param eo        EO id
+ * @param error     Error code (EM internal)
+ * @param escope    Error scope (EM internal)
+ * @param args      Variable arguments
+ *
+ * @return Output string length
+ */
+int em_error_format_string(char* str, size_t size, em_eo_t eo, em_status_t error, em_escope_t escope, va_list args);
+
+
+
+
+/*
+ *
+ * Physical core ids
+ ***************************************
+ *
+ *
+ */
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Converts a logical core id to a physical core id
+ *
+ * Mainly needed when interfacing HW specific APIs
+ *
+ * @param core     logical (Event Machine) core id
+ *
+ * @return Physical core id
+ *
+ */
+int em_core_id_get_physical(int core);
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Converts a logical core mask to a physical core mask
+ *
+ * Mainly needed when interfacing HW specific APIs
+ *
+ * @param phys     Core mask of physical core ids
+ * @param logic    Core mask of logical (Event Machine) core ids
+ *
+ */
+void em_core_mask_get_physical(em_core_mask_t* phys, const em_core_mask_t* logic);
+
+
+
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* EVENT_MACHINE_HELPER_H_ */
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw.h
new file mode 100644
index 0000000..6c5f274
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw.h
@@ -0,0 +1,57 @@ 
+/*
+ * Copyright (c) 2012, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ * @file: event_machine_hw.h
+ *
+ * @brief
+ *    Open Event Machine HW public include file
+ *
+ */
+
+#ifndef EVENT_MACHINE_HW_H
+#define EVENT_MACHINE_HW_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <event_machine_hw_config.h>
+#include <event_machine_hw_functions.h>
+#include <event_machine_hw_macros.h>
+#include <event_machine_hw_types.h>
+
+#include <event_machine_hw_ti.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* EVENT_MACHINE_HW_H */
+
+
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_config.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_config.h
new file mode 100644
index 0000000..d9d3e3d
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_config.h
@@ -0,0 +1,104 @@ 
+/*
+ *   Copyright (c) 2012, Nokia Siemens Networks
+ *   All rights reserved.
+ *
+ *   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 Nokia Siemens Networks 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.
+ */
+
+
+/**
+ *
+ * Contributors
+ *
+ * The initial developer of the original code is Nokia Siemens Networks.
+ *  The following contributors have made changes to 
+ *  the original code as described below.
+ * 
+ *----------------------------------------------------------------------------------------------
+ * Copyright (c) 2012, Texas Instruments Incorporated. All Rights Reserved. - http://www.ti.com/
+ * 
+ * From the original event_machine_hw_config.h.template , openem/event_machine_hw_config.h was
+ * created with:
+ *   - Compilation symbols check
+ *----------------------------------------------------------------------------------------------
+ *
+ */
+
+
+/**
+ * @file: event_machine_hw_config.h
+ *
+ * @brief
+ *    Open Event Machine HW TI specific configuration
+ *
+ */
+
+#ifndef EVENT_MACHINE_HW_CONFIG_H
+#define EVENT_MACHINE_HW_CONFIG_H
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef EM_64_BIT
+  #error TI implementation only supports EM_32_BIT!
+#endif
+
+#if defined(TI_EM_C6670)
+#if defined(TI_EM_C6678)
+  #error Conflicting platform definition. Define TI_EM_C6670 or TI_EM_C6678!
+#endif
+#endif
+
+#if defined(TI_EM_C6670)
+#if defined(TI_EM_C6634)
+  #error Conflicting platform definition. Define TI_EM_C6670 or TI_EM_C6634!
+#endif
+#endif
+
+#if defined(TI_EM_C6634)
+#if defined(TI_EM_C6678)
+  #error Conflicting platform definition. Define TI_EM_C6634 or TI_EM_C6678!
+#endif
+#endif
+
+#if defined(TI_EM_C6670)
+#if defined(TI_EM_C6678)
+#if defined(TI_EM_C6634)
+  #error Missing platform definition. Define TI_EM_C6670 or TI_EM_C6678 or TI_EM_C6634!
+#endif
+#endif
+#endif
+
+#include <event_machine_sw_config.h>
+#include <event_machine_hw_macros.h>
+#include <event_machine_hw_types.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_functions.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_functions.h
new file mode 100644
index 0000000..65e001f
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_functions.h
@@ -0,0 +1,94 @@ 
+/*
+ *   Copyright (c) 2012, Nokia Siemens Networks
+ *   All rights reserved.
+ *
+ *   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 Nokia Siemens Networks 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.
+ */
+
+
+/**
+ *
+ * Contributors
+ *
+ * The initial developer of the original code is Nokia Siemens Networks.
+ *  The following contributors have made changes to 
+ *  the original code as described below.
+ * 
+ *----------------------------------------------------------------------------------------------
+ * Copyright (c) 2012, Texas Instruments Incorporated. All Rights Reserved. - http://www.ti.com/
+ * 
+ * From the original event_machine_hw_config.h.template , openem/event_machine_hw_functions.h was
+ * created with:
+ *   - A modified returned value for em_get_type_minor() function 
+ *   - Doxygen tags are added for API documentation generation.
+ *----------------------------------------------------------------------------------------------
+ *
+ */
+
+
+/**
+ * @file: event_machine_hw_functions.h
+ *
+ * @brief
+ *    Open Event Machine HW functions declarations
+ *
+ */
+
+#ifndef EVENT_MACHINE_HW_FUNCTIONS_H_
+#define EVENT_MACHINE_HW_FUNCTIONS_H_
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Get major event type.
+ * 
+ * Event type includes major and minor part. This function
+ * returns the major part. It can be compared against 
+ * enumeration em_event_type_major_e.
+ * 
+ * @param type          Event type
+ *
+ * @return Major event type
+ */
+em_event_type_t em_get_type_major(em_event_type_t type);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Get minor event type.
+ * 
+ * Event type includes major and minor part. This function
+ * returns the minor part. It can be compared against 
+ * the enumeration specified by the major part.
+ * 
+ * EM_EVENT_TYPE_SW_DEFAULT is reserved for (SW) events that are
+ * generic and directly accessible buffers of memory. 
+ * 
+ * @param type          Event type
+ *
+ * @return Minor event type
+ */
+em_event_type_t em_get_type_minor(em_event_type_t type);
+
+#endif /* EVENT_MACHINE_HW_FUNCTIONS_H_ */
+
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_macros.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_macros.h
new file mode 100644
index 0000000..39d4467
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_macros.h
@@ -0,0 +1,212 @@ 
+/*
+ *   Copyright (c) 2012, Nokia Siemens Networks
+ *   All rights reserved.
+ *
+ *   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 Nokia Siemens Networks 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.
+ */
+
+
+/**
+ *
+ * Contributors
+ *
+ * The initial developer of the original code is Nokia Siemens Networks.
+ *  The following contributors have made changes to 
+ *  the original code as described below.
+ * 
+ *----------------------------------------------------------------------------------------------
+ * Copyright (c) 2012, Texas Instruments Incorporated. All Rights Reserved. - http://www.ti.com/
+ * 
+ * From the original event_machine_hw_config.h.template , openem/event_machine_hw_macros.h was
+ * created with:
+ *   - Static HW macro definitions with the TI optimized implementation values
+ *   - Doxygen tags are added for API documentation generation.
+ *----------------------------------------------------------------------------------------------
+ *
+ */
+
+
+/**
+ * @file: event_machine_hw_macros.h
+ *
+ * @brief
+ *    Open Event Machine HW TI specific macros
+ *
+ */
+
+#ifndef EVENT_MACHINE_HW_MACROS_H
+#define EVENT_MACHINE_HW_MACROS_H
+
+#include <event_machine_hw_ti_macros.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ *
+ * HW specific constants
+ ***************************************
+ */
+
+
+/** 
+ * @ingroup DOC_api_generic
+ *
+ * Invalid identifier (64-bit)
+ *
+ */
+#define EM_UNDEF_U64       (0x0000000000000000u)
+
+/** 
+ * @ingroup DOC_api_generic
+ *
+ * Invalid identifier (32-bit)
+ */
+#define EM_UNDEF_U32       (0x00000000u)
+
+/** 
+ * @ingroup DOC_api_generic
+ *
+ * Invalid identifier (16-bit)
+ */
+#define EM_UNDEF_U16       (0x0000u)
+
+/** 
+ * @ingroup DOC_api_generic
+ *
+ * Invalid identifier (8-bit)
+ */
+#define EM_UNDEF_U8        (0x00u)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Undefined event
+ */
+#define EM_EVENT_UNDEF     (0x00000000u)
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Default queue group for EM
+ */
+#define EM_QUEUE_GROUP_DEFAULT    (1u)
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Maximum number of queue groups supported by the event machine.
+ *
+ * @note This value can be modified by an application. But the event machine library needs to be recompiled.
+ *
+ */
+#define EM_MAX_QUEUE_GROUPS       (16u)
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Define default memory pool
+ */
+#define EM_POOL_DEFAULT           (0u)
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Fatal error mask
+ */
+#define EM_ERROR_FATAL_MASK       (0x80000000u)
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Test if error is fatal
+ */
+#define EM_ERROR_IS_FATAL(error)  (EM_ERROR_FATAL_MASK & (error))
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Set a fatal error code
+ */
+#define EM_ERROR_SET_FATAL(error) (EM_ERROR_FATAL_MASK | (error))
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * EM internal error scope mask
+ */
+#define EM_ESCOPE_INTERNAL_TYPE       (0x00u)
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * EM internal error scope type
+ */
+#define EM_ESCOPE_INTERNAL_MASK             (EM_ESCOPE_BIT | (EM_ESCOPE_INTERNAL_TYPE << 24))
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Test if the error scope identifies an EM Internal function
+ */
+#define EM_ESCOPE_INTERNAL(escope) (((escope) & EM_ESCOPE_MASK) == EM_ESCOPE_INTERNAL_MASK)
+
+/*
+ *
+ * EM scaling
+ ***************************************
+ */
+
+
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Static queues: minimal value
+ *
+ */
+#define EM_QUEUE_STATIC_MIN         (1)
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Static queues: maximal value
+ *
+ */
+#define EM_QUEUE_STATIC_MAX         ((TI_EM_QUEUE_SET_NUM * TI_EM_STATIC_QUEUE_NUM_IN_SET) - 1)
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Static queues: number of status queues
+ *
+ */
+#define EM_QUEUE_STATIC_NUM         (EM_QUEUE_STATIC_MAX - EM_QUEUE_STATIC_MIN + 1)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
+
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_ti.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_ti.h
new file mode 100644
index 0000000..6ec0242
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_ti.h
@@ -0,0 +1,54 @@ 
+/*
+ * Copyright (c) 2012, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ * @file: event_machine_hw_ti.h
+ *
+ * @brief
+ *    Open Event Machine HW TI specific public include file
+ *
+ */
+ 
+#ifndef EVENT_MACHINE_HW_TI_H
+#define EVENT_MACHINE_HW_TI_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <event_machine_hw_ti_types.h>
+#include <event_machine_hw_ti_macros.h>
+#include <event_machine_hw_ti_functions.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* EVENT_MACHINE_HW_TI_H */
+
+
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_ti_functions.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_ti_functions.h
new file mode 100644
index 0000000..9537033
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_ti_functions.h
@@ -0,0 +1,1467 @@ 
+/*
+ * Copyright (c) 2012, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ * @file: event_machine_hw_ti_functions.h
+ *
+ * @brief
+ *    Open Event Machine HW TI specific functions declarations
+ *
+ */
+
+#ifndef EVENT_MACHINE_HW_TI_FUNCTIONS_H_
+#define EVENT_MACHINE_HW_TI_FUNCTIONS_H_
+
+#include <event_machine_group.h>
+#include <event_machine_hw_ti_types.h>
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Returns the buffer size.
+ *
+ * Returns the size of the event attached data buffer.
+ *
+ * @param event         Event handle.
+ *
+ * @return              Size of the attached buffer.
+ *
+ */
+size_t ti_em_buffer_size(em_event_t event);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Returns the event payload size.
+ *
+ * Returns the size of the event attached data buffers.
+ *
+ * @param event         Event handle.
+ *
+ * @return              Size of the attached buffers.
+ *
+ */
+size_t ti_em_event_size(em_event_t event);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Indicates that the scheduler can pre-schedule events to this core.
+ *
+ */
+void ti_em_preschedule(void);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Indicates that the atomic processing locality has been achieved by the scheduler.
+ *
+ * @return              Hint if the atomic processing locality has been achieved.
+ *
+ */
+uint32_t ti_em_atomic_processing_locality(void);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * The function returns the needed size for the dispatcher control block in bytes. It is stored in the .tiEmLobal memory section.
+ *
+ * @return    size for the Dispatcher Control Block structure
+ */
+size_t ti_em_get_tcb_size (void);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * The function returns the needed size for the master control block plus the runtime master control block in bytes. It is stored in the .tiEmGlobalFast memory section.
+ *
+ * @return    size for the Master Control Block structure
+ */
+size_t ti_em_get_pcb_size (void);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * The function returns the needed size for the slow part of the EO descriptor in bytes. It is stored in the .tiEmGlobalSlow memory section preferably located in non cached MSMC RAM or DDR3 RAM.
+ *
+ * @return    size for the slow part of a EO structure
+ */
+size_t ti_em_get_eo_size_slow (void);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * The function returns the needed size for the fast part of the EO descriptor in bytes. It is stored in the .tiEmGlobalFast memory section preferably located in non cached MSMC RAM or DDR3 RAM.
+ *
+ * @return    size for the fast part of a EO structure
+ */
+size_t ti_em_get_eo_size_fast (void);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * The function returns the needed size for the slow part of the event group descriptor in bytes. It is stored in the .tiEmGlobalSlow memory section preferably located in non cached MSMC RAM or DDR3 RAM.
+ *
+ * @return    size for the slow part of a event group structure
+ *
+ */
+size_t ti_em_get_event_group_size_slow (void);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * The function returns the needed size for the fast part of the event group descriptor in bytes. It is stored in the .tiEmGlobalFast memory section preferably located in non cached MSMC RAM or DDR3 RAM.
+ *
+ * @return    size for the fast part of a event group structure
+ *
+ */
+size_t ti_em_get_event_group_size_fast (void);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * The function returns the needed size for the slow part of the queue group descriptor in bytes. It is stored in the .tiEmGlobalSlow memory section preferably located in non cached MSMC RAM or DDR3 RAM. 
+ *
+ * @return    size for the slow part of a queue group structure
+ *
+ */
+size_t ti_em_get_queue_group_size_slow (void);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * The function returns the needed size for the fast part of the queue group descriptor in bytes. It is stored in the .tiEmGlobalFast memory section preferably located in non cached MSMC RAM or DDR3 RAM. 
+ *
+ * @return    size for the fast part of a queue group structure
+ *
+ */
+size_t ti_em_get_queue_group_size_fast (void);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * The function returns the needed size for the slow part of the queue descriptor in bytes. It is stored in the .tiEmGlobalSlow memory section preferably located in non cached MSMC RAM or DDR3 RAM.
+ *
+ * @return    size for the slow part of a queue structure
+ *
+ */
+size_t ti_em_get_queue_size_slow (void);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * The function returns the needed size for the fast part of the queue descriptor in bytes. It is stored in the .tiEmGlobalFast memory section preferably located in non cached MSMC RAM or DDR3 RAM.
+ *
+ * @return    size for the fast part of a queue structure
+ *
+ */
+size_t ti_em_get_queue_size_fast (void);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Global initialization of EM internals.
+ *
+ * Only one core does this and this must be called before any other call.
+ *
+ * @param config_ptr   Pointer to the hardware configuration structure.
+ *
+ * @return status, EM_OK on success
+ */
+em_status_t ti_em_init_global(const ti_em_config_t* config_ptr);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Local initialization of EM internals.
+ *
+ * All cores call this and it must be called after em_init_global(), but before any other call.
+ * Implementation may be actually empty, but this might be needed later for some
+ * core specific initializations, so application startup should call this always.
+ *
+ * @return status, EM_OK on success
+ */
+em_status_t ti_em_init_local(void);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Global shutdown of EM internals.
+ *
+ * Only one core does this and after this call, no other call is allowed.
+ *
+ * @return status, EM_OK on success
+ */
+em_status_t ti_em_exit_global (void);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * The function runs the dispatcher once.
+ *
+ * The dispatcher code is responsible for calling a execution object receive API.
+ * It checks once if a event has been scheduled to its core and calls the receive function.
+ *
+ * @return returns EM_ERR_NOT_FOUND if no receive function was executed.
+ *         returns EM_OK when a public event was executed.
+ */
+em_status_t ti_em_dispatch_once (void);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * The function returns the local event buffer pointer for a local event or 
+ * NULL if there is no local event.
+ *
+ * @return        Pointer to the event buffer.
+ *
+ */
+void* ti_em_claim_local (void);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Allocate a local event (for post-storing feature).
+ *
+ * Memory address of the allocated event is system specific and
+ * can depend on given pool id, event size and type. Returned 
+ * event (handle) may refer to a memory buffer or a HW specific 
+ * descriptor, i.e. the event structure is system specific. 
+ *
+ * Use em_event_pointer() to convert an event (handle) to a pointer to 
+ * the event structure. 
+ *
+ * EM_EVENT_TYPE_SW with minor type 0 is reserved for direct portability.
+ * It is always guaranteed to return a 64-bit aligned contiguous 
+ * data buffer, that can directly be used by the application up to
+ * the given size (no HW specific descriptors etc are visible).
+ *
+ * @param size          Event size in octets
+ * @param type          Event type to allocate
+ *
+ * @return the allocated event or EM_EVENT_UNDEF on an error
+ *
+ * @see em_free(), em_send(), em_event_pointer(), em_receive_func_t()
+ */
+em_event_t ti_em_alloc_local(size_t size, em_event_type_t type);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function that converts an event handle into a packet.
+ *
+ * @param    event    Event handle.
+ *
+ * @return            Pointer to the packet.
+ *
+ */
+ti_em_packet_t* ti_em_to_packet(em_event_t event);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function that converts into an event handle from a packet.
+ *
+ * @param    packet_ptr      Pointer to the packet.
+ *
+ * @return                   Event handle.
+ *
+ */
+em_event_t ti_em_from_packet(ti_em_packet_t* packet_ptr);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which sets the 12 first words of an event to their default values.
+ *
+ * The CPPI type is set to Host, The EPIB flag is ON and the PS location flag is ON.
+ *
+ * @param packet_ptr      Pointer to the packet.
+ *
+ */
+void ti_em_packet_set_default(ti_em_packet_t* packet_ptr);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which sets the event pool information in the packet.
+ *
+ * @param packet_ptr    Pointer to the packet.
+ * @param pool_config   Structure containing the pool info.
+ *
+ */
+void ti_em_packet_set_pool_info(ti_em_packet_t* packet_ptr, ti_em_pool_config_t pool_config);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which sets the buffer information in the packet.
+ *
+ * @param packet_ptr    Pointer to the packet.
+ * @param buffer_config Structure containing the buffer info.
+ *
+ */
+void ti_em_packet_set_buffer_info(ti_em_packet_t* packet_ptr, ti_em_buffer_config_t buffer_config);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which restores the free information in the packet.
+ *
+ * @param packet_ptr     Pointer to the packet.
+ *
+ */
+void ti_em_packet_restore_free_info(ti_em_packet_t * packet_ptr);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which sets the event type in the packet.
+ *
+ * @param     packet_ptr    Pointer to the packet.
+ * @param     event_type    Event type of the packet.
+ *
+ */
+void ti_em_packet_set_type(ti_em_packet_t* packet_ptr, em_event_type_t event_type);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which sets the queue information in the packet.
+ *
+ * @param packet_ptr    Pointer to the packet.
+ * @param queue_hdl     Queue handle to set.
+ *
+ */
+void ti_em_packet_set_queue(ti_em_packet_t* packet_ptr, em_queue_t queue_hdl);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which sets the event group information in the packet.
+ *
+ * @param packet_ptr         Pointer to the packet.
+ * @param event_group_hdl    Event group handle to set.
+ *
+ */
+void ti_em_packet_set_event_group(ti_em_packet_t* packet_ptr, em_event_group_t event_group_hdl);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which sets the event type in the event.
+ *
+ * @param event         Event handle.
+ * @param event_type    Event type to set.
+ *
+ */
+void ti_em_set_type(em_event_t event, em_event_type_t event_type);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which returns the event type.
+ *
+ * @param     event    Event handle.
+ *
+ * @return             Event type of the descriptor.
+ *
+ */
+em_event_type_t ti_em_get_type(const em_event_t event);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which extracts the preload policy from the event type.
+ *
+ * @param     type     Event type.
+ *
+ * @return             Preload policy.
+ *
+ */
+em_event_type_t ti_em_get_type_preload(em_event_type_t type);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which returns the buffer mode.
+ *
+ * @param     event    Event handle.
+ *
+ * @return             Buffer mode of the event.
+ *
+ */
+ti_em_buf_mode_t ti_em_get_buf_mode(const em_event_t event);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which returns the cache coherency mode.
+ *
+ * @param     event    Event handle.
+ *
+ * @return             Cache coherency mode of the event.
+ *
+ */
+ti_em_coh_mode_t ti_em_get_coh_mode(const em_event_t event);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which sets the queue and event group information in the event.
+ *
+ * @param event              Event handle.
+ * @param queue_hdl          Queue handle to set.
+ * @param event_group_hdl    Event group handle to set.
+ *
+ */
+void ti_em_set_queue(em_event_t event, em_queue_t queue_hdl, em_event_group_t event_group_hdl);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which sets the queue information in the event tag location.
+ *
+ * @param tag_ptr            Pointer to tag location.
+ * @param queue_hdl          Queue handle to set.
+ *
+ */
+void ti_em_tag_set_queue(uint32_t* tag_ptr, em_queue_t queue_hdl);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which sets the event type in the tag location.
+ *
+ * @param tag_ptr            Pointer to tag location.
+ * @param event_type         Event type to set.
+ *
+ */
+void ti_em_tag_set_type(uint32_t* tag_ptr, em_event_type_t event_type);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which generates a global queue handle.
+ *
+ * @param     queue_hdl     Local queue handle.
+ * @param     device_idx    Device index.
+ * @param     process_idx   Process index.
+ *
+ * @return                  Global queue handle.
+ *
+ */
+em_queue_t ti_em_queue_make_global(em_queue_t queue_hdl, ti_em_device_id_t device_idx, ti_em_process_id_t process_idx);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which extracts the device index from the queue handle.
+ *
+ * @param     queue_hdl     Queue handle.
+ *
+ * @return                  Device index.
+ *
+ */
+ti_em_device_id_t ti_em_queue_get_device_id(em_queue_t queue_hdl);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which extracts the process index from the queue handle.
+ *
+ * @param     queue_hdl     Queue handle.
+ *
+ * @return                  Process index.
+ *
+ */
+ti_em_process_id_t ti_em_queue_get_process_id(em_queue_t queue_hdl);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which extracts the queue mode (HW or SD) from the queue handle.
+ *
+ * @param     queue_hdl     Queue handle.
+ *
+ * @return                  Queue mode.
+ *
+ */
+ti_em_queue_mode_t ti_em_queue_get_mode(em_queue_t queue_hdl);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which returns the index of the associated Multicore Navigator queue.
+ *
+ * @param     queue_hdl     Queue handle.
+ *
+ * @return                  Device index.
+ *
+ */
+ti_em_queue_id_t ti_em_queue_get_queue_id(em_queue_t queue_hdl);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Registers the trace handler.
+ *
+ * @param handler   Trace handler.
+ *
+ * @return Success code.
+ */
+em_status_t ti_em_register_trace_handler(ti_em_trace_handler_t handler);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Unregisters the trace handler.
+ *
+ * @return Success code is 0,
+ */
+em_status_t ti_em_unregister_trace_handler(void);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Allocates an event while providing buffer(s) to attach.
+ *
+ * It allocates a primary event from pools with zero-buffer descriptors.\n
+ * It attaches one or more buffers to the event.\n
+ * The event comes with optional free function and coherency mode for each buffer.
+ *
+ * @param event_type         Event type to allocate
+ * @param pool_id            Event pool id
+ * @param buffer_num         Event buffers number
+ * @param buffer_config_tbl  Data buffers configuration table
+ *
+ * @return                   Event handle
+ *
+ * @see ti_em_free_with_buffers()
+ *
+ */
+em_event_t ti_em_alloc_with_buffers(em_event_type_t event_type, em_pool_id_t pool_id, int32_t buffer_num, ti_em_buffer_config_t* buffer_config_tbl);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Frees an event with buffers.
+ *
+ * It returns an event to its free pool(s).\n
+ * It doesn't call free function, even if provided.\n
+ * It fills out the configuration for each buffer that has been attached with ti_em_alloc_with_buffers().\n
+ * It returns the number of such buffers - error if too many buffer pointers to return (wrt to buffer_num).\n
+ *
+ * @param event              Event to be freed
+ * @param buffer_num         Event buffers number
+ * @param buffer_config_tbl  Data buffers configuration table
+ *
+ * @return                   Event handle.
+ *
+ * @see ti_em_alloc_with_buffers()
+ *
+ */
+em_event_t ti_em_free_with_buffers(em_event_t event, int32_t buffer_num, ti_em_buffer_config_t* buffer_config_tbl);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Combines two (2) event handles into one scattered event handle.\n
+ * When returned, the iterator buffer points to last descriptor of the old pair.head_event.\n
+ *
+ * @param          event_pair   pair to combine.
+ *
+ * @param          iterator_ptr Pointer to iterator.
+ *
+ * @return         event handle.
+ */
+em_event_t ti_em_combine(ti_em_pair_t event_pair, ti_em_iterator_t * iterator_ptr);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Splits one scattered event into two events.\n
+ * when returned, the iterator buffer points to the last buffer of pair.head_event (can be recombined right away).\n
+ * Second and following buffers of pair.tail_event are cache coherent.\n
+ *
+ * @param   event           Event to split.
+ * @param   iterator_ptr    Pointer to iterator where the split starts.
+ *
+ * @return                  Events pair.
+ */
+ti_em_pair_t ti_em_split(em_event_t event, ti_em_iterator_t* iterator_ptr);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Returns the size of the iterator attached data buffer.
+ *
+ * @param iterator_ptr      Pointer to iterator.
+ *
+ * @return                  Size of the attached buffer.
+ *
+ */
+size_t ti_em_iterator_size(ti_em_iterator_t* iterator_ptr);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Initializes the iterator to the first buffer. Two iterators may not be started at the same time for a single event.
+ *
+ * @param event             Event handle to start.
+ * @param iterator_ptr      Pointer to iterator.
+ *
+ * @return                  returns EM_OK.
+ *
+ */
+em_status_t ti_em_iterator_start(em_event_t event, ti_em_iterator_t* iterator_ptr);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * It registers all the touched buffers.\n
+ * It is mandatory to perform ti_em_iterator_stop() before em_free(), em_send() or em_event_group_apply().\n
+ * It is forbidden to use the iterator or any iterator content from this point onwards.
+ *
+ * @param iterator_ptr      Pointer to iterator.
+ *
+ * @return                  returns EM_OK when successfull, EM_ERR_BAD_STATE when iterator is in a wrong state.
+ *
+ */
+em_status_t ti_em_iterator_stop(ti_em_iterator_t* iterator_ptr);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Moves the iterator to the next buffer.
+ *
+ * @param iterator_ptr      Pointer to iterator.
+ *
+ * @return                  returns EM_OK when successfull, EM_ERR_BAD_STATE when iterator is in a wrong state. EM_ERR_NOT_FOUND when the iterator points to the last buffer.
+ *
+ */
+em_status_t ti_em_iterator_next(ti_em_iterator_t* iterator_ptr);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Moves the iterator to the previous buffer.
+ *
+ * @param iterator_ptr      Pointer to iterator.
+ *
+ * @return                  returns EM_OK when successfull, EM_ERR_BAD_STATE when iterator is in a wrong state. EM_ERR_NOT_FOUND when the iterator points to the first buffer.
+ *
+ */
+em_status_t ti_em_iterator_previous(ti_em_iterator_t* iterator_ptr);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Returns a pointer to the iterator attached data buffer.
+ *
+ * @param iterator_ptr      Pointer to iterator.
+ *
+ * @return                  Pointer to the buffer.
+ *
+ */
+void* ti_em_iterator_pointer(ti_em_iterator_t* iterator_ptr);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Opens an hard-ware queue on the data-base.
+ *
+ * @pre   The hard-ware queue shall not be used by another
+ *        part of the application on the device.\n
+ *        If the hard-ware queue is already used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the Qmss_queueOpen PDK function.
+ *
+ * @param queue_idx   Index of the queue to be open.\n
+ *                    It ranges from 0 to the maximum queue index
+ *                    supported by the Multicore Navigator.
+ *
+ * @post  None.
+ *
+ * @return status, EM_OK on success.
+ */
+extern em_status_t ti_em_hw_queue_open(int queue_idx);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Closes an hard-ware queue on the data-base.
+ *
+ * @pre   The hard-ware queue shall already be used by the
+ *        Open-Em process.\n
+ *        If the hard-ware queue is not used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the Qmss_queueClose PDK function.
+ *
+ * @param queue_idx   Index of the queue to be open.\n
+ *                    It ranges from 0 to the maximum queue index
+ *                    supported by the Multicore Navigator.
+ *
+ * @post  None.
+ *
+ * @return status, EM_OK on success.
+ */
+extern em_status_t ti_em_hw_queue_close(int queue_idx);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Opens an hard-ware receive flow on the data-base and configure the hard-ware registers of this receive flow.
+ *
+ * @pre   The hard-ware receive flow shall not be used by another
+ *        part of the application on the device.\n
+ *        If the hard-ware receive flow is already used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the Cppi_configureRxFlow PDK function.
+ *
+ * @param dma_idx         Index of the dma instance.\n
+ *                        This refers to the Multicore Navigator PktDMA instance.
+ * @param flow_idx        Index of the receive flow to be open.\n
+ *                        It ranges from 0 to the maximum Rx Flow index
+ *                        supported by the Multicore Navigator instance.
+ * @param dst_queue_idx   Index of the destination queue.
+ * @param free_queue_idx  Index of the destination free queue.\n
+ *                        Queue indexes range from 0 to the maximum queue index
+ *                        supported by the Multicore Navigator instance.
+ * @param error_handling  Receive flow error handling mode when starvation occurs.\n
+ *                        0 = Starvation errors result in dropping packet.\n
+ *                        1 = Starvation errors result in subsequent re-try.
+ *
+ * @post  On success, the RX_FLOW_CONFIG registers shall be correctly configured.
+ *
+ * @return status, EM_OK on success
+ */
+extern em_status_t ti_em_rx_flow_open(int dma_idx, int flow_idx, int dst_queue_idx, int free_queue_idx, int error_handling);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Closes an hard-ware receive flow on the data-base.
+ *
+ * @pre   The hard-ware receive flow shall be used by the Open-EM process.\n
+ *        If the hard-ware receive flow is not used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the Cppi_closeRxFlow PDK function.
+ *
+ * @param dma_idx         Index of the dma instance.\n
+ *                        This refers to the Multicore Navigator PktDMA instance.
+ * @param flow_idx        Index of the receive flow to be closed.\n
+ *                        It ranges from 0 to the maximum Rx Flow index
+ *                        supported by the Multicore Navigator instance.
+ *
+ * @return status, EM_OK on success
+ */
+extern em_status_t ti_em_rx_flow_close(int dma_idx, int flow_idx);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Opens an hard-ware xge receive flow on the data-base and configure the hard-ware registers of this receive flow.
+ *
+ * @pre   The hard-ware receive flow shall not be used by another
+ *        part of the application on the device.\n
+ *        If the hard-ware receive flow is already used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the Cppi_configureRxFlow PDK function.
+ *
+ * @param dma_idx         Index of the dma instance.\n
+ *                        This refers to the Multicore Navigator PktDMA instance.
+ * @param flow_idx        Index of the receive flow to be open.\n
+ *                        It ranges from 0 to the maximum Rx Flow index
+ *                        supported by the Multicore Navigator instance.
+ * @param dst_queue_idx   Index of the destination queue.
+ * @param free_queue_idx0 Index of the destination free queue.\n
+ *                        Queue indexes range from 0 to the maximum queue index
+ *                        supported by the Multicore Navigator instance.
+ * @param free_queue_idx1 Index of the destination free queue.\n
+ *                        Queue indexes range from 0 to the maximum queue index
+ *                        supported by the Multicore Navigator instance.
+ * @param error_handling  Receive flow error handling mode when starvation occurs.\n
+ *                        0 = Starvation errors result in dropping packet.\n
+ *                        1 = Starvation errors result in subsequent re-try.
+ *
+ * @post  On success, the RX_FLOW_CONFIG registers shall be correctly configured.
+ *
+ * @return status, EM_OK on success
+ */
+extern em_status_t ti_em_xge_rx_flow_open(int dma_idx, int flow_idx, int dst_queue_idx, int free_queue_idx0, int free_queue_idx1, int error_handling);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Closes an hard-ware XGE receive flow on the data-base.
+ *
+ * @pre   The hard-ware receive flow shall be used by the Open-EM process.\n
+ *        If the hard-ware receive flow is not used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the Cppi_closeRxFlow PDK function.
+ *
+ * @param dma_idx         Index of the dma instance.\n
+ *                        This refers to the Multicore Navigator PktDMA instance.
+ * @param flow_idx        Index of the receive flow to be closed.\n
+ *                        It ranges from 0 to the maximum Rx Flow index
+ *                        supported by the Multicore Navigator instance.
+ *
+ * @return status, EM_OK on success
+ */
+extern em_status_t ti_em_xge_rx_flow_close (int dma_idx, int flow_idx);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Opens an hard-ware process RIO receive flow on the data-base and configure the hard-ware registers of this receive flow.
+ * It also creates the mapping between the Type9 message parameters and the opened flow.
+ *
+ * @pre   The hard-ware receive flow shall not be used by another
+ *        part of the application on the device.\n
+ *        If the hard-ware receive flow is already used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the Cppi_configureRxFlow PDK function and the CSL_SRIO_MapType9MessageToQueue CSL API.
+ *
+ * @param dma_idx                Index of the dma instance.\n
+ *                               This refers to the Multicore Navigator PktDMA instance.
+ * @param flow_idx               Index of the receive flow to be open.\n
+ *                               It ranges from 0 to the maximum Rx Flow index
+ *                               supported by the Multicore Navigator instance.
+ * @param dst_queue_idx          Index of the destination queue.
+ * @param free_queue_idxSizeA    Index of the destination free queue for packet length\n 
+ *                               smaller than sizeA. Queue indexes range from 0 to the 
+ *                               maximum queue index supported by the Multicore Navigator 
+ *                               instance.
+ * @param sizeA                  Maximal size in bytes of the packet length for free queue A
+ * @param free_queue_idxSizeB    Index of the destination free queue for packet length\n 
+ *                               smaller than sizeB. Queue indexes range from 0 to the 
+ *                               maximum queue index supported by the Multicore Navigator 
+ *                               instance.
+ * @param sizeB                  Maximal size in bytes of the packet length for free queue B
+ * @param free_queue_idxSizeC    Index of the destination free queue for packet length\n 
+ *                               smaller than sizeC. Queue indexes range from 0 to the 
+ *                               maximum queue index supported by the Multicore Navigator 
+ *                               instance.
+ * @param sizeC                  Maximal size in bytes of the packet length for free queue C
+ * @param free_queue_idxSizeD    Index of the destination free queue for packet length\n 
+ *                               smaller than sizeD. Queue indexes range from 0 to the 
+ *                               maximum queue index supported by the Multicore Navigator 
+ *                               instance.
+ * @param sizeD                  Maximal size in bytes of the packet length for free queue D
+ * @param free_queue_idxOverflow Index of the destination free queue for packet length\n 
+ *                               with overflow. Queue indexes range from 0 to the 
+ *                               maximum queue index supported by the Multicore Navigator 
+ *                               instance.
+ * @param deviceIdx              Index of the current device
+ * @param processIdx             Index of the current process
+ * @param error_handling         Receive flow error handling mode when starvation occurs.\n
+ *                               0 = Starvation errors result in dropping packet.\n
+ *                               1 = Starvation errors result in subsequent re-try.
+ *
+ * @post  On success, the RX_FLOW_CONFIG registers shall be correctly configured.
+ *
+ * @return status, EM_OK on success
+ */
+extern em_status_t ti_em_rio_rx_flow_open(int dma_idx,
+					  int flow_idx,
+					  int dst_queue_idx,
+					  int free_queue_idxSizeA,
+					  int sizeA,
+					  int free_queue_idxSizeB,
+					  int sizeB,
+					  int free_queue_idxSizeC,
+					  int sizeC,
+					  int free_queue_idxSizeD,
+					  int sizeD,
+					  int free_queue_idxOverflow,
+					  int deviceIdx,
+					  int processIdx,
+					  int error_handling);
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Opens an hard-ware process chaining receive flow on the data-base and configure the hard-ware registers of this receive flow.
+ *
+ * @pre   The hard-ware receive flow shall not be used by another
+ *        part of the application on the device.\n
+ *        If the hard-ware receive flow is already used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the Cppi_configureRxFlow PDK function.
+ *
+ * @param dma_idx                Index of the dma instance.\n
+ *                               This refers to the Multicore Navigator PktDMA instance.
+ * @param flow_idx               Index of the receive flow to be open.\n
+ *                               It ranges from 0 to the maximum Rx Flow index
+ *                               supported by the Multicore Navigator instance.
+ * @param dst_queue_idx          Index of the destination queue.
+ * @param free_queue_idxSizeA    Index of the destination free queue for packet length\n 
+ *                               smaller than sizeA. Queue indexes range from 0 to the 
+ *                               maximum queue index supported by the Multicore Navigator 
+ *                               instance.
+ * @param sizeA                  Maximal size in bytes of the packet length for free queue A
+ * @param free_queue_idxSizeB    Index of the destination free queue for packet length\n 
+ *                               smaller than sizeB. Queue indexes range from 0 to the 
+ *                               maximum queue index supported by the Multicore Navigator 
+ *                               instance.
+ * @param sizeB                  Maximal size in bytes of the packet length for free queue B
+ * @param free_queue_idxSizeC    Index of the destination free queue for packet length\n 
+ *                               smaller than sizeC. Queue indexes range from 0 to the 
+ *                               maximum queue index supported by the Multicore Navigator 
+ *                               instance.
+ * @param sizeC                  Maximal size in bytes of the packet length for free queue C
+ * @param free_queue_idxSizeD    Index of the destination free queue for packet length\n 
+ *                               smaller than sizeD. Queue indexes range from 0 to the 
+ *                               maximum queue index supported by the Multicore Navigator 
+ *                               instance.
+ * @param sizeD                  Maximal size in bytes of the packet length for free queue D
+ * @param free_queue_idxOverflow Index of the destination free queue for packet length\n 
+ *                               with overflow. Queue indexes range from 0 to the 
+ *                               maximum queue index supported by the Multicore Navigator 
+ *                               instance.
+ * @param error_handling         Receive flow error handling mode when starvation occurs.\n
+ *                               0 = Starvation errors result in dropping packet.\n
+ *                               1 = Starvation errors result in subsequent re-try.
+ *
+ * @post  On success, the RX_FLOW_CONFIG registers shall be correctly configured.
+ *
+ * @return status, EM_OK on success
+ */
+extern em_status_t ti_em_chain_rx_flow_open(int dma_idx,
+					    int flow_idx,
+					    int dst_queue_idx,
+					    int free_queue_idxSizeA,
+					    int sizeA,
+					    int free_queue_idxSizeB,
+					    int sizeB,
+					    int free_queue_idxSizeC,
+					    int sizeC,
+					    int free_queue_idxSizeD,
+					    int sizeD,
+					    int free_queue_idxOverflow,
+					    int error_handling);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Opens an hard-ware transmit channel on the data-base and configure the hard-ware registers of this transmit channel.
+ *
+ * @pre   The hard-ware transmit channel shall not be used by another
+ *        part of the application on the device.\n
+ *        If the hard-ware transmit channel is already used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the Cppi_txChannelOpen PDK function.
+ *
+ * @param dma_idx         Index of the dma instance.\n
+ *                        This refers to the Multicore Navigator PktDMA instance.
+ * @param channel_idx     Index of the transmit channel to be open.\n
+ *                        It ranges from 0 to the maximum Tx Channel index
+ *                        supported by the Multicore Navigator instance.
+ *
+ * @post  On success, the TX_CHANNEL_GLOBAL_CONFIG_REG_A register shall be enabled.\n
+ *        The TX_CHANNEL_SCHEDULER_CONFIG_REG_PRIORITY register shall be configured to the desired value.
+ *
+ * @return status, EM_OK on success
+ */
+extern em_status_t ti_em_tx_channel_open(int dma_idx, int channel_idx);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Closes an hard-ware transmit channel on the data-base.
+ *
+ * @pre   The hard-ware transmit channel shall be used by the Open-EM
+ *        process.\n
+ *        If the hard-ware transmit channel is not used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the Cppi_channelClose PDK function.
+ *
+ * @param dma_idx         Index of the dma instance.\n
+ *                        This refers to the Multicore Navigator PktDMA instance.
+ * @param channel_idx     Index of the transmit channel to be closed.\n
+ *                        It ranges from 0 to the maximum Tx Channel index
+ *                        supported by the Multicore Navigator instance.
+ *
+ * @return status, EM_OK on success
+ */
+extern em_status_t ti_em_tx_channel_close(int dma_idx, int channel_idx);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Opens an hard-ware xge transmit channel on the data-base and configure the hard-ware registers of this transmit channel.
+ *
+ * @pre   The hard-ware transmit channel shall not be used by another
+ *        part of the application on the device.\n
+ *        If the hard-ware transmit channel is already used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the Cppi_txChannelOpen PDK function.
+ *
+ * @param dma_idx         Index of the dma instance.\n
+ *                        This refers to the Multicore Navigator PktDMA instance.
+ * @param channel_idx     Index of the transmit channel to be open.\n
+ *                        It ranges from 0 to the maximum Tx Channel index
+ *                        supported by the Multicore Navigator instance.
+ *
+ * @post  On success, the TX_CHANNEL_GLOBAL_CONFIG_REG_A register shall be enabled.\n
+ *        The TX_CHANNEL_SCHEDULER_CONFIG_REG_PRIORITY register shall be configured to the desired value.
+ *
+ * @return status, EM_OK on success
+ */
+extern em_status_t ti_em_xge_tx_channel_open(int dma_idx, int channel_idx);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Closes an hard-ware XGE transmit channel on the data-base.
+ *
+ * @pre   The hard-ware transmit channel shall be used by the Open-EM
+ *        process.\n
+ *        If the hard-ware transmit channel is not used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the Cppi_channelClose PDK function.
+ *
+ * @param dma_idx         Index of the dma instance.\n
+ *                        This refers to the Multicore Navigator PktDMA instance.
+ * @param channel_idx     Index of the transmit channel to be closed.\n
+ *                        It ranges from 0 to the maximum Tx Channel index
+ *                        supported by the Multicore Navigator instance.
+ *
+ * @return status, EM_OK on success
+ */
+extern em_status_t ti_em_xge_tx_channel_close (int dma_idx, int channel_idx);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Opens an hard-ware SRIO transmit channel on the data-base and configure the hard-ware registers of this transmit channel.
+ *
+ * @pre   The hard-ware transmit channel shall not be used by another
+ *        part of the application on the device.\n
+ *        If the hard-ware transmit channel is already used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the Cppi_txChannelOpen PDK function.
+ *
+ * @param dma_idx         Index of the dma instance.\n
+ *                        This refers to the Multicore Navigator PktDMA instance.
+ *
+ * @post  On success, the TX_CHANNEL_GLOBAL_CONFIG_REG_A register shall be enabled.\n
+ *        The TX_CHANNEL_SCHEDULER_CONFIG_REG_PRIORITY register shall be configured to the desired value.
+ *
+ * @return status, EM_OK on success
+ */
+extern em_status_t ti_em_rio_tx_channel_open(int dma_idx);
+
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Opens an hard-ware receive channel on the data-base and configure the hard-ware registers of this receive channel.
+ *
+ * @pre   The hard-ware receive channel shall not be used by another
+ *        part of the application on the device.\n
+ *        If the hard-ware receive channel is already used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the Cppi_rxChannelOpen PDK function.
+ *
+ * @param dma_idx         Index of the dma instance.\n
+ *                        This refers to the Multicore Navigator PktDMA instance.
+ * @param channel_idx     Index of the receive channel to be open.\n
+ *                        It ranges from 0 to the maximum Rx Channel index
+ *                        supported by the Multicore Navigator instance.
+ *
+ * @post  On success, the RX_CHANNEL_GLOBAL_CONFIG_REG register shall be enabled.
+ *
+ * @return status, EM_OK on success
+ */
+extern em_status_t ti_em_rx_channel_open(int dma_idx, int channel_idx);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Closes an hard-ware receive channel on the data-base.
+ *
+ * @pre   The hard-ware receive channel shall be used by the
+ *        Open-EM process.\n
+ *        If the hard-ware receive channel is not used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the Cppi_channelClose PDK function.
+ *
+ * @param dma_idx         Index of the dma instance.\n
+ *                        This refers to the Multicore Navigator PktDMA instance.
+ * @param channel_idx     Index of the receive channel to be closed.\n
+ *                        It ranges from 0 to the maximum Rx Channel index
+ *                        supported by the Multicore Navigator instance.
+ *
+ * @return status, EM_OK on success
+ */
+extern em_status_t ti_em_rx_channel_close(int dma_idx, int channel_idx);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Opens an hard-ware xge receive channel on the data-base and configure the hard-ware registers of this receive channel.
+ *
+ * @pre   The hard-ware receive channel shall not be used by another
+ *        part of the application on the device.\n
+ *        If the hard-ware receive channel is already used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the Cppi_rxChannelOpen PDK function.
+ *
+ * @param dma_idx         Index of the dma instance.\n
+ *                        This refers to the Multicore Navigator PktDMA instance.
+ * @param channel_idx     Index of the receive channel to be open.\n
+ *                        It ranges from 0 to the maximum Rx Channel index
+ *                        supported by the Multicore Navigator instance.
+ *
+ * @post  On success, the RX_CHANNEL_GLOBAL_CONFIG_REG register shall be enabled.
+ *
+ * @return status, EM_OK on success
+ */
+extern em_status_t ti_em_xge_rx_channel_open(int dma_idx, int channel_idx);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Closes an hard-ware XGE receive channel on the data-base.
+ *
+ * @pre   The hard-ware receive channel shall be used by the
+ *        Open-EM process.\n
+ *        If the hard-ware receive channel is not used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the Cppi_channelClose PDK function.
+ *
+ * @param dma_idx         Index of the dma instance.\n
+ *                        This refers to the Multicore Navigator PktDMA instance.
+ * @param channel_idx     Index of the receive channel to be closed.\n
+ *                        It ranges from 0 to the maximum Rx Channel index
+ *                        supported by the Multicore Navigator instance.
+ *
+ * @return status, EM_OK on success
+ */
+extern em_status_t ti_em_xge_rx_channel_close (int dma_idx, int channel_idx);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Opens an hard-ware xge transmit queue on the data-base and configure the hard-ware registers of this transmit queue.
+ *
+ * @pre   The hard-ware transmit queue shall not be used by another
+ *        part of the application on the device.\n
+ *        If the hard-ware transmit queue is already used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the ti_em_hw_queue_open function.
+ *
+ * @param queue_base_idx          Index of the 1st XGE tx queue
+ * @param vlan_priority           VLAN priority.
+ *
+ * @return index of the XGE transmit queue
+ */
+extern ti_em_queue_id_t ti_em_xge_tx_queue_open(ti_em_queue_id_t queue_base_idx, int    vlan_priority);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Returns the first hard-ware xge transmit queue among TI_EM_XGE_VLAN_PRIO_NUM (8).
+ *
+ * @pre   The hard-ware transmit queue shall not be used by another
+ *        part of the application on the device.\n
+ *        If the hard-ware transmit queue is already used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the ti_em_xge_tx_queue_base_idx_get function.
+ *
+ * @param .
+ *
+ * @return index of the first XGE transmit queue
+ */
+extern ti_em_queue_id_t ti_em_xge_tx_queue_base_idx_get (void);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Opens an hard-ware SRIO transmit queue on the data-base and configure the hard-ware registers of this transmit queue.
+ *
+ * @pre   The hard-ware transmit queue shall not be used by another
+ *        part of the application on the device.\n
+ *        If the hard-ware transmit queue is already used, the function
+ *        is not successful.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the ti_em_hw_queue_open function.
+ *
+ * @param rio_tx_queue_idx           RIO queue index
+ *
+ * @return index of the RIO transmit queue or error
+ */
+extern ti_em_queue_id_t ti_em_rio_tx_queue_open(int rio_tx_queue_idx);
+
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Retrieves the absolute queue index from the associated Multicore Navigator PkDMA engine index
+ * and the relative TX queue index.
+ *
+ * @remark The implementation is left to the user. An
+ *         example is provided in em_pdk_hal.c file
+ *         using the CPPI LLD.
+ *
+ * @param dma_idx         Index of the dma instance.\n
+ *                        This refers to the Multicore Navigator PktDMA instance.
+ *
+ * @param queue_idx       Relative index of the queue.
+ *
+ * @return Absolute index of the queue.
+ */
+extern ti_em_queue_id_t ti_em_get_absolute_queue_id(ti_em_dma_id_t dma_idx, ti_em_queue_id_t queue_idx);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Loops over all data buffers of the event and perform a cache write back invalidate if the data buffer is dirty.
+ *
+ * @param event           Event handle.
+ *
+ */
+void ti_em_flush(em_event_t event);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which sets the ps words in the event.
+ *
+ * @param event         Event handle.
+ * @param ps_word_ptr   Pointer to ps words.
+ * @param ps_wsize      Number of ps words.
+ *
+ * @return status, EM_OK on success
+ */
+em_status_t ti_em_set_ps_words(em_event_t event, uint32_t* ps_word_ptr, size_t ps_wsize);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which gets the ps words from the event.
+ *
+ * @param event         Event handle.
+ * @param ps_word_ptr   Pointer to ps words.
+ * @param ps_wsize      Number of ps words.
+ *
+ * @return status, EM_OK on success
+ */
+em_status_t ti_em_get_ps_words(em_event_t event, uint32_t* ps_word_ptr, size_t ps_wsize);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which sets the number of ps words in the event.
+ *
+ * @param event         Event handle.
+ * @param ps_wsize      Number of ps words.
+ *
+ * @return status, EM_OK on success
+ */
+em_status_t ti_em_set_ps_wsize(em_event_t event, size_t ps_wsize);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Helper function which gets the number of ps words from the event.
+ *
+ * @param event         Event handle.
+ *
+ * @return Number of ps words
+ */
+size_t ti_em_get_ps_wsize(em_event_t event);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Adds a process route to the device router.
+ *
+ * @param process_route  Parameters of the process route.
+ *
+ * @param process_idx  Process index.
+ *
+ * @return status, EM_OK on success
+ */
+em_status_t ti_em_process_add_route(ti_em_process_route_t process_route, ti_em_process_id_t process_idx);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Adds an XGE route to the device router.
+ *
+ * @param device_idx  Device index.
+ *
+ * @param device_route  Device route.
+ *
+ * @return status, EM_OK on success
+ */
+em_status_t ti_em_device_add_xge_route(ti_em_device_id_t device_idx, ti_em_device_xge_route_t device_route);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Adds an SRIO route to the device router.
+ *
+ * @param device_idx  Device index.
+ *
+ * @param device_route  Device route.
+ *
+ * @return status, EM_OK on success
+ */
+em_status_t ti_em_device_add_rio_route(ti_em_device_id_t device_idx, ti_em_device_rio_route_t device_route);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Creates a static HW queue.
+ *
+ * @param name          Queue name for debugging purposes (optional, NULL ok)
+ *
+ * @param hw_queue_idx  Hw queue index
+ *
+ * @param queue         Requested queue id from the static range
+ *
+ * @return  EM_OK on success or EM_QUEUE_UNDEF on an error
+ */
+em_status_t ti_em_queue_create_hw_static(const char* name, ti_em_queue_id_t hw_queue_idx, em_queue_t queue);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Creates a HW queue.
+ *
+ * @param name          Queue name for debugging purposes (optional, NULL ok)
+ *
+ * @param hw_queue_idx  Hw queue index
+ *
+ * @return new queue id or EM_QUEUE_UNDEF on an error
+ */
+em_queue_t ti_em_queue_create_hw(const char* name, ti_em_queue_id_t hw_queue_idx);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Receives an event from a queue.
+ *
+ * Event must have been allocated with em_alloc().
+ *
+ * @param queue         Receiving queue
+ *
+ * @return the received event or EM_EVENT_UNDEF if the queue is empty.
+ * 
+ * @see em_alloc()
+ */
+em_event_t ti_em_receive(em_queue_t queue);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Enables the interrupt generation for the attached dispatcher.
+ * The interrupt channel index used is based on the configuration
+ * hw_queue_base_idx and the physical core index.
+ * If the interrupt channel index is inferior to 32, it is mapped to
+ * one of the 32 HI channels in the associated INTD register.
+ * Otherwise it is mapped to one of the 16 LOW channels.
+ * By default, the interrupt are not enabled.
+ *
+ * @return status, EM_OK on success
+ */
+em_status_t ti_em_interrupt_enable(void);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Disables the interrupt generation for the attached dispatcher.
+ *
+ * @return status, EM_OK on success
+ */
+em_status_t ti_em_interrupt_disable(void);
+
+#endif /* EVENT_MACHINE_HW_TI_FUNCTIONS_H_ */
+
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_ti_macros.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_ti_macros.h
new file mode 100644
index 0000000..51830df
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_ti_macros.h
@@ -0,0 +1,570 @@ 
+/*
+ * Copyright (c) 2012, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ * @file: event_machine_hw_ti_macros.h
+ *
+ * @brief
+ *    Open Event Machine HW TI specific constant definitions
+ *
+ */
+
+#ifndef EVENT_MACHINE_HW_TI_MACROS_H_
+#define EVENT_MACHINE_HW_TI_MACROS_H_
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Number of 32 bits words in an ti_em_iterator_t array.
+ */
+#define TI_EM_ITERATOR_WSIZE (8u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Number of PF events per core.
+ */
+#define TI_EM_PF_LEN (1u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of cores on a device on which the Event Machine can be executed.
+ */
+#define TI_EM_CORE_NUM (8u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of Navigator PDSP instances on which this process scheduler can be executed.
+ * Only relevant on a Keystone II target.
+ */
+#define TI_EM_SCHEDULER_THREAD_NUM (4u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of Open-EM processes on a device on which the Event Machine can be executed.
+ */
+#define TI_EM_PROCESS_NUM (2u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Chaining disabled on Open-EM process.
+ */
+#define TI_EM_CHAIN_DISABLED (0u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Chaining enabled on Open-EM process.
+ */
+#define TI_EM_CHAIN_ENABLED (1u)
+
+/** 
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of TX queues for chaining and poststoring. Must be a power of 2: 1, 2, 4 or 8.
+ */
+#ifdef TI_EM_LINUX
+#define TI_EM_CHAIN_TX_QUEUE_NUM (1u)
+#else /* TI_EM_LINUX */
+#define TI_EM_CHAIN_TX_QUEUE_NUM (4u)
+#endif /* TI_EM_LINUX */
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Preload disabled.
+ */
+#define TI_EM_PRELOAD_DISABLED (0u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Preload enabled.
+ */
+#define TI_EM_PRELOAD_ENABLED (1u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of devices on which the Open-EM can be executed.
+ */
+#define TI_EM_DEVICE_NUM (4096u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of queue sets. Must be a power of 2.
+ */
+#define TI_EM_QUEUE_SET_NUM (256u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of queues in a set. TI_EM_QUEUE_SET_NUM * TI_EM_QUEUE_NUM_IN_SET <= TI_EM_QUEUE_NUM_MAX.
+ */
+#define TI_EM_QUEUE_NUM_IN_SET (8u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of queues.
+ */
+#define TI_EM_QUEUE_NUM_MAX (16384u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Number of static queues in a set. TI_EM_QUEUE_SET_NUM*TI_EM_STATIC_QUEUE_NUM_IN_SET <= TI_EM_STATIC_QUEUE_NUM_MAX
+ */
+#define TI_EM_STATIC_QUEUE_NUM_IN_SET (2u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of static queues. TI_EM_STATIC_QUEUE_NUM_MAX <= TI_EM_QUEUE_NUM_MAX.
+ */
+#define TI_EM_STATIC_QUEUE_NUM_MAX (256u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of execution objects.
+ */
+#define TI_EM_EO_NUM_MAX (TI_EM_QUEUE_NUM_MAX)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of event groups.
+ */
+#define TI_EM_EVENT_GROUP_NUM_MAX (16384u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of queue groups.
+ */
+#define TI_EM_QUEUE_GROUP_NUM_MAX (TI_EM_PRIO_NUM * TI_EM_CORE_NUM)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Alignment of QM queue base index
+ */
+#define TI_EM_HW_QUEUE_STEP (32u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of XGE streams.
+ */
+#define TI_EM_STREAM_NUM (256u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Size (in bytes) of the XGE header.
+ */
+#define TI_EM_XGE_ENET_HEADER_SIZE (18u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Size (in bytes) of the XGE header.
+ */
+#define TI_EM_XGE_CHAIN_HEADER_SIZE (8u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Size (in bytes) of the XGE header (18+8=26).
+ */
+#define TI_EM_XGE_HEADER_SIZE (TI_EM_XGE_ENET_HEADER_SIZE + TI_EM_XGE_CHAIN_HEADER_SIZE)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Minimal size (in bytes) of the XGE frame.
+ */
+#define TI_EM_XGE_FRAME_SIZE_MIN (64u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Size (in bytes) of the CRC added by XGE.
+ */
+#define TI_EM_XGE_CRC_SIZE (4)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Minimum size (in bytes) of the fragment size (64 - 26 - 4 = 34 Bytes).
+ */
+#define TI_EM_XGE_PAYLOAD_SIZE_MIN (TI_EM_XGE_FRAME_SIZE_MIN - TI_EM_XGE_HEADER_SIZE - TI_EM_XGE_CRC_SIZE )
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Minimal size (in bytes) to be allocated for the XGE RX fragment buffer (34 + 4 = 38).
+ */
+#define TI_EM_XGE_RX_FRAGMENT_SIZE_MIN (TI_EM_XGE_PAYLOAD_SIZE_MIN + TI_EM_XGE_CRC_SIZE)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Size (in bytes) to be allocated for the XGE TX header buffer (26 + 34 = 60).
+ */
+#define TI_EM_XGE_TX_HEADER_SIZE (TI_EM_XGE_HEADER_SIZE + TI_EM_XGE_PAYLOAD_SIZE_MIN)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Size (in bytes) to be allocated for the XGE RX header buffer (26).
+ */
+#define TI_EM_XGE_RX_HEADER_SIZE (TI_EM_XGE_HEADER_SIZE)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Size (in bytes) to be allocated for the XGE TX fragment buffer
+ */
+#define TI_EM_XGE_TX_FRAGMENT_SIZE 0
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of contiguous XGE TX queues
+ */
+#define TI_EM_XGE_TX_QUEUE_NUM (1u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Number of VLAN priorities that need to be reserved for chaining over XGE
+ */
+#define TI_EM_XGE_VLAN_PRIO_NUM (8u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Number of contiguous RX miss queues that need to be reserved for chaining over XGE
+ */
+#define TI_EM_XGE_RX_MISS_QUEUE_NUM (TI_EM_XGE_VLAN_PRIO_NUM)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Number of contiguous TX divert queues that need to be reserved for chaining over XGE
+ */
+#define TI_EM_XGE_TX_DIVERT_QUEUE_NUM (32u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Total number of PKTDMA queues used by the EM
+ */
+#define TI_EM_DMA_QUEUE_NUM (TI_EM_CORE_NUM + 2)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Highest Priority
+ */
+#define TI_EM_PRIO_NUM (EM_QUEUE_PRIO_HIGHEST + 1)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Total number of queues used by the EM
+ */
+#define TI_EM_HW_QUEUE_NUM (11                        \
+                + TI_EM_PRIO_NUM                \
+                + (3 * TI_EM_CORE_NUM)            \
+                + (3 * TI_EM_CORE_NUM * TI_EM_PRIO_NUM)    \
+                + (TI_EM_CORE_NUM * TI_EM_PRIO_NUM * TI_EM_PF_LEN) \
+                + TI_EM_XGE_VLAN_PRIO_NUM)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Size for all the private token used by the EM
+ */
+#define TI_EM_PRIVATE_EVENT_DSC_SIZE (16u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Multi-core Navigator PDSP memory size to allocated for
+ * private events and private firmware data.
+ */
+#define TI_EM_PDSP_GLOBAL_DATA_SIZE (8192u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of AP private tokens used by the EM
+ */
+#define TI_EM_AP_PRIVATE_EVENT_NUM (256u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of CD private tokens used by the EM
+ */
+#define TI_EM_CD_PRIVATE_EVENT_NUM (64u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Trace scope for the em_alloc API.
+ *
+ */
+#define TI_EM_TSCOPE_ALLOC (1)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Trace scope for the em_send API.
+ *
+ */
+#define TI_EM_TSCOPE_SEND (2)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Trace scope for the ti_em_dispatch_once API.
+ *
+ */
+#define TI_EM_TSCOPE_DISPATCH (3)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Trace scope for the ti_em_preschedule API.
+ *
+ */
+#define TI_EM_TSCOPE_PRESCHEDULE (4)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Trace scope for the ti_em_claim_local API.
+ *
+ */
+#define TI_EM_TSCOPE_CLAIM_LOCAL (5)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Trace scope for the em_atomic_processing_end API.
+ *
+ */
+#define TI_EM_TSCOPE_ATOMIC_PROCESSING_END (6)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Trace scope for the em_free API.
+ *
+ */
+#define TI_EM_TSCOPE_FREE (7)
+
+/**
+ * @ingroup DOC_api_specific
+ * 
+ * Major event types (portable) : Data Preloading Off
+ * @note Application should always ignore the actual values.
+ */
+#define TI_EM_EVENT_TYPE_PRELOAD_OFF (0u)
+
+/**
+ * @ingroup DOC_api_specific
+ * 
+ * Major event types (portable) : Data Preloading up to size A
+ * @note Application should always ignore the actual values.
+ */
+#define TI_EM_EVENT_TYPE_PRELOAD_ON_SIZE_A (1u<<6)
+
+/**
+ * @ingroup DOC_api_specific
+ * 
+ * Major event types (portable) : Data Preloading up to size B
+ * @note Application should always ignore the actual values.
+ */
+#define TI_EM_EVENT_TYPE_PRELOAD_ON_SIZE_B (2u<<6)
+
+/**
+ * @ingroup DOC_api_specific
+ * 
+ * Major event types (portable) : Data Preloading up to size C
+ * @note Application should always ignore the actual values.
+ */
+#define TI_EM_EVENT_TYPE_PRELOAD_ON_SIZE_C (3u<<6)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Event type preload mask.
+ *
+ */
+#define TI_EM_EVENT_TYPE_PRELOAD_MSK (0xC0)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Buffer mode - Tight buffer
+ */
+#define TI_EM_BUF_MODE_GLOBAL_TIGHT (0)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Buffer mode - Loose buffer
+ */
+#define TI_EM_BUF_MODE_GLOBAL_LOOSE (1)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Buffer mode - Local buffer
+ */
+#define TI_EM_BUF_MODE_LOCAL (2)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Cache coherency mode - Off
+ */
+#define TI_EM_COH_MODE_OFF (0x0)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Cache coherency mode - On
+ */
+#define TI_EM_COH_MODE_ON (0x1)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Cache coherency mode - Reserved0
+ */
+#define TI_EM_COH_MODE_RESERVED0 (0x2)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Cache coherency mode - Reserved1
+ */
+#define TI_EM_COH_MODE_RESERVED1 (0x3)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Queue associated with a scheduling (SD) queue.
+ */
+#define TI_EM_QUEUE_MODE_SD (0u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Queue associated with an hardware (HW) queue.
+ */
+#define TI_EM_QUEUE_MODE_HW (1u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Push policy to tail
+ */
+#define TI_EM_PUSH_POLICY_TAIL (0x0)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Push policy to head
+ */
+#define TI_EM_PUSH_POLICY_HEAD (0x1)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * ID for the various chaining mechanisms (i.e. chaining modules)
+ */
+#define TI_EM_CHAINING_PKTDMA    (0)
+#define TI_EM_CHAINING_XGE       (1)
+#define TI_EM_CHAINING_RIO       (2)
+#define TI_EM_CHAINING_POSTSTORE (3)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Definitions of the various PDSP communication memory slots
+ */
+#define TI_EM_SLOT_SPCB        (0)
+#define TI_EM_SLOT_RPCB        (1)
+#define TI_EM_SLOT_SPSB        (2)
+#define TI_EM_SLOT_RPSB        (3)
+#define TI_EM_SLOT_RDCB        (4)
+#define TI_EM_SLOT_ESB         (5 + DNUM)
+
+/*
+ * @ingroup DOC_api_specific
+ * 
+ * These are the different memory mappings for I/O, descriptors or PDSP memory
+ */
+#define TI_EM_MEM_NONE         (0)
+#define TI_EM_MEM_QMSS_REGS    (1)
+#define TI_EM_MEM_PDSP_DRAM    (2)
+#define TI_EM_MEM_PUBLIC_DESC  (3)
+#define TI_EM_MEM_LOCAL_DESC   (4)
+#define TI_EM_MEM_PRIVATE_DESC (5)
+#define TI_EM_MEM_PDSP_COMM    (6)
+#define TI_EM_MEM_BUFFER       (7)
+#define TI_EM_MEM_NUM          (TI_EM_BUFFER_POOL_ID_NUM + TI_EM_MEM_BUFFER) /* total number of available mappings */
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of pool Id that can be set in the event descriptor pool index field (8 bits)
+ */
+#define TI_EM_BUFFER_POOL_ID_NUM (256u)
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Enable/disable PDSP interrupt generation
+ */
+#define TI_EM_INTERRUPT_DISABLE (0)
+#define TI_EM_INTERRUPT_ENABLE  (1)
+
+#endif /*EVENT_MACHINE_HW_TI_MACROS_H_*/
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_ti_types.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_ti_types.h
new file mode 100644
index 0000000..ebb2b7b
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_ti_types.h
@@ -0,0 +1,792 @@ 
+/*
+ * Copyright (c) 2012, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ * @file: event_machine_hw_ti_types.h
+ *
+ * @brief
+ *    Open Event Machine HW TI specific type definitions
+ *
+ */
+
+#ifndef EVENT_MACHINE_HW_TI_TYPES_H_
+#define EVENT_MACHINE_HW_TI_TYPES_H_
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * typedef associated with ti_em_config_t_
+ */
+typedef struct ti_em_config_t_ ti_em_config_t;
+typedef struct ti_em_chain_config_t_ ti_em_chain_config_t;
+typedef struct ti_em_chain_xge_config_t_ ti_em_chain_xge_config_t;
+typedef struct ti_em_chain_rio_config_t_ ti_em_chain_rio_config_t;
+typedef struct ti_em_preload_config_t_ ti_em_preload_config_t;
+typedef struct ti_em_poststore_config_t_ ti_em_poststore_config_t;
+typedef struct ti_em_device_xge_route_t_ ti_em_device_xge_route_t;
+typedef struct ti_em_device_rio_route_t_ ti_em_device_rio_route_t;
+typedef struct ti_em_buffer_config_t_ ti_em_buffer_config_t;
+typedef struct ti_em_pool_config_t_ ti_em_pool_config_t;
+typedef struct ti_em_pair_t_ ti_em_pair_t;
+typedef struct ti_em_iterator_t_ ti_em_iterator_t; 
+typedef struct ti_em_process_route_t_ ti_em_process_route_t; 
+
+#include <inttypes.h>
+#include <stdlib.h>
+#include <event_machine_hw_types.h>
+#include <event_machine_hw_ti_macros.h>
+#include <event_machine_sw_ti_config.h>
+#include <src/event_machine_hwpform.h>
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Packet.
+ * Identifies the packet of the event.
+ *
+ */
+typedef uint32_t ti_em_packet_t;
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Event queue id.
+ * Identifies the event queue.
+ *
+ */
+typedef uint16_t ti_em_queue_id_t;
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * DMA id.
+ * Identifies the DMA.
+ *
+ */
+typedef uint32_t ti_em_dma_id_t;
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * flow id.
+ * Identifies the flow.
+ *
+ */
+typedef uint32_t ti_em_flow_id_t;
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Hardware semaphore id.
+ * Identifies the hardware semaphore.
+ *
+ */
+typedef uint32_t ti_em_sem_id_t;
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Openem process id.
+ * Identifies the openem process.
+ *
+ */
+typedef uint8_t ti_em_process_id_t;
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Openem process type.
+ * Identifies the openem process type.
+ *
+ */
+typedef uint32_t ti_em_process_type_t;
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Pdsp id.
+ * Identifies the Pdsp.
+ *
+ */
+typedef uint8_t ti_em_pdsp_id_t;
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Device id.
+ * Identifies the device.
+ *
+ */
+typedef uint32_t ti_em_device_id_t;
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Destination id.
+ * Identifies the destination for a route. It may be a ti_em_process_id_t or
+ * a ti_em_device_id_t.
+ */
+typedef uint32_t ti_em_destination_id_t;
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Stream id.
+ * Identifies the stream.
+ *
+ */
+typedef uint32_t ti_em_stream_id_t;
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Trace scope.
+ * Identifies the scope for interpreting trace codes and variable arguments
+ *
+ */
+typedef uint32_t ti_em_tscope_t;
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Cache Coherency mode.
+ * Identifies the data buffer cache coherency mode.
+ *
+ */
+typedef uint32_t ti_em_coh_mode_t;
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ *
+ * Identifies the event buffer mode.
+ *
+ */
+typedef uint32_t ti_em_buf_mode_t;
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ *
+ * Identifies the push policy.
+ *
+ */
+typedef uint32_t ti_em_push_policy_t;
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Identifies the Interrupt index.
+ *
+ */
+typedef uint8_t ti_em_interrupt_id_t;
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Identifies the Queue Mode.
+ *
+ */
+typedef uint8_t ti_em_queue_mode_t;
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Free funtion handler.
+ * 
+ * @param buffer_ptr        buffer pointer
+ * @param buffer_size       buffer size
+ *
+ */
+typedef void (*ti_em_free_func_t)(void* buffer_ptr, size_t buffer_size);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Trace function handler.
+ * 
+ * @param tscope        Error scope. Identifies the scope for interpreting the error code and variable arguments
+ * @param args          Variable number and type of arguments
+ *
+ * @return The function may not return depending on implementation.
+ *
+ * @see em_register_trace_handler(), em_unregister_trace_handler()
+ */
+typedef em_status_t (*ti_em_trace_handler_t)(ti_em_tscope_t tscope, ...);
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ *
+ * Identifies the iterator type.
+ *
+ * @details This describes the array of iterator fields.
+ *
+ */
+struct ti_em_iterator_t_ 
+{
+    /**
+      * array of iterator fields
+      */
+    uint32_t body[TI_EM_ITERATOR_WSIZE];
+}; 
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Data buffer pool configuration.
+ *
+ * @details This describes the data buffer pool configurable parameters which are required.
+ */
+struct ti_em_pool_config_t_
+{
+    /**
+      * Number of bytes used for storing a buffer
+      */
+    size_t buf_size;
+
+    /**
+      * Number of words used for storing a descriptor
+      */
+    size_t dsc_wsize;
+    
+    /**
+      * Event machine pool buffer mode
+      */
+    ti_em_buf_mode_t buf_mode;
+
+    /**
+      * Event machine pool free queues
+      */
+    uint16_t free_queue_idx;
+};
+
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Buffer parameters.
+ *
+ * @details This describes the buffer configurable parameters which are required.
+ */
+struct ti_em_buffer_config_t_
+{
+    /**
+      * Buffer pointer
+      */
+    void* buffer_ptr;
+
+    /**
+      * Buffer size
+      */
+    size_t buffer_size;
+
+    /**
+      * Original buffer pointer
+      */
+    void* orig_buffer_ptr;
+
+    /**
+      * Original buffer size
+      */
+    size_t orig_buffer_size;
+
+   /**
+      * Original buffer pool id 
+      */
+    uint32_t orig_buffer_pool;
+
+    /**
+      * Buffer coherency mode
+      */
+    ti_em_coh_mode_t coh_mode;
+
+    /**
+      * Buffer free function
+      */
+    ti_em_free_func_t free_func;
+
+    /**
+      * Event machine pool free push policy
+      */
+    ti_em_push_policy_t free_push_policy;
+};
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Event Machine hardware configuration.
+ *
+ * @details This describes the EM configurable parameters which are required.
+ */
+#ifndef TI_EM_GCC
+#pragma STRUCT_ALIGN (ti_em_config_t_, 64);
+#pragma STRUCT_ALIGN (ti_em_config_t_, 64)
+#endif
+struct ti_em_config_t_
+{
+    /**
+      * Pointer to the chaining configuration.
+      */
+    ti_em_chain_config_t* chain_config_ptr;
+
+    /**
+      * Pointer to the preload configuration.
+      */
+    ti_em_preload_config_t* preload_config_ptr;
+
+    /**
+      * Index for Packet DMA flows configuration. It has to map to a Multicore Navigator infrastructure Packet DMA.
+      */
+    ti_em_dma_id_t  dma_idx;
+
+    /**
+      * Index of the first DMA queue that will be used by the TI EM.
+      */
+    uint16_t dma_queue_base_idx;
+
+    /**
+      * Index of the 1st hardware queue that will be used by the TI EM.
+      */
+    uint16_t hw_queue_base_idx;
+
+    /**
+      * Hardware Semaphore used to protect internal data structures.
+      */
+    uint32_t hw_sem_idx;
+
+    /**
+     * @brief   Identifies the device on which this OpenEM instance is running.
+     */
+    ti_em_device_id_t my_device_idx;
+
+    /**
+     * @brief   Identifies the process in which this OpenEM instance is running.
+     */
+    ti_em_process_id_t my_process_idx;
+
+    /**
+      * Indexes of the pdsp threads running the FW scheduler.
+      */
+    ti_em_pdsp_id_t  pdsp_idx_tbl[TI_EM_SCHEDULER_THREAD_NUM];
+
+    /**
+      * pool configuration descriptors.
+      */
+    ti_em_pool_config_t pool_config_tbl[TI_EM_POOL_NUM];
+
+    /**
+     * Number of pools
+     */
+    uint32_t pool_num;
+
+    /**
+      * Hardware queue containing the private events used for Atomic Processing.
+      * This queue shall contain at least 256 private events.
+      */
+    ti_em_queue_id_t ap_region_queue_idx;
+
+    /**
+      * Hardware queue containing the private events used for Command Processing.
+      * This queue shall contain at least 32 private events.
+      * This queue may be the same as ap_region_queue_idx.
+      */
+    ti_em_queue_id_t cd_region_queue_idx;
+
+    /**
+      * Number of pdsp instances running the FW scheduler.
+      */
+    uint8_t pdsp_num;
+
+    /**
+      * Identifies the interrupt base index on which the scheduler will notify dispatching.
+      */
+    ti_em_interrupt_id_t hw_interrupt_base_idx;
+
+#ifdef TI_EM_GCC
+} __attribute__ ((aligned(CACHE_L1D_LINESIZE)));
+#else /* TI_EM_GCC */
+};
+#endif /* TI_EM_GCC */
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Event machine chaining configuration.
+ *
+ * @details This describes the EM configurable parameters which are required for the chaining.
+ */
+#ifndef TI_EM_GCC
+#pragma STRUCT_ALIGN (ti_em_chain_config_t_, 64);
+#pragma STRUCT_ALIGN (ti_em_chain_config_t_, 64)
+#endif
+struct ti_em_chain_config_t_
+{
+    /**
+      * Identifies the pool used for allocating very small events (event size <= size A).
+      * Size A corresponds to the buffer size of the pool.
+      * The received event uses one buffer from the pool.
+      */
+    em_pool_id_t pool_idx_size_a;
+
+    /**
+      * Identifies the pool used for allocating small events (size A <= event size <= size B).
+      * Size B corresponds to the buffer size of the pool.
+      * The received event uses one buffer from the pool.
+      */
+    em_pool_id_t pool_idx_size_b;
+
+    /**
+      * Identifies the pool used for allocating big events (size B <= event size <= size C).
+      * Size C corresponds to the buffer size of the pool.
+      * The received event uses one buffer from the pool.
+      */
+    em_pool_id_t pool_idx_size_c;
+
+    /**
+      * Identifies the pool used for allocating very big events (size C <= event size <= size D).
+      * Size D corresponds to the buffer size of the pool.
+      * The received event uses one buffer from the pool.
+      */
+    em_pool_id_t pool_idx_size_d;
+
+    /**
+      * Identifies the pool used for allocating even bigger events (size D <= event size).
+      * The received event uses one buffer (first) from the pool 'pool_idx_size_d'.
+      * The received event uses one or more buffers (second and next) from the pool 'pool_idx_overflow'.
+      */
+    em_pool_id_t pool_idx_overflow;
+
+    /**
+      * Pointer to the SRIO Configuration.
+      */
+    ti_em_chain_rio_config_t* rio_config_ptr;
+
+    /**
+      * Pointer to the 10 Gigabit Configuration.
+      */
+    ti_em_chain_xge_config_t* xge_config_ptr;
+
+    /**
+      * Pointer to the post-storing configuration.
+      */
+    ti_em_poststore_config_t* poststore_config_ptr;
+
+    /**
+      * Index for Packet DMA flows configuration. It has to map to a Multicore Navigator infrastructure Packet DMA.
+      */
+    ti_em_dma_id_t dma_idx;
+
+    /**
+      * Identifies the first relative DMA TX queue index used for the chaining flows.
+      */
+    ti_em_queue_id_t dma_tx_queue_base_idx;
+
+#ifdef TI_EM_GCC
+} __attribute__ ((aligned(CACHE_L1D_LINESIZE)));
+#else /* TI_EM_GCC */
+};
+#endif /* TI_EM_GCC */
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Event machine chaining configuration for xge.
+ *
+ * @details This describes the EM configurable parameters which are required for the chaining over xge.
+ */
+#ifndef TI_EM_GCC
+#pragma STRUCT_ALIGN (ti_em_chain_xge_config_t_, 64);
+#pragma STRUCT_ALIGN (ti_em_chain_xge_config_t_, 64)
+#endif
+struct ti_em_chain_xge_config_t_
+{
+    /**
+      * Index for Packet DMA flows configuration. It has to map to a Multicore Navigator infrastructure Packet DMA.
+      */
+    ti_em_dma_id_t dma_idx;
+
+    /**
+      * Specifies the Ethernet type.
+      */
+    uint8_t ether_type[2];
+
+    /**
+      * Specifies the MAC address of the device on which this OpenEM instance is running.
+      */
+    uint8_t my_mac_address[6];
+
+    /**
+      * Identifies the free queue for RX fragments.
+      */
+    ti_em_queue_id_t rx_fragment_free_queue_idx;
+
+    /**
+      * Identifies the free queue for RX headers.
+      */
+    ti_em_queue_id_t rx_header_free_queue_idx;
+
+    /**
+     * Identifies the first of TI_EM_XGE_VLAN_PRIO_NUM XGE RX miss queues
+     */
+     ti_em_queue_id_t rx_miss_queue_base_idx;
+    
+    
+    /**
+      * Identifies the free queue for TX fragments (without buffers).
+      */
+    ti_em_queue_id_t tx_fragment_free_queue_idx;
+
+    /**
+      * Identifies the free queue for TX headers
+      */
+    ti_em_queue_id_t tx_header_free_queue_idx;
+
+    /**
+      * Identifies the base index for the OpenEM instance to allocate the XGE TX divert queue.
+      */
+    ti_em_queue_id_t tx_divert_queue_base_idx;
+
+    /**
+      * Identifies a PDSP running the chaining firmware.
+      */
+    ti_em_pdsp_id_t pdsp_idx;
+
+    /**
+      * Specifies the VLAN priority Mask.
+      */
+    uint8_t vlan_prio_mask;
+#ifdef TI_EM_GCC
+} __attribute__ ((aligned(CACHE_L1D_LINESIZE)));
+#else /* TI_EM_GCC */
+};
+#endif /* TI_EM_GCC */
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Event machine chaining configuration for SRIO.
+ *
+ * @details This describes the EM configurable parameters which are required for the chaining over SRIO.
+ */
+#ifndef TI_EM_GCC
+#pragma STRUCT_ALIGN (ti_em_chain_rio_config_t_, 64);
+#pragma STRUCT_ALIGN (ti_em_chain_rio_config_t_, 64)
+#endif
+struct ti_em_chain_rio_config_t_
+{
+    /**
+      * Index for Packet DMA flows configuration. It has to map to a Multicore Navigator infrastructure Packet DMA.
+      */
+    ti_em_dma_id_t dma_idx;
+
+    /**
+      * Index for SRIO tx queue.
+      */
+    ti_em_queue_id_t dma_tx_queue_idx;
+    
+    /**
+      * Specifies the SRIO node index
+      */
+    uint8_t my_node_idx[2];
+    
+    /**
+      * Specifies the Service Class
+      */
+    uint8_t service_class;
+#ifdef TI_EM_GCC
+} __attribute__ ((aligned(CACHE_L1D_LINESIZE)));
+#else /* TI_EM_GCC */
+};
+#endif /* TI_EM_GCC */
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Event machine preload configuration.
+ *
+ * @details This describes the EM configurable parameters which are required for the preload.
+ */
+#ifndef TI_EM_GCC
+#pragma STRUCT_ALIGN (ti_em_preload_config_t_, 64);
+#pragma STRUCT_ALIGN (ti_em_preload_config_t_, 64)
+#endif
+struct ti_em_preload_config_t_
+{
+    /**
+      * Identifies the preload free queues.
+      */
+    ti_em_queue_id_t local_free_queue_idx_tbl[TI_EM_CORE_NUM];
+
+    /**
+      * Specifies the maximum number of bytes to preload if event type matches TI_EM_EVENT_TYPE_PRELOAD_ON_SIZE_A.
+      * Must be more than 0 and less than or equal to 8Kbytes.
+      */
+    size_t preload_size_a;
+
+    /**
+      * Specifies the maximum number of bytes to preload if event type matches TI_EM_EVENT_TYPE_PRELOAD_ON_SIZE_B.
+      * Must be more than 0 and less than or equal to 8Kbytes.
+      */
+    size_t preload_size_b;
+
+    /**
+      * Specifies the maximum number of bytes to preload if event type matches TI_EM_EVENT_TYPE_PRELOAD_ON_SIZE_B.
+      * Must be more than 0 and less than or equal to 1Mbytes.
+      */
+    size_t preload_size_c;
+#ifdef TI_EM_GCC
+} __attribute__ ((aligned(CACHE_L1D_LINESIZE)));
+#else /* TI_EM_GCC */
+};
+#endif /* TI_EM_GCC */
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Event machine post-storing configuration.
+ *
+ * @details This describes the EM configurable parameters which are required for the post-storing.
+ */
+#ifndef TI_EM_GCC
+#pragma STRUCT_ALIGN (ti_em_poststore_config_t_, 64);
+#pragma STRUCT_ALIGN (ti_em_poststore_config_t_, 64)
+#endif
+struct ti_em_poststore_config_t_
+{
+    /**
+      * Identifies the post-storing free queues. Array entry allocations per core are (core index * 2) + 0 and (core index * 2) + 1.
+      */
+    ti_em_queue_id_t local_free_queue_idx_tbl[2 * TI_EM_CORE_NUM];
+
+    /**
+      * Identifies the post-storing heap pointers. Array entry allocations per core are (core index * 2) + 0 and (core index * 2) + 1.
+      */
+    void * local_heap_ptr_tbl[2 * TI_EM_CORE_NUM];
+
+    /**
+      * Specifies the maximum number of bytes to post-store.
+      */
+    size_t poststore_size_max;
+
+#ifdef TI_EM_GCC
+} __attribute__ ((aligned(CACHE_L1D_LINESIZE)));
+#else /* TI_EM_GCC */
+};
+#endif /* TI_EM_GCC */
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * ...
+ *
+ * @details This describes the parameters required to configure a route over the 10 Gigabit Ethernet (XGE).
+ */
+struct ti_em_device_xge_route_t_
+{
+    /**
+      * Specifies the size of an event fragment.
+      */
+    size_t fragmentSize;
+
+    /**
+      * Specifies the MAC address.
+      */
+    uint8_t mac_address[6];
+
+    /**
+      * Specifies the stream.
+      */
+    uint8_t stream_idx[2];
+
+    /**
+      * Specifies the VLAN tag.
+      * Must match the VLAN priority .
+      */
+    uint8_t vlan_tag[4];
+};
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * ...
+ *
+ * @details This describes the parameters required to configure a route over the Serial Rapid IO.
+ */
+struct ti_em_device_rio_route_t_
+{
+    /**
+      * Specifies the node index.
+      */
+    uint8_t node_idx[2];
+
+};
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Event handle pair.
+ *
+ * @details This describes the event handle pair when combining/splitting events.
+ *
+ */
+struct ti_em_pair_t_
+{
+    /**
+      * Event machine head event in the pair.
+      */
+    em_event_t head_event_hdl;
+    /**
+      * Event machine tail event in the pair.
+      */
+    em_event_t tail_event_hdl;
+};
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Event handle pair.
+ *
+ * @details This describes the parameters required to configure a route to another process.
+ *
+ */
+struct ti_em_process_route_t_
+{
+    /**
+      * Index for Packet DMA flows configuration. It has to map to infrastructure Packet DMA.
+      */
+    ti_em_dma_id_t dma_idx;
+    /**
+      * Identifies the relative DMA TX queue index used for the chaining flow.
+      */
+    ti_em_queue_id_t dma_tx_queue_idx;
+};
+
+#endif /*EVENT_MACHINE_HW_TI_TYPES_H_*/
+
+
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_types.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_types.h
new file mode 100644
index 0000000..b12b319
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_hw_types.h
@@ -0,0 +1,338 @@ 
+/*
+ *   Copyright (c) 2012, Nokia Siemens Networks
+ *   All rights reserved.
+ *
+ *   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 Nokia Siemens Networks 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.
+ */
+
+
+/**
+ *
+ * Contributors
+ *
+ * The initial developer of the original code is Nokia Siemens Networks.
+ *  The following contributors have made changes to 
+ *  the original code as described below.
+ * 
+ *----------------------------------------------------------------------------------------------
+ * Copyright (c) 2012, Texas Instruments Incorporated. All Rights Reserved. - http://www.ti.com/
+ * 
+ * From the original event_machine_hw_config.h.template , openem/event_machine_hw_types.h was
+ * created with:
+ *   - HW types definitions 
+ *   - Doxygen tags are added for API documentation generation.
+ *----------------------------------------------------------------------------------------------
+ *
+ */
+
+
+/*
+ *   Copyright (c) 2012, Nokia Siemens Networks
+ *   All rights reserved.
+ *
+ *   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 Nokia Siemens Networks 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.
+ */
+
+
+/**
+ *
+ * Contributors
+ *
+ * The initial developer of the original code is Nokia Siemens Networks.
+ *  The following contributors have made changes to 
+ *  the original code as described below.
+ * 
+ *----------------------------------------------------------------------------------------------
+ * Copyright (c) 2012, Texas Instruments Incorporated. All Rights Reserved. - http://www.ti.com/
+ *
+ * Elements of the Nokia Siemens Networks template files have been concatenated in this file and 
+ * configured to match TI implementation.
+ *----------------------------------------------------------------------------------------------
+ */
+
+ /**
+ * @file: event_machine_hw_types.h
+ *
+ * @brief
+ *    Open Event Machine HW specific types
+ *
+ */
+
+#ifndef EVENT_MACHINE_HW_TYPES_H
+#define EVENT_MACHINE_HW_TYPES_H
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+/*
+ *
+ * HW specific types
+ ***************************************
+ */
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * The structure describes the queue types
+ *
+ */
+typedef enum em_queue_type_e
+{
+
+    /**
+     * @brief Application receives events one by one, non-concurrently to guarantee exclusive processing and ordering
+     */
+    EM_QUEUE_TYPE_UNDEF            = 0,
+
+    /**
+     * @brief Application receives events one by one, non-concurrently to guarantee exclusive processing and ordering
+     */
+    EM_QUEUE_TYPE_ATOMIC           = 1,  
+
+    /**
+     * @brief Application may receive events fully concurrently, egress event ordering (when processed in parallel) not guaranteed
+     */
+    EM_QUEUE_TYPE_PARALLEL         = 2,  
+
+    /**
+     * @brief Application may receive events concurrently, but system takes care of egress order (between two queues)
+     */
+    EM_QUEUE_TYPE_PARALLEL_ORDERED = 3   
+
+} em_queue_type_e;
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * The structure describes the portable queue priorities
+ *
+ */
+typedef enum em_queue_prio_e
+{
+    /**
+     * @brief Undefined
+     */
+    
+    EM_QUEUE_PRIO_UNDEF    = 0xFF, 
+    /**
+     * @brief lowest priority
+     */
+    EM_QUEUE_PRIO_LOWEST   =  0,    
+    
+    /**
+     * @brief low priority
+     */
+     EM_QUEUE_PRIO_LOW     =  12,
+
+     /**
+     * @brief normal priority
+     */
+    EM_QUEUE_PRIO_NORMAL   =  13,
+    
+    /**
+     * @brief high priority
+     */
+    EM_QUEUE_PRIO_HIGH     =  14,
+    
+    /**
+     * @brief highest priority
+     */
+    EM_QUEUE_PRIO_HIGHEST  =  15
+
+} em_queue_prio_e;
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * The structure lists the error codes
+ *
+ */
+typedef enum em_status_e
+{
+
+    /**
+     * @brief Illegal context for this function call
+     */
+    EM_ERR_BAD_CONTEXT      = 1, 
+
+    /**
+     * @brief Illegal (eo, queue, ...) state for this function call
+     */
+    EM_ERR_BAD_STATE        = 2,   
+
+    /**
+     * @brief ID not from a valid range
+     */
+    EM_ERR_BAD_ID           = 3,   
+
+    /**
+     * @brief Resource allocation failed
+     */
+    EM_ERR_ALLOC_FAILED     = 4, 
+
+    /**
+     * @brief Resource already reserved by someone else
+     */
+    EM_ERR_NOT_FREE         = 5,   
+
+    /**
+     * @brief Resource not found
+     */
+    EM_ERR_NOT_FOUND        = 6,   
+
+    /**
+     * @brief Value over the limit
+     */
+    EM_ERR_TOO_LARGE        = 7, 
+
+    /**
+     * @brief Failure in a library function
+     */
+    EM_ERR_LIB_FAILED       = 8,
+
+    /**
+     * @brief Implementation missing (placeholder)
+     */
+    EM_ERR_NOT_IMPLEMENTED  = 9,
+
+    /**
+     * @brief Pointer from bad memory area (e.g. NULL)
+     */
+    EM_ERR_BAD_POINTER      = 10,
+
+
+    /**
+     * @brief Other error. This is the last error code (for bounds checking).
+     */
+    EM_ERR        
+
+} em_status_e;
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * The structure describes the major event types
+ *
+ */
+typedef enum em_event_type_major_e
+{
+
+    /**
+     * @brief
+     */
+    EM_EVENT_TYPE_UNDEF  = 0,
+
+    /**
+     * @brief event from SW (EO)
+     */
+    EM_EVENT_TYPE_SW     = 1 << 24,
+
+    /**
+     * @brief event from packet HW
+     */
+    EM_EVENT_TYPE_PACKET = 2 << 24, 
+
+    /**
+     * @brief event from timer HW
+     */
+    EM_EVENT_TYPE_TIMER  = 3 << 24, 
+
+    /**
+     * @brief event from crypto HW
+     */
+    EM_EVENT_TYPE_CRYPTO = 4 << 24 
+
+} em_event_type_major_e;
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * The structure describes the Minor event types for the major EM_EVENT_TYPE_SW type
+ *
+ */
+typedef enum em_event_type_sw_minor_e
+{
+
+    /**
+     * @brief
+     */
+    EM_EVENT_TYPE_SW_DEFAULT  = 1
+
+} em_event_type_sw_minor_e;
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Event type
+ *
+ * In Event Machine application processing is driven by events. An event 
+ * describes a piece of work. Structure of an event is implementation and
+ * event type specific. It may be a directly accessible buffer of memory, 
+ * a descriptor containing a list of buffer pointers, a descriptor of 
+ * a packet buffer, etc.
+ *
+ * Applications use event type to interpret the event structure.
+ *
+ * Since em_event_t may not carry a direct pointer value to the event
+ * structure, em_event_pointer() must be used to translate an event to
+ * an event structure pointer (for maintaining portability).
+ *
+ * @see em_event_pointer()
+
+ */
+typedef uint32_t em_event_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
+
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_macros.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_macros.h
new file mode 100644
index 0000000..fe7117f
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_macros.h
@@ -0,0 +1,514 @@ 
+/*
+ *   Copyright (c) 2012, Nokia Siemens Networks
+ *   All rights reserved.
+ *
+ *   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 Nokia Siemens Networks 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.
+ */
+
+
+/**
+ *
+ * Contributors
+ *
+ * The initial developer of the original code is Nokia Siemens Networks.
+ *  The following contributors have made changes to 
+ *  the original code as described below.
+ * 
+ *----------------------------------------------------------------------------------------------
+ * Copyright (c) 2012, Texas Instruments Incorporated. All Rights Reserved. - http://www.ti.com/
+ * 
+ * Changes were done on the original NSN header files in order to avoid 
+ * circular dependencies when called in the TI implementation files.
+ *
+ * From the original event_machine_types.h, openem/ti/event_machine_macros.h was
+ * created with:
+ *   - Constants definitions
+ *   - Doxygen tags are added for API documentation generation.
+ *----------------------------------------------------------------------------------------------
+ *
+ */
+
+
+/**
+ * @file: event_machine_macros.h
+ *
+ * @brief
+ *    Open Event Machine public constant definitions
+ */
+
+#ifndef EVENT_MACHINE_MACROS_H_
+#define EVENT_MACHINE_MACROS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <event_machine_hw_macros.h>
+
+#ifdef EM_64_BIT
+
+/*
+ * Printf formats
+ */
+/**
+ * @ingroup DOC_api_generic
+ *
+ * em_eo_t printf format 
+ */
+#define PRI_EO      PRIu64       
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * em_queue_t printf format 
+ */
+#define PRI_QUEUE   PRIu64
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * em_queue_group_t printf format 
+ */
+#define PRI_QGRP    PRIu64        
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Invalid EO id 
+ */
+#define EM_EO_UNDEF             EM_UNDEF_U64    
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Invalid queue 
+ */
+#define EM_QUEUE_UNDEF          EM_UNDEF_U64    
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Invalid queue group 
+ */
+#define EM_QUEUE_GROUP_UNDEF    EM_UNDEF_U64    
+
+
+#elif defined(EM_32_BIT)
+
+/*
+ * Printf formats
+ */
+/**
+ * @ingroup DOC_api_generic
+ *
+ * em_eo_t printf format          
+ */
+#define PRI_EO       PRIu32                     
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * em_queue_t printf format       
+ */
+#define PRI_QUEUE    PRIu32                     
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * em_queue_group_t printf format 
+ */
+#define PRI_QGRP     PRIu32                     
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Invalid EO id 
+ */
+#define EM_EO_UNDEF      EM_UNDEF_U32           
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Invalid queue 
+ */
+#define EM_QUEUE_UNDEF   EM_UNDEF_U32           
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Invalid queue group id 
+ */
+#define EM_QUEUE_GROUP_UNDEF     EM_UNDEF_U32   
+
+
+#else
+
+  #error Missing architecture definition. Define EM_64_BIT or EM_32_BIT!
+
+#endif
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Operation successful 
+ */
+#define EM_OK   0      
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Operation not successful 
+ */
+#define EM_ERROR 0xffffffff
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * All EM internal error scopes should have bit 31 set
+ * NOTE: High bit is RESERVED for EM internal escopes and should not be
+ * used by the application.
+ */
+#define EM_ESCOPE_BIT                  (0x80000000u)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Test if the error scope identifies an EM function (API or other internal)
+ */
+#define EM_ESCOPE(escope)              (EM_ESCOPE_BIT & (escope))
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Mask selects the high byte of the 32-bit escope
+ */
+#define EM_ESCOPE_MASK                 (0xFF000000)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * EM API functions error scope type
+ */
+#define EM_ESCOPE_API_TYPE             (0xFFu)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * EM API functions error scope mask
+ */
+#define EM_ESCOPE_API_MASK             (EM_ESCOPE_BIT | (EM_ESCOPE_API_TYPE << 24))
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Test if the error scope identifies an API function
+ */
+#define EM_ESCOPE_API(escope)          (((escope) & EM_ESCOPE_MASK) == EM_ESCOPE_API_MASK)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_create API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_CREATE                    (EM_ESCOPE_API_MASK | 0x0001)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_create_static API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_CREATE_STATIC             (EM_ESCOPE_API_MASK | 0x0002)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_delete API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_DELETE                    (EM_ESCOPE_API_MASK | 0x0003)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_enable API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_ENABLE                    (EM_ESCOPE_API_MASK | 0x0004)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_enable_all API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_ENABLE_ALL                (EM_ESCOPE_API_MASK | 0x0005)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_disable API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_DISABLE                   (EM_ESCOPE_API_MASK | 0x0006)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_disable_all API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_DISABLE_ALL               (EM_ESCOPE_API_MASK | 0x0007)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_set_context API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_SET_CONTEXT               (EM_ESCOPE_API_MASK | 0x0008)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_get_context API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_GET_CONTEXT               (EM_ESCOPE_API_MASK | 0x0009)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_get_name API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_GET_NAME                  (EM_ESCOPE_API_MASK | 0x000A)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_get_priority API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_GET_PRIORITY              (EM_ESCOPE_API_MASK | 0x000B)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_get_type API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_GET_TYPE                  (EM_ESCOPE_API_MASK | 0x000C)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_group_create API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_GET_GROUP                 (EM_ESCOPE_API_MASK | 0x000D)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_group_create API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_GROUP_CREATE              (EM_ESCOPE_API_MASK | 0x0101)
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_group_delete API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_GROUP_DELETE              (EM_ESCOPE_API_MASK | 0x0102)
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_group_modify API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_GROUP_MODIFY              (EM_ESCOPE_API_MASK | 0x0103)
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_group_find API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_GROUP_FIND                (EM_ESCOPE_API_MASK | 0x0104)
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_queue_group_mask API.
+ *
+ */
+#define EM_ESCOPE_QUEUE_GROUP_MASK                (EM_ESCOPE_API_MASK | 0x0105)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_eo_create API.
+ *
+ */
+#define EM_ESCOPE_EO_CREATE                       (EM_ESCOPE_API_MASK | 0x0201)
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_eo_delete API.
+ *
+ */
+#define EM_ESCOPE_EO_DELETE                       (EM_ESCOPE_API_MASK | 0x0202)
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_eo_get_name API.
+ *
+ */
+#define EM_ESCOPE_EO_GET_NAME                     (EM_ESCOPE_API_MASK | 0x0203)
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_eo_add_queue API.
+ *
+ */
+#define EM_ESCOPE_EO_ADD_QUEUE                    (EM_ESCOPE_API_MASK | 0x0204)
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_eo_remove_queue API.
+ *
+ */
+#define EM_ESCOPE_EO_REMOVE_QUEUE                 (EM_ESCOPE_API_MASK | 0x0205)
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_eo_register_error_handler API.
+ *
+ */
+#define EM_ESCOPE_EO_REGISTER_ERROR_HANDLER       (EM_ESCOPE_API_MASK | 0x0206)
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_eo_unregister_error_handler API.
+ *
+ */
+#define EM_ESCOPE_EO_UNREGISTER_ERROR_HANDLER     (EM_ESCOPE_API_MASK | 0x0207)
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_eo_start API.
+ *
+ */
+#define EM_ESCOPE_EO_START                        (EM_ESCOPE_API_MASK | 0x0208)
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_eo_stop API.
+ *
+ */
+#define EM_ESCOPE_EO_STOP                         (EM_ESCOPE_API_MASK | 0x0209)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_core_id API.
+ *
+ */
+#define EM_ESCOPE_CORE_ID                         (EM_ESCOPE_API_MASK | 0x0301)
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_core_count API.
+ *
+ */
+#define EM_ESCOPE_CORE_COUNT                      (EM_ESCOPE_API_MASK | 0x0302)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_alloc API.
+ *
+ */
+#define EM_ESCOPE_ALLOC                           (EM_ESCOPE_API_MASK | 0x0401)
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_free API.
+ *
+ */
+#define EM_ESCOPE_FREE                            (EM_ESCOPE_API_MASK | 0x0402)
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_send API.
+ *
+ */
+#define EM_ESCOPE_SEND                            (EM_ESCOPE_API_MASK | 0x0403)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_atomic_processing_end API.
+ *
+ */
+#define EM_ESCOPE_ATOMIC_PROCESSING_END           (EM_ESCOPE_API_MASK | 0x0404)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_register_error_handler API.
+ *
+ */
+#define EM_ESCOPE_REGISTER_ERROR_HANDLER          (EM_ESCOPE_API_MASK | 0x0501)
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_unregister_error_handler API.
+ *
+ */
+#define EM_ESCOPE_UNREGISTER_ERROR_HANDLER        (EM_ESCOPE_API_MASK | 0x0502)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope for the em_error API.
+ *
+ */
+#define EM_ESCOPE_ERROR                           (EM_ESCOPE_API_MASK | 0x0503)
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Size of the core mask in bits
+ */
+#define EM_CORE_MASK_SIZE  64
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* EVENT_MACHINE_MACROS_H_ */
+
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_sw.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_sw.h
new file mode 100644
index 0000000..4c284ac
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_sw.h
@@ -0,0 +1,54 @@ 
+/*
+ * Copyright (c) 2012, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ * @file: event_machine_sw.h
+ *
+ * @brief
+ *    Open Event Machine SW public include file
+ *
+ */
+
+#ifndef EVENT_MACHINE_SW_H
+#define EVENT_MACHINE_SW_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <event_machine_sw_config.h>
+
+#include <event_machine_sw_ti.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* EVENT_MACHINE_SW_H */
+
+
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_sw_config.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_sw_config.h
new file mode 100644
index 0000000..1cf5913
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_sw_config.h
@@ -0,0 +1,155 @@ 
+/*
+ *   Copyright (c) 2012, Nokia Siemens Networks
+ *   All rights reserved.
+ *
+ *   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 Nokia Siemens Networks 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.
+ */
+
+
+/**
+ *
+ * Contributors
+ *
+ * The initial developer of the original code is Nokia Siemens Networks.
+ *  The following contributors have made changes to 
+ *  the original code as described below.
+ * 
+ *----------------------------------------------------------------------------------------------
+ * Copyright (c) 2012, Texas Instruments Incorporated. All Rights Reserved. - http://www.ti.com/
+ * 
+ * From the original event_machine_hw_config.h.template , openem/event_machine_sw_config.h was
+ * created with:
+ *   - SW macro definitions with the TI optimized implementation values
+ *   - Doxygen tags are added for API documentation generation.
+ *----------------------------------------------------------------------------------------------
+ *
+ */
+
+
+/**
+ * @file: event_machine_sw_config.h
+ *
+ * @brief
+ *    Open Event Machine SW specific configuration
+ *
+ */
+
+#ifndef EVENT_MACHINE_SW_CONFIG_H
+#define EVENT_MACHINE_SW_CONFIG_H
+
+#include <event_machine_hw_ti_macros.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ *
+ * EM scaling
+ ***************************************
+ */
+
+
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Maximum number of queues supported by the event machine.
+ *
+ * @note This value can be modified by an application. But the event machine library needs to be recompiled.
+ *
+ */
+#define EM_MAX_QUEUES               (TI_EM_QUEUE_SET_NUM * TI_EM_QUEUE_NUM_IN_SET)
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Max queue name string length.
+ *
+ * @note This value can be modified by an application. But the event machine library needs to be recompiled.
+ *
+ */
+#define EM_QUEUE_NAME_LEN           (32)
+
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Maximum number of execution objects supported by the event machine. EM_MAX_EOS <= TI_EM_EO_NUM_MAX.
+ *
+ * @note This value can be modified by an application. But the event machine library needs to be recompiled.
+ *
+ */
+#define EM_MAX_EOS                  (256)
+
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Max EO name string lenght.
+ *
+ * @note This value can be modified by an application. But the event machine library needs to be recompiled.
+ */
+#define EM_EO_NAME_LEN              (32)
+
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Maximum number of event groups supported by the event machine. EM_MAX_EVENT_GROUPS <= TI_EM_EVENT_GROUP_NUM_MAX.
+ *
+ * @note This value can be modified by an application. But the event machine library needs to be recompiled.
+ *
+ */
+#define EM_MAX_EVENT_GROUPS         (1024)
+
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Maximum number of event notifications supported by one event group.
+ *
+ */
+#define EM_EVENT_GROUP_MAX_NOTIF    (8)
+
+
+/**
+ * @ingroup DOC_api_generic
+ * 
+ * Max queue group name string lenght.
+ *
+ * @note This value can be modified by an application. But the event machine library needs to be recompiled.
+ */
+#define EM_QUEUE_GROUP_NAME_LEN    (8u)
+
+
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_sw_ti.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_sw_ti.h
new file mode 100644
index 0000000..9d81ddc
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_sw_ti.h
@@ -0,0 +1,52 @@ 
+/*
+ * Copyright (c) 2012, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ * @file: event_machine_sw_ti.h
+ *
+ * @brief
+ *    Open Event Machine SW TI specific public include file
+ *
+ */
+
+#ifndef EVENT_MACHINE_SW_TI_H
+#define EVENT_MACHINE_SW_TI_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <event_machine_sw_ti_config.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* EVENT_MACHINE_SW_TI_H */
+
+
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_sw_ti_config.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_sw_ti_config.h
new file mode 100644
index 0000000..c5cc296
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_sw_ti_config.h
@@ -0,0 +1,49 @@ 
+/*
+ * Copyright (c) 2012, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ * @file: event_machine_sw_ti_config.h
+ *
+ * @brief
+ *    Open Event Machine SW TI specific constant definitions
+ *
+ */
+
+#ifndef EVENT_MACHINE_SW_TI_CONFIG_H_
+#define EVENT_MACHINE_SW_TI_CONFIG_H_
+
+/**
+ * @ingroup DOC_api_specific
+ *
+ * Maximum number of buffer pools that can be specified.
+ *
+ * @note This value can be modified by an application. But the event machine library needs to be recompiled.
+ */
+#define TI_EM_POOL_NUM                  (32u)
+
+#endif /*EVENT_MACHINE_SW_TI_CONFIG_H_*/
diff --git a/platform/linux-keystone2/prebuilts/openem/include/event_machine_types.h b/platform/linux-keystone2/prebuilts/openem/include/event_machine_types.h
new file mode 100644
index 0000000..5584c6c
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/event_machine_types.h
@@ -0,0 +1,549 @@ 
+/*
+ *   Copyright (c) 2012, Nokia Siemens Networks
+ *   All rights reserved.
+ *
+ *   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 Nokia Siemens Networks 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.
+ */
+
+
+/**
+ *
+ * Contributors
+ *
+ * The initial developer of the original code is Nokia Siemens Networks.
+ *  The following contributors have made changes to 
+ *  the original code as described below.
+ * 
+ *----------------------------------------------------------------------------------------------
+ * Copyright (c) 2012, Texas Instruments Incorporated. All Rights Reserved. - http://www.ti.com/
+ * 
+ * Changes were done on the original NSN header files in order to avoid 
+ * circular dependencies when called in the TI implementation files.
+ *
+ * This file is a merge of the type definitions from the original
+ * event_machine.h and event_machine_types.h files.
+ * The list of changes are:
+ *   - Doxygen tags are added for API documentation generation.
+ *----------------------------------------------------------------------------------------------
+ *
+ */
+
+
+/**
+ * @file: event_machine_types.h
+ *
+ * @brief
+ *    Open Event Machine basic types
+ */
+
+#ifndef EVENT_MACHINE_TYPES_H_
+#define EVENT_MACHINE_TYPES_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#include <inttypes.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <event_machine_macros.h>
+#include <event_machine_hw_types.h>
+
+#ifdef EM_64_BIT
+
+/*
+ * Optimize EM for 64 bit architecture
+ * =====================================
+ */
+
+ /* page  64 bit version */
+/**
+ *
+ * @page DOC_intro Introduction
+ * @section page_version 64 bit version
+ * This is documentation represent the 64 bit version of Event Machine API.
+ * Define EM_64_BIT or EM_32_BIT to select between 64 and 32 bit versions.
+ *
+ */
+
+
+/*
+ * Printf formats
+ */
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ *  Execution Object identifier
+ *
+ * @see em_eo_create() 
+ */
+typedef uint64_t em_eo_t;
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Queue identifier
+ *
+ * @see em_queue_create(), em_receive_func_t(), em_send()
+ */
+typedef uint64_t em_queue_t;
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Queue group identifier
+ *
+ * Each queue belongs to one queue group, that defines a core mask for scheduling
+ * events, i.e. define which cores participate in the load balancing. Group can
+ * also allow only a single core for no load balancing.
+ *
+ * Groups needs to be created as needed. One default group (EM_QUEUE_GROUP_DEFAULT)
+ * always exists, and that allows scheduling to all the cores running this execution
+ * binary instance.
+ *
+ * @see em_queue_group_create()
+ */
+typedef uint64_t em_queue_group_t;
+
+
+
+
+#elif defined(EM_32_BIT)
+/*
+ * Optimize EM for 32 bit architecture
+ * =====================================
+ */
+
+ /* @page page_version 32 bit version */
+
+/**
+ *
+ * @page DOC_intro Introduction
+ * @section page_version 32 bit version
+ * This is documentation represent the 32 bit version of Event Machine API.
+ * Define EM_64_BIT or EM_32_BIT to select between 64 and 32 bit versions.
+ *
+ */
+
+
+/* ************* 32 bit ************************ */
+
+
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Execution Object identifier
+ *
+ * @see em_eo_create() 
+ */
+typedef uint32_t em_eo_t;
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Queue identifier
+ *
+ * @see em_queue_create(), em_receive_func_t(), em_send()
+ */
+typedef uint32_t em_queue_t;
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Queue group identifier
+ *
+ * Each queue belongs to one queue group, that defines a core mask for scheduling
+ * events, i.e. define which cores participate in the load balancing. Group can
+ * also allow only a single core for no load balancing.
+ *
+ * Groups needs to be created as needed. One default group (EM_QUEUE_GROUP_DEFAULT)
+ * always exists, and that allows scheduling to all the cores running this execution
+ * binary instance.
+ *
+ * @see em_queue_group_create()
+ */
+typedef uint32_t em_queue_group_t;
+
+
+
+#else
+
+  #error Missing architecture definition. Define EM_64_BIT or EM_32_BIT!
+
+  /**
+   *
+   * @page page_version 64/32 bit version not selected
+   * This is documentation has not selected between 64/32 bit version of Event Machine API.
+   * Some types might be missing. Define EM_64_BIT or EM_32_BIT to select between 64 and 32 bit versions.
+   *
+   */
+   
+#endif
+
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error/Status code.
+ * EM_OK (0) is the general code for success, other values
+ * describe failed operation.
+ * 
+ * @see event_machine_hw_config.h, em_error_handler_t(), em_error()
+ */
+typedef uint32_t em_status_t;
+
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error scope.
+ *
+ * Identifies the error scope for interpreting error codes and variable arguments.
+ * 
+ * @see em_error_handler_t(), em_error()
+ */
+typedef uint32_t em_escope_t;
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Queue type.
+ *
+ * Affects the scheduling principle
+ *
+ * @see em_queue_create(), event_machine_hw_config.h
+ */
+typedef uint32_t em_queue_type_t;
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Queue priority class
+ *
+ * Queue priority defines a system dependent QoS class, not just an absolute
+ * priority. EM gives freedom to implement the actual scheduling disciplines
+ * and the corresponding numeric values as needed, i.e. the actual values are
+ * system dependent and thus not portable, but the 5 pre-defined enums
+ * (em_queue_prio_e) are always valid.
+ * Application platform or middleware needs to define and distribute the
+ * other available values.
+ *
+ * @see em_queue_create(), event_machine_hw_config.h
+ */
+typedef uint32_t em_queue_prio_t;
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Event type. This is given to application for each received
+ * event and also needed for event allocation.
+ * It's an integer, but split into major and minor part.
+ * major-field categorizes the event and minor is
+ * more detailed system specific description.
+ * Major-part will not change by HW, but minor can be HW/SW platform
+ * specific and thus could be split into more sub-fields as needed.
+ * Application should use the access functions for reading major 
+ * and minor part.
+ *
+ * The only event type with defined content is EM_EVENT_TYPE_SW with
+ * minor type 0, which needs to be portable (direct pointer to data).
+ *
+ * @see em_get_type_major(), em_get_type_minor(), em_receive_func_t()
+ */
+typedef uint32_t em_event_type_t;
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Memory pool id.
+ *
+ * Defines memory pool in em_alloc(). Default pool id is defined by
+ * EM_POOL_DEFAULT.
+ *
+ * @see em_alloc(), event_machine_hw_config.h
+ */
+typedef uint32_t em_pool_id_t;
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Type for queue group core mask.
+ * Each bit represents one core, core 0 is the lsb (1 << em_core_id())
+ * Note, that EM will enumerate the core identifiers to always start from 0 and
+ * be contiguous meaning the core numbers are not necessarily physical.
+ * This type can handle up to 64 cores.
+ * 
+ * @see em_queue_group_create()
+ */
+typedef union em_core_mask_t em_core_mask_t;
+
+union em_core_mask_t
+{
+  uint8_t   u8[EM_CORE_MASK_SIZE / 8];
+  uint16_t u16[EM_CORE_MASK_SIZE / 16];
+  uint32_t u32[EM_CORE_MASK_SIZE / 32];
+  uint64_t u64[EM_CORE_MASK_SIZE / 64];
+};
+
+
+
+
+
+/**
+ * \internal
+ *--------------------------------------------------------------------------
+ * Copyright (c) 2012, Texas Instruments Incorporated - http://www.ti.com/
+ * This part of file is a copy from the original event_machine.h 
+ *--------------------------------------------------------------------------
+ * \endinternal
+ */
+
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Notification structure allows user to define a notification event and
+ * destination queue pair. EM will notify user by sending the event into
+ * the queue.
+ */
+typedef struct em_notif_t
+{
+  em_event_t  event;  /**< User defined notification event */
+  em_queue_t  queue;  /**< Destination queue */
+
+} em_notif_t;
+
+
+
+/*
+ *
+ * From Event Machine to application interface (call-back functions)
+ * ----------------------------------------------------------------------------
+ * 
+ */
+
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Receive event
+ *
+ * Application receives events through the EO receive function. It implements main part of
+ * the application logic. EM calls the receive function when it has dequeued an event from one
+ * of the EO's queues. Application processes the event and returns immediately (in 
+ * run-to-completion fashion).
+ *
+ * On multicore systems several events (from the same or different queues) may be dequeued
+ * in parallel and thus same receive function may be executed concurrently on several cores.
+ * Parallel execution may be limited by queue group setup or using queues with atomic
+ * scheduling mode.
+ *
+ * EO and queue context pointers are user defined (in EO and queue creation time) and 
+ * may be used any way needed. For example, EO context may be used to store global EO state
+ * information, which is common to all queues and events. In addition, queue context may be
+ * used to store queue (or user data flow) specific state data. EM never touches the data, 
+ * just passes the pointers. 
+ *
+ * Event (handle) must be converted to an event structure pointer with em_event_pointer().
+ * Event type specifies the event structure, which is implementation or application specific.
+ * Queue id specifies the queue which the event was dequeued from.
+ *
+ * @param eo_ctx        EO context data. The pointer is passed in em_eo_create(), EM does not touch the data.
+ * @param event         Event handle
+ * @param type          Event type
+ * @param queue         Queue from which this event came from
+ * @param q_ctx         Queue context data. The pointer is passed in em_queue_set_context(), EM does not touch the data.
+ *
+ * @see em_event_pointer(), em_free(), em_alloc(), em_send(), em_queue_set_context(), em_eo_create()
+ */
+typedef void (*em_receive_func_t)(void* eo_ctx, em_event_t event, em_event_type_t type, em_queue_t queue, void* q_ctx);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Execution object start, global.
+ * 
+ * If load balancing/several cores share the EO, this function is called
+ * once on one core only (any). Purpose of this global start is to provide
+ * a placeholder for first level initialization, like allocating memory and
+ * initializing shared data. After this global start returns, the core local
+ * version (if defined), is called (see em_start_local_func_t below). If there
+ * is no core local start, then event dispatching is immediately enabled.
+ *
+ * If Execution object does not return EM_OK,
+ * the system will not call the core local init and will not enable event
+ * dispatching.
+ *
+ * This function should never be called directly from the application,
+ * but using the, which maintains state information!
+ *
+ * @param eo_ctx        Execution object internal state/instance data
+ * @param eo            Execution object id
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_eo_start(), em_eo_create()
+ */
+typedef em_status_t (*em_start_func_t)(void* eo_ctx, em_eo_t eo);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Execution object start, core local.
+ * 
+ * This is similar to the global start above, but this one is called after the
+ * global start has completed and is called on all cores.
+ *
+ * Purpose of this optional local start is to work as a placeholder for
+ * core local initialization, e.g. allocating core local memory for example.
+ * The global start is only called on one core. The use of local start is
+ * optional.
+ * Note, that application should never directly call this function, this
+ * will be called via em_eo_start().
+ *
+ * If this does not return EM_OK on all involved cores, the event dispatching
+ * is not enabled.
+ *
+ * @param eo_ctx        Execution object internal state/instance data
+ * @param eo            Execution object id
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_eo_start(), em_eo_create()
+ */
+typedef em_status_t (*em_start_local_func_t)(void* eo_ctx, em_eo_t eo);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Execution object stop, core local.
+ *
+ * If load balancing/several cores share the EO, this function is
+ * called once on each core before the global stop (reverse order of start).
+ * System disables event dispatching before calling this
+ * and also makes sure this does not get called before the core
+ * has been notified the stop condition for this EO (won't dispatch new events)
+ * Return value is only for logging purposes, EM does not use it currently.
+ *
+ * Note, that application should never directly call this stop function,
+ * em_eo_stop() will trigger this.
+ *
+ * @param eo_ctx        Execution object internal state data
+ * @param eo            Execution object id
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_eo_stop(), em_eo_create()
+ */
+typedef em_status_t (*em_stop_local_func_t)(void* eo_ctx, em_eo_t eo);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Execution object stop, global.
+ *
+ * If load balancing/several cores share the EO, this function is
+ * called once on one core (any) after the (optional) core local
+ * stop return on all cores.
+ * System disables event dispatching before calling this and also
+ * makes sure this does not get called before all cores have
+ * been notified the stop condition for this EO (can't dispatch new events)
+ * event if there is no core local stop defined.
+ * Return value is only for logging purposes, EM does not use it currently.
+ *
+ * Note, that application should never directly call this stop function,
+ * but use the em_eo_stop() instead, which maintains state information and
+ * guarantees synchronized operation.
+ *
+ * @param eo_ctx        Execution object internal state data
+ * @param eo            Execution object id
+ *
+ * @return EM_OK if successful.
+ *
+ * @see em_eo_stop(), em_eo_create()
+ */
+typedef em_status_t (*em_stop_func_t)(void* eo_ctx, em_eo_t eo);
+
+/**
+ * @ingroup DOC_api_generic
+ *
+ * Error handler.
+ *
+ * Error handler maybe called after EM notices an error or user have called em_error().
+ * 
+ * User can register EO specific and/or EM global error handlers. When an error is noticed, 
+ * EM calls EO specific error handler, if registered. If there's no EO specific handler registered 
+ * (for the EO) or the error is noticed outside of an EO context, EM calls the global error 
+ * handler (if registered). If no error handlers are found, EM just returns an error code depending on 
+ * the API function.
+ *
+ * Error handler is called with the original error code from the API call or em_error(). Error 
+ * scope identifies the source of the error and how the error code and variable arguments 
+ * should be interpreted (number of arguments and types).
+ *
+ * @param eo            Execution object id
+ * @param error         The error code
+ * @param escope        Error scope. Identifies the scope for interpreting the error code and variable arguments.
+ * @param args          Variable number and type of arguments
+ *
+ * @return The function may not return depending on implementation/error code/error scope. If it
+ * returns, it can return the original or modified error code or even EM_OK, if it could fix the problem.
+ *
+ * @see em_register_error_handler(), em_eo_register_error_handler()
+ */
+#ifndef TI_EM_GCC
+typedef em_status_t (*em_error_handler_t)(em_eo_t eo, em_status_t error, em_escope_t escope, va_list args);
+#else /* TI_EM_GCC */
+typedef em_status_t (*em_error_handler_t)(em_eo_t eo, em_status_t error, em_escope_t escope, ...);
+#endif /* TI_EM_GCC */
+
+
+/**
+ * \internal
+ *--------------------------------------------------------------------------
+ * Copyright (c) 2012, Texas Instruments Incorporated - http://www.ti.com/
+ * End of the copy from the original event_machine.h 
+ *--------------------------------------------------------------------------
+ * \endinternal
+ */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* EVENT_MACHINE_TYPES_H_ */
+
diff --git a/platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_cppi.h b/platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_cppi.h
new file mode 100644
index 0000000..13df8a7
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_cppi.h
@@ -0,0 +1,1288 @@ 
+/*
+ * Copyright (c) 2012, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ *   @file  ti_em_hw_cppi.h
+ *
+ *   @brief   
+ *      This is the CPPI Descriptor Management include file.
+ *
+ */
+
+#ifndef TI_EM_HW_CPPI_H_
+#define TI_EM_HW_CPPI_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <string.h> /* for memcpy() */
+
+/** CPPI maximum number of CPDMAs */
+#define CPPI_MAX_CPDMA                      13
+
+/** Used as input parameter when queue number is 
+ * not known and not specified */
+#define CPPI_PARAM_NOT_SPECIFIED            -1
+
+/** CPPI Low level Driver return and Error Codes */
+/** CPPI successful return code */
+#define CPPI_SOK                            0
+/** CPPI Error Base */       
+#define CPPI_LLD_EBASE                      (-128)
+/** CPPI CPDMA not yet initialized */
+#define CPPI_CPDMA_NOT_INITIALIZED          CPPI_LLD_EBASE-1
+/** CPPI invalid parameter */
+#define CPPI_INVALID_PARAM                  CPPI_LLD_EBASE-2
+/** CPPI Rx/Tx channel not yet enabled */
+#define CPPI_CHANNEL_NOT_OPEN               CPPI_LLD_EBASE-3
+/** CPPI Rx flow not yet enabled */
+#define CPPI_FLOW_NOT_OPEN                  CPPI_LLD_EBASE-4
+/** CPPI Tx channels are still open. 
+ * All Tx channels should be closed 
+ * before calling CPPI_close */
+#define CPPI_TX_CHANNELS_NOT_CLOSED         CPPI_LLD_EBASE-5
+/** CPPI Rx channels are still open. 
+ * All Rx channels should be closed 
+ * before calling CPPI_close */
+#define CPPI_RX_CHANNELS_NOT_CLOSED         CPPI_LLD_EBASE-6
+/** CPPI Rx flows are still open. 
+ * All Rx flows should be closed 
+ * before calling CPPI_close */
+#define CPPI_RX_FLOWS_NOT_CLOSED            CPPI_LLD_EBASE-7
+
+/** Queue Manager subsystem memory region not enabled */
+#define CPPI_QMSS_MEMREGION_NOT_INITIALIZED CPPI_LLD_EBASE-8
+/** Queue open error */
+#define CPPI_QUEUE_OPEN_ERROR               CPPI_LLD_EBASE-9
+/** CPPI extended packet information block not present in descriptor */
+#define CPPI_EPIB_NOT_PRESENT               CPPI_LLD_EBASE-10
+/** CPPI protocol specific data not present in descriptor */
+#define CPPI_PSDATA_NOT_PRESENT             CPPI_LLD_EBASE-11
+/** CPPI CPDMA instances are still open. 
+ * All CPDMA instances should be closed 
+ * before calling CPPI_exit */
+#define CPPI_CPDMA_NOT_CLOSED               CPPI_LLD_EBASE-12
+/** CPPI resource initialization permission denied */
+#define CPPI_RESOURCE_INIT_DENIED           CPPI_LLD_EBASE-13
+/** CPPI resource usage permission denied */
+#define CPPI_RESOURCE_USE_DENIED            CPPI_LLD_EBASE-14
+
+/**
+@}
+*/
+
+/** 
+ * @brief CPPI CPDMA types
+ */
+typedef enum
+{
+    /** SRIO */
+    Cppi_CpDma_SRIO_CPDMA = 0,
+    /** AIF */
+    Cppi_CpDma_AIF_CPDMA,
+    /** FFTC A */
+    Cppi_CpDma_FFTC_A_CPDMA,
+    /** FFTC B */
+    Cppi_CpDma_FFTC_B_CPDMA,
+    /** FFTC C */
+    Cppi_CpDma_FFTC_C_CPDMA,
+    /** FFTC D */
+    Cppi_CpDma_FFTC_D_CPDMA,
+    /** FFTC E */
+    Cppi_CpDma_FFTC_E_CPDMA,
+    /** FFTC F */
+    Cppi_CpDma_FFTC_F_CPDMA,
+    /** PASS */
+    Cppi_CpDma_PASS_CPDMA,
+    /** QMSS in first QM */
+    Cppi_CpDma_QMSS_CPDMA,
+    /** QMSS in second QM */
+    Cppi_CpDma_QMSS_QM2_CPDMA,
+    /** BCP */
+    Cppi_CpDma_BCP_CPDMA,
+    /** XGE */
+    Cppi_CpDma_XGE_CPDMA,
+}Cppi_CpDma;
+
+/** 
+ * @brief CPPI Channel type 
+ */
+typedef enum
+{
+    /** Receive Channel */
+    Cppi_ChType_RX_CHANNEL = 0,
+    /** Transmit Channel */
+    Cppi_ChType_TX_CHANNEL
+}Cppi_ChType;
+
+/** 
+ * @brief CPPI Channel Enable
+ */
+typedef enum
+{
+    /** Disable Channel */
+    Cppi_ChState_CHANNEL_DISABLE = 0,
+    /** Enable Channel */
+    Cppi_ChState_CHANNEL_ENABLE 
+}Cppi_ChState;
+
+/** 
+ * @brief CPPI Wait after Channel Teardown
+ */
+typedef enum
+{
+    /** No wait */
+    Cppi_Wait_NO_WAIT = 0,
+    /** Wait */
+    Cppi_Wait_WAIT
+}Cppi_Wait;
+
+/**
+@}
+*/
+
+/** @addtogroup CPPI_LLD_DATASTRUCT
+@{ 
+*/
+
+/** 
+ * @brief CPPI CPDMA configuration structure
+ */
+typedef struct
+{
+    /** CPDMA configuring control registers */
+    Cppi_CpDma                  dmaNum;
+
+    /** This field sets the depth of the write arbitration FIFO which stores write transaction information
+     * between the command arbiter and write data arbiters in the Bus Interface Unit. Setting this field to smaller 
+     * values will cause prevent the CDMAHP from having an excess of write transactions outstanding whose data is 
+     * still waiting to be transferred.
+     * System performance can suffer if write commands are allowed to be issued long before the corresponding 
+     * write data will be transferred.  This field allows the command count to be optimized based on system dynamics
+     *
+     * Valid range is 1 to 32. If writeFifoDepth field is set to 0, this field will not be configured. The reset/default value is 20.
+     */
+    uint8_t                     writeFifoDepth;
+    /** This field sets the timeout duration in clock cycles.  This field controls the minimum 
+     * amount of time that an Rx channel will be required to wait when it encounters a buffer starvation 
+     * condition and the Rx error handling bit is set to 1 (packet is to be preserved - no discard).  
+     * If the Rx error handling bit in the flow table is cleared, this field will have no effect on the Rx operation.  
+     * When this field is set to 0, the Rx engine will not force an Rx channel to wait after encountering a starvation 
+     * event (the feature is disabled).  When this field is set to a value other than 0, the Rx engine will force any 
+     * channel whose associated flow had the Rx error handling bit asserted and which encounters starvation to wait for 
+     * at least the specified # of clock cycles before coming into context again to retry the access to the QM
+     */ 
+    uint16_t                    timeoutCount;
+    /** The QM N Queues Region Base Address Register is used to provide a programmable 
+     * pointer to the base address of the queues region in Queue Manager N in the system 
+     */
+
+    /** Queue Manager 0 base address register - 0 means use default from Cppi_GlobalConfigParams */
+    uint32_t            qm0BaseAddress;
+    /** Queue Manager 1 base address register - 0 means use default from Cppi_GlobalConfigParams */
+    uint32_t            qm1BaseAddress;
+    /** Queue Manager 2 base address register - 0 means use default from Cppi_GlobalConfigParams */
+    uint32_t            qm2BaseAddress;
+    /** Queue Manager 3 base address register - 0 means use default from Cppi_GlobalConfigParams */
+    uint32_t            qm3BaseAddress;
+}Cppi_CpDmaInitCfg;
+
+/** 
+ * @brief CPPI transmit channel configuration structure
+ */
+typedef struct
+{
+    /** Channel number */
+    /** If channelNum is set to CPPI_PARAM_NOT_SPECIFIED then the next 
+     * available channel will be allocated */
+    int32_t           channelNum;
+    /** Enable Tx Channel on creation. If not set use CPPI_channelEnable() API to enable it later */
+    Cppi_ChState    txEnable;
+    /** Tx scheduling priority for channelNum */
+    uint8_t           priority;
+    /** Tx Filter Software Info.  This field controls whether or not the DMA controller will pass the 
+     * extended packet information fields (if present) from the descriptor to the back end application.
+     * 0 - DMA controller will pass extended packet info fields if they are present in the descriptor
+     * 1 - DMA controller will filter extended packet info fields
+     */
+    uint16_t             filterEPIB;
+    /** Filter Protocol Specific Words. This field controls whether or not the DMA controller will 
+     * pass the protocol specific words (if present) from the descriptor to the back end application.
+     * 0 - DMA controller will pass PS words if present in descriptor
+     * 1 - DMA controller will filter PS words
+     */
+    uint16_t             filterPS;
+    /**
+     * AIF Specific Monolithic Packet Mode. This field when set indicates that all monolithic packets 
+     * which will be transferred on this channel will be formatted in an optimal configuration as needed 
+     * by the Antenna Interface Peripheral.  The AIF configuration uses a fixed descriptor format which 
+     * includes the 3 mandatory descriptor info words, a single Protocol Specific Word and data 
+     * immediately following (data offset = 16).
+     */
+    uint16_t             aifMonoMode;
+}Cppi_TxChInitCfg;
+
+/** 
+ * @brief CPPI receive channel configuration structure
+ */
+typedef struct
+{
+    /** Channel number */
+    /** If channelNum is set to CPPI_PARAM_NOT_SPECIFIED then the next 
+     * available channel will be allocated */
+    int32_t           channelNum;
+    /** Enable Rx Channel on creation. If not set use CPPI_channelEnable() API to enable it later */
+    Cppi_ChState    rxEnable;
+}Cppi_RxChInitCfg;
+
+/** 
+ * @brief CPPI receive flow configuration structure
+ */
+typedef struct 
+{
+    /** Rx flow configuration register A */
+
+    /** flow ID number */
+    /** If flowIdNum is set to CPPI_PARAM_NOT_SPECIFIED then the next available flow ID will be allocated */
+    int16_t           flowIdNum;
+    /** This field indicates the default receive queue that this channel should use */
+    uint16_t          rx_dest_qnum;
+    /** This field indicates the default receive queue manager that this channel should use */
+    uint16_t          rx_dest_qmgr;
+    /** This field specifies the number of bytes that are to be skipped in the SOP buffer before beginning 
+     * to write the payload or protocol specific bytes(if they are in the sop buffer).  This value must
+     * be less than the minimum size of a buffer in the system */
+    uint16_t          rx_sop_offset;
+    /** This field controls where the Protocol Specific words will be placed in the Host Mode CPPI data structure 
+     * 0 - protocol specific information is located in descriptor 
+     * 1 - protocol specific information is located in SOP buffer */
+    uint16_t             rx_ps_location;
+    /** This field indicates the descriptor type to use 1 = Host, 2 = Monolithic */
+    uint8_t           rx_desc_type;
+    /** This field controls the error handling mode for the flow and is only used when channel errors occurs 
+     * 0 = Starvation errors result in dropping packet and reclaiming any used descriptor or buffer resources 
+     * back to the original queues/pools they were allocated to
+     * 1 = Starvation errors result in subsequent re-try of the descriptor allocation operation.  
+     */
+    uint16_t             rx_error_handling;
+    /** This field controls whether or not the Protocol Specific words will be present in the Rx Packet Descriptor 
+     * 0 - The port DMA will set the PS word count to 0 in the PD and will drop any PS words that are presented 
+     * from the back end application.
+     * 1 - The port DMA will set the PS word count to the value given by the back end application and will copy 
+     * the PS words from the back end application to the location 
+     */
+    uint16_t             rx_psinfo_present;
+    /** This field controls whether or not the Extended Packet Info Block will be present in the Rx Packet Descriptor.  
+     * 0 - The port DMA will clear the Extended Packet Info Block Present bit in the PD and will drop any extended 
+     * packet info words that are presented from the back end application. 
+     * 1 - The port DMA will set the Extended Packet Info Block Present bit in the PD and will copy any extended packet
+     * info words that are presented across the Rx streaming interface into the extended packet info words in the descriptor.
+     * If no extended packet info words are presented from the back end application, the port DMA will overwrite the fields with zeroes.
+     */
+    uint16_t             rx_einfo_present;
+
+    /** Rx flow configuration register B */
+
+    /** This is the value to insert into bits 7:0 of the destination tag if the rx_dest_tag_lo_sel is set to 1 */
+    uint8_t           rx_dest_tag_lo;
+    /** This is the value to insert into bits 15:8 of the destination tag if the rx_dest_tag_hi_sel is set to 1 */
+    uint8_t           rx_dest_tag_hi;
+    /** This is the value to insert into bits 7:0 of the source tag if the rx_src_tag_lo_sel is set to 1 */
+    uint8_t           rx_src_tag_lo;
+    /** This is the value to insert into bits 15:8 of the source tag if the rx_src_tag_hi_sel is set to 1 */
+    uint8_t           rx_src_tag_hi;    
+
+    /** Rx flow configuration register C */
+    /** This bits control whether or not the flow will compare the packet size received from the back end application 
+     * against the rx_size_thresh0 fields to determine which FDQ to allocate the SOP buffer from.  
+     * The bits in this field is encoded as follows:
+     * 0 = Do not use the threshold.
+     * 1 = Use the thresholds to select SOP FDQ rx_fdq0_sz0_qnum/rx_fdq0_sz0_qmgr.
+     */
+    uint8_t             rx_size_thresh0_en;
+    /** This bits control whether or not the flow will compare the packet size received from the back end application 
+     * against the rx_size_thresh1 fields to determine which FDQ to allocate the SOP buffer from.  
+     * The bits in this field is encoded as follows:
+     * 0 = Do not use the threshold.
+     * 1 = Use the thresholds to select SOP FDQ rx_fdq0_sz1_qnum/rx_fdq0_sz1_qmgr.
+     */
+    uint8_t             rx_size_thresh1_en;
+        /** This bits control whether or not the flow will compare the packet size received from the back end application 
+     * against the rx_size_thresh2 fields to determine which FDQ to allocate the SOP buffer from.  
+     * The bits in this field is encoded as follows:
+     * 0 = Do not use the threshold.
+     * 1 = Use the thresholds to select SOP FDQ rx_fdq0_sz2_qnum/rx_fdq0_sz2_qmgr.
+     */
+    uint8_t             rx_size_thresh2_en;
+
+    /** This field specifies the source for bits 7:0 of the source tag field in word 1 of the output PD.
+     * This field is encoded as follows:
+     * 0 = do not overwrite
+     * 1 = overwrite with value given in rx_dest_tag_lo
+     * 2 = overwrite with flow_id[7:0] from back end application
+     * 3 = RESERVED
+     * 4 = overwrite with dest_tag[7:0] from back end application
+     * 5 = overwrite with dest_tag[15:8] from back end application
+     * 6-7 = RESERVED
+     */    
+    uint8_t           rx_dest_tag_lo_sel;
+    /** This field specifies the source for bits 15:8 of the source tag field in the word 1 of the output PD.
+     * This field is encoded as follows:
+     * 0 = do not overwrite
+     * 1 = overwrite with value given in rx_dest_tag_hi
+     * 2 = overwrite with flow_id[7:0] from back end application
+     * 3 = RESERVED
+     * 4 = overwrite with dest_tag[7:0] from back end application
+     * 5 = overwrite with dest_tag[15:8] from back end application
+     * 6-7 = RESERVED
+     */
+    uint8_t           rx_dest_tag_hi_sel;
+    /** This field specifies the source for bits 7:0 of the source tag field in the output packet descriptor.
+     * This field is encoded as follows:
+     * 0 = do not overwrite
+     * 1 = overwrite with value given in rx_src_tag_lo
+     * 2 = overwrite with flow_id[7:0] from back end application
+     * 3 = RESERVED
+     * 4 = overwrite with src_tag[7:0] from back end application
+     * 5 = RESERVED
+     * 6-7 = RESERVED
+     */
+    uint8_t           rx_src_tag_lo_sel;
+    /** This field specifies the source for bits 15:8 of the source tag field in the output packet descriptor.
+     * This field is encoded as follows:
+     * 0 = do not overwrite
+     * 1 = overwrite with value given in rx_src_tag_hi
+     * 2 = overwrite with flow_id[7:0] from back end application
+     * 3 = RESERVED
+     * 4 = overwrite with src_tag[7:0] from back end application
+     * 5 = RESERVED
+     * 6-7 = RESERVED
+     */
+    uint8_t           rx_src_tag_hi_sel;    
+ 
+    /** Rx flow configuration register D */
+
+    /** This field specifies which Free Descriptor Queue should be used for the 2nd Rx buffer in a host type packet */
+    uint16_t          rx_fdq1_qnum;
+    /** This field specifies which Queue Manager should be used for the 2nd Rx buffer in a host type packet */
+    uint16_t          rx_fdq1_qmgr;
+    /** This field specifies which Free Descriptor Queue should be used for the 1st Rx buffer in a packet whose 
+     * size is less than or equal to the rx_size0 value */
+    uint16_t          rx_fdq0_sz0_qnum;
+    /** This field specifies which Queue Manager should be used for the 1st Rx buffer in a packet whose size 
+     * is less than or equal to the rx_size0 value */
+    uint16_t          rx_fdq0_sz0_qmgr;
+
+    /** Rx flow configuration register E */
+
+    /** This field specifies which Free Descriptor Queue should be used for the 4th or later Rx
+     *  buffers in a host type packet */
+    uint16_t          rx_fdq3_qnum;
+    /** This field specifies which Queue Manager should be used for the 4th or later Rx buffers 
+     * in a host type packet */
+    uint16_t          rx_fdq3_qmgr;
+    /** This field specifies which Free Descriptor Queue should be used for the 3rd Rx buffer in a host type packet */
+    uint16_t          rx_fdq2_qnum;
+    /** This field specifies which Queue Manager should be used for the 3rd Rx buffer in a host type packet */
+    uint16_t          rx_fdq2_qmgr;
+
+    /** Rx flow configuration register F */
+
+    /** This value is left shifted by 5 bits and compared against the packet size to determine which free descriptor 
+     * queue should be used for the SOP buffer in the packet.  If the  packet size is greater than the rx_size_thresh0 
+     * but is less than or equal to the value given in this threshold, the DMA controller in the port will allocate the 
+     * SOP buffer from the queue given by the rx_fdq0_sz1_qmgr and rx_fdq0_sz1_qnum fields. 
+     * If enabled, this value must be greater than the value given in the rx_size_thresh0 field. This field is optional.
+     */
+    uint16_t          rx_size_thresh1;
+    /** This value is left shifted by 5 bits and compared against the packet size to determine which free descriptor 
+     * queue should be used for the SOP buffer in the packet.  If the packet size is less than or equal to the value 
+     * given in this threshold, the DMA controller in the port will allocate the SOP buffer from the queue given by 
+     * the rx_fdq0_sz0_qmgr and rx_fdq0_sz0_qnum fields. This field is optional.
+     */
+    uint16_t          rx_size_thresh0;
+    
+    /** Rx flow configuration register G */
+
+    /** This field specifies which Queue should be used for the 1st Rx buffer in a packet whose size is 
+     * less than or equal to the rx_size0 value */
+    uint16_t          rx_fdq0_sz1_qnum;
+    /** This field specifies which Queue Manager should be used for the 1st Rx buffer in a packet whose size 
+     * is less than or equal to the rx_size0 value */
+    uint16_t          rx_fdq0_sz1_qmgr;
+    /** This value is left shifted by 5 bits and compared against the packet size to determine which free descriptor 
+     * queue should be used for the SOP buffer in the packet.  If the  packet size is less than or equal to the value
+     * given in this threshold, the DMA controller in the port will allocate the SOP buffer from the queue given by the 
+     * rx_fdq0_sz2_qmgr and rx_fdq0_sz2_qnum fields.
+     * If enabled, this value must be greater than the value given in the rx_size_thresh1 field. This field is optional.
+     */
+    uint16_t  		rx_size_thresh2;
+
+    /** Rx flow configuration register H */
+
+    /** This field specifies which Free Descriptor Queue should be used for the 1st Rx buffer in a
+     * packet whose size is less than or equal to the rx_size3 value */
+    uint16_t          rx_fdq0_sz3_qnum;
+    /** This field specifies which Free Descriptor Queue Manager should be used for the 1st Rx buffer in a 
+     * packet whose size is less than or equal to the rx_size3 value */
+    uint16_t          rx_fdq0_sz3_qmgr;
+    /** This field specifies which Free Descriptor Queue should be used for the 1st Rx buffer in a packet 
+     * whose size is less than or equal to the rx_size2 value */
+    uint16_t          rx_fdq0_sz2_qnum;
+    /** This field specifies which Free Descriptor Queue Manager should be used for the 1st Rx buffer in a packet 
+     * whose size is less than or equal to the rx_size2 value */
+    uint16_t          rx_fdq0_sz2_qmgr;
+}Cppi_RxFlowCfg;
+
+/** 
+ * @brief CPPI return result
+ */
+typedef int32_t   Cppi_Result;
+
+/** 
+ * @brief CPPI handle
+ */
+typedef uint32_t  *Cppi_Handle;
+
+/** 
+ * @brief CPPI channel handle
+ */
+typedef uint32_t  *Cppi_ChHnd;
+
+/** 
+ * @brief CPPI receive flow handle
+ */
+typedef uint32_t  *Cppi_FlowHnd;
+
+/** Monolithic descriptor extended packet information block size */
+#define CPPI_MONOLITHIC_DESC_EPIB_SIZE      20
+/** Host descriptor extended packet information block size */
+#define CPPI_HOST_DESC_EPIB_SIZE            16
+
+/** 
+ * @brief CPPI descriptor types
+ */
+typedef enum
+{
+    /** Host descriptor */
+    Cppi_DescType_HOST = 0,
+    /** Monolithic descriptor */
+    Cppi_DescType_MONOLITHIC = 2
+}Cppi_DescType;
+
+/** 
+ * @brief Packet return policy
+ */
+typedef enum
+{
+    /** Return entire packet */
+    Cppi_ReturnPolicy_RETURN_ENTIRE_PACKET = 0,
+    /** Return one buffer at a time */
+    Cppi_ReturnPolicy_RETURN_BUFFER 
+}Cppi_ReturnPolicy;
+
+/** 
+ * @brief protocol specific information location 
+ */
+typedef enum
+{
+    /** protocol specific information is located in descriptor */
+    Cppi_PSLoc_PS_IN_DESC = 0,
+    /** protocol specific information is located in SOP buffer */
+    Cppi_PSLoc_PS_IN_SOP
+}Cppi_PSLoc;
+
+/** 
+ * @brief extended packet information block
+ */
+typedef enum
+{
+    /** extended packet information block is not present in descriptor */
+    Cppi_EPIB_NO_EPIB_PRESENT = 0,
+    /** extended packet information block is present in descriptor  */
+    Cppi_EPIB_EPIB_PRESENT
+}Cppi_EPIB;
+
+/** 
+ * @brief Descriptor resource management
+ */
+typedef enum
+{
+    /** LLD initializes the descriptors with specified values */
+    Cppi_InitDesc_INIT_DESCRIPTOR = 0,
+    /** LLD does not initialize the descriptor with specified values */    
+    Cppi_InitDesc_BYPASS_INIT 
+}Cppi_InitDesc;
+
+/** 
+@} 
+*/
+
+/** @addtogroup CPPI_LLD_DATASTRUCT
+@{ 
+*/
+
+/** 
+ * @brief CPPI host descriptor configuration structure
+ */
+typedef struct 
+{
+    /** Indicates return policy for the packet. 
+     * Valid only for host descriptor */
+    Cppi_ReturnPolicy       returnPolicy;
+    /** Indicates protocol specific location CPPI_PS_DESC - located in descriptor, CPPI_PS_SOP - located in SOP buffer 
+     * Valid only for host descriptor */
+    Cppi_PSLoc              psLocation;
+}Cppi_HostDescCfg;
+
+/** 
+ * @brief CPPI monolithic descriptor configuration structure
+ */
+typedef struct 
+{
+    /** Byte offset from byte 0 of monolithic descriptor to the location where the valid data begins */
+    uint32_t                  dataOffset;
+}Cppi_MonolithicDescCfg;
+
+/** 
+ * @brief CPPI descriptor configuration structure
+ */
+typedef struct 
+{
+    /** Memory Region corresponding to the descriptor. */
+    Qmss_MemRegion          memRegion;
+    /** Group for memRegion (only applicable in when QMSS is in split mode) */
+    uint32_t                queueGroup;
+    /** Number of descriptors that should be configured with value below */
+    uint32_t                  descNum;
+    /** Queue where the descriptor is stored. If destQueueNum is set to QMSS_PARAM_NOT_SPECIFIED then the next 
+     * available queue of type Qmss_QueueType will be allocated */
+    int32_t                   destQueueNum;
+    /** If destQueueNum is set to QMSS_PARAM_NOT_SPECIFIED then the next available queue of type 
+     * Qmss_QueueType will be allocated */
+    Qmss_QueueType          queueType;
+
+    /** Descriptor configuration parameters */
+    /** Indicates if the descriptor should be initialized with parameters listed below */
+    Cppi_InitDesc           initDesc;
+
+    /** Type of descriptor - Host or Monolithic */
+    Cppi_DescType           descType;
+    /** Indicates return Queue Manager and Queue Number. If both qMgr and qNum in returnQueue is 
+     * set to QMSS_PARAM_NOT_SPECIFIED then the destQueueNum is configured in returnQueue of the descriptor */
+    Qmss_Queue              returnQueue;
+    /** Indicates how the CPDMA returns descriptors to free queue */
+    Qmss_Location           returnPushPolicy;
+    /** Indicates presence of EPIB */
+    Cppi_EPIB               epibPresent;
+
+    /** Union contains configuration that should be initialized in for host or monolithic descriptor. 
+     * The configuration for host or monolithic descriptor is choosen based on "descType" field. 
+     * The approriate structure fields must be specified if "initDesc" field is set to CPPI_INIT_DESCRIPTOR. */
+    union{
+    /** Host descriptor configuration parameters */
+    Cppi_HostDescCfg        host;
+    /** Monolithic  descriptor configuration parameters */
+    Cppi_MonolithicDescCfg  mono;
+    }cfg;
+
+}Cppi_DescCfg;
+
+/** 
+ * @brief CPPI descriptor Word 1 Tag information
+ */
+typedef struct {
+    uint8_t srcTagHi;
+    uint8_t srcTagLo;
+    uint8_t destTagHi;
+    uint8_t destTagLo;
+}Cppi_DescTag;
+
+/** 
+ * @brief CPPI host descriptor layout
+ */
+typedef struct {
+    /** Descriptor type, packet type, protocol specific region location, packet length */
+    uint32_t          descInfo;  
+    /** Source tag, Destination tag */
+    uint32_t          tagInfo;
+    /** EPIB present, PS valid word count, error flags, PS flags, return policy, return push policy, 
+     * packet return QM number, packet return queue number */
+    uint32_t          packetInfo;
+    /** Number of valid data bytes in the buffer */
+    uint32_t          buffLen;
+    /** Byte aligned memory address of the buffer associated with this descriptor */
+    uint32_t          buffPtr;
+    /** 32-bit word aligned memory address of the next buffer descriptor */
+    uint32_t          nextBDPtr;       
+    /** Completion tag, original buffer size */
+    uint32_t          origBufferLen;
+    /** Original buffer pointer */
+    uint32_t          origBuffPtr;
+    /** Optional EPIB word0 */
+    uint32_t          timeStamp;
+    /** Optional EPIB word1 */
+    uint32_t          softwareInfo0;
+    /** Optional EPIB word2 */
+    uint32_t          softwareInfo1;
+    /** Optional EPIB word3 */
+    uint32_t          softwareInfo2;
+    /** Optional protocol specific data */
+    uint32_t          psData; 
+}Cppi_HostDesc;
+
+/** 
+ * @brief CPPI monolithic descriptor layout
+ */
+typedef struct {
+    /** Descriptor type, packet type, data offset, packet length */
+    uint32_t          descInfo;  
+    /** Source tag, Destination tag */
+    uint32_t          tagInfo;
+    /** EPIB present, PS valid word count, error flags, PS flags, return push policy, 
+     * packet return QM number, packet return queue number */
+    uint32_t          packetInfo;
+    /** NULL word to align the extended packet words to a 128 bit boundary */
+    uint32_t          Reserved;
+    /** Optional EPIB word0 */
+    uint32_t          timeStamp;
+    /** Optional EPIB word1 */
+    uint32_t          softwareInfo0;
+    /** Optional EPIB word2 */
+    uint32_t          softwareInfo1;
+    /** Optional EPIB word3 */
+    uint32_t          softwareInfo2;
+    /** Optional protocol specific data */
+    uint32_t          psData; 
+}Cppi_MonolithicDesc;
+
+/** 
+ * @brief CPPI descriptor
+ */
+typedef union {
+    /** Host descriptor */
+    Cppi_HostDesc       *ptrHostDesc;  
+    /** Monolithic descriptor */
+    Cppi_MonolithicDesc *ptrMonoDesc;
+}Cppi_Desc;
+
+/**
+ * @brief CPPI global configuration structure
+ */
+typedef struct
+{
+    /** CPDMA this configuration belongs to */
+    Cppi_CpDma      dmaNum;
+    /** Maximum supported Rx Channels */
+    uint32_t          maxRxCh;
+    /** Maximum supported Tx Channels */
+    uint32_t          maxTxCh;
+    /** Maximum supported Rx Flows */
+    uint32_t          maxRxFlow;
+    /** Priority for all Rx transactions of this CPDMA */
+    uint8_t           rxPriority;
+    /** Priority for all Tx transactions of this CPDMA */
+    uint8_t           txPriority;
+
+    /** Base address for the CPDMA overlay registers */
+
+    /** Global Config registers */
+    CSL_Cppidma_global_configRegs       *gblCfgRegs;
+    /** Tx Channel Config registers */
+    CSL_Cppidma_tx_channel_configRegs   *txChRegs;
+    /** Rx Channel Config registers */
+    CSL_Cppidma_rx_channel_configRegs   *rxChRegs;
+    /** Tx Channel Scheduler registers */
+    CSL_Cppidma_tx_scheduler_configRegs *txSchedRegs;
+    /** Rx Flow Config registers */
+    CSL_Cppidma_rx_flow_configRegs      *rxFlowRegs;
+} Cppi_GlobalCPDMAConfigParams;
+    
+/**
+ *  @b Description
+ *  @n  
+ *      This function is used to set the original buffer information in the host descriptor. 
+ *
+ *      **No validation is done on the input parameters**.
+ *
+ *  @param[in]  descType
+ *      Type of descriptor - Cppi_DescType_HOST
+ *
+ *  @param[in]  descAddr
+ *      Memory address of descriptor.
+ *
+ *  @param[in]  buffAddr
+ *      Memory address of data buffer pointer.
+ *      
+ *  @param[in]  buffLen
+ *      Size of the original data buffer.
+ *
+ *  @pre  
+ *      Descriptor must be allocated and be valid.
+ *
+ *  @post  
+ *      In case of host descriptor Word 6(bits 0 to 31) and Word 7 are updated
+ *
+ *  @retval
+ *      None.
+ */
+static inline void ti_em_cppi_set_original_buf_info (Cppi_DescType descType, 
+						     Cppi_Desc    *descAddr,
+						     uint32_t      buffAddr, 
+						     uint32_t      buffLen)
+{
+    Cppi_HostDesc *hostDescPtr = (Cppi_HostDesc *) descAddr;
+
+    (void)descType;
+    hostDescPtr->origBuffPtr = buffAddr;
+    CSL_FINSR (hostDescPtr->origBufferLen, 21, 0, buffLen);
+
+    return;
+}
+
+/**
+ *  @b Description
+ *  @n  
+ *      This function is used to retrieve the original buffer information from host descriptor. 
+ *
+ *      **No validation is done on the input parameters**.
+ *
+ *  @param[in]  descType
+ *      Type of descriptor - Cppi_DescType_HOST
+ *
+ *  @param[in]  descAddr
+ *      Memory address of descriptor.
+ *
+ *  @param[out]  buffAddr
+ *      Memory address of data buffer pointer.
+ *      
+ *  @param[out]  buffLen
+ *      Size of the original data buffer.
+ *
+ *  @pre  
+ *      Descriptor must be allocated and be valid.
+ *
+ *  @post  
+ *      In case of host descriptor Word 6(bits 0 to 21) and Word 7 are returned
+ *
+ *  @retval
+ *      None.
+ */
+static inline void ti_em_cppi_get_original_buf_info (Cppi_DescType descType, 
+						     Cppi_Desc *descAddr,
+						     uint8_t **buffAddr, 
+						     uint32_t *buffLen)
+{
+    Cppi_HostDesc   *hostDescPtr = (Cppi_HostDesc *) descAddr;
+
+    (void)descType;
+    *buffAddr = (uint8_t *) hostDescPtr->origBuffPtr;
+    *buffLen = CSL_FEXTR (hostDescPtr->origBufferLen, 21, 0);
+
+    return;
+}
+
+/**
+ *  @b Description
+ *  @n  
+ *      This function is used to set the packet type in host or monolithic descriptor.
+ *
+ *      **No validation is done on the input parameters**.
+ *
+ *  @param[in]  descType
+ *      Type of descriptor - Cppi_DescType_HOST, Cppi_DescType_MONOLITHIC
+ *
+ *  @param[in]  descAddr
+ *      Memory address of descriptor.
+ *
+ *  @param[in]  packetType
+ *      Indicates type of packet. Valid range is 0 to 31.
+ *      
+ *  @pre  
+ *      Descriptor must be allocated and be valid.
+ *
+ *  @post  
+ *      Word 0 (bits 25 to 29) of host or monolithic descriptor are updated.
+ *
+ *  @retval
+ *      None
+ */
+static inline void ti_em_cppi_set_packet_type (Cppi_DescType descType, 
+					       Cppi_Desc *descAddr,
+					       uint8_t packetType)
+{
+    Cppi_HostDesc   *descPtr = (Cppi_HostDesc *) descAddr;
+
+    (void)descType;
+    CSL_FINSR (descPtr->descInfo, 29, 25, packetType);
+    return;
+}
+
+/**
+ *  @b Description
+ *  @n  
+ *      This function is used to get the packet type from host or monolithic descriptor.
+ *
+ *      **No validation is done on the input parameters**.
+ *
+ *  @param[in]  descType
+ *      Type of descriptor - Cppi_DescType_HOST, Cppi_DescType_MONOLITHIC
+ *      
+ *  @param[in]  descAddr
+ *      Memory address of descriptor.
+ *      
+ *  @pre  
+ *      Descriptor must be allocated and be valid.
+ *
+ *  @retval
+ *      5 bit packet type field. Valid range is 0 to 31.
+ */
+static inline uint8_t ti_em_cppi_get_packet_type (Cppi_DescType descType, 
+						  Cppi_Desc *descAddr)
+{
+    Cppi_HostDesc   *descPtr = (Cppi_HostDesc *) descAddr;
+
+    (void)descType;
+    return (CSL_FEXTR (descPtr->descInfo, 29, 25));
+}
+
+/**
+ *  @b Description
+ *  @n  
+ *      This function copies the data buffer to the host or monolithic descriptor. 
+ *      It is assumed that enough words are available to store the payload in case 
+ *      of monolithic descriptor.
+ *
+ *      **No validation is done on the input parameters**.
+ *      **Does not update packet length**.
+ *
+ *  @param[in]  descType
+ *      Type of descriptor - Cppi_DescType_HOST, Cppi_DescType_MONOLITHIC
+ *
+ *  @param[in]  descAddr
+ *      Memory address of descriptor.
+ *
+ *  @param[in]  buffAddr
+ *      Memory address of data buffer.
+ *      
+ *  @param[in]  buffLen
+ *      Size of the data buffer.
+ *
+ *  @pre  
+ *      Descriptor and data buffer must be allocated and be valid.
+ *
+ *  @post  
+ *      In case of host descriptor 
+ *          Word 3 and Word 4 are updated
+ *
+ *      In case of monolithic descriptor 
+ *          Word 0 (bits 0 to 15) and payload are updated.
+ *
+ *  @retval
+ *      None.
+ */
+static inline void ti_em_cppi_set_data (Cppi_DescType descType,
+					Cppi_Desc *descAddr,
+					uint8_t *buffAddr,
+					uint32_t buffLen)
+{
+    Cppi_HostDesc   *hostDescPtr;
+
+    /* Does not update packet length */
+    if (descType == Cppi_DescType_HOST)
+    {
+        hostDescPtr = (Cppi_HostDesc *) descAddr;
+        hostDescPtr->buffPtr = (uint32_t) buffAddr;
+        hostDescPtr->buffLen = (uint32_t) buffLen;
+    }
+    else
+    {
+        Cppi_MonolithicDesc *monolithicDescPtr = (Cppi_MonolithicDesc *) descAddr;
+        uint16_t              dataOffset;
+
+        dataOffset = CSL_FEXTR (monolithicDescPtr->descInfo, 24, 16);
+        memcpy ((void *) (((uint8_t *) monolithicDescPtr) + dataOffset), buffAddr, buffLen);
+        CSL_FINSR (monolithicDescPtr->descInfo, 15, 0, buffLen);
+    }
+    return;
+}
+
+/**
+ *  @b Description
+ *  @n  
+ *      This function is update protocol specific data length in host or monolithic descriptor. 
+ *
+ *      **No validation is done on the input parameters**.
+ *      **Does not update packet length**.
+ *
+ *
+ *  @param[in]  descType
+ *      Type of descriptor - Cppi_DescType_HOST, Cppi_DescType_MONOLITHIC
+ *      
+ *  @param[in]  descAddr
+ *      Memory address of descriptor.
+ *
+ *  @param[in]  dataLen
+ *      Size of PS data.
+ *      
+ *  @pre  
+ *      Descriptor must be allocated and be valid.
+ *
+ *  @post  
+ *      Word 2 (bits 24 to 29) are updated.
+ *
+ *  @retval
+ *      None
+ */
+static inline void ti_em_cppi_set_pslen (Cppi_DescType descType, 
+					 Cppi_Desc *descAddr,
+					 uint32_t dataLen)
+{
+    Cppi_HostDesc   *descPtr = (Cppi_HostDesc *) descAddr;
+ 
+    (void)descType;
+    /* Does not update packet length */
+    CSL_FINSR (descPtr->packetInfo, 29, 24, (dataLen / 4));
+    return;
+}
+
+/**
+ *  @b Description
+ *  @n
+ *      This function updates protocol specific flags in host descriptor.
+ *
+ *      **No validation is done on the input parameters**.
+ *
+ *  @param[in]  descAddr
+ *      Memory address of host descriptor.
+ *
+ *  @param[in]  flags
+ *      PS flags.
+ *
+ *  @pre
+ *      Descriptor must be allocated and be valid.
+ *
+ *  @post
+ *      Word 2 (bits 16 to 19) are updated.
+ *
+ *  @retval
+ *      None
+ */
+static inline void ti_em_cppi_set_psflags (Cppi_HostDesc *descAddr,
+						uint32_t flags)
+{
+    CSL_FINSR (descAddr->packetInfo, 19, 16, flags);
+}
+
+/**
+ *  @b Description
+ *  @n
+ *      This function updates packet length in host descriptor.
+ *
+ *      **No validation is done on the input parameters**.
+ *
+ *  @param[in]  descAddr
+ *      Memory address of host descriptor.
+ *
+ *  @param[in]  dataLen
+ *      Size of packet data.
+ *
+ *  @pre
+ *      Descriptor must be allocated and be valid.
+ *
+ *  @post
+ *      Word 0 (bits 0 to 21) are updated.
+ *
+ *  @retval
+ *      None
+ */
+static inline void ti_em_cppi_set_pktlen (Cppi_HostDesc *descAddr,
+					       uint32_t dataLen)
+{
+    Cppi_HostDesc *descPtr = (Cppi_HostDesc *) descAddr;
+    CSL_FINSR (descPtr->descInfo, 21, 0, dataLen);
+    return;
+}
+
+/**
+ *  @b Description
+ *  @n
+ *      This function reads packet length in host descriptor.
+ *
+ *      **No validation is done on the input parameters**.
+ *
+ *  @param[in]  descAddr
+ *      Memory address of host descriptor.
+ *
+ *  @pre
+ *      Descriptor must be allocated and be valid.
+ *
+ *  @retval
+ *      Packet data length in host descriptor.
+ */
+static inline uint32_t ti_em_cppi_get_pktlen (Cppi_HostDesc *descAddr)
+{
+    Cppi_HostDesc *descPtr = (Cppi_HostDesc *) descAddr;
+    return CSL_FEXTR(descPtr->descInfo, 21, 0);
+}
+
+/**
+ *  @b Description
+ *  @n  
+ *      This function is used to set source and destination tags in 
+ *      host or monolithic descriptor. 
+ *
+ *      **No validation is done on the input parameters**.
+ *
+ *  @param[in]  descType
+ *      Type of descriptor - Cppi_DescType_HOST, Cppi_DescType_MONOLITHIC
+ *
+ *  @param[in]  descAddr
+ *      Memory address of descriptor.
+ *
+ *  @param[in]  tag
+ *      Destination and source low and High tag value.
+ *      
+ *  @pre  
+ *      Descriptor must be allocated and be valid.
+ *
+ *  @post  
+ *      Word 1 of host or monolithic descriptor is updated.
+ *
+ *  @retval
+ *      None
+ */
+static inline void ti_em_cppi_set_tag (Cppi_DescType descType, 
+				       Cppi_Desc *descAddr,
+				       Cppi_DescTag *tag)
+{
+    Cppi_HostDesc   *descPtr = (Cppi_HostDesc *) descAddr;
+
+    (void)descType;
+    CSL_FINSR (descPtr->tagInfo, 7, 0, tag->destTagLo);
+    CSL_FINSR (descPtr->tagInfo, 15, 8, tag->destTagHi);
+    CSL_FINSR (descPtr->tagInfo, 23, 16, tag->srcTagLo);
+    CSL_FINSR (descPtr->tagInfo, 31, 24, tag->srcTagHi);
+    return;
+}
+
+/**
+ *  @b Description
+ *  @n  
+ *      This function configures a receive flow.
+ */
+static inline int ti_em_cppi_configure_rx_flow (
+    Cppi_Handle hnd,
+    Cppi_GlobalCPDMAConfigParams *cppiGblCfgParams,
+    Cppi_RxFlowCfg *cfg)
+{
+    CSL_Cppidma_rx_flow_configRegs *rxFlowRegs;
+    uint32_t index  = 0;
+    int32_t  flowId = -1;
+    uint32_t temp   = 0;
+    uint32_t reg;
+
+    if (cfg == NULL)
+        return -1;
+
+    flowId = cfg->flowIdNum;
+    index = flowId;
+
+    rxFlowRegs = cppiGblCfgParams[(uint32_t) hnd].rxFlowRegs;
+
+    /* Rx flow configuration register A */
+    reg = 0;
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_DEST_QNUM, cfg->rx_dest_qnum);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_DEST_QMGR, cfg->rx_dest_qmgr);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_SOP_OFFSET, cfg->rx_sop_offset);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_PS_LOCATION, cfg->rx_ps_location);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_DESC_TYPE, cfg->rx_desc_type);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_ERROR_HANDLING, cfg->rx_error_handling);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_PSINFO_PRESENT, cfg->rx_psinfo_present);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_EINFO_PRESENT, cfg->rx_einfo_present);
+    rxFlowRegs->RX_FLOW_CONFIG[index].RX_FLOW_CONFIG_REG_A = reg;
+
+    /* Rx flow configuration register B */
+    reg = 0;
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_B_RX_DEST_TAG_LO, cfg->rx_dest_tag_lo);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_B_RX_DEST_TAG_HI, cfg->rx_dest_tag_hi);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_B_RX_SRC_TAG_LO, cfg->rx_src_tag_lo);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_B_RX_SRC_TAG_HI, cfg->rx_src_tag_hi);
+    rxFlowRegs->RX_FLOW_CONFIG[index].RX_FLOW_CONFIG_REG_B = reg;
+
+    /* Rx flow configuration register C */                
+    temp = ((cfg->rx_size_thresh0_en) | (cfg->rx_size_thresh1_en << 1) | (cfg->rx_size_thresh2_en << 2));
+    reg = 0;    
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_SIZE_THRESH_EN, temp);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_DEST_TAG_LO_SEL, cfg->rx_dest_tag_lo_sel);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_DEST_TAG_HI_SEL, cfg->rx_dest_tag_hi_sel);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_SRC_TAG_LO_SEL, cfg->rx_src_tag_lo_sel);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_SRC_TAG_HI_SEL, cfg->rx_src_tag_hi_sel);
+    rxFlowRegs->RX_FLOW_CONFIG[index].RX_FLOW_CONFIG_REG_C = reg;
+
+    /* Rx flow configuration register D */
+    reg = 0;
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_D_RX_FDQ1_QNUM, cfg->rx_fdq1_qnum);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_D_RX_FDQ1_QMGR, cfg->rx_fdq1_qmgr);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_D_RX_FDQ0_SZ0_QNUM, cfg->rx_fdq0_sz0_qnum);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_D_RX_FDQ0_SZ0_QMGR, cfg->rx_fdq0_sz0_qmgr);
+    rxFlowRegs->RX_FLOW_CONFIG[index].RX_FLOW_CONFIG_REG_D = reg;
+
+    /* Rx flow configuration register E */
+    reg = 0;
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_E_RX_FDQ3_QNUM, cfg->rx_fdq3_qnum);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_E_RX_FDQ3_QMGR, cfg->rx_fdq3_qmgr);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_E_RX_FDQ2_QNUM, cfg->rx_fdq2_qnum);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_E_RX_FDQ2_QMGR, cfg->rx_fdq2_qmgr);
+    rxFlowRegs->RX_FLOW_CONFIG[index].RX_FLOW_CONFIG_REG_E = reg;
+
+    /* Rx flow configuration register F */
+    reg = 0;
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_F_RX_SIZE_THRESH1, (cfg->rx_size_thresh1 >> 5));
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_F_RX_SIZE_THRESH0, (cfg->rx_size_thresh0  >> 5));
+    rxFlowRegs->RX_FLOW_CONFIG[index].RX_FLOW_CONFIG_REG_F = reg;
+
+    /* Rx flow configuration register G */
+    reg = 0;
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_G_RX_FDQ0_SZ1_QNUM, cfg->rx_fdq0_sz1_qnum);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_G_RX_FDQ0_SZ1_QMGR, cfg->rx_fdq0_sz1_qmgr);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_G_RX_SIZE_THRESH2, (cfg->rx_size_thresh2) >> 5);
+    rxFlowRegs->RX_FLOW_CONFIG[index].RX_FLOW_CONFIG_REG_G = reg;
+
+    /* Rx flow configuration register H */
+    reg = 0;
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_H_RX_FDQ0_SZ3_QNUM, cfg->rx_fdq0_sz3_qnum);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_H_RX_FDQ0_SZ3_QMGR, cfg->rx_fdq0_sz3_qmgr);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_H_RX_FDQ0_SZ2_QNUM, cfg->rx_fdq0_sz2_qnum);
+    CSL_FINS (reg, CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_H_RX_FDQ0_SZ2_QMGR, cfg->rx_fdq0_sz2_qmgr);
+    rxFlowRegs->RX_FLOW_CONFIG[index].RX_FLOW_CONFIG_REG_H = reg;
+
+    return 0;
+}
+    
+/**
+ *  @b Description
+ *  @n  
+ *      This function opens a CPPI transmit channel. 
+ */
+static inline int ti_em_cppi_tx_channel_open (
+    Cppi_Handle hnd,
+    Cppi_GlobalCPDMAConfigParams *cppiGblCfgParams,
+    Cppi_TxChInitCfg *cfg)
+{
+    CSL_Cppidma_tx_scheduler_configRegs *txSchedRegs;
+    CSL_Cppidma_tx_channel_configRegs   *txChRegs;
+    int32_t chNum  = -1;
+
+    if (cfg == NULL)
+        return -1;
+
+    chNum       = cfg->channelNum;
+    txSchedRegs = cppiGblCfgParams[(uint32_t) hnd].txSchedRegs;
+    txChRegs    = cppiGblCfgParams[(uint32_t) hnd].txChRegs;
+
+    CSL_FINS (txSchedRegs->TX_CHANNEL_SCHEDULER_CONFIG_REG[chNum],
+	      CPPIDMA_TX_SCHEDULER_CONFIG_TX_CHANNEL_SCHEDULER_CONFIG_REG_PRIORITY, cfg->priority);
+
+    CSL_FINS (txChRegs->TX_CHANNEL_GLOBAL_CONFIG[chNum].TX_CHANNEL_GLOBAL_CONFIG_REG_B,
+	      CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_B_TX_FILT_EINFO, cfg->filterEPIB);
+    
+    CSL_FINS (txChRegs->TX_CHANNEL_GLOBAL_CONFIG[chNum].TX_CHANNEL_GLOBAL_CONFIG_REG_B, 
+	      CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_B_TX_FILT_PSWORDS, cfg->filterPS);
+    
+    CSL_FINS (txChRegs->TX_CHANNEL_GLOBAL_CONFIG[chNum].TX_CHANNEL_GLOBAL_CONFIG_REG_B, 
+	      CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_B_TX_AIF_MONO_MODE, cfg->aifMonoMode);
+    
+    if (cfg->txEnable)
+    {
+	uint32_t value = 0;
+	CSL_FINS (value, CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_A_TX_ENABLE, cfg->txEnable);
+	txChRegs->TX_CHANNEL_GLOBAL_CONFIG[chNum].TX_CHANNEL_GLOBAL_CONFIG_REG_A = value;
+    }
+    return 0;
+}
+
+/**
+ *  @b Description
+ *  @n  
+ *      This function opens a CPPI transmit channel. 
+ */
+static inline int ti_em_cppi_rx_channel_open (
+    Cppi_Handle hnd,
+    Cppi_GlobalCPDMAConfigParams *cppiGblCfgParams,
+    Cppi_RxChInitCfg *cfg)
+{
+    CSL_Cppidma_rx_channel_configRegs *rxChRegs;
+    int32_t chNum = -1;
+    uint32_t value = 0;
+
+    if (cfg == NULL)
+        return -1;
+
+    chNum    = cfg->channelNum;
+    rxChRegs = cppiGblCfgParams[(uint32_t) hnd].rxChRegs;
+
+    CSL_FINS (value, CPPIDMA_RX_CHANNEL_CONFIG_RX_CHANNEL_GLOBAL_CONFIG_REG_RX_ENABLE, cfg->rxEnable);
+    rxChRegs->RX_CHANNEL_GLOBAL_CONFIG[chNum].RX_CHANNEL_GLOBAL_CONFIG_REG = value;
+
+    return 0;
+}
+
+/**
+ * @brief Map PDK HAL to Linux OSAL
+ */
+#define ti_em_rx_flow_open          ti_em_osal_cppi_rx_flow_open
+#define ti_em_rx_channel_open       ti_em_osal_cppi_rx_channel_open
+#define ti_em_tx_channel_open       ti_em_osal_cppi_tx_channel_open
+#define ti_em_rx_flow_close         ti_em_osal_cppi_rx_flow_close
+#define ti_em_rx_channel_close      ti_em_osal_cppi_rx_channel_close
+#define ti_em_tx_channel_close      ti_em_osal_cppi_tx_channel_close
+
+#define ti_em_chain_rx_flow_open    ti_em_osal_chain_rx_flow_open
+
+#define ti_em_xge_rx_flow_open      ti_em_osal_xge_rx_flow_open
+#define ti_em_xge_tx_channel_open   ti_em_osal_xge_tx_channel_open
+#define ti_em_xge_rx_channel_open   ti_em_osal_xge_rx_channel_open
+#define ti_em_xge_tx_queue_open     ti_em_osal_xge_tx_queue_open
+#define ti_em_xge_rx_flow_close     ti_em_osal_xge_rx_flow_close
+#define ti_em_xge_rx_channel_close  ti_em_osal_xge_rx_channel_close
+#define ti_em_xge_tx_channel_close  ti_em_osal_xge_tx_channel_close
+#define ti_em_xge_tx_queue_base_idx_get ti_em_osal_xge_tx_queue_base_idx_get
+
+#define ti_em_rio_rx_flow_open      ti_em_osal_rio_rx_flow_open
+#define ti_em_rio_tx_channel_open   ti_em_osal_rio_tx_channel_open
+#define ti_em_rio_tx_queue_open     ti_em_osal_rio_tx_queue_open
+
+#define ti_em_get_absolute_queue_id ti_em_osal_cppi_get_absolute_queue_id
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*TI_EM_HW_CPPI_H_*/
diff --git a/platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_csl.h b/platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_csl.h
new file mode 100644
index 0000000..7f8f63f
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_csl.h
@@ -0,0 +1,1146 @@ 
+/*
+ * Copyright (c) 2012, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ *   @file  ti_em_hw_csl.h
+ *
+ *   @brief   
+ *      This is the Chip Support Library definition file
+ *
+ */
+
+#ifndef TI_EM_HW_CSL_H_
+#define TI_EM_HW_CSL_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef STD_
+
+/*
+ * Aliases for standard C types
+ */
+typedef int		Int;
+typedef unsigned	Uns;
+typedef char		Char;
+
+/* pointer to null-terminated character sequence */
+typedef char	       *String;
+
+typedef void	       *Ptr;		/* pointer to arbitrary type */
+
+typedef unsigned short	Bool;		/* boolean */
+
+#endif /* STD_ */
+
+/* Unsigned integer definitions (32bit, 16bit, 8bit) follow... */
+typedef unsigned int	Uint32;
+typedef unsigned short	Uint16;
+typedef unsigned char	Uint8;
+
+/* Signed integer definitions (32bit, 16bit, 8bit) follow... */
+typedef int		Int32;
+typedef short		Int16;
+typedef char		Int8;
+
+/* the "expression" macros */
+
+/* the Field MaKe macro */
+#define CSL_FMK(PER_REG_FIELD, val)                                         \
+    (((val) << CSL_##PER_REG_FIELD##_SHIFT) & CSL_##PER_REG_FIELD##_MASK)
+
+/* the Field EXTract macro */
+#define CSL_FEXT(reg, PER_REG_FIELD)                                        \
+    (((reg) & CSL_##PER_REG_FIELD##_MASK) >> CSL_##PER_REG_FIELD##_SHIFT)
+
+/* the Field INSert macro */
+#define CSL_FINS(reg, PER_REG_FIELD, val)                                   \
+    ((reg) = ((reg) & ~CSL_##PER_REG_FIELD##_MASK)                          \
+    | CSL_FMK(PER_REG_FIELD, val))
+
+
+/* the "token" macros */
+
+/* the Field MaKe (Token) macro */
+#define CSL_FMKT(PER_REG_FIELD, TOKEN)                                      \
+    CSL_FMK(PER_REG_FIELD, CSL_##PER_REG_FIELD##_##TOKEN)
+
+/* the Field INSert (Token) macro */
+#define CSL_FINST(reg, PER_REG_FIELD, TOKEN)                                \
+    CSL_FINS((reg), PER_REG_FIELD, CSL_##PER_REG_FIELD##_##TOKEN)
+
+
+/* the "raw" macros */
+
+/* the Field MaKe (Raw) macro */
+#define CSL_FMKR(msb, lsb, val)                                             \
+    (((val) & ((1 << ((msb) - (lsb) + 1)) - 1)) << (lsb))
+
+/* the Field EXTract (Raw) macro */
+#define CSL_FEXTR(reg, msb, lsb)                                            \
+    (((reg) >> (lsb)) & ((1 << ((msb) - (lsb) + 1)) - 1))
+
+/* the Field INSert (Raw) macro */
+#define CSL_FINSR(reg, msb, lsb, val)                                       \
+    ((reg) = ((reg) &~ (((1 << ((msb) - (lsb) + 1)) - 1) << (lsb)))         \
+    | CSL_FMKR(msb, lsb, val))
+
+/**************************************************************************\
+* Register Overlay Structure
+\**************************************************************************/
+typedef struct CSL_Qm_Queue_Status
+{
+    volatile Uint32 QUEUE_THRESHOLD_STATUS_REG[256];
+}CSL_Qm_Queue_Status;
+
+/**************************************************************************\
+* Register Overlay Structure
+\**************************************************************************/
+typedef struct  {
+    volatile Uint32 REVISION_REG;
+    volatile Uint8 RSVD0[4];
+    volatile Uint32 QUEUE_DIVERSION_REG;
+    volatile Uint32 LINKING_RAM_REGION_0_BASE_ADDRESS_REG;
+    volatile Uint32 LINKING_RAM_REGION_0_SIZE_REG;
+    volatile Uint32 LINKING_RAM_REGION_1_BASE_ADDRESS_REG;
+    volatile Uint8 RSVD1[8];
+    volatile Uint32 FREE_DESCRIPTOR_STARVE_COUNT_REG[16];
+} CSL_Qm_configRegs;
+
+/**************************************************************************\
+* Field Definition Macros
+\**************************************************************************/
+
+/* REVISION_REG */
+
+#define CSL_QM_CONFIG_REVISION_REG_SCHEME_MASK (0xC0000000u)
+#define CSL_QM_CONFIG_REVISION_REG_SCHEME_SHIFT (0x0000001Eu)
+#define CSL_QM_CONFIG_REVISION_REG_SCHEME_RESETVAL (0x00000001u)
+
+#define CSL_QM_CONFIG_REVISION_REG_FUNCTION_MASK (0x0FFF0000u)
+#define CSL_QM_CONFIG_REVISION_REG_FUNCTION_SHIFT (0x00000010u)
+#define CSL_QM_CONFIG_REVISION_REG_FUNCTION_RESETVAL (0x00000E5Du)
+
+#define CSL_QM_CONFIG_REVISION_REG_REVRTL_MASK (0x0000F800u)
+#define CSL_QM_CONFIG_REVISION_REG_REVRTL_SHIFT (0x0000000Bu)
+#define CSL_QM_CONFIG_REVISION_REG_REVRTL_RESETVAL (0x00000000u)
+
+#define CSL_QM_CONFIG_REVISION_REG_REVMAJ_MASK (0x00000700u)
+#define CSL_QM_CONFIG_REVISION_REG_REVMAJ_SHIFT (0x00000008u)
+#define CSL_QM_CONFIG_REVISION_REG_REVMAJ_RESETVAL (0x00000001u)
+
+#define CSL_QM_CONFIG_REVISION_REG_REVCUSTOM_MASK (0x000000C0u)
+#define CSL_QM_CONFIG_REVISION_REG_REVCUSTOM_SHIFT (0x00000006u)
+#define CSL_QM_CONFIG_REVISION_REG_REVCUSTOM_RESETVAL (0x00000000u)
+
+#define CSL_QM_CONFIG_REVISION_REG_REVMIN_MASK (0x0000003Fu)
+#define CSL_QM_CONFIG_REVISION_REG_REVMIN_SHIFT (0x00000000u)
+#define CSL_QM_CONFIG_REVISION_REG_REVMIN_RESETVAL (0x00000005u)
+
+#define CSL_QM_CONFIG_REVISION_REG_RESETVAL (0x4E5D0105u)
+
+/* QUEUE_DIVERSION_REG */
+
+#define CSL_QM_CONFIG_QUEUE_DIVERSION_REG_HEAD_TAIL_MASK (0x80000000u)
+#define CSL_QM_CONFIG_QUEUE_DIVERSION_REG_HEAD_TAIL_SHIFT (0x0000001Fu)
+#define CSL_QM_CONFIG_QUEUE_DIVERSION_REG_HEAD_TAIL_RESETVAL (0x00000000u)
+
+#define CSL_QM_CONFIG_QUEUE_DIVERSION_REG_DEST_QNUM_MASK (0x3FFF0000u)
+#define CSL_QM_CONFIG_QUEUE_DIVERSION_REG_DEST_QNUM_SHIFT (0x00000010u)
+#define CSL_QM_CONFIG_QUEUE_DIVERSION_REG_DEST_QNUM_RESETVAL (0x00000000u)
+
+#define CSL_QM_CONFIG_QUEUE_DIVERSION_REG_SOURCE_QNUM_MASK (0x00003FFFu)
+#define CSL_QM_CONFIG_QUEUE_DIVERSION_REG_SOURCE_QNUM_SHIFT (0x00000000u)
+#define CSL_QM_CONFIG_QUEUE_DIVERSION_REG_SOURCE_QNUM_RESETVAL (0x00000000u)
+
+#define CSL_QM_CONFIG_QUEUE_DIVERSION_REG_RESETVAL (0x00000000u)
+
+/* LINKING_RAM_REGION_0_BASE_ADDRESS_REG */
+
+#define CSL_QM_CONFIG_LINKING_RAM_REGION_0_BASE_ADDRESS_REG_REGION0_BASE_MASK (0xFFFFFFFFu)
+#define CSL_QM_CONFIG_LINKING_RAM_REGION_0_BASE_ADDRESS_REG_REGION0_BASE_SHIFT (0x00000000u)
+#define CSL_QM_CONFIG_LINKING_RAM_REGION_0_BASE_ADDRESS_REG_REGION0_BASE_RESETVAL (0x00000000u)
+
+#define CSL_QM_CONFIG_LINKING_RAM_REGION_0_BASE_ADDRESS_REG_RESETVAL (0x00000000u)
+
+/* LINKING_RAM_REGION_0_SIZE_REG */
+
+#define CSL_QM_CONFIG_LINKING_RAM_REGION_0_SIZE_REG_REGION0_SIZE_MASK (0x0007FFFFu)
+#define CSL_QM_CONFIG_LINKING_RAM_REGION_0_SIZE_REG_REGION0_SIZE_SHIFT (0x00000000u)
+#define CSL_QM_CONFIG_LINKING_RAM_REGION_0_SIZE_REG_REGION0_SIZE_RESETVAL (0x00000000u)
+
+#define CSL_QM_CONFIG_LINKING_RAM_REGION_0_SIZE_REG_RESETVAL (0x00000000u)
+
+/* LINKING_RAM_REGION_1_BASE_ADDRESS_REG */
+
+#define CSL_QM_CONFIG_LINKING_RAM_REGION_1_BASE_ADDRESS_REG_REGION1_BASE_MASK (0xFFFFFFFFu)
+#define CSL_QM_CONFIG_LINKING_RAM_REGION_1_BASE_ADDRESS_REG_REGION1_BASE_SHIFT (0x00000000u)
+#define CSL_QM_CONFIG_LINKING_RAM_REGION_1_BASE_ADDRESS_REG_REGION1_BASE_RESETVAL (0x00000000u)
+
+#define CSL_QM_CONFIG_LINKING_RAM_REGION_1_BASE_ADDRESS_REG_RESETVAL (0x00000000u)
+
+/* FREE_DESCRIPTOR_STARVE_COUNT_REG */
+
+#define CSL_QM_CONFIG_FREE_DESCRIPTOR_STARVE_COUNT_REG_FDBQ3_STARVE_CNT_MASK (0xFF000000u)
+#define CSL_QM_CONFIG_FREE_DESCRIPTOR_STARVE_COUNT_REG_FDBQ3_STARVE_CNT_SHIFT (0x00000018u)
+#define CSL_QM_CONFIG_FREE_DESCRIPTOR_STARVE_COUNT_REG_FDBQ3_STARVE_CNT_RESETVAL (0x00000000u)
+
+#define CSL_QM_CONFIG_FREE_DESCRIPTOR_STARVE_COUNT_REG_FDBQ2_STARVE_CNT_MASK (0x00FF0000u)
+#define CSL_QM_CONFIG_FREE_DESCRIPTOR_STARVE_COUNT_REG_FDBQ2_STARVE_CNT_SHIFT (0x00000010u)
+#define CSL_QM_CONFIG_FREE_DESCRIPTOR_STARVE_COUNT_REG_FDBQ2_STARVE_CNT_RESETVAL (0x00000000u)
+
+#define CSL_QM_CONFIG_FREE_DESCRIPTOR_STARVE_COUNT_REG_FDBQ1_STARVE_CNT_MASK (0x0000FF00u)
+#define CSL_QM_CONFIG_FREE_DESCRIPTOR_STARVE_COUNT_REG_FDBQ1_STARVE_CNT_SHIFT (0x00000008u)
+#define CSL_QM_CONFIG_FREE_DESCRIPTOR_STARVE_COUNT_REG_FDBQ1_STARVE_CNT_RESETVAL (0x00000000u)
+
+#define CSL_QM_CONFIG_FREE_DESCRIPTOR_STARVE_COUNT_REG_FDBQ0_STARVE_CNT_MASK (0x000000FFu)
+#define CSL_QM_CONFIG_FREE_DESCRIPTOR_STARVE_COUNT_REG_FDBQ0_STARVE_CNT_SHIFT (0x00000000u)
+#define CSL_QM_CONFIG_FREE_DESCRIPTOR_STARVE_COUNT_REG_FDBQ0_STARVE_CNT_RESETVAL (0x00000000u)
+
+#define CSL_QM_CONFIG_FREE_DESCRIPTOR_STARVE_COUNT_REG_RESETVAL (0x00000000u)
+
+/**************************************************************************\
+* Register Overlay Structure
+\**************************************************************************/
+typedef struct  {
+    volatile Uint32 MEMORY_REGION_BASE_ADDRESS_REG;
+    volatile Uint32 MEMORY_REGION_START_INDEX_REG;
+    volatile Uint32 MEMORY_REGION_DESCRIPTOR_SETUP_REG;
+    volatile Uint8 RSVD0[4];
+} CSL_Qm_descriptor_region_configMemory_region_base_address_groupRegs;
+
+/**************************************************************************\
+* Register Overlay Structure
+\**************************************************************************/
+typedef struct  {
+    CSL_Qm_descriptor_region_configMemory_region_base_address_groupRegs MEMORY_REGION_BASE_ADDRESS_GROUP[64];
+} CSL_Qm_descriptor_region_configRegs;
+
+/**************************************************************************\
+* Field Definition Macros
+\**************************************************************************/
+
+/* MEMORY_REGION_BASE_ADDRESS_REG */
+
+#define CSL_QM_DESCRIPTOR_REGION_CONFIG_MEMORY_REGION_BASE_ADDRESS_REG_REGR_BASE_MASK (0xFFFFFFFFu)
+#define CSL_QM_DESCRIPTOR_REGION_CONFIG_MEMORY_REGION_BASE_ADDRESS_REG_REGR_BASE_SHIFT (0x00000000u)
+#define CSL_QM_DESCRIPTOR_REGION_CONFIG_MEMORY_REGION_BASE_ADDRESS_REG_REGR_BASE_RESETVAL (0x00000000u)
+
+#define CSL_QM_DESCRIPTOR_REGION_CONFIG_MEMORY_REGION_BASE_ADDRESS_REG_RESETVAL (0x00000000u)
+
+/* MEMORY_REGION_START_INDEX_REG */
+
+#define CSL_QM_DESCRIPTOR_REGION_CONFIG_MEMORY_REGION_START_INDEX_REG_START_INDEX_MASK (0x0007FFFFu)
+#define CSL_QM_DESCRIPTOR_REGION_CONFIG_MEMORY_REGION_START_INDEX_REG_START_INDEX_SHIFT (0x00000000u)
+#define CSL_QM_DESCRIPTOR_REGION_CONFIG_MEMORY_REGION_START_INDEX_REG_START_INDEX_RESETVAL (0x00000000u)
+
+#define CSL_QM_DESCRIPTOR_REGION_CONFIG_MEMORY_REGION_START_INDEX_REG_RESETVAL (0x00000000u)
+
+/* MEMORY_REGION_DESCRIPTOR_SETUP_REG */
+
+#define CSL_QM_DESCRIPTOR_REGION_CONFIG_MEMORY_REGION_DESCRIPTOR_SETUP_REG_DESC_SIZE_MASK (0x1FFF0000u)
+#define CSL_QM_DESCRIPTOR_REGION_CONFIG_MEMORY_REGION_DESCRIPTOR_SETUP_REG_DESC_SIZE_SHIFT (0x00000010u)
+#define CSL_QM_DESCRIPTOR_REGION_CONFIG_MEMORY_REGION_DESCRIPTOR_SETUP_REG_DESC_SIZE_RESETVAL (0x00000000u)
+
+#define CSL_QM_DESCRIPTOR_REGION_CONFIG_MEMORY_REGION_DESCRIPTOR_SETUP_REG_REG_SIZE_MASK (0x0000000Fu)
+#define CSL_QM_DESCRIPTOR_REGION_CONFIG_MEMORY_REGION_DESCRIPTOR_SETUP_REG_REG_SIZE_SHIFT (0x00000000u)
+#define CSL_QM_DESCRIPTOR_REGION_CONFIG_MEMORY_REGION_DESCRIPTOR_SETUP_REG_REG_SIZE_RESETVAL (0x00000000u)
+
+#define CSL_QM_DESCRIPTOR_REGION_CONFIG_MEMORY_REGION_DESCRIPTOR_SETUP_REG_RESETVAL (0x00000000u)
+
+/**************************************************************************\
+* Register Overlay Structure for QUEUE_MGMT_GROUP
+\**************************************************************************/
+typedef struct  {
+    volatile Uint32 QUEUE_REG_A;
+    volatile Uint32 QUEUE_REG_B;
+    volatile Uint32 QUEUE_REG_C;
+    volatile Uint32 QUEUE_REG_D;
+} CSL_Qm_queue_managementQueue_mgmt_groupRegs;
+
+/**************************************************************************\
+* Register Overlay Structure
+\**************************************************************************/
+typedef struct  {
+    CSL_Qm_queue_managementQueue_mgmt_groupRegs QUEUE_MGMT_GROUP[8192];
+} CSL_Qm_queue_managementRegs;
+
+/**************************************************************************\
+* Field Definition Macros
+\**************************************************************************/
+
+/* QUEUE_REG_A */
+
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_A_QUEUE_ENTRY_COUNT_MASK (0x0007FFFFu)
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_A_QUEUE_ENTRY_COUNT_SHIFT (0x00000000u)
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_A_QUEUE_ENTRY_COUNT_RESETVAL (0x00000000u)
+
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_A_RESETVAL (0x00000000u)
+
+/* QUEUE_REG_B */
+
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_B_QUEUE_BYTE_COUNT_MASK (0xFFFFFFFFu)
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_B_QUEUE_BYTE_COUNT_SHIFT (0x00000000u)
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_B_QUEUE_BYTE_COUNT_RESETVAL (0x00000000u)
+
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_B_RESETVAL (0x00000000u)
+
+/* QUEUE_REG_C */
+
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_C_HEAD_TAIL_MASK (0x80000000u)
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_C_HEAD_TAIL_SHIFT (0x0000001Fu)
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_C_HEAD_TAIL_RESETVAL (0x00000000u)
+
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_C_PACKET_SIZE_MASK (0x0001FFFFu)
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_C_PACKET_SIZE_SHIFT (0x00000000u)
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_C_PACKET_SIZE_RESETVAL (0x00000000u)
+
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_C_RESETVAL (0x00000000u)
+
+/* QUEUE_REG_D */
+
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_D_DESC_PTR_MASK (0xFFFFFFF0u)
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_D_DESC_PTR_SHIFT (0x00000004u)
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_D_DESC_PTR_RESETVAL (0x00000000u)
+
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_D_DESC_INFO_MASK (0x0000000Fu)
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_D_DESC_INFO_SHIFT (0x00000000u)
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_D_DESC_INFO_RESETVAL (0x00000000u)
+
+#define CSL_QM_QUEUE_MANAGEMENT_QUEUE_REG_D_RESETVAL (0x00000000u)
+
+/**************************************************************************\
+* Register Overlay Structure for QUEUE_STATUS_CONFIG_GROUP
+\**************************************************************************/
+typedef struct  {
+    volatile Uint32 QUEUE_STATUS_CONFIG_REG_A;
+    volatile Uint32 QUEUE_STATUS_CONFIG_REG_B;
+    volatile Uint32 QUEUE_STATUS_CONFIG_REG_C;
+    volatile Uint32 QUEUE_STATUS_CONFIG_REG_D;
+} CSL_Qm_queue_status_configQueue_status_config_groupRegs;
+
+/**************************************************************************\
+* Register Overlay Structure
+\**************************************************************************/
+typedef struct  {
+    CSL_Qm_queue_status_configQueue_status_config_groupRegs QUEUE_STATUS_CONFIG_GROUP[8192];
+} CSL_Qm_queue_status_configRegs;
+
+/**************************************************************************\
+* Field Definition Macros
+\**************************************************************************/
+
+/* QUEUE_STATUS_CONFIG_REG_A */
+
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_A_QUEUE_ENTRY_COUNT_MASK (0x0007FFFFu)
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_A_QUEUE_ENTRY_COUNT_SHIFT (0x00000000u)
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_A_QUEUE_ENTRY_COUNT_RESETVAL (0x00000000u)
+
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_A_RESETVAL (0x00000000u)
+
+/* QUEUE_STATUS_CONFIG_REG_B */
+
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_B_QUEUE_BYTE_COUNT_MASK (0xFFFFFFFFu)
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_B_QUEUE_BYTE_COUNT_SHIFT (0x00000000u)
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_B_QUEUE_BYTE_COUNT_RESETVAL (0x00000000u)
+
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_B_RESETVAL (0x00000000u)
+
+/* QUEUE_STATUS_CONFIG_REG_C */
+
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_C_PACKET_SIZE_MASK (0x0001FFFFu)
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_C_PACKET_SIZE_SHIFT (0x00000000u)
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_C_PACKET_SIZE_RESETVAL (0x00000000u)
+
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_C_RESETVAL (0x00000000u)
+
+/* QUEUE_STATUS_CONFIG_REG_D */
+
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_D_THRESHOLD_MASK (0x0000000Fu)
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_D_THRESHOLD_SHIFT (0x00000000u)
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_D_THRESHOLD_RESETVAL (0x00000000u)
+
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_D_THRESHOLD_HILO_MASK (0x00000080u)
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_D_THRESHOLD_HILO_SHIFT (0x00000007u)
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_D_THRESHOLD_HILO_RESETVAL (0x00000000u)
+
+#define CSL_QM_QUEUE_STATUS_CONFIG_QUEUE_STATUS_CONFIG_REG_D_RESETVAL (0x00000000u)
+
+/**************************************************************************\
+* Register Overlay Structure
+\**************************************************************************/
+typedef struct  {
+    volatile Uint32 REVISION_REG;
+    volatile Uint8 RSVD0[12];
+    volatile Uint32 EOI_REG;
+    volatile Uint32 INTR_VECTOR_REG;
+    volatile Uint8 RSVD1[488];
+    volatile Uint32 STATUS_REG0;
+    volatile Uint32 STATUS_REG1;
+    volatile Uint32 STATUS_REG2;
+    volatile Uint32 STATUS_REG3;
+    volatile Uint32 STATUS_REG4;
+    volatile Uint8 RSVD2[108];
+    volatile Uint32 STATUS_CLR_REG0;
+    volatile Uint32 STATUS_CLR_REG1;
+    volatile Uint8 RSVD3[8];
+    volatile Uint32 STATUS_CLR_REG4;
+    volatile Uint8 RSVD4[108];
+    volatile Uint32 INTCNT_REG[50];
+    volatile Uint8 RSVD5[184];
+    volatile Uint32 INTR_VECTOR_REG_HOST;
+} CSL_Qm_intdRegs;
+
+/**************************************************************************\
+* Field Definition Macros
+\**************************************************************************/
+
+/* REVISION_REG */
+
+#define CSL_QM_INTD_REVISION_REG_SCHEME_MASK (0xC0000000u)
+#define CSL_QM_INTD_REVISION_REG_SCHEME_SHIFT (0x0000001Eu)
+#define CSL_QM_INTD_REVISION_REG_SCHEME_RESETVAL (0x00000001u)
+
+#define CSL_QM_INTD_REVISION_REG_MODULE_MASK (0x0FFF0000u)
+#define CSL_QM_INTD_REVISION_REG_MODULE_SHIFT (0x00000010u)
+#define CSL_QM_INTD_REVISION_REG_MODULE_RESETVAL (0x00000E83u)
+
+#define CSL_QM_INTD_REVISION_REG_REV_RTL_MASK (0x0000F800u)
+#define CSL_QM_INTD_REVISION_REG_REV_RTL_SHIFT (0x0000000Bu)
+#define CSL_QM_INTD_REVISION_REG_REV_RTL_RESETVAL (0x00000016u)
+
+#define CSL_QM_INTD_REVISION_REG_REV_MAJOR_MASK (0x00000700u)
+#define CSL_QM_INTD_REVISION_REG_REV_MAJOR_SHIFT (0x00000008u)
+#define CSL_QM_INTD_REVISION_REG_REV_MAJOR_RESETVAL (0x00000001u)
+
+#define CSL_QM_INTD_REVISION_REG_REV_CUSTOM_MASK (0x000000C0u)
+#define CSL_QM_INTD_REVISION_REG_REV_CUSTOM_SHIFT (0x00000006u)
+#define CSL_QM_INTD_REVISION_REG_REV_CUSTOM_RESETVAL (0x00000000u)
+
+#define CSL_QM_INTD_REVISION_REG_REV_MINOR_MASK (0x0000003Fu)
+#define CSL_QM_INTD_REVISION_REG_REV_MINOR_SHIFT (0x00000000u)
+#define CSL_QM_INTD_REVISION_REG_REV_MINOR_RESETVAL (0x00000000u)
+
+#define CSL_QM_INTD_REVISION_REG_RESETVAL (0x4E83B100u)
+
+/* EOI_REG */
+
+#define CSL_QM_INTD_EOI_REG_EOI_VECTOR_MASK (0x000000FFu)
+#define CSL_QM_INTD_EOI_REG_EOI_VECTOR_SHIFT (0x00000000u)
+#define CSL_QM_INTD_EOI_REG_EOI_VECTOR_RESETVAL (0x00000000u)
+
+#define CSL_QM_INTD_EOI_REG_RESETVAL     (0x00000000u)
+
+/* INTR_VECTOR_REG */
+
+#define CSL_QM_INTD_INTR_VECTOR_REG_INTR_VECTOR_MASK (0xFFFFFFFFu)
+#define CSL_QM_INTD_INTR_VECTOR_REG_INTR_VECTOR_SHIFT (0x00000000u)
+#define CSL_QM_INTD_INTR_VECTOR_REG_INTR_VECTOR_RESETVAL (0x00000000u)
+
+#define CSL_QM_INTD_INTR_VECTOR_REG_RESETVAL (0x00000000u)
+
+/* STATUS_REG0 */
+
+#define CSL_QM_INTD_STATUS_REG0_STATUS_HOST_HI_IN_INTR_MASK (0xFFFFFFFFu)
+#define CSL_QM_INTD_STATUS_REG0_STATUS_HOST_HI_IN_INTR_SHIFT (0x00000000u)
+#define CSL_QM_INTD_STATUS_REG0_STATUS_HOST_HI_IN_INTR_RESETVAL (0x00000000u)
+
+#define CSL_QM_INTD_STATUS_REG0_RESETVAL (0x00000000u)
+
+/* STATUS_REG1 */
+
+#define CSL_QM_INTD_STATUS_REG1_STATUS_HOST_LO_IN_INTR_MASK (0x0000FFFFu)
+#define CSL_QM_INTD_STATUS_REG1_STATUS_HOST_LO_IN_INTR_SHIFT (0x00000000u)
+#define CSL_QM_INTD_STATUS_REG1_STATUS_HOST_LO_IN_INTR_RESETVAL (0x00000000u)
+
+#define CSL_QM_INTD_STATUS_REG1_RESETVAL (0x00000000u)
+
+/* STATUS_REG2 */
+
+#define CSL_QM_INTD_STATUS_REG2_STATUS_HOST_HI_LINTR_MASK (0xFFFFFFFFu)
+#define CSL_QM_INTD_STATUS_REG2_STATUS_HOST_HI_LINTR_SHIFT (0x00000000u)
+#define CSL_QM_INTD_STATUS_REG2_STATUS_HOST_HI_LINTR_RESETVAL (0x00000000u)
+
+#define CSL_QM_INTD_STATUS_REG2_RESETVAL (0x00000000u)
+
+/* STATUS_REG3 */
+
+#define CSL_QM_INTD_STATUS_REG3_STATUS_HOST_LO_LINTR_MASK (0x0001FFFFu)
+#define CSL_QM_INTD_STATUS_REG3_STATUS_HOST_LO_LINTR_SHIFT (0x00000000u)
+#define CSL_QM_INTD_STATUS_REG3_STATUS_HOST_LO_LINTR_RESETVAL (0x00000000u)
+
+#define CSL_QM_INTD_STATUS_REG3_RESETVAL (0x00000000u)
+
+/* STATUS_REG4 */
+
+#define CSL_QM_INTD_STATUS_REG4_STATUS_HOST_CDMA_STARVE0_MASK (0x00000001u)
+#define CSL_QM_INTD_STATUS_REG4_STATUS_HOST_CDMA_STARVE0_SHIFT (0x00000000u)
+#define CSL_QM_INTD_STATUS_REG4_STATUS_HOST_CDMA_STARVE0_RESETVAL (0x00000000u)
+
+#define CSL_QM_INTD_STATUS_REG4_STATUS_HOST_CDMA_STARVE1_MASK (0x00000002u)
+#define CSL_QM_INTD_STATUS_REG4_STATUS_HOST_CDMA_STARVE1_SHIFT (0x00000001u)
+#define CSL_QM_INTD_STATUS_REG4_STATUS_HOST_CDMA_STARVE1_RESETVAL (0x00000000u)
+
+#define CSL_QM_INTD_STATUS_REG4_RESETVAL (0x00000000u)
+
+/* STATUS_CLR_REG0 */
+
+#define CSL_QM_INTD_STATUS_CLR_REG0_STATUS_HOST_HI_IN_INTR_CLR_MASK (0xFFFFFFFFu)
+#define CSL_QM_INTD_STATUS_CLR_REG0_STATUS_HOST_HI_IN_INTR_CLR_SHIFT (0x00000000u)
+#define CSL_QM_INTD_STATUS_CLR_REG0_STATUS_HOST_HI_IN_INTR_CLR_RESETVAL (0x00000000u)
+
+#define CSL_QM_INTD_STATUS_CLR_REG0_RESETVAL (0x00000000u)
+
+/* STATUS_CLR_REG1 */
+
+#define CSL_QM_INTD_STATUS_CLR_REG1_STATUS_HOST_LO_IN_INTR_CLR_MASK (0x0000FFFFu)
+#define CSL_QM_INTD_STATUS_CLR_REG1_STATUS_HOST_LO_IN_INTR_CLR_SHIFT (0x00000000u)
+#define CSL_QM_INTD_STATUS_CLR_REG1_STATUS_HOST_LO_IN_INTR_CLR_RESETVAL (0x00000000u)
+
+#define CSL_QM_INTD_STATUS_CLR_REG1_RESETVAL (0x00000000u)
+
+/* STATUS_CLR_REG4 */
+
+#define CSL_QM_INTD_STATUS_CLR_REG4_STATUS_HOST_CDMA_STARVE0_CLR_MASK (0x00000001u)
+#define CSL_QM_INTD_STATUS_CLR_REG4_STATUS_HOST_CDMA_STARVE0_CLR_SHIFT (0x00000000u)
+#define CSL_QM_INTD_STATUS_CLR_REG4_STATUS_HOST_CDMA_STARVE0_CLR_RESETVAL (0x00000000u)
+
+#define CSL_QM_INTD_STATUS_CLR_REG4_STATUS_HOST_CDMA_STARVE1_CLR_MASK (0x00000002u)
+#define CSL_QM_INTD_STATUS_CLR_REG4_STATUS_HOST_CDMA_STARVE1_CLR_SHIFT (0x00000001u)
+#define CSL_QM_INTD_STATUS_CLR_REG4_STATUS_HOST_CDMA_STARVE1_CLR_RESETVAL (0x00000000u)
+
+#define CSL_QM_INTD_STATUS_CLR_REG4_RESETVAL (0x00000000u)
+
+/* INTCNT_REG */
+
+#define CSL_QM_INTD_INTCNT_REG_INTCNT_HOST_CNT_HI_IN_INTR_MASK (0x000000FFu)
+#define CSL_QM_INTD_INTCNT_REG_INTCNT_HOST_CNT_HI_IN_INTR_SHIFT (0x00000000u)
+#define CSL_QM_INTD_INTCNT_REG_INTCNT_HOST_CNT_HI_IN_INTR_RESETVAL (0x00000000u)
+
+#define CSL_QM_INTD_INTCNT_REG_RESETVAL  (0x00000000u)
+
+/* INTR_VECTOR_REG_HOST */
+
+#define CSL_QM_INTD_INTR_VECTOR_REG_HOST_INTR_VECTOR_HOST_MASK (0xFFFFFFFFu)
+#define CSL_QM_INTD_INTR_VECTOR_REG_HOST_INTR_VECTOR_HOST_SHIFT (0x00000000u)
+#define CSL_QM_INTD_INTR_VECTOR_REG_HOST_INTR_VECTOR_HOST_RESETVAL (0x00000000u)
+
+#define CSL_QM_INTD_INTR_VECTOR_REG_HOST_RESETVAL (0x00000000u)
+
+/**************************************************************************\
+* Register Overlay Structure
+\**************************************************************************/
+typedef struct  {
+    volatile Uint32 PDSP_CONTROL_REG;
+    volatile Uint32 PDSP_STATUS_REG;
+    volatile Uint32 PDSP_WAKEUP_ENABLE_REG;
+    volatile Uint32 PDSP_CYCLE_COUNT_REG;
+    volatile Uint32 PDSP_STALL_COUNT_REG;
+    volatile Uint8 RSVD0[12];
+    volatile Uint32 PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_0;
+    volatile Uint32 PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_1;
+    volatile Uint32 PDSP_CONSTANT_TABLE_PROG_PTR_REG_0;
+    volatile Uint32 PDSP_CONSTANT_TABLE_PROG_PTR_REG_1;
+} CSL_PdspPdsp_regsRegs;
+
+/**************************************************************************\
+* Register Overlay Structure for PDSP_DEBUG_REGS
+\**************************************************************************/
+typedef struct  {
+    volatile Uint32 PDSP_IGP[32];
+    volatile Uint32 PDSP_ICTE[32];
+} CSL_PdspPdsp_debug_regsRegs;
+
+/**************************************************************************\
+* Register Overlay Structure
+\**************************************************************************/
+typedef struct  {
+    volatile Uint32 PDSP_CONTROL_REG;
+    volatile Uint32 PDSP_STATUS_REG;
+    volatile Uint32 PDSP_WAKEUP_ENABLE_REG;
+    volatile Uint32 PDSP_CYCLE_COUNT_REG;
+    volatile Uint32 PDSP_STALL_COUNT_REG;
+    volatile Uint8 RSVD0[12];
+    volatile Uint32 PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_0;
+    volatile Uint32 PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_1;
+    volatile Uint32 PDSP_CONSTANT_TABLE_PROG_PTR_REG_0;
+    volatile Uint32 PDSP_CONSTANT_TABLE_PROG_PTR_REG_1;
+    volatile Uint8 RSVD1[2000];
+    volatile Uint32 PDSP_IGP[32];
+    volatile Uint32 PDSP_ICTE[32];
+    volatile Uint8 RSVD2[1792];
+    volatile Uint32 PDSP_IRAM[2048];
+} CSL_PdspRegs;
+
+/**************************************************************************\
+* Field Definition Macros
+\**************************************************************************/
+
+/* PDSP_CONTROL_REG */
+
+#define CSL_PDSP_PDSP_CONTROL_REG_SOFT_RST_N_MASK (0x00000001u)
+#define CSL_PDSP_PDSP_CONTROL_REG_SOFT_RST_N_SHIFT (0x00000000u)
+#define CSL_PDSP_PDSP_CONTROL_REG_SOFT_RST_N_RESETVAL (0x00000001u)
+
+#define CSL_PDSP_PDSP_CONTROL_REG_PDSP_ENABLE_MASK (0x00000002u)
+#define CSL_PDSP_PDSP_CONTROL_REG_PDSP_ENABLE_SHIFT (0x00000001u)
+#define CSL_PDSP_PDSP_CONTROL_REG_PDSP_ENABLE_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_CONTROL_REG_PDSP_SLEEPING_MASK (0x00000004u)
+#define CSL_PDSP_PDSP_CONTROL_REG_PDSP_SLEEPING_SHIFT (0x00000002u)
+#define CSL_PDSP_PDSP_CONTROL_REG_PDSP_SLEEPING_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_CONTROL_REG_COUNTER_ENABLE_MASK (0x00000008u)
+#define CSL_PDSP_PDSP_CONTROL_REG_COUNTER_ENABLE_SHIFT (0x00000003u)
+#define CSL_PDSP_PDSP_CONTROL_REG_COUNTER_ENABLE_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_CONTROL_REG_RESTART_MASK (0x00000010u)
+#define CSL_PDSP_PDSP_CONTROL_REG_RESTART_SHIFT (0x00000004u)
+#define CSL_PDSP_PDSP_CONTROL_REG_RESTART_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_CONTROL_REG_SINGLE_STEP_MASK (0x00000100u)
+#define CSL_PDSP_PDSP_CONTROL_REG_SINGLE_STEP_SHIFT (0x00000008u)
+#define CSL_PDSP_PDSP_CONTROL_REG_SINGLE_STEP_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_CONTROL_REG_BIG_ENDIAN_MASK (0x00004000u)
+#define CSL_PDSP_PDSP_CONTROL_REG_BIG_ENDIAN_SHIFT (0x0000000Eu)
+#define CSL_PDSP_PDSP_CONTROL_REG_BIG_ENDIAN_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_CONTROL_REG_PDSP_STATE_MASK (0x00008000u)
+#define CSL_PDSP_PDSP_CONTROL_REG_PDSP_STATE_SHIFT (0x0000000Fu)
+#define CSL_PDSP_PDSP_CONTROL_REG_PDSP_STATE_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_CONTROL_REG_PCOUNTER_RST_VAL_MASK (0xFFFF0000u)
+#define CSL_PDSP_PDSP_CONTROL_REG_PCOUNTER_RST_VAL_SHIFT (0x00000010u)
+#define CSL_PDSP_PDSP_CONTROL_REG_PCOUNTER_RST_VAL_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_CONTROL_REG_RESETVAL (0x00000001u)
+
+/* PDSP_STATUS_REG */
+
+#define CSL_PDSP_PDSP_STATUS_REG_PCOUNTER_MASK (0x0000FFFFu)
+#define CSL_PDSP_PDSP_STATUS_REG_PCOUNTER_SHIFT (0x00000000u)
+#define CSL_PDSP_PDSP_STATUS_REG_PCOUNTER_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_STATUS_REG_RESETVAL (0x00000000u)
+
+/* PDSP_WAKEUP_ENABLE_REG */
+
+#define CSL_PDSP_PDSP_WAKEUP_ENABLE_REG_BITWISE_ENABLES_MASK (0xFFFFFFFFu)
+#define CSL_PDSP_PDSP_WAKEUP_ENABLE_REG_BITWISE_ENABLES_SHIFT (0x00000000u)
+#define CSL_PDSP_PDSP_WAKEUP_ENABLE_REG_BITWISE_ENABLES_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_WAKEUP_ENABLE_REG_RESETVAL (0x00000000u)
+
+/* PDSP_CYCLE_COUNT_REG */
+
+#define CSL_PDSP_PDSP_CYCLE_COUNT_REG_CYCLECOUNT_MASK (0xFFFFFFFFu)
+#define CSL_PDSP_PDSP_CYCLE_COUNT_REG_CYCLECOUNT_SHIFT (0x00000000u)
+#define CSL_PDSP_PDSP_CYCLE_COUNT_REG_CYCLECOUNT_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_CYCLE_COUNT_REG_RESETVAL (0x00000000u)
+
+/* PDSP_STALL_COUNT_REG */
+
+#define CSL_PDSP_PDSP_STALL_COUNT_REG_STALLCOUNT_MASK (0xFFFFFFFFu)
+#define CSL_PDSP_PDSP_STALL_COUNT_REG_STALLCOUNT_SHIFT (0x00000000u)
+#define CSL_PDSP_PDSP_STALL_COUNT_REG_STALLCOUNT_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_STALL_COUNT_REG_RESETVAL (0x00000000u)
+
+/* PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_0 */
+
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_0_C24_BLK_INDEX_MASK (0x000000FFu)
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_0_C24_BLK_INDEX_SHIFT (0x00000000u)
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_0_C24_BLK_INDEX_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_0_C25_BLK_INDEX_MASK (0x00FF0000u)
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_0_C25_BLK_INDEX_SHIFT (0x00000010u)
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_0_C25_BLK_INDEX_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_0_RESETVAL (0x00000000u)
+
+/* PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_1 */
+
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_1_C26_BLK_INDEX_MASK (0x000000FFu)
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_1_C26_BLK_INDEX_SHIFT (0x00000000u)
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_1_C26_BLK_INDEX_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_1_C27_BLK_INDEX_MASK (0x00FF0000u)
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_1_C27_BLK_INDEX_SHIFT (0x00000010u)
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_1_C27_BLK_INDEX_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_BLOCK_INDEX_REG_1_RESETVAL (0x00000000u)
+
+/* PDSP_CONSTANT_TABLE_PROG_PTR_REG_0 */
+
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_PROG_PTR_REG_0_C28_POINTER_MASK (0x0000FFFFu)
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_PROG_PTR_REG_0_C28_POINTER_SHIFT (0x00000000u)
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_PROG_PTR_REG_0_C28_POINTER_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_PROG_PTR_REG_0_C29_POINTER_MASK (0xFFFF0000u)
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_PROG_PTR_REG_0_C29_POINTER_SHIFT (0x00000010u)
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_PROG_PTR_REG_0_C29_POINTER_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_PROG_PTR_REG_0_RESETVAL (0x00000000u)
+
+/* PDSP_CONSTANT_TABLE_PROG_PTR_REG_1 */
+
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_PROG_PTR_REG_1_C30_POINTER_MASK (0x0000FFFFu)
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_PROG_PTR_REG_1_C30_POINTER_SHIFT (0x00000000u)
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_PROG_PTR_REG_1_C30_POINTER_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_PROG_PTR_REG_1_C31_POINTER_MASK (0xFFFF0000u)
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_PROG_PTR_REG_1_C31_POINTER_SHIFT (0x00000010u)
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_PROG_PTR_REG_1_C31_POINTER_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_CONSTANT_TABLE_PROG_PTR_REG_1_RESETVAL (0x00000000u)
+
+/* PDSP_IGP */
+
+#define CSL_PDSP_PDSP_IGP_REGN_MASK      (0xFFFFFFFFu)
+#define CSL_PDSP_PDSP_IGP_REGN_SHIFT     (0x00000000u)
+#define CSL_PDSP_PDSP_IGP_REGN_RESETVAL  (0x00000000u)
+
+#define CSL_PDSP_PDSP_IGP_RESETVAL       (0x00000000u)
+
+/* PDSP_ICTE */
+
+#define CSL_PDSP_PDSP_ICTE_CT_ENTRYN_MASK (0xFFFFFFFFu)
+#define CSL_PDSP_PDSP_ICTE_CT_ENTRYN_SHIFT (0x00000000u)
+#define CSL_PDSP_PDSP_ICTE_CT_ENTRYN_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_ICTE_RESETVAL      (0x00000000u)
+
+/* PDSP_IRAM */
+
+#define CSL_PDSP_PDSP_IRAM_PDSP_IRAM_MASK (0xFFFFFFFFu)
+#define CSL_PDSP_PDSP_IRAM_PDSP_IRAM_SHIFT (0x00000000u)
+#define CSL_PDSP_PDSP_IRAM_PDSP_IRAM_RESETVAL (0x00000000u)
+
+#define CSL_PDSP_PDSP_IRAM_RESETVAL      (0x00000000u)
+
+/**************************************************************************\
+* Register Overlay Structure
+\**************************************************************************/
+typedef struct  {
+    volatile Uint32 REVISION_REG;
+    volatile Uint32 PERF_CONTROL_REG;
+    volatile Uint32 EMULATION_CONTROL_REG;
+    volatile Uint32 PRIORITY_CONTROL_REG;
+    volatile Uint32 QM_BASE_ADDRESS_REG[4];
+} CSL_Cppidma_global_configRegs;
+
+/**************************************************************************\
+* Field Definition Macros
+\**************************************************************************/
+
+/* REVISION_REG */
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_REVMIN_MASK (0x0000003Fu)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_REVMIN_SHIFT (0x00000000u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_REVMIN_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_CUSTOM_MASK (0x000000C0u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_CUSTOM_SHIFT (0x00000006u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_CUSTOM_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_REVMAJ_MASK (0x00000700u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_REVMAJ_SHIFT (0x00000008u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_REVMAJ_RESETVAL (0x00000001u)
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_REVRTL_MASK (0x0000F800u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_REVRTL_SHIFT (0x0000000Bu)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_REVRTL_RESETVAL (0x00000019u)
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_FUNCTION_ID_MASK (0x0FFF0000u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_FUNCTION_ID_SHIFT (0x00000010u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_FUNCTION_ID_RESETVAL (0x00000E5Au)
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_BU_MASK (0x30000000u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_BU_SHIFT (0x0000001Cu)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_BU_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_RESERVED_MASK (0xC0000000u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_RESERVED_SHIFT (0x0000001Eu)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_RESERVED_RESETVAL (0x00000001u)
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_REVISION_REG_RESETVAL (0x4E5AC900u)
+
+/* PERF_CONTROL_REG */
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_PERF_CONTROL_REG_TIMEOUT_CNT_MASK (0x0000FFFFu)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_PERF_CONTROL_REG_TIMEOUT_CNT_SHIFT (0x00000000u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_PERF_CONTROL_REG_TIMEOUT_CNT_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_PERF_CONTROL_REG_WARB_FIFO_DEPTH_MASK (0x003F0000u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_PERF_CONTROL_REG_WARB_FIFO_DEPTH_SHIFT (0x00000010u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_PERF_CONTROL_REG_WARB_FIFO_DEPTH_RESETVAL (0x00000020u)
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_PERF_CONTROL_REG_RESETVAL (0x00200000u)
+
+/* EMULATION_CONTROL_REG */
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_EMULATION_CONTROL_REG_FREE_MASK (0x00000001u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_EMULATION_CONTROL_REG_FREE_SHIFT (0x00000000u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_EMULATION_CONTROL_REG_FREE_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_EMULATION_CONTROL_REG_SOFT_MASK (0x00000002u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_EMULATION_CONTROL_REG_SOFT_SHIFT (0x00000001u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_EMULATION_CONTROL_REG_SOFT_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_EMULATION_CONTROL_REG_LOOPBACK_EN_MASK (0x80000000u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_EMULATION_CONTROL_REG_LOOPBACK_EN_SHIFT (0x0000001Fu)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_EMULATION_CONTROL_REG_LOOPBACK_EN_RESETVAL (0x00000001u)
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_EMULATION_CONTROL_REG_RESETVAL (0x80000000u)
+
+/* PRIORITY_CONTROL_REG */
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_PRIORITY_CONTROL_REG_TX_PRIORITY_MASK (0x00000007u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_PRIORITY_CONTROL_REG_TX_PRIORITY_SHIFT (0x00000000u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_PRIORITY_CONTROL_REG_TX_PRIORITY_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_PRIORITY_CONTROL_REG_RX_PRIORITY_MASK (0x00070000u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_PRIORITY_CONTROL_REG_RX_PRIORITY_SHIFT (0x00000010u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_PRIORITY_CONTROL_REG_RX_PRIORITY_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_PRIORITY_CONTROL_REG_RESETVAL (0x00000000u)
+
+/* QM_BASE_ADDRESS_REG */
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_QM_BASE_ADDRESS_REG_QM_BASE_MASK (0xFFFFFFFFu)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_QM_BASE_ADDRESS_REG_QM_BASE_SHIFT (0x00000000u)
+#define CSL_CPPIDMA_GLOBAL_CONFIG_QM_BASE_ADDRESS_REG_QM_BASE_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_GLOBAL_CONFIG_QM_BASE_ADDRESS_REG_RESETVAL (0x00000000u)
+
+/**************************************************************************\
+* Register Overlay Structure for TX_CHANNEL_GLOBAL_CONFIG
+\**************************************************************************/
+typedef struct  {
+    volatile Uint32 TX_CHANNEL_GLOBAL_CONFIG_REG_A;
+    volatile Uint32 TX_CHANNEL_GLOBAL_CONFIG_REG_B;
+    volatile Uint8 RSVD0[24];
+} CSL_Cppidma_tx_channel_configTx_channel_global_configRegs;
+
+/**************************************************************************\
+* Register Overlay Structure
+\**************************************************************************/
+typedef struct  {
+    CSL_Cppidma_tx_channel_configTx_channel_global_configRegs TX_CHANNEL_GLOBAL_CONFIG[129];
+} CSL_Cppidma_tx_channel_configRegs;
+
+/**************************************************************************\
+* Field Definition Macros
+\**************************************************************************/
+
+/* TX_CHANNEL_GLOBAL_CONFIG_REG_A */
+
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_A_TX_PAUSE_MASK (0x20000000u)
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_A_TX_PAUSE_SHIFT (0x0000001Du)
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_A_TX_PAUSE_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_A_TX_TEARDOWN_MASK (0x40000000u)
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_A_TX_TEARDOWN_SHIFT (0x0000001Eu)
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_A_TX_TEARDOWN_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_A_TX_ENABLE_MASK (0x80000000u)
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_A_TX_ENABLE_SHIFT (0x0000001Fu)
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_A_TX_ENABLE_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_A_RESETVAL (0x00000000u)
+
+/* TX_CHANNEL_GLOBAL_CONFIG_REG_B */
+
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_B_TX_AIF_MONO_MODE_MASK (0x01000000u)
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_B_TX_AIF_MONO_MODE_SHIFT (0x00000018u)
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_B_TX_AIF_MONO_MODE_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_B_TX_FILT_PSWORDS_MASK (0x20000000u)
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_B_TX_FILT_PSWORDS_SHIFT (0x0000001Du)
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_B_TX_FILT_PSWORDS_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_B_TX_FILT_EINFO_MASK (0x40000000u)
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_B_TX_FILT_EINFO_SHIFT (0x0000001Eu)
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_B_TX_FILT_EINFO_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_TX_CHANNEL_CONFIG_TX_CHANNEL_GLOBAL_CONFIG_REG_B_RESETVAL (0x00000000u)
+
+/**************************************************************************\
+* Register Overlay Structure for RX_CHANNEL_GLOBAL_CONFIG
+\**************************************************************************/
+typedef struct  {
+    volatile Uint32 RX_CHANNEL_GLOBAL_CONFIG_REG;
+    volatile Uint8 RSVD0[28];
+} CSL_Cppidma_rx_channel_configRx_channel_global_configRegs;
+
+/**************************************************************************\
+* Register Overlay Structure
+\**************************************************************************/
+typedef struct  {
+    CSL_Cppidma_rx_channel_configRx_channel_global_configRegs RX_CHANNEL_GLOBAL_CONFIG[129];
+} CSL_Cppidma_rx_channel_configRegs;
+
+/**************************************************************************\
+* Field Definition Macros
+\**************************************************************************/
+
+/* RX_CHANNEL_GLOBAL_CONFIG_REG */
+
+#define CSL_CPPIDMA_RX_CHANNEL_CONFIG_RX_CHANNEL_GLOBAL_CONFIG_REG_RX_PAUSE_MASK (0x20000000u)
+#define CSL_CPPIDMA_RX_CHANNEL_CONFIG_RX_CHANNEL_GLOBAL_CONFIG_REG_RX_PAUSE_SHIFT (0x0000001Du)
+#define CSL_CPPIDMA_RX_CHANNEL_CONFIG_RX_CHANNEL_GLOBAL_CONFIG_REG_RX_PAUSE_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_CHANNEL_CONFIG_RX_CHANNEL_GLOBAL_CONFIG_REG_RX_TEARDOWN_MASK (0x40000000u)
+#define CSL_CPPIDMA_RX_CHANNEL_CONFIG_RX_CHANNEL_GLOBAL_CONFIG_REG_RX_TEARDOWN_SHIFT (0x0000001Eu)
+#define CSL_CPPIDMA_RX_CHANNEL_CONFIG_RX_CHANNEL_GLOBAL_CONFIG_REG_RX_TEARDOWN_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_CHANNEL_CONFIG_RX_CHANNEL_GLOBAL_CONFIG_REG_RX_ENABLE_MASK (0x80000000u)
+#define CSL_CPPIDMA_RX_CHANNEL_CONFIG_RX_CHANNEL_GLOBAL_CONFIG_REG_RX_ENABLE_SHIFT (0x0000001Fu)
+#define CSL_CPPIDMA_RX_CHANNEL_CONFIG_RX_CHANNEL_GLOBAL_CONFIG_REG_RX_ENABLE_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_CHANNEL_CONFIG_RX_CHANNEL_GLOBAL_CONFIG_REG_RESETVAL (0x00000000u)
+/**************************************************************************\
+* Register Overlay Structure
+\**************************************************************************/
+typedef struct  {
+    volatile Uint32 TX_CHANNEL_SCHEDULER_CONFIG_REG[129];
+} CSL_Cppidma_tx_scheduler_configRegs;
+
+/**************************************************************************\
+ * Field Definition Macros
+\**************************************************************************/
+
+/* TX_CHANNEL_SCHEDULER_CONFIG_REG */
+
+#define CSL_CPPIDMA_TX_SCHEDULER_CONFIG_TX_CHANNEL_SCHEDULER_CONFIG_REG_PRIORITY_MASK (0x00000003u)
+#define CSL_CPPIDMA_TX_SCHEDULER_CONFIG_TX_CHANNEL_SCHEDULER_CONFIG_REG_PRIORITY_SHIFT (0x00000000u)
+#define CSL_CPPIDMA_TX_SCHEDULER_CONFIG_TX_CHANNEL_SCHEDULER_CONFIG_REG_PRIORITY_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_TX_SCHEDULER_CONFIG_TX_CHANNEL_SCHEDULER_CONFIG_REG_RESETVAL (0x00000000u)
+
+/**************************************************************************\
+* Register Overlay Structure for RX_FLOW_CONFIG
+\**************************************************************************/
+typedef struct  {
+    volatile Uint32 RX_FLOW_CONFIG_REG_A;
+    volatile Uint32 RX_FLOW_CONFIG_REG_B;
+    volatile Uint32 RX_FLOW_CONFIG_REG_C;
+    volatile Uint32 RX_FLOW_CONFIG_REG_D;
+    volatile Uint32 RX_FLOW_CONFIG_REG_E;
+    volatile Uint32 RX_FLOW_CONFIG_REG_F;
+    volatile Uint32 RX_FLOW_CONFIG_REG_G;
+    volatile Uint32 RX_FLOW_CONFIG_REG_H;
+} CSL_Cppidma_rx_flow_configRx_flow_configRegs;
+
+/**************************************************************************\
+ * Register Overlay Structure
+\**************************************************************************/
+typedef struct  {
+    CSL_Cppidma_rx_flow_configRx_flow_configRegs RX_FLOW_CONFIG[129];
+} CSL_Cppidma_rx_flow_configRegs;
+
+/**************************************************************************\
+ * Field Definition Macros
+\**************************************************************************/
+
+/* RX_FLOW_CONFIG_REG_A */
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_DEST_QNUM_MASK (0x00000FFFu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_DEST_QNUM_SHIFT (0x00000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_DEST_QNUM_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_DEST_QMGR_MASK (0x00003000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_DEST_QMGR_SHIFT (0x0000000Cu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_DEST_QMGR_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_SOP_OFFSET_MASK (0x01FF0000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_SOP_OFFSET_SHIFT (0x00000010u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_SOP_OFFSET_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_PS_LOCATION_MASK (0x02000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_PS_LOCATION_SHIFT (0x00000019u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_PS_LOCATION_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_DESC_TYPE_MASK (0x0C000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_DESC_TYPE_SHIFT (0x0000001Au)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_DESC_TYPE_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_ERROR_HANDLING_MASK (0x10000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_ERROR_HANDLING_SHIFT (0x0000001Cu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_ERROR_HANDLING_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_PSINFO_PRESENT_MASK (0x20000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_PSINFO_PRESENT_SHIFT (0x0000001Du)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_PSINFO_PRESENT_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_EINFO_PRESENT_MASK (0x40000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_EINFO_PRESENT_SHIFT (0x0000001Eu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RX_EINFO_PRESENT_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_A_RESETVAL (0x00000000u)
+
+/* RX_FLOW_CONFIG_REG_B */
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_B_RX_DEST_TAG_LO_MASK (0x000000FFu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_B_RX_DEST_TAG_LO_SHIFT (0x00000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_B_RX_DEST_TAG_LO_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_B_RX_DEST_TAG_HI_MASK (0x0000FF00u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_B_RX_DEST_TAG_HI_SHIFT (0x00000008u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_B_RX_DEST_TAG_HI_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_B_RX_SRC_TAG_LO_MASK (0x00FF0000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_B_RX_SRC_TAG_LO_SHIFT (0x00000010u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_B_RX_SRC_TAG_LO_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_B_RX_SRC_TAG_HI_MASK (0xFF000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_B_RX_SRC_TAG_HI_SHIFT (0x00000018u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_B_RX_SRC_TAG_HI_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_B_RESETVAL (0x00000000u)
+
+/* RX_FLOW_CONFIG_REG_C */
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_SIZE_THRESH_EN_MASK (0x0000000Fu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_SIZE_THRESH_EN_SHIFT (0x00000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_SIZE_THRESH_EN_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_DEST_TAG_LO_SEL_MASK (0x00070000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_DEST_TAG_LO_SEL_SHIFT (0x00000010u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_DEST_TAG_LO_SEL_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_DEST_TAG_HI_SEL_MASK (0x00700000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_DEST_TAG_HI_SEL_SHIFT (0x00000014u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_DEST_TAG_HI_SEL_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_SRC_TAG_LO_SEL_MASK (0x07000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_SRC_TAG_LO_SEL_SHIFT (0x00000018u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_SRC_TAG_LO_SEL_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_SRC_TAG_HI_SEL_MASK (0x70000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_SRC_TAG_HI_SEL_SHIFT (0x0000001Cu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RX_SRC_TAG_HI_SEL_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_C_RESETVAL (0x00000000u)
+
+/* RX_FLOW_CONFIG_REG_D */
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_D_RX_FDQ1_QNUM_MASK (0x00000FFFu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_D_RX_FDQ1_QNUM_SHIFT (0x00000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_D_RX_FDQ1_QNUM_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_D_RX_FDQ1_QMGR_MASK (0x00003000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_D_RX_FDQ1_QMGR_SHIFT (0x0000000Cu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_D_RX_FDQ1_QMGR_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_D_RX_FDQ0_SZ0_QNUM_MASK (0x0FFF0000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_D_RX_FDQ0_SZ0_QNUM_SHIFT (0x00000010u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_D_RX_FDQ0_SZ0_QNUM_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_D_RX_FDQ0_SZ0_QMGR_MASK (0x30000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_D_RX_FDQ0_SZ0_QMGR_SHIFT (0x0000001Cu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_D_RX_FDQ0_SZ0_QMGR_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_D_RESETVAL (0x00000000u)
+
+/* RX_FLOW_CONFIG_REG_E */
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_E_RX_FDQ3_QNUM_MASK (0x00000FFFu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_E_RX_FDQ3_QNUM_SHIFT (0x00000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_E_RX_FDQ3_QNUM_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_E_RX_FDQ3_QMGR_MASK (0x00003000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_E_RX_FDQ3_QMGR_SHIFT (0x0000000Cu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_E_RX_FDQ3_QMGR_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_E_RX_FDQ2_QNUM_MASK (0x0FFF0000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_E_RX_FDQ2_QNUM_SHIFT (0x00000010u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_E_RX_FDQ2_QNUM_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_E_RX_FDQ2_QMGR_MASK (0x30000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_E_RX_FDQ2_QMGR_SHIFT (0x0000001Cu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_E_RX_FDQ2_QMGR_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_E_RESETVAL (0x00000000u)
+
+/* RX_FLOW_CONFIG_REG_F */
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_F_RX_SIZE_THRESH1_MASK (0x0000FFFFu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_F_RX_SIZE_THRESH1_SHIFT (0x00000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_F_RX_SIZE_THRESH1_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_F_RX_SIZE_THRESH0_MASK (0xFFFF0000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_F_RX_SIZE_THRESH0_SHIFT (0x00000010u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_F_RX_SIZE_THRESH0_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_F_RESETVAL (0x00000000u)
+
+/* RX_FLOW_CONFIG_REG_G */
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_G_RX_FDQ0_SZ1_QNUM_MASK (0x00000FFFu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_G_RX_FDQ0_SZ1_QNUM_SHIFT (0x00000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_G_RX_FDQ0_SZ1_QNUM_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_G_RX_FDQ0_SZ1_QMGR_MASK (0x00003000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_G_RX_FDQ0_SZ1_QMGR_SHIFT (0x0000000Cu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_G_RX_FDQ0_SZ1_QMGR_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_G_RX_SIZE_THRESH2_MASK (0xFFFF0000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_G_RX_SIZE_THRESH2_SHIFT (0x00000010u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_G_RX_SIZE_THRESH2_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_G_RESETVAL (0x00000000u)
+
+/* RX_FLOW_CONFIG_REG_H */
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_H_RX_FDQ0_SZ3_QNUM_MASK (0x00000FFFu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_H_RX_FDQ0_SZ3_QNUM_SHIFT (0x00000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_H_RX_FDQ0_SZ3_QNUM_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_H_RX_FDQ0_SZ3_QMGR_MASK (0x00003000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_H_RX_FDQ0_SZ3_QMGR_SHIFT (0x0000000Cu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_H_RX_FDQ0_SZ3_QMGR_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_H_RX_FDQ0_SZ2_QNUM_MASK (0x0FFF0000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_H_RX_FDQ0_SZ2_QNUM_SHIFT (0x00000010u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_H_RX_FDQ0_SZ2_QNUM_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_H_RX_FDQ0_SZ2_QMGR_MASK (0x30000000u)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_H_RX_FDQ0_SZ2_QMGR_SHIFT (0x0000001Cu)
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_H_RX_FDQ0_SZ2_QMGR_RESETVAL (0x00000000u)
+
+#define CSL_CPPIDMA_RX_FLOW_CONFIG_RX_FLOW_CONFIG_REG_H_RESETVAL (0x00000000u)
+    
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*TI_EM_HW_CSL_H_*/
diff --git a/platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_functions.h b/platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_functions.h
new file mode 100644
index 0000000..029ea17
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_functions.h
@@ -0,0 +1,105 @@ 
+/*
+ * Copyright (c) 2012, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ *   @file  ti_em_hw_functions.h
+ *
+ *   @brief
+ *      Machine platform functions
+ *
+ */
+
+#ifndef TI_EM_HW_FUNCTIONS_H_
+#define TI_EM_HW_FUNCTIONS_H_
+
+/* 
+ * This is for compatibility purpose, DNUM should be removed from OpenEM in the near
+ * future.
+ */
+#define DNUM         (ti_em_osal_get_core_idx())
+
+/* Temporary intrinsic definition, must be written in proper assembly per arch */
+#define _itoll(h, l) (((uint64_t)(h) << 32) | (uint64_t)(l))
+#define _loll(ll)    ((uint32_t)((ll) & 0xFFFFFFFFULL))
+#define _hill(ll)    ((uint32_t)(((ll) >> 32) & 0xFFFFFFFFULL))
+#define _mem8(i)     (*(uint64_t*)(i))
+
+#ifdef TI_EM_C66X
+#define TI_EM_HW_HAS_FAST_TSC
+#define TI_EM_HW_INIT_TSC()  0
+#define TI_EM_HW_GET_TSC()   ti_em_get_hw_c66x_tsc()
+
+static inline uint64_t ti_em_get_hw_c66x_tsc(void) {
+	unsigned int l, h;
+	__asm__ __volatile__  (" dint\n"
+			       " mvc .s2 TSCL,%0\n"
+			       " mvc .s2 TSCH,%1\n"
+			       " rint\n"
+			       : "=b"(l), "=b"(h));
+	return ((uint64_t) h << 32) | l;
+}
+
+static inline unsigned long _ffz(int val)
+{
+	__asm__ __volatile__ (" bitr  .M1  %0,%0\n"
+			      " nop\n"
+			      " lmbd  .L1  0,%0,%0\n"
+			      : "+a"(val));
+	return val;
+}
+
+#define	TI_EM_ARCH_MEM_BARRIER() __asm__ __volatile__ (" .word 0x10008000\n" \
+						       " .word 0x10008000\n")
+#endif /* TI_EM_C66X */
+
+#ifdef TI_EM_ARM_A15
+#include <ti_em_osal_cma.h>
+#define TI_EM_HW_HAS_FAST_TSC
+#define TI_EM_HW_INIT_TSC()  ti_em_osal_cma_enable_user_pmu()
+#define TI_EM_HW_GET_TSC()   ti_em_get_hw_arm_pmccntr()
+
+static inline uint64_t ti_em_get_hw_arm_pmccntr(void) {
+	unsigned int val;
+
+	/* read PMCCNTR */
+        asm volatile("mrc p15, 0, %0, c9, c13, 0" : "=r" (val));
+        return (uint64_t) val;
+}
+
+static inline int _ffz(int val)
+{
+        int bit;
+	val = ~val;
+        __asm__ __volatile__ ("clz %0, %1" : "=r" (bit) : "r" (val & -val) : "cc");
+        return (31 - bit);
+}
+
+#define	TI_EM_ARCH_MEM_BARRIER() __asm__ __volatile__ ("dmb" : : : "memory")
+
+#endif /* TI_EM_ARM_A15 */
+#endif /* TI_EM_HW_FUNCTIONS_H_ */
diff --git a/platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_mach.h b/platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_mach.h
new file mode 100644
index 0000000..1d814f1
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_mach.h
@@ -0,0 +1,166 @@ 
+/*
+ * Copyright (c) 2012, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ *   @file  ti_em_hw_mach.h
+ *
+ *   @brief
+ *      Machine platform definitions
+ *
+ */
+
+#ifndef TI_EM_HW_MACH_H_
+#define TI_EM_HW_MACH_H_
+
+/*
+ * Architecture definitions
+ */
+#ifdef TI_EM_ARM_A15
+#define TI_EM_COHERENT_IO                            /* I/O are coherent */     
+#undef  TI_EM_USE_HUGETLB                            /* use hugeTLB feature (not yet available) */
+#define CACHE_L1D_LINESIZE                           (64)   /* size of L1D cache line for alignment purpose */
+#define CACHE_L2_LINESIZE                            (64)   /* size of L2 cache line for alignment purpose */
+#define QMSS_GENERAL_PURPOSE_USER_QUEUE_BASE         (4096) /* first queue available and not used by Linux */
+#endif /* TI_EM_ARM_A15 */
+
+#ifdef TI_EM_C66X
+#define CACHE_L1D_LINESIZE                           (64)   /* size of L1D cache line for alignment purpose */
+#define CACHE_L2_LINESIZE                            (128)  /* size of L2 cache line for alignment purpose */
+#define QMSS_GENERAL_PURPOSE_USER_QUEUE_BASE         (4096) /* first queue available and not used by Linux */
+#endif /* TI_EM_C66X */
+
+/* Linux MMU page size */
+#define PAGE_SIZE                                    (4096)
+
+/* This is the physical memory range that will be mapped as I/O in the virtual user address space*/
+#define TI_EM_IO_CFG_BASE                            (0x02000000)
+#define TI_EM_IO_CFG_SIZE                            (0x01000000)
+
+/*
+ * KeyStone 2 platform definitions
+ */
+#define CSL_QMSS_CFG_QM_1_CFG_REGS                   (0x02A02000)
+#define CSL_QMSS_CFG_QM_1_DESCRIPTOR_REGS            (0x02A02000 + 0x1000)
+#define CSL_QMSS_CFG_QM_2_CFG_REGS                   (0x02A04000)
+#define CSL_QMSS_CFG_QM_2_DESCRIPTOR_REGS            (0x02A04000 + 0x1000)
+#define CSL_QMSS_CFG_QM_1_STATUS_RAM                 (0x02A06000)
+#define CSL_QMSS_CFG_QM_2_STATUS_RAM                 (0x02A06400)
+#define CSL_QMSS_CFG_PKTDMA_1                        (0x02A08000)
+#define CSL_QMSS_CFG_PKTDMA_1_GLOBAL_CFG_REGS        (0x02A08000)
+#define CSL_QMSS_CFG_PKTDMA_1_TX_CFG_REGS            (0x02A08000 + 0x400)
+#define CSL_QMSS_CFG_PKTDMA_1_RX_CFG_REGS            (0x02A08000 + 0x800)
+#define CSL_QMSS_CFG_PKTDMA_1_TX_SCHEDULER_CFG_REGS  (0x02A08000 + 0xC00)
+#define CSL_QMSS_CFG_PKTDMA_1_RX_FLOW_CFG_REGS       (0x02A08000 + 0x1000)
+#define CSL_QMSS_CFG_PKTDMA_2                        (0x02A0A000)
+#define CSL_QMSS_CFG_PKTDMA_2_GLOBAL_CFG_REGS        (0x02A0A000)
+#define CSL_QMSS_CFG_PKTDMA_2_TX_CFG_REGS            (0x02A0A000 + 0x400)
+#define CSL_QMSS_CFG_PKTDMA_2_RX_CFG_REGS            (0x02A0A000 + 0x800)
+#define CSL_QMSS_CFG_PKTDMA_2_TX_SCHEDULER_CFG_REGS  (0x02A0A000 + 0xC00)
+#define CSL_QMSS_CFG_PKTDMA_2_RX_FLOW_CFG_REGS       (0x02A0A000 + 0x1000)
+#define CSL_QMSS_CFG_INTD_1_REGS                     (0x02A0C000)
+#define CSL_QMSS_CFG_INTD_2_REGS                     (0x02A0D000)
+#define CSL_QMSS_CFG_PDSP1_REGS                      (0x02A0F000)
+#define CSL_QMSS_CFG_PDSP2_REGS                      (0x02A0F000 + 0x100)
+#define CSL_QMSS_CFG_PDSP3_REGS                      (0x02A0F000 + 0x200)
+#define CSL_QMSS_CFG_PDSP4_REGS                      (0x02A0F000 + 0x300)
+#define CSL_QMSS_CFG_PDSP5_REGS                      (0x02A0F000 + 0x400)
+#define CSL_QMSS_CFG_PDSP6_REGS                      (0x02A0F000 + 0x500)
+#define CSL_QMSS_CFG_PDSP7_REGS                      (0x02A0F000 + 0x600)
+#define CSL_QMSS_CFG_PDSP8_REGS                      (0x02A0F000 + 0x700)
+#define CSL_QMSS_CFG_PDSP1_IRAM                      (0x02A10000)
+#define CSL_QMSS_CFG_PDSP2_IRAM                      (0x02A10000 + 0x1000)
+#define CSL_QMSS_CFG_PDSP3_IRAM                      (0x02A10000 + 0x2000)
+#define CSL_QMSS_CFG_PDSP4_IRAM                      (0x02A10000 + 0x3000)
+#define CSL_QMSS_CFG_PDSP5_IRAM                      (0x02A10000 + 0x4000)
+#define CSL_QMSS_CFG_PDSP6_IRAM                      (0x02A10000 + 0x5000)
+#define CSL_QMSS_CFG_PDSP7_IRAM                      (0x02A10000 + 0x6000)
+#define CSL_QMSS_CFG_PDSP8_IRAM                      (0x02A10000 + 0x7000)
+#define CSL_QMSS_CFG_PDSP1_SRAM                      (0x02A20000)
+#define CSL_QMSS_CFG_PDSP2_SRAM                      (0x02A20000 + 0x4000)
+#define CSL_QMSS_CFG_PDSP3_SRAM                      (0x02A20000 + 0x8000)
+#define CSL_QMSS_CFG_PDSP4_SRAM                      (0x02A20000 + 0xC000)
+#define CSL_QMSS_CFG_PDSP5_SRAM                      (0x02A20000 + 0x10000)
+#define CSL_QMSS_CFG_PDSP6_SRAM                      (0x02A20000 + 0x14000)
+#define CSL_QMSS_CFG_PDSP7_SRAM                      (0x02A20000 + 0x18000)
+#define CSL_QMSS_CFG_PDSP8_SRAM                      (0x02A20000 + 0x1C000)
+#define CSL_QMSS_CFG_QM_1_QUEUE_PEEK_REGS            (0x02A40000)
+#define CSL_QMSS_CFG_QM_2_QUEUE_PEEK_REGS            (0x02A60000)
+#define CSL_QMSS_CFG_QM_1_QUEUE_MANAGEMENT_REGS      (0x02A80000)
+#define CSL_QMSS_CFG_QM_2_QUEUE_MANAGEMENT_REGS      (0x02AA0000)
+#define CSL_QMSS_CFG_QM_1_QUEUE_PROXY_REGS           (0x02AC0000)
+#define CSL_QMSS_CFG_QM_2_QUEUE_PROXY_REGS           (0x02AE0000)
+#define CSL_QMSS_LINKING_RAM                         (0x02B00000)
+
+#define CSL_SRIO_CFG_PKTDMA_GLOBAL_CFG_REGS          (0x02900000 + 0x1000)
+#define CSL_SRIO_CFG_PKTDMA_TX_CFG_REGS              (0x02900000 + 0x1400)
+#define CSL_SRIO_CFG_PKTDMA_RX_CFG_REGS              (0x02900000 + 0x1800)
+#define CSL_SRIO_CFG_PKTDMA_TX_SCHEDULER_CFG_REGS    (0x02900000 + 0x1C00)
+#define CSL_SRIO_CFG_PKTDMA_RX_FLOW_CFG_REGS         (0x02900000 + 0x2000)
+
+#define CSL_NETCP_CFG_PKTDMA_GLOBAL_CFG_REGS         (0x02000000 + 0x4000)
+#define CSL_NETCP_CFG_PKTDMA_TX_CFG_REGS             (0x02000000 + 0x4400)
+#define CSL_NETCP_CFG_PKTDMA_RX_CFG_REGS             (0x02000000 + 0x4800)
+#define CSL_NETCP_CFG_PKTDMA_TX_SCHEDULER_CFG_REGS   (0x02000000 + 0x4C00)
+#define CSL_NETCP_CFG_PKTDMA_RX_FLOW_CFG_REGS        (0x02000000 + 0x5000)
+
+#define CSL_XGE_CFG_PKTDMA_GLOBAL_CFG_REGS           (0x02F00000 + 0xA1000)
+#define CSL_XGE_CFG_PKTDMA_TX_CFG_REGS               (0x02F00000 + 0xA1400)
+#define CSL_XGE_CFG_PKTDMA_RX_CFG_REGS               (0x02F00000 + 0xA1800)
+#define CSL_XGE_CFG_PKTDMA_TX_SCHEDULER_CFG_REGS     (0x02F00000 + 0xA1C00)
+#define CSL_XGE_CFG_PKTDMA_RX_FLOW_CFG_REGS          (0x02F00000 + 0xA2000)
+
+/*
+ * Our QMSS defines and aliases
+ */
+#define QMSS_OFFSET(i)                               ((CSL_QMSS_CFG_QM_2_CFG_REGS - CSL_QMSS_CFG_QM_1_CFG_REGS) * (i))
+
+#define TI_EM_QMSS_CFG_STARVATION_REGS(i)            (CSL_QMSS_CFG_QM_1_CFG_REGS + QMSS_OFFSET(i))
+#define TI_EM_QMSS_CFG_DESCRIPTOR_REGS(i)            (CSL_QMSS_CFG_QM_1_DESCRIPTOR_REGS + QMSS_OFFSET(i))
+#define TI_EM_QMSS_CFG_QUEUE_MGT_REGS                CSL_QMSS_CFG_QM_1_QUEUE_MANAGEMENT_REGS
+#define TI_EM_QMSS_CFG_DEQUEUE_REGS                  CSL_QMSS_CFG_QM_1_QUEUE_PROXY_REGS
+#define TI_EM_QMSS_CFG_QUEUE_PEEK_REGS               CSL_QMSS_CFG_QM_1_QUEUE_PEEK_REGS
+
+/*
+ * PDSP firmwares
+ */
+#define TI_EM_FIRMWARE_SCHED_PDSP1                   em_scheduler_router_fw_c663x
+#define TI_EM_FIRMWARE_SCHED_PDSP2                   em_scheduler_router_fw_c663x
+#define TI_EM_FIRMWARE_ROUTER_PDSP                   em_router_fw_c663x
+
+/*
+ * PDSP DRAM
+ *
+ * This is located at offset 0x20000 and 0x24000 of the QMSS data space
+ *
+ */
+#define TI_EM_PDSP_DRAM_SIZE                         (0x00004000)
+#define TI_EM_PDSP_DRAM(i)                           (0x23a20000 + (i) * TI_EM_PDSP_DRAM_SIZE)
+#define TI_EM_PDSPSH_DRAM                            (0x23a1c000)
+#define TI_EM_PDSP_DRAM_OFFSET                       (0x0)        /* no offset, CPU and QMSS/PDSP mapping is same */
+
+#endif /*TI_EM_HW_MACH_H_*/
diff --git a/platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_qmss.h b/platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_qmss.h
new file mode 100644
index 0000000..4bf64b7
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/linux/keystone2/ti_em_hw_qmss.h
@@ -0,0 +1,633 @@ 
+/*
+ * Copyright (c) 2012, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ *   @file  ti_em_hw_qmss.h
+ *
+ *   @brief   
+ *      This is the Queue Manager module include file.
+ *
+ *  \par
+ *  ============================================================================
+ *  @n   (C) Copyright 2009, 2013 Texas Instruments, Inc.
+ *  @n   Use of this software is controlled by the terms and conditions found 
+ *  @n   in the license agreement under which this software has been supplied.
+ *  ============================================================================ 
+ *  \par
+ */
+
+#ifndef TI_EM_HW_QMSS_H_
+#define TI_EM_HW_QMSS_H_
+
+/** 
+ * @brief Queue start number and maximum number of each type of queue supported.
+ */
+#define QMSS_LOW_PRIORITY_QUEUE_BASE                0
+#define QMSS_MAX_LOW_PRIORITY_QUEUE               512
+
+#define QMSS_AIF_QUEUE_BASE                       512
+#define QMSS_MAX_AIF_QUEUE                        128
+#define QMSS_PASS_QUEUE_BASE                      640
+#define QMSS_MAX_PASS_QUEUE                         9
+
+/* Broadcast to CPINTC 0/1/2 */
+#define QMSS_INTC_SET1_QUEUE_BASE                 652
+#define QMSS_MAX_INTC_SET1_QUEUE                    6
+/* For backward compatibility */
+#define QMSS_INTC_QUEUE_BASE     QMSS_INTC_SET1_QUEUE_BASE
+#define QMSS_MAX_INTC_QUEUE      QMSS_MAX_INTC_SET1_QUEUE
+
+/* Broadcast to CPINTC 0/1/2, GIC, EDMA 4 and Hyperlink */
+#define QMSS_INTC_SET2_QUEUE_BASE                 658
+#define QMSS_MAX_INTC_SET2_QUEUE                    8
+/* Broadcast to CPINTC 0/1/2 */
+#define QMSS_INTC_SET3_QUEUE_BASE                 666
+#define QMSS_MAX_INTC_SET3_QUEUE                    6
+
+#define QMSS_SRIO_QUEUE_BASE                      672
+#define QMSS_MAX_SRIO_QUEUE                        16
+#define QMSS_FFTC_A_QUEUE_BASE                    688
+#define QMSS_MAX_FFTC_A_QUEUE                       4
+#define QMSS_FFTC_B_QUEUE_BASE                    692
+#define QMSS_MAX_FFTC_B_QUEUE                       4
+
+#define QMSS_HIGH_PRIORITY_QUEUE_BASE             704
+#define QMSS_MAX_HIGH_PRIORITY_QUEUE               32
+#define QMSS_STARVATION_COUNTER_QUEUE_BASE        736
+#define QMSS_MAX_STARVATION_COUNTER_QUEUE          64
+
+#define QMSS_QM1_INFRASTRUCTURE_DMA_QUEUE_BASE    800
+#define QMSS_MAX_QM1_INFRASTRUCTURE_DMA_QUEUE      32
+/* For backward compatibility */
+#define QMSS_INFRASTRUCTURE_QUEUE_BASE   QMSS_QM1_INFRASTRUCTURE_DMA_QUEUE_BASE
+#define QMSS_MAX_INFRASTRUCTURE_QUEUE    QMSS_MAX_QM1_INFRASTRUCTURE_DMA_QUEUE
+
+#define QMSS_TRAFFIC_SHAPING_QUEUE_BASE           832
+#define QMSS_MAX_TRAFFIC_SHAPING_QUEUE             32
+
+#define QMSS_BCP_QUEUE_BASE                       864
+#define QMSS_MAX_BCP_QUEUE                          8
+#define QMSS_FFTC_C_QUEUE_BASE                    872
+#define QMSS_MAX_FFTC_C_QUEUE                       4
+#define QMSS_FFTC_D_QUEUE_BASE                    876
+#define QMSS_MAX_FFTC_D_QUEUE                       4
+#define QMSS_FFTC_E_QUEUE_BASE                    880
+#define QMSS_MAX_FFTC_E_QUEUE                       4
+#define QMSS_FFTC_F_QUEUE_BASE                    884
+#define QMSS_MAX_FFTC_F_QUEUE                       4
+
+#define QMSS_GENERAL_PURPOSE_QUEUE_BASE           896
+#define QMSS_MAX_GENERAL_PURPOSE_QUEUE           7296
+
+#define QMSS_QM2_LOW_PRIORITY_QUEUE_BASE         8192
+#define QMSS_MAX_QM2_LOW_PRIORITY_QUEUE           512
+
+#define QMSS_GIC400_QUEUE_BASE                   8704
+#define QMSS_MAX_GIC400_QUEUE                      32
+#define QMSS_EDMA4_QUEUE_BASE                    8736
+#define QMSS_MAX_EDMA4_QUEUE                        8
+#define QMSS_BCAST_HYPERLINK_0_1_QUEUE_BASE      8744
+#define QMSS_MAX_BCAST_HYPERLINK_0_1_QUEUE          8
+#define QMSS_XGE_QUEUE_BASE                      8752
+#define QMSS_MAX_XGE_QUEUE                          8
+#define QMSS_DXB_QUEUE_BASE                      8836
+#define QMSS_DXB_XGE_QUEUE                          8
+
+#define QMSS_HYPERLINK_0_QUEUE_BASE              8760
+#define QMSS_MAX_HYPERLINK_0_QUEUE                 16
+
+/* Broadcast to CPINTC 0/1/2 */                  
+#define QMSS_INTC_SET4_QUEUE_BASE                8844
+#define QMSS_MAX_INTC_SET4_QUEUE                   20
+                                                 
+#define QMSS_HYPERLINK_1_QUEUE_BASE              8864
+#define QMSS_MAX_HYPERLINK_1_QUEUE                 16
+
+#define QMSS_QM2_INFRASTRUCTURE_DMA_QUEUE_BASE   8992
+#define QMSS_MAX_QM2_INFRASTRUCTURE_DMA_QUEUE      32
+
+#define QMSS_QM2_GENERAL_PURPOSE_QUEUE_BASE      9024
+#define QMSS_MAX_QM2_GENERAL_PURPOSE_QUEUE       7360
+
+/** 
+ * @brief Queue Type. Specifies different queue classifications
+ */
+typedef enum
+{
+    /** Low priority queue */
+    Qmss_QueueType_LOW_PRIORITY_QUEUE = 0,
+    /** AIF queue */
+    Qmss_QueueType_AIF_QUEUE,
+    /** PASS queue */
+    Qmss_QueueType_PASS_QUEUE,
+    /** INTC pending queue */
+    Qmss_QueueType_INTC_QUEUE,
+    /** SRIO queue */
+    Qmss_QueueType_SRIO_QUEUE,
+    /** FFTC queue A */
+    Qmss_QueueType_FFTC_A_QUEUE,
+    /** FFTC queue B */
+    Qmss_QueueType_FFTC_B_QUEUE,
+    /** FFTC queue C */
+    Qmss_QueueType_FFTC_C_QUEUE,
+    /** FFTC queue D */
+    Qmss_QueueType_FFTC_D_QUEUE,
+    /** FFTC queue E */
+    Qmss_QueueType_FFTC_E_QUEUE,
+    /** FFTC queue F */
+    Qmss_QueueType_FFTC_F_QUEUE,
+    /** BCP queue */
+    Qmss_QueueType_BCP_QUEUE,
+    /** High priority queue */
+    Qmss_QueueType_HIGH_PRIORITY_QUEUE,
+    /** starvation counter queue */
+    Qmss_QueueType_STARVATION_COUNTER_QUEUE,
+    /** Infrastructure queue first QM */
+    Qmss_QueueType_INFRASTRUCTURE_QUEUE,
+    /** Infrastructure queue second QM */
+    Qmss_QueueType_QM2_INFRASTRUCTURE_QUEUE,
+    /** Traffic shaping queue */
+    Qmss_QueueType_TRAFFIC_SHAPING_QUEUE,
+    /** GIC400 queue */
+    Qmss_QueueType_GIC400_QUEUE,
+    /** EDMA 4 queue */
+    Qmss_QueueType_EDMA_4_QUEUE,
+    /** Broadcast to Hyperlink 0 and 1 queue */
+    Qmss_QueueType_HLINK_BROADCAST_QUEUE,
+    /** Hyperlink 0 queue */
+    Qmss_QueueType_HLINK_0_QUEUE,
+    /** Hyperlink 1 queue */
+    Qmss_QueueType_HLINK_1_QUEUE,
+    /** XGE (10 gigabit ethernet) queue */
+    Qmss_QueueType_XGE_QUEUE,
+    /** DXB queue */
+    Qmss_QueueType_DXB_QUEUE,
+    /** General purpose queue -- MUST be last */
+    Qmss_QueueType_GENERAL_PURPOSE_QUEUE
+}Qmss_QueueType;
+
+/**
+@}
+*/
+/** QMSS maximum number of memory regions */
+#define QMSS_MAX_MEM_REGIONS                        64
+/** QMSS maximum number of PDSPS */
+#define QMSS_MAX_PDSP                               8
+/** QMSS maximum number of INTDs */
+#define QMSS_MAX_INTD                               2
+/** QMSS maximum number of queue groups (QMGRs that run independently) */
+#define QMSS_MAX_QMGR_GROUPS                        2
+/** QMSS maximum number of queue types (per group) */
+#define QMSS_MAX_QUEUE_TYPES                        30
+/** QMSS maximum number of queues */
+#define QMSS_MAX_QUEUES                             16384
+
+/** 
+ * @brief QMSS RM Handle
+ */
+typedef void *  Qmss_RmHnd;
+
+/** 
+ * @brief QMSS start configuration structure
+ */
+typedef struct
+{
+    /** Provide a handle to the Resource Manager instance */
+    Qmss_RmHnd rmHandle;
+} Qmss_StartCfg;
+
+/** 
+ * @brief Queue definition
+ */
+typedef struct
+{
+    /** Queue manager number */
+    int32_t qMgr;        
+    /** Queue number within Queue Manager */
+    int32_t qNum;
+}Qmss_Queue;
+
+/** 
+ * @brief Queue definition
+ */
+typedef struct
+{
+    /** Queue type */
+    Qmss_QueueType queueType;
+    /** Queue manager number */
+    int32_t        startIndex;        
+    /** Queue number within Queue Manager */
+    int32_t        maxNum;
+}Qmss_QueueNumRange;
+
+/** 
+ * @brief QMSS Global register definition for registers that replicate
+ * per QM group
+ */
+typedef struct 
+{
+    /** QM Global Config registers */
+    CSL_Qm_configRegs                       *qmConfigReg;
+    /** QM Descriptor Config registers */
+    CSL_Qm_descriptor_region_configRegs     *qmDescReg;
+    /** QM queue Management registers, accessed via CFG port */
+    CSL_Qm_queue_managementRegs             *qmQueMgmtReg;
+    /** QM queue Management Proxy registers, accessed via CFG port */
+    CSL_Qm_queue_managementRegs             *qmQueMgmtProxyReg;
+    /** QM queue status registers */
+    CSL_Qm_queue_status_configRegs          *qmQueStatReg;
+    /** QM Status RAM */
+    CSL_Qm_Queue_Status                     *qmStatusRAM;
+    /** QM queue Management registers, accessed via DMA port */
+    CSL_Qm_queue_managementRegs             *qmQueMgmtDataReg;
+    /** QM queue Management Proxy registers, accessed via DMA port */
+    CSL_Qm_queue_managementRegs             *qmQueMgmtProxyDataReg;
+} Qmss_GlobalConfigGroupRegs;
+
+/** 
+ * @brief QMSS Global register definition for registers that do not replicate
+ * per QM group
+ */
+typedef struct 
+{
+    /** QM INTD registers */
+    CSL_Qm_intdRegs                         *qmQueIntdReg[QMSS_MAX_INTD];
+    /** QM PDSP command register */
+    volatile uint32_t                       *qmPdspCmdReg[QMSS_MAX_PDSP];
+    /** QM PDSP control register */
+    CSL_PdspRegs                            *qmPdspCtrlReg[QMSS_MAX_PDSP];
+    /** QM PDSP IRAM register */
+    volatile uint32_t                       *qmPdspIRamReg[QMSS_MAX_PDSP];
+    /** QM Linking RAM register */
+    volatile uint32_t                       *qmLinkingRAMReg;
+    /** QM peripheral base address used to calculate internal addresses */
+    void                                    *qmBaseAddr;
+} Qmss_GlobalConfigRegs;
+
+/** 
+ * @brief QMSS Global configuration structure definition
+ */
+typedef struct
+{
+    /** Maximum number of queue manager groups */
+    uint32_t                                maxQueMgrGroups;
+    /** Maximum number of queue Managers */
+    uint32_t                                maxQueMgr;
+    /** Maximum number of queues */
+    uint32_t                                maxQue;
+    /** Maximum number of memory regions */
+    uint32_t                                maxMemReg;
+    /** Maximum number of PDSPs */
+    uint32_t                                maxPDSP;
+    /** Requires ordered memory regions? */
+    int                                     orderedMemReg;
+    /** Queue start index and maximum number of queues of each queue type for each queue group */
+    Qmss_QueueNumRange                      maxQueueNum[QMSS_MAX_QMGR_GROUPS][QMSS_MAX_QUEUE_TYPES];
+    /* Register definitions for each QM group */
+    Qmss_GlobalConfigGroupRegs              groupRegs[QMSS_MAX_QMGR_GROUPS];
+    /* Register definitions for whole SS */
+    Qmss_GlobalConfigRegs                   regs;
+    /** QM stores the Resource Manager handle for internal use */
+    Qmss_RmHnd                              qmRmHandle;
+} Qmss_GlobalConfigParams;
+
+/**
+@}
+*/
+/** Internal Linking RAM default size */
+#define QMSS_LINKING_RAM_REGION_0_DEFAULT_SIZE      0x7FFF
+
+/** Used as input parameter when queue number is 
+ * not known and not specified */
+#define QMSS_PARAM_NOT_SPECIFIED                    -1
+
+/** Used to indicate that QMSS HW Initialization is complete */
+#define QMSS_HW_INIT_COMPLETE                       0xABCD
+
+/** QMSS Low level Driver return and Error Codes */
+/** QMSS successful return code */
+#define QMSS_SOK                                    0
+/** QMSS Error Base */       
+#define QMSS_LLD_EBASE                              (-128)
+/** QMSS LLD invalid parameter */
+#define QMSS_INVALID_PARAM                          QMSS_LLD_EBASE-1
+/** QMSS LLD not initialized */
+#define QMSS_NOT_INITIALIZED                        QMSS_LLD_EBASE-2
+/** QMSS LLD queue open error */
+#define QMSS_QUEUE_OPEN_ERROR                       QMSS_LLD_EBASE-3
+/** QMSS memory region not initialized */
+#define QMSS_MEMREGION_NOT_INITIALIZED              QMSS_LLD_EBASE-4
+/** QMSS memory region already initialized */
+#define QMSS_MEMREGION_ALREADY_INITIALIZED          QMSS_LLD_EBASE-5
+/** QMSS memory region invalid parameter */
+#define QMSS_MEMREGION_INVALID_PARAM                QMSS_LLD_EBASE-6
+/** QMSS maximum number of allowed descriptor are already configured */
+#define QMSS_MAX_DESCRIPTORS_CONFIGURED             QMSS_LLD_EBASE-7
+/** QMSS Specified memory region index is invalid or no memory regions are available */
+#define QMSS_MEMREGION_INVALID_INDEX                QMSS_LLD_EBASE-8
+/** QMSS memory region overlap */
+#define QMSS_MEMREGION_OVERLAP                      QMSS_LLD_EBASE-9
+/** QMSS memory region not in acscending order */
+#define QMSS_MEMREGION_ORDERING                     QMSS_LLD_EBASE-10
+/** QMSS PDSP firmware download failure */
+#define QMSS_FIRMWARE_DOWNLOAD_FAILED               QMSS_LLD_EBASE-11
+/** QMSS resource initialization permission denied */
+#define QMSS_RESOURCE_INIT_DENIED                   QMSS_LLD_EBASE-12
+/** QMSS resource usage permission denied */
+#define QMSS_RESOURCE_USE_DENIED                    QMSS_LLD_EBASE-13
+/** QMSS memory region initialization permission denied */
+#define QMSS_RESOURCE_MEM_REGION_INIT_DENIED        QMSS_LLD_EBASE-14
+/** QMSS memory region usage permission denied */
+#define QMSS_RESOURCE_MEM_REGION_USE_DENIED         QMSS_LLD_EBASE-15
+/** QMSS general linking RAM initialization permission denied */
+#define QMSS_RESOURCE_LINKING_RAM_INIT_DENIED       QMSS_LLD_EBASE-16
+/** QMSS firmware revision difference */
+#define QMSS_FIRMWARE_REVISION_DIFFERENCE           QMSS_LLD_EBASE-17
+/** QMSS firmware invalid garbage return queue */
+#define QMSS_INVALID_SRIO_GARBAGE_QUEUE             QMSS_LLD_EBASE-18
+/** QMSS Bad Queue Number Configuration Table */
+#define QMSS_INVALID_QUEUE_NUMBER_TAB               QMSS_LLD_EBASE-19
+
+/** QMSS maximum number of memory regions */
+#define QMSS_MAX_MEM_REGIONS                        64
+/** QMSS maximum number of PDSPS */
+#define QMSS_MAX_PDSP                               8
+/** QMSS maximum number of INTDs */
+#define QMSS_MAX_INTD                               2
+/** QMSS maximum number of queue groups (QMGRs that run independently) */
+#define QMSS_MAX_QMGR_GROUPS                        2
+/** QMSS maximum number of queue types (per group) */
+#define QMSS_MAX_QUEUE_TYPES                        30
+/** QMSS maximum number of queues */
+#define QMSS_MAX_QUEUES                             16384
+
+/** Macro to get the descriptor pointer if the popped descriptor contains the descriptor size. 
+ * If Qmss_queuePushDescSize() API is used to push a descriptor onto a queue, the descriptor when 
+ * popped will have the descriptor size information in the lower 4 bits. This macro is provided to 
+ * clear out the size information */
+#define QMSS_DESC_PTR(desc)                         ((uint32_t)desc & 0xFFFFFFF0)
+
+/** Macro to get the descriptor size if the popped descriptor contains the descriptor size. 
+ * If Qmss_queuePushDescSize() API is used to push a descriptor onto a queue, the descriptor when 
+ * popped will have the descriptor size information in the lower 4 bits. This macro is provided to 
+ * obtain the size information. Minimum size is 16 bytes. Maximum size is 256 bytes */
+#define QMSS_DESC_SIZE(desc)                        ((((uint32_t)desc & 0x0000000F) + 1) << 4) 
+
+/** Macro to extract the queue manager group from the queue handle */
+#define QMSS_QUEUE_GROUP(hndl)                      ((uint32_t)(hndl) >> 13)
+#define QMSS_QUEUE_NUMBER(hndl)                     ((uint32_t)(hndl) & 0x1FFF)
+
+/** 
+ * @brief location where the packet is queued
+ */
+typedef enum
+{
+    /** Queue packet to the tail of the queue. Default behavior. */
+    Qmss_Location_TAIL = 0,
+    /** Queue packet to the head of the queue. */
+    Qmss_Location_HEAD 
+}Qmss_Location;
+
+/** 
+ * @brief Descriptor resource management
+ */
+typedef enum
+{
+    /** LLD doesnot manage the descriptors. The caller should manage them. */
+    Qmss_ManageDesc_UNMANAGED_DESCRIPTOR = 0,
+    /** LLD manages the descriptors. The descriptors are reclaimed using 
+     * the QMSS_initDescriptor() or CPPI_initDescriptor() APIs
+     * */
+    Qmss_ManageDesc_MANAGE_DESCRIPTOR 
+}Qmss_ManageDesc;
+
+/** 
+ * @brief Queue Manager's memory regions
+ */
+typedef enum
+{
+    /** Memory region not specified. LLD allocates the next available memory region */
+    Qmss_MemRegion_MEMORY_REGION_NOT_SPECIFIED = -1,
+    /** Configure memory region0. */
+    Qmss_MemRegion_MEMORY_REGION0 = 0,
+    /** Configure memory region 1. */
+    Qmss_MemRegion_MEMORY_REGION1,
+    /** Configure memory region 2. */
+    Qmss_MemRegion_MEMORY_REGION2,
+    /** Configure memory region 3. */
+    Qmss_MemRegion_MEMORY_REGION3,
+    /** Configure memory region 4. */
+    Qmss_MemRegion_MEMORY_REGION4,
+    /** Configure memory region 5. */
+    Qmss_MemRegion_MEMORY_REGION5,
+    /** Configure memory region 6. */
+    Qmss_MemRegion_MEMORY_REGION6,
+    /** Configure memory region 7. */
+    Qmss_MemRegion_MEMORY_REGION7,
+    /** Configure memory region 8. */
+    Qmss_MemRegion_MEMORY_REGION8,
+    /** Configure memory region 9. */
+    Qmss_MemRegion_MEMORY_REGION9,
+    /** Configure memory region 10. */
+    Qmss_MemRegion_MEMORY_REGION10,
+    /** Configure memory region 11. */
+    Qmss_MemRegion_MEMORY_REGION11,
+    /** Configure memory region 12. */
+    Qmss_MemRegion_MEMORY_REGION12,
+    /** Configure memory region 13. */
+    Qmss_MemRegion_MEMORY_REGION13,
+    /** Configure memory region 14. */
+    Qmss_MemRegion_MEMORY_REGION14,
+    /** Configure memory region 15. */
+    Qmss_MemRegion_MEMORY_REGION15,
+    /** Configure memory region 16. */
+    Qmss_MemRegion_MEMORY_REGION16,
+    /** Configure memory region 17. */
+    Qmss_MemRegion_MEMORY_REGION17,
+    /** Configure memory region 18. */
+    Qmss_MemRegion_MEMORY_REGION18,
+    /** Configure memory region 19. */
+    Qmss_MemRegion_MEMORY_REGION19,
+    /** Configure memory region 20. */
+    Qmss_MemRegion_MEMORY_REGION20,
+    /** Configure memory region 21. */
+    Qmss_MemRegion_MEMORY_REGION21,
+    /** Configure memory region 22. */
+    Qmss_MemRegion_MEMORY_REGION22,
+    /** Configure memory region 23. */
+    Qmss_MemRegion_MEMORY_REGION23,
+    /** Configure memory region 24. */
+    Qmss_MemRegion_MEMORY_REGION24,
+    /** Configure memory region 25. */
+    Qmss_MemRegion_MEMORY_REGION25,
+    /** Configure memory region 26. */
+    Qmss_MemRegion_MEMORY_REGION26,
+    /** Configure memory region 27. */
+    Qmss_MemRegion_MEMORY_REGION27,
+    /** Configure memory region 28. */
+    Qmss_MemRegion_MEMORY_REGION28,
+    /** Configure memory region 29. */
+    Qmss_MemRegion_MEMORY_REGION29,
+    /** Configure memory region 30. */
+    Qmss_MemRegion_MEMORY_REGION30,
+    /** Configure memory region 31. */
+    Qmss_MemRegion_MEMORY_REGION31,
+    /** Configure memory region 32. */
+    Qmss_MemRegion_MEMORY_REGION32,
+    /** Configure memory region 33. */
+    Qmss_MemRegion_MEMORY_REGION33,
+    /** Configure memory region 34. */
+    Qmss_MemRegion_MEMORY_REGION34,
+    /** Configure memory region 35. */
+    Qmss_MemRegion_MEMORY_REGION35,
+    /** Configure memory region 36. */
+    Qmss_MemRegion_MEMORY_REGION36,
+    /** Configure memory region 37. */
+    Qmss_MemRegion_MEMORY_REGION37,
+    /** Configure memory region 38. */
+    Qmss_MemRegion_MEMORY_REGION38,
+    /** Configure memory region 39. */
+    Qmss_MemRegion_MEMORY_REGION39,
+    /** Configure memory region 40. */
+    Qmss_MemRegion_MEMORY_REGION40,
+    /** Configure memory region 41. */
+    Qmss_MemRegion_MEMORY_REGION41,
+    /** Configure memory region 42. */
+    Qmss_MemRegion_MEMORY_REGION42,
+    /** Configure memory region 43. */
+    Qmss_MemRegion_MEMORY_REGION43,
+    /** Configure memory region 44. */
+    Qmss_MemRegion_MEMORY_REGION44,
+    /** Configure memory region 45. */
+    Qmss_MemRegion_MEMORY_REGION45,
+    /** Configure memory region 46. */
+    Qmss_MemRegion_MEMORY_REGION46,
+    /** Configure memory region 47. */
+    Qmss_MemRegion_MEMORY_REGION47,
+    /** Configure memory region 48. */
+    Qmss_MemRegion_MEMORY_REGION48,
+    /** Configure memory region 49. */
+    Qmss_MemRegion_MEMORY_REGION49,
+    /** Configure memory region 50. */
+    Qmss_MemRegion_MEMORY_REGION50,
+    /** Configure memory region 51. */
+    Qmss_MemRegion_MEMORY_REGION51,
+    /** Configure memory region 52. */
+    Qmss_MemRegion_MEMORY_REGION52,
+    /** Configure memory region 53. */
+    Qmss_MemRegion_MEMORY_REGION53,
+    /** Configure memory region 54. */
+    Qmss_MemRegion_MEMORY_REGION54,
+    /** Configure memory region 55. */
+    Qmss_MemRegion_MEMORY_REGION55,
+    /** Configure memory region 56. */
+    Qmss_MemRegion_MEMORY_REGION56,
+    /** Configure memory region 57. */
+    Qmss_MemRegion_MEMORY_REGION57,
+    /** Configure memory region 58. */
+    Qmss_MemRegion_MEMORY_REGION58,
+    /** Configure memory region 59. */
+    Qmss_MemRegion_MEMORY_REGION59,
+    /** Configure memory region 60. */
+    Qmss_MemRegion_MEMORY_REGION60,
+    /** Configure memory region 61. */
+    Qmss_MemRegion_MEMORY_REGION61,
+    /** Configure memory region 62. */
+    Qmss_MemRegion_MEMORY_REGION62,
+    /** Configure memory region 63. */
+    Qmss_MemRegion_MEMORY_REGION63
+}Qmss_MemRegion;
+
+/** 
+ * @brief PDSP ID
+ */
+typedef enum
+{
+    /** PDSP 1 */
+    Qmss_PdspId_PDSP1 = 0,
+    /** PDSP 2 */
+    Qmss_PdspId_PDSP2,
+    /** PDSP 3 */
+    Qmss_PdspId_PDSP3,
+    /** PDSP 4 */
+    Qmss_PdspId_PDSP4,
+    /** PDSP 5 */
+    Qmss_PdspId_PDSP5,
+    /** PDSP 6 */
+    Qmss_PdspId_PDSP6,
+    /** PDSP 7 */
+    Qmss_PdspId_PDSP7,
+    /** PDSP 8 */
+    Qmss_PdspId_PDSP8
+}Qmss_PdspId;
+
+/** 
+ * @brief Queue handle
+ */
+typedef int32_t   Qmss_QueueHnd;
+
+/** 
+ * @brief QMSS return result
+ */
+typedef int32_t   Qmss_Result;
+
+/** 
+ * @brief Handle used in the "Fast Push" set of APIs
+ */
+typedef uint32_t* Qmss_QueuePushHnd;
+
+/**
+ * @brief Map PDK HAL to Linux OSAL
+ */
+#define ti_em_hw_queue_open      ti_em_osal_hw_queue_open
+#define ti_em_hw_queue_close     ti_em_osal_hw_queue_close
+
+/* Retrieve QMSS manager number from queue (8192 queues per QMSS) */
+#define ti_em_qmss_get(queue)    ((queue) >> 13)
+
+/* Retrieve absolute base queue for a given infrastructure DMA */
+#define ti_em_qmss_get_dma_queue_base(dma_idx) ((dma_idx == Cppi_CpDma_QMSS_CPDMA) ? \
+						QMSS_QM1_INFRASTRUCTURE_DMA_QUEUE_BASE : \
+						QMSS_QM2_INFRASTRUCTURE_DMA_QUEUE_BASE)
+/*
+ * XGE
+ */
+#define TI_EM_XGE_FLOW_NUM       (16) /* total number of flow used for XGE (8 VLAN priorities per interface) */
+
+#ifdef TI_EM_XGE_LOOPBACK
+/* Use infra-PktDMA to simulate XGE */
+#define TI_EM_XGE_FLOW_IDX_START (14) /* starting at flow 14 */
+#define TI_EM_XGE_TX_QUEUE_BASE  (QMSS_INFRASTRUCTURE_QUEUE_BASE)
+#define TI_EM_XGE_TMP_RX_QUEUE   (QMSS_GENERAL_PURPOSE_QUEUE_BASE + QMSS_MAX_GENERAL_PURPOSE_QUEUE -  TI_EM_XGE_FLOW_NUM)
+#else /* TI_EM_XGE_LOOPBACK */
+/* XGE transmit queue base */
+#define TI_EM_XGE_FLOW_IDX_START (0) /* starting at first flow */
+#define TI_EM_XGE_TX_QUEUE_BASE  (QMSS_XGE_QUEUE_BASE)
+#endif /* TI_EM_XGE_LOOPBACK */
+
+#endif /*TI_EM_HW_QMSS_H_*/
diff --git a/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal.h b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal.h
new file mode 100644
index 0000000..0b49d60
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal.h
@@ -0,0 +1,131 @@ 
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+/**
+ *   @file  ti_em_osal_cma.h
+ *
+ *   @brief
+ *      This is the OS abstraction layer for basic services (log, timers, ...).
+ *
+ */
+
+#ifndef TI_EM_OSAL_H_
+#define TI_EM_OSAL_H_
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <time.h>
+#include <sched.h>
+#include <signal.h>
+
+#include <ti_em_hw_functions.h>
+
+/*
+ * Trace, error and assert logging macros
+ */
+#define __TI_EM_OSAL_PRINTF(tl, type, fmt, args...)			\
+    do{ if ((tl) <= TI_EM_TRACE_LEVEL) printf("EM[%s][C%d] %s(): " fmt, type, ti_em_osal_get_core_idx(), __FUNCTION__ , ## args); } while(0);
+#define TI_EM_OSAL_ERROR(fmt, args...)      __TI_EM_OSAL_PRINTF(1,  "error", fmt, ## args)
+#define TI_EM_OSAL_TRACE(tl, fmt, args...)  __TI_EM_OSAL_PRINTF(tl, "trace", fmt, ## args)
+#define TI_EM_OSAL_PRINTF(fmt, args...)     printf(fmt, ## args)
+
+#if (EM_CHECK_LEVEL >= 1)
+#define TI_EM_OSAL_ASSERT(cond)             if (!(cond)) TI_EM_OSAL_TRACE(0, "ASSERT %s FAILURE\n", # cond)
+#else
+#define TI_EM_OSAL_ASSERT(cond)
+#endif
+
+#define PAGE_ALIGN_UP(x)     (((x) + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1))
+#define PAGE_ALIGN_LOW(x)    (((x) & ~(PAGE_SIZE - 1)))
+
+/*
+ * Functions to map OS basic services
+ */
+#define TI_EM_OSAL_TIMER_LOCAL    (0)
+#define TI_EM_OSAL_TIMER_GLOBAL   (1)
+
+static inline int ti_em_osal_timer_init(int type)
+{
+	if (type ==  TI_EM_OSAL_TIMER_LOCAL) {
+#ifdef TI_EM_HW_HAS_FAST_TSC
+		return TI_EM_HW_INIT_TSC();
+#endif
+	}
+	return 0;
+}
+
+/*
+ * Retrieve current time:
+ * - local time is in cycles (direct core timestamp counter)
+ * - global time is in nanoseconds (Linux syscall) but is consistent accross cores
+ */
+static inline uint64_t ti_em_osal_timer_read(int type)
+{
+	struct timespec ts;
+	
+#ifdef TI_EM_HW_HAS_FAST_TSC
+	if (type == TI_EM_OSAL_TIMER_LOCAL)
+		return TI_EM_HW_GET_TSC();
+#endif	
+	(void) clock_gettime(type == TI_EM_OSAL_TIMER_LOCAL ?
+			     CLOCK_PROCESS_CPUTIME_ID : CLOCK_MONOTONIC, &ts);
+
+	return (((uint64_t) ts.tv_sec * 1000000000ULL) + (uint64_t) ts.tv_nsec); 
+}
+
+/*
+ * Wait until data written to memory
+ */
+static inline void ti_em_osal_mfence(void)
+{
+	TI_EM_ARCH_MEM_BARRIER();
+}
+
+/*
+ * Cache management functions (not used on Linux)
+ */
+static inline void ti_em_osal_cache_wbinv_L1D(void* block_ptr, unsigned int count) {(void)block_ptr; (void)count;}
+static inline void ti_em_osal_cache_wbinv_L2(void* block_ptr, unsigned int count) {(void)block_ptr; (void)count;}
+static inline void ti_em_osal_cache_wb_L1D(void* block_ptr, unsigned int count) {(void)block_ptr; (void)count;}
+static inline void ti_em_osal_cache_wb_L2(void* block_ptr, unsigned int count) {(void)block_ptr; (void)count;}
+static inline void ti_em_osal_cache_inv_L1D(void* block_ptr, unsigned int count) {(void)block_ptr; (void)count;}
+static inline void ti_em_osal_cache_inv_L2(void* block_ptr, unsigned int count) {(void)block_ptr; (void)count;}
+static inline void ti_em_osal_cache_inv_all_L2(void) { }
+static inline void ti_em_osal_cache_inv_prefetch(void) { }
+
+/*
+ * Main exit wrapper
+ */
+static inline void ti_em_osal_exit(int retval) 
+{
+	exit(retval);
+}
+
+#endif /*TI_EM_OSAL_H_*/
diff --git a/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_cma.h b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_cma.h
new file mode 100644
index 0000000..10a7737
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_cma.h
@@ -0,0 +1,61 @@ 
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ *   @file  ti_em_osal_cma.h
+ *
+ *   @brief
+ *      This is the OS abstraction layer for the CMA and kernel services management.
+ *
+ */
+
+#ifndef TI_EM_OSAL_CMA_H_
+#define TI_EM_OSAL_CMA_H_
+
+#include <event_machine_hw_ti_macros.h>
+#include <ti_em_hw_mach.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#define TI_EM_OSAL_CMA_DEVICE   "/dev/openem0"
+
+#define EM_IOC_MAGIC		'O'
+#define EM_IOC_ALLOC	        _IOWR(EM_IOC_MAGIC, 0, int)
+#define EM_IOC_ENABLEPMU        _IO(EM_IOC_MAGIC, 1)
+
+extern int   ti_em_osal_cma_init(void);
+extern void* ti_em_osal_cma_alloc(unsigned int size, int flags, unsigned int *paddr);
+extern void  ti_em_osal_cma_exit(void);
+extern int   ti_em_osal_cma_enable_user_pmu(void);
+
+#endif /*TI_EM_OSAL_CMA_H_*/
diff --git a/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_core.h b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_core.h
new file mode 100644
index 0000000..116431f
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_core.h
@@ -0,0 +1,133 @@ 
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ *   @file  ti_em_osal_core.h
+ *
+ *   @brief
+ *      This is the OS abstraction layer for the core execution services.
+ *
+ */
+
+#ifndef TI_EM_OSAL_CORE_H_
+#define TI_EM_OSAL_CORE_H_
+
+#include <ti_em_osal.h>
+
+#include <sys/mman.h>
+
+#define TI_EM_OSAL_CORE_NUM (8) /* max number of cores manageable by the OSAL library for Core Id */
+
+#ifdef TI_EM_THREAD_MODEL
+ #include <pthread.h>
+ #ifdef TI_EM_HAS___THREAD
+ #define TI_EM_OSAL_CORE_LOCAL_VARIABLE(type, var)  __thread type var
+ #define TI_EM_OSAL_CORE_LOCAL_INIT(var)
+ #define TI_EM_OSAL_CORE_LOCAL_STORE(var, value)    var = *value
+ #define TI_EM_OSAL_CORE_LOCAL_READ(var, dest)      dest = var
+ #define TI_EM_OSAL_CORE_LOCAL_WRITE(var, value)    var = value
+ #else /* TI_EM_HAS___THREAD */
+ #define TI_EM_OSAL_CORE_LOCAL_VARIABLE(type, var)  pthread_key_t __key_##var
+ #define TI_EM_OSAL_CORE_LOCAL_INIT(var)            (void) pthread_key_create(&__key_##var, NULL)
+ #define TI_EM_OSAL_CORE_LOCAL_STORE(var, value)    (void) pthread_setspecific(__key_##var, value)
+
+ #define TI_EM_OSAL_CORE_LOCAL_READ(var, dest)				\
+	{								\
+		typeof(dest) *ptr =					\
+			(typeof(dest)*) pthread_getspecific( __key_##var); \
+		dest = *ptr;						\
+	}
+
+ #define TI_EM_OSAL_CORE_LOCAL_WRITE(var, value)				\
+	{								\
+		typeof(value) *ptr =					\
+			(typeof(value)*) pthread_getspecific( __key_##var); \
+		*ptr = value;						\
+	}
+
+ #endif  /* TI_EM_HAS___THREAD */
+#else   /* TI_EM_THREAD_MODEL */
+ /* Here are the process model definitions and macros */
+ #include <unistd.h>
+ #include <sys/types.h>
+ #include <sys/wait.h>
+ #include <semaphore.h>
+ #include <sched.h>
+ #define TI_EM_OSAL_CORE_LOCAL_VARIABLE(type, var)   type var
+ #define TI_EM_OSAL_CORE_LOCAL_INIT(var, value)
+ #define TI_EM_OSAL_CORE_LOCAL_STORE(var, value)
+ #define TI_EM_OSAL_CORE_LOCAL_READ(var, dest)       dest =  var
+ #define TI_EM_OSAL_CORE_LOCAL_WRITE(var, value)     var = value
+#endif  /* TI_EM_THREAD_MODEL */
+
+extern TI_EM_OSAL_CORE_LOCAL_VARIABLE(uint32_t, __ti_em_osal_core_id);
+
+/*
+ * Return the EM core index
+ */
+static inline uint32_t ti_em_osal_get_core_idx(void)
+{
+	uint32_t id;
+	TI_EM_OSAL_CORE_LOCAL_READ(__ti_em_osal_core_id, id);
+	return id;
+}
+
+/*
+ * Return the hardware core number on which we run (aka cpu id)
+ */
+static inline uint32_t ti_em_osal_get_hw_core(void)
+{
+#ifdef TI_EM_C66X
+	return 0;
+#else
+	return sched_getcpu();
+#endif
+}
+
+static inline int ti_em_osal_core_mlock(void)
+{
+	return mlockall(MCL_FUTURE);
+}
+
+extern int   ti_em_osal_core_spawn(int(*start_routine)(void*), void *arg);
+extern int   ti_em_osal_core_instance_create(int(*start_routine)(void*), void *arg);
+extern int   ti_em_osal_core_exit(int retval);
+extern int   ti_em_osal_core_wait_exit(int core_handler, int *retval);
+extern int   ti_em_osal_core_kill(int core_handler, int sig);
+extern int   ti_em_osal_core_set_affinity(int core_handler, int hw_core_id);
+extern int   ti_em_osal_core_set_rt_priority(int core_handler, int priority);
+extern void  ti_em_osal_core_lock(void);
+extern void  ti_em_osal_core_unlock(void);
+extern int   ti_em_osal_core_barrier_init(int core_num);
+extern void  ti_em_osal_core_barrier_wait(void);
+extern void* ti_em_osal_alloc_per_core(void *ptr, uint32_t size);
+extern void* ti_em_osal_alloc_shared(void *ptr, uint32_t size);
+extern void  ti_em_osal_core_init_global(void);
+extern int   ti_em_osal_core_join(int core_id);
+
+#endif /* TI_EM_OSAL_CORE_H_ */
diff --git a/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_cppi.h b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_cppi.h
new file mode 100644
index 0000000..0526dd8
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_cppi.h
@@ -0,0 +1,73 @@ 
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ *   @file  ti_em_osal_cppi.h
+ *
+ *   @brief
+ *      This is the OS abstraction layer for the PktDMA (CPPI) management.
+ *
+ */
+
+#ifndef TI_EM_OSAL_CPPI_H_
+#define TI_EM_OSAL_CPPI_H_
+
+#include <event_machine_types.h>
+
+#include <ti_em_hw_csl.h>
+#include <ti_em_hw_qmss.h>
+#include <ti_em_hw_cppi.h>
+
+#include <ti_em_osal_uaccess.h>
+#include <ti_em_osal_queue.h>
+
+extern Cppi_GlobalCPDMAConfigParams ti_em_osal_cppi_global_cfg_params[CPPI_MAX_CPDMA];
+
+extern em_status_t ti_em_osal_cppi_rx_flow_open(int dma_idx, int flow_idx, int dst_queue, int free_queue, int error_handling);
+extern em_status_t ti_em_osal_cppi_tx_channel_open(int dma_idx, int channel_idx);
+extern em_status_t ti_em_osal_cppi_rx_channel_open(int dma_idx, int channel_idx);
+extern em_status_t ti_em_osal_cppi_rx_flow_close(int dma_idx, int flow_idx);
+extern em_status_t ti_em_osal_cppi_tx_channel_close(int dma_idx, int channel_idx);
+extern em_status_t ti_em_osal_cppi_rx_channel_close(int dma_idx, int channel_idx);
+extern em_status_t ti_em_osal_cppi_init(void);
+extern em_status_t ti_em_osal_chain_rx_flow_open(int dma_idx,
+						 int flow_idx,
+						 int dst_queue,
+						 int free_queue_sizea,
+						 int sizea,
+						 int free_queue_sizeb,
+						 int sizeb,
+						 int free_queue_sizec,
+						 int sizec,
+						 int free_queue_sized,
+						 int sized,
+						 int free_queue_overflow,
+						 int error_handling);
+extern ti_em_queue_id_t ti_em_osal_cppi_get_absolute_queue_id(ti_em_dma_id_t dma_idx, ti_em_queue_id_t queue_idx);
+
+#endif /*TI_EM_OSAL_CPPI_H_*/
diff --git a/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_event.h b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_event.h
new file mode 100644
index 0000000..2eb6c2b
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_event.h
@@ -0,0 +1,65 @@ 
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ *   @file  ti_em_osal_event.h
+ *
+ *   @brief
+ *      This is the OS abstraction layer for waiting events
+ *
+ */
+#ifndef TI_EM_OSAL_EVENT_H_
+#define TI_EM_OSAL_EVENT_H_
+
+#include <event_machine_hw_ti_macros.h>
+#include <ti_em_hw_mach.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#define TI_EM_OSAL_EVENT_DEVICE_BASENAME   "/dev/openem"
+
+struct ti_em_intd_irq_config {
+	int channel_base;
+	int intd;
+};
+
+#define EM_IOC_MAGIC		           'O'
+#define EM_IOC_WAITEVENT                   _IO(EM_IOC_MAGIC, 2)
+#define EM_IOC_WAITEVENTINIT               _IOWR(EM_IOC_MAGIC, 3, struct ti_em_intd_irq_config)
+#define EM_IOC_WAITEVENTFREE               _IO(EM_IOC_MAGIC, 4)
+
+extern int  ti_em_osal_event_init(int pdsp, int channel_base);
+extern int  ti_em_osal_event_release(void);
+extern int  ti_em_osal_event_wait(void);
+
+#endif /*TI_EM_OSAL_EVENT_H_*/
diff --git a/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_firmware.h b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_firmware.h
new file mode 100644
index 0000000..99fdd9d
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_firmware.h
@@ -0,0 +1,43 @@ 
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ *   @file  ti_em_osal_cma.h
+ *
+ *   @brief
+ *      This is the OS abstraction layer for the firmware management.
+ *
+ */
+
+#ifndef TI_EM_OSAL_FIRMWARE_H_
+#define TI_EM_OSAL_FIRMWARE_H_
+
+extern em_status_t ti_em_osal_pdsp_download_firmware(short pdsp_id, void* firmware, unsigned int size);
+extern em_status_t ti_em_osal_pdsp_stop(short pdsp_id);
+
+#endif /*TI_EM_OSAL_FIRMWARE_H_*/
diff --git a/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_queue.h b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_queue.h
new file mode 100644
index 0000000..f7c5ff1
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_queue.h
@@ -0,0 +1,84 @@ 
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ *   @file  ti_em_osal_queue.h
+ *
+ *   @brief
+ *      This is the OS abstraction layer for the QMSS management.
+ *
+ */
+
+#ifndef TI_EM_OSAL_QUEUE_H_
+#define TI_EM_OSAL_QUEUE_H_
+
+#include <event_machine_types.h>
+
+#include <ti_em_hw_csl.h>
+#include <ti_em_hw_qmss.h>
+#include <ti_em_hw_cppi.h>
+
+#include <ti_em_osal_uaccess.h>
+
+typedef struct ti_em_osal_hw_region_config_t_
+{
+	uint32_t    region_idx;
+	phys_addr_t desc_base;
+	uint32_t    desc_vbase;
+	uint32_t    desc_offset;
+	uint32_t    desc_size;
+	uint32_t    desc_num;
+	uint32_t    desc_flag;
+	int32_t     start_idx;
+} ti_em_osal_hw_region_config_t;
+
+extern em_status_t  ti_em_osal_hw_queue_open(int queue);
+extern em_status_t  ti_em_osal_hw_queue_close(int queue);
+extern em_status_t  ti_em_osal_hw_queue_empty(int queue);
+extern em_status_t  ti_em_osal_hw_queue_insert_region(ti_em_osal_hw_region_config_t *config, int qmss);
+extern unsigned int ti_em_osal_hw_queue_get_memory_region_addr(short memory_idx, int qmss);
+extern void         ti_em_osal_hw_queue_push(int queue, void *desc, short mapping);
+extern void         ti_em_osal_hw_queue_push_size(int queue, void *desc, int size, short mapping);
+
+extern void         ti_em_osal_hw_queue_push_to_head(int queue, void *desc, short mapping);
+extern void*        ti_em_osal_hw_queue_pop(int queue, short mapping);
+extern void         ti_em_osal_hw_queue_set_threshold(int queue, short hilo, char threshold);
+extern void         ti_em_osal_hw_queue_divert(int src_queue, int dst_queue, char location);
+extern unsigned int ti_em_osal_hw_queue_peek(int queue);
+
+static inline void* ti_em_osal_queue_desc_ptov(unsigned int paddr, short mapping) {
+	return (paddr == 0) ?
+		NULL : (void*) ti_em_osal_mem_phys_to_virt(paddr, mapping);
+}
+
+static inline unsigned int ti_em_osal_queue_desc_vtop(void *vaddr, short mapping) {
+	return (vaddr == NULL) ?
+		0 : ti_em_osal_mem_virt_to_phys((unsigned int) vaddr, mapping);
+}
+
+#endif /*TI_EM_OSAL_QUEUE_H_*/
diff --git a/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_shm.h b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_shm.h
new file mode 100644
index 0000000..39c1927
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_shm.h
@@ -0,0 +1,57 @@ 
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ *   @file  ti_em_osal_shm.h
+ *
+ *   @brief
+ *      This is the OS abstraction layer for the shared memory management
+ *
+ */
+
+#ifndef TI_EM_OSAL_SHM_H_
+#define TI_EM_OSAL_SHM_H_
+
+extern int   ti_em_osal_shm_init(int id, const char *shm_name, unsigned int size, short create);
+extern void  ti_em_osal_shm_release(int id);
+extern void* ti_em_osal_shm_get(int id, unsigned int size);
+extern void* ti_em_osal_shm_alloc(int id, unsigned int size);
+extern void  ti_em_osal_shm_free(void *ptr);
+
+
+#define TI_EM_OSAL_SHM_MAPPING_NUM             8 /* number of shared memory mappings */
+#define TI_EM_OSAL_SHM_OSAL_ID                 1 /* shared mem Id 1 is used by OSAL */
+#define TI_EM_OSAL_SHM_OSAL_NAME               "openem_osal"
+#define TI_EM_OSAL_SHM_OSAL_MAPPING_DB_ID      2 /* shared mem Id 2 is used for OSAL mapping db */
+#define TI_EM_OSAL_SHM_OSAL_MAPPING_DB_NAME    "openem_osal_mapping_db"
+#define TI_EM_OSAL_SHM_DEFAULT_ID              3 /* first available mapping*/
+
+#define TI_EM_OSAL_SHM_GLOBAL_ALLOC(p) p  = (typeof(p)) ti_em_osal_shm_alloc(TI_EM_OSAL_SHM_DEFAULT_ID, \
+									     sizeof(*p))
+
+#endif /* TI_EM_OSAL_SHM_H_ */
diff --git a/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_uaccess.h b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_uaccess.h
new file mode 100644
index 0000000..dec8624
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_uaccess.h
@@ -0,0 +1,119 @@ 
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ *   @file  ti_em_osal_uaccess.h
+ *
+ *   @brief
+ *      This is the OS abstraction layer for the I/O accesses from user mode
+ *
+ */
+
+#ifndef TI_EM_OSAL_UACCESS_H_
+#define TI_EM_OSAL_UACCESS_H_
+
+#include <event_machine_hw_ti_macros.h>
+#include <ti_em_hw_mach.h>
+
+#define TI_EM_OSAL_MEM_UACCESS_DEVICE    "/dev/openem0"
+
+#define TI_EM_OSAL_MEM_CACHED            (0x0)
+#define TI_EM_OSAL_MEM_UNCACHED          (0x1)
+
+#define TI_EM_OSAL_DEFAULT_MAPPING_FLAGS (TI_EM_OSAL_MEM_UNCACHED)
+
+typedef unsigned int phys_addr_t;
+
+struct ti_em_osal_mem_mapping {
+	int          fd;
+	phys_addr_t  paddr;
+	unsigned int vaddr;
+	unsigned int size;
+	off_t        offset;
+	unsigned int flags;
+};
+
+extern struct ti_em_osal_mem_mapping __ti_em_osal_mem_mappings[TI_EM_MEM_NUM];
+
+/*
+ * Transform a physical address to a virtual one for a given mapping
+ *
+ * There is no check here since we must do this fast.
+ */
+static inline unsigned int ti_em_osal_mem_phys_to_virt(phys_addr_t paddr, short mapping)
+{
+	return __ti_em_osal_mem_mappings[mapping].vaddr
+	    + (paddr - __ti_em_osal_mem_mappings[mapping].paddr);
+}
+
+/*
+ * Transform a physical address to a virtual one for a given mapping
+ *
+ * There is no check here since we must do this fast.
+ */
+static inline phys_addr_t ti_em_osal_mem_virt_to_phys(unsigned int vaddr, short mapping)
+{
+	return (phys_addr_t) __ti_em_osal_mem_mappings[mapping].paddr
+	    + (vaddr -  __ti_em_osal_mem_mappings[mapping].vaddr);
+}
+
+static inline unsigned int ti_em_osal_io_phys_to_virt(phys_addr_t paddr)
+{
+	return (unsigned int) ti_em_osal_mem_phys_to_virt(paddr, TI_EM_MEM_QMSS_REGS);
+}
+
+static inline phys_addr_t ti_em_osal_io_virt_to_phys(unsigned int vaddr)
+{
+	return (phys_addr_t) ti_em_osal_mem_virt_to_phys(vaddr, TI_EM_MEM_QMSS_REGS);
+}
+
+static inline phys_addr_t ti_em_osal_get_mem_base(short mapping)
+{
+	return __ti_em_osal_mem_mappings[mapping].paddr;
+}
+
+extern phys_addr_t __ti_em_osal_pdsp_comm_mem_base;
+
+static inline phys_addr_t ti_em_osal_get_pdsp_comm_mem_base(uint32_t slot)
+{
+	return __ti_em_osal_pdsp_comm_mem_base + (slot * PAGE_SIZE);
+}
+
+static inline void ti_em_osal_set_pdsp_comm_mem_base(phys_addr_t paddr)
+{
+	__ti_em_osal_pdsp_comm_mem_base = paddr;
+}
+
+extern int ti_em_osal_create_mapping(short mapping, struct ti_em_osal_mem_mapping *mapping_info);
+extern void ti_em_osal_release_mapping(short mapping);
+
+#ifndef TI_EM_THREAD_MODEL
+extern int ti_em_osal_retrieve_mapping(short mapping, struct ti_em_osal_mem_mapping *mapping_info);
+#endif
+
+#endif /*TI_EM_OSAL_UACCESS_H_*/
diff --git a/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_xge.h b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_xge.h
new file mode 100644
index 0000000..5299580
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/linux/osal/ti_em_osal_xge.h
@@ -0,0 +1,69 @@ 
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ *   @file  ti_em_osal_xge.c
+ *
+ *   @brief
+ *      This is the OS abstraction layer for the 10Gig Ethernet management.
+ *
+ */
+
+#ifndef TI_EM_OSAL_XGE_H_
+#define TI_EM_OSAL_XGE_H_
+
+#include <event_machine_types.h>
+
+#include <ti_em_hw_csl.h>
+#include <ti_em_hw_qmss.h>
+#include <ti_em_hw_cppi.h>
+
+#include <ti_em_osal_uaccess.h>
+#include <ti_em_osal_queue.h>
+
+extern em_status_t ti_em_osal_xge_rx_flow_open(int dma_idx, int flow_idx, int dst_queue_idx, int free_queue_idx0, int free_queue_idx1, int error_handling);
+extern em_status_t ti_em_osal_xge_tx_channel_open(int dma_idx, int channel_idx);
+extern em_status_t ti_em_osal_xge_rx_channel_open(int dma_idx, int channel_idx);
+extern ti_em_queue_id_t ti_em_osal_xge_tx_queue_open(ti_em_queue_id_t queue_base_idx, int vlan_priority);
+extern em_status_t ti_em_osal_xge_rx_flow_close(int dma_idx, int flow_idx);
+extern em_status_t ti_em_osal_xge_rx_channel_close(int dma_idx, int channel_idx);
+extern em_status_t ti_em_osal_xge_tx_channel_close(int dma_idx, int channel_idx);
+extern ti_em_queue_id_t ti_em_osal_xge_tx_queue_base_idx_get (void);
+extern ti_em_queue_id_t ti_em_osal_xge_rx_queue_idx_get(int flow_idx);
+#ifdef TI_EM_XGE_LOOPBACK
+extern em_status_t ti_em_osal_xge_rx_insert_crc(int flow_idx,
+						ti_em_queue_id_t rx_fragment_free_queue,
+						ti_em_queue_id_t xge_dst_queue,
+						int count);
+#else /* TI_EM_XGE_LOOPBACK */
+static inline em_status_t ti_em_osal_xge_rx_insert_crc(int flow_idx,
+						       ti_em_queue_id_t rx_fragment_free_queue,
+						       ti_em_queue_id_t xge_dst_queue,
+						       int count) { return EM_OK; };
+#endif /* TI_EM_XGE_LOOPBACK */
+#endif /*TI_EM_OSAL_XGE_H_*/
diff --git a/platform/linux-keystone2/prebuilts/openem/include/linux/rh/ti_em_rh.h b/platform/linux-keystone2/prebuilts/openem/include/linux/rh/ti_em_rh.h
new file mode 100644
index 0000000..6e2d262
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/linux/rh/ti_em_rh.h
@@ -0,0 +1,139 @@ 
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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.
+ */
+
+
+/**
+ *   @file  ti_em_rh.h
+ *
+ *   @brief
+ *      This is the OpenEM runtime helper library for Linux
+ *
+ */
+#ifndef _TI_EM_RH_H_
+#define _TI_EM_RH_H_
+
+#include <ti_em_osal.h>
+#include <ti_em_osal_queue.h>
+
+#include <event_machine_hw_ti_types.h>
+
+#define TI_EM_RH_PUBLIC                (0)
+#define TI_EM_RH_PRIVATE               (1)
+
+#define TI_EM_RH_UNMANAGED_DESCRIPTOR  (0)
+#define TI_EM_RH_MANAGE_DESCRIPTOR     (1)
+
+#define TI_EM_RH_POLL_MODE             (0)
+#define TI_EM_RH_INTERRUPT_MODE        (1)
+
+#define TI_EM_RH_PRIVATE_EVENT_NUM     (TI_EM_PDSP_GLOBAL_DATA_SIZE / TI_EM_PRIVATE_EVENT_DSC_SIZE)
+
+/* 
+ * PDSP firmware download information structure
+ */
+typedef struct ti_em_rh_pdsp_config_t_
+{
+	short     pdsp_id;
+	void     *firmware;
+	uint32_t  size; 
+} ti_em_rh_pdsp_config_t;
+
+/*
+ * Physical memory description structure
+ */
+typedef struct ti_em_rh_mem_config_t_
+{
+	phys_addr_t paddr;
+	uint32_t    vaddr;
+	uint32_t    size;
+	uint32_t    offset;
+	uint32_t    mapping_id;
+	uint32_t    flags;
+} ti_em_rh_mem_config_t;
+
+/*
+ * Pool of event configuration structure
+ */
+typedef struct ti_em_rh_pool_config_t_
+{
+	uint32_t              event_num;
+	uint32_t              buffer_size;
+	uint32_t              offset;
+	uint32_t              ps_word_num;
+	uint32_t              free_policy;
+	ti_em_pool_config_t   pool;
+	ti_em_rh_mem_config_t mem;
+} ti_em_rh_pool_config_t;
+
+/*
+ * Main OpenEM hw configuration structure
+ */
+typedef struct ti_em_rh_hw_config_t_
+{
+	ti_em_device_id_t              device_id;
+	ti_em_process_id_t             process_id;
+	ti_em_chain_config_t*          chain_config_ptr;
+	uint32_t                       private_free_queue_idx;
+	uint32_t                       region_num; 
+	ti_em_osal_hw_region_config_t *region_configs;
+	uint32_t                       hw_queue_base_idx;
+	uint32_t                       dma_queue_base_idx;
+	int32_t                        dma_idx;
+	uint32_t                       preload_size_a;
+	uint32_t                       preload_size_b;
+	uint32_t                       preload_size_c;
+	ti_em_rh_mem_config_t          pdsp_comm_mem_config;
+	uint32_t                       pdsp_num;
+	ti_em_rh_pdsp_config_t         pdsp_sched[TI_EM_SCHEDULER_THREAD_NUM];
+	ti_em_rh_pdsp_config_t         pdsp_router;
+	uint32_t                       dispatch_mode;
+	uint32_t                       hw_interrupt_base_idx;
+} ti_em_rh_hw_config_t;
+
+extern em_status_t ti_em_rh_init_global(
+	uint32_t                       pool_num,
+	ti_em_rh_pool_config_t        *pool_configs,
+	uint32_t                       core_num,
+	ti_em_rh_hw_config_t          *hw_config);
+extern em_status_t ti_em_rh_release_global(void);
+extern em_status_t ti_em_rh_init_local(void);
+extern em_status_t ti_em_rh_release_local(void);
+extern em_status_t ti_em_rh_join(int core_id);
+extern em_status_t ti_em_rh_create_cores(
+	int core_num,
+	int(*dispatcher_fn)(void*),
+	int(*init_fn)(void),
+	int hw_core_start);
+extern em_status_t ti_em_rh_wait_cores(int core_num);
+extern em_status_t ti_em_rh_kill_cores(int core_num);
+extern em_status_t ti_em_rh_dispatch(int mode, uint32_t sleep_quota, uint32_t cancel_quota);
+extern int ti_em_rh_alloc_map_cma(ti_em_rh_mem_config_t *mem);
+extern void* ti_em_rh_public_desc_addr(uint32_t idx, uintptr_t *paddr);
+void ti_em_rh_dump_io_mem(phys_addr_t paddr, uint32_t size, const char *desc);
+void ti_em_rh_dump_mem(void *addr, uint32_t size, const char *desc);
+
+#endif /*_TI_EM_RH_H_*/
diff --git a/platform/linux-keystone2/prebuilts/openem/include/src/event_machine_hwpform.h b/platform/linux-keystone2/prebuilts/openem/include/src/event_machine_hwpform.h
new file mode 100644
index 0000000..23e5881
--- /dev/null
+++ b/platform/linux-keystone2/prebuilts/openem/include/src/event_machine_hwpform.h
@@ -0,0 +1,51 @@ 
+/*
+ * Copyright (c) 2012, Texas Instruments Incorporated - http://www.ti.com/
+ *   All rights reserved.
+ *
+ *   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 EVENT_MACHINE_HWPFORM_H_
+#define EVENT_MACHINE_HWPFORM_H_
+
+#ifndef TI_EM_LINUX
+/* CSL Header Files. */
+#include <ti/csl/csl_chip.h>
+#include <ti/csl/csl_cache.h>
+#include <ti/csl/csl_cacheAux.h>
+#include <ti/csl/csl_semAux.h>
+
+/* CPPI/QMSS Include Files. */
+#include <ti/drv/cppi/cppi_drv.h>
+#include <ti/drv/cppi/cppi_desc.h>
+#include <ti/drv/qmss/qmss_drv.h>
+#include <ti/csl/csl_xmcAux.h>
+#else /* TI_EM_LINUX */
+#include <ti_em_hw_mach.h>      /* needed for CACHE_L2_LINESIZE definitions */
+#include <ti_em_hw_csl.h>       /* CPPI/QMSS descriptor definitions */
+#include <ti_em_hw_qmss.h>      /* CPPI/QMSS descriptor definitions */
+#include <ti_em_hw_cppi.h>      /* CPPI/QMSS descriptor definitions */
+#endif /* TI_EM_LINUX */
+
+#endif /*EVENT_MACHINE_HWPFORM_H_ */