tegra: integrate AVP transport RM service to kernel

communication between the operating system running on the AVP (ARM7) and
software running in Linux uses an RPC message-passing system called RM
Transport, implemented using shared message buffers in memory and a
hardware mailbox register.

this interface has previously been implemented in user-space; however,
in order to support Linux kernel sound drivers (e.g., ALSA), this
needs to be implemented in the kernel.

bug 624425

4 files changed, 1017 insertions, 1 deletions

diff --git a/arch/arm/mach-tegra/nvrm/dispatch/Makefile b/arch/arm/mach-tegra/nvrm/dispatch/Makefile
index 959155944f47..dd1710b2b750 100644
--- a/arch/arm/mach-tegra/nvrm/dispatch/Makefile
+++ b/arch/arm/mach-tegra/nvrm/dispatch/Makefile
@@ -26,3 +26,5 @@ obj-y += nvrm_pmu_dispatch.o
 obj-y += nvrm_keylist_dispatch.o
 obj-y += nvrm_pcie_dispatch.o
 obj-y += nvrm_memctrl_dispatch.o
+obj-y += nvrm_transport_dispatch.o
+obj-y += nvrm_xpc_dispatch.o
diff --git a/arch/arm/mach-tegra/nvrm/dispatch/NvRm_Dispatch.c b/arch/arm/mach-tegra/nvrm/dispatch/NvRm_Dispatch.c
index e8ea4ee5be9e..c321c393b6cf 100644
--- a/arch/arm/mach-tegra/nvrm/dispatch/NvRm_Dispatch.c
+++ b/arch/arm/mach-tegra/nvrm/dispatch/NvRm_Dispatch.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009 NVIDIA Corporation.
+ * Copyright (c) 2009-2010 NVIDIA Corporation.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -35,6 +35,8 @@
 #include "nvassert.h"
 #include "nvidlcmd.h"
 #include "nvreftrack.h"
+#include "nvrm_xpc.h"
+#include "nvrm_transport.h"
 #include "nvrm_memctrl.h"
 #include "nvrm_pcie.h"
 #include "nvrm_pwm.h"
@@ -53,6 +55,8 @@
 #include "nvrm_module.h"
 #include "nvrm_memmgr.h"
 #include "nvrm_init.h"
+NvError nvrm_xpc_Dispatch( NvU32 function, void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx );
+NvError nvrm_transport_Dispatch( NvU32 function, void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx );
 NvError nvrm_memctrl_Dispatch( NvU32 function, void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx );
 NvError nvrm_pcie_Dispatch( NvU32 function, void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx );
 NvError nvrm_pwm_Dispatch( NvU32 function, void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx );
@@ -76,6 +80,8 @@ NvError nvrm_init_Dispatch( NvU32 function, void *InBuffer, NvU32 InSize, void *
 typedef enum
 {
     NvRm_Invalid = 0,
+    NvRm_nvrm_xpc,
+    NvRm_nvrm_transport,
     NvRm_nvrm_memctrl,
     NvRm_nvrm_pcie,
     NvRm_nvrm_pwm,
@@ -108,6 +114,8 @@ typedef struct NvIdlDispatchTableRec
 
 static NvIdlDispatchTable gs_DispatchTable[] =
 {
+    { NvRm_nvrm_xpc, nvrm_xpc_Dispatch },
+    { NvRm_nvrm_transport, nvrm_transport_Dispatch },
     { NvRm_nvrm_memctrl, nvrm_memctrl_Dispatch },
     { NvRm_nvrm_pcie, nvrm_pcie_Dispatch },
     { NvRm_nvrm_pwm, nvrm_pwm_Dispatch },
@@ -149,3 +157,4 @@ NvError NvRm_Dispatch( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutS
     return table_[packid_ - 1].DispFunc( funcid_, InBuffer, InSize,
         OutBuffer, OutSize, Ctx );
 }
+
diff --git a/arch/arm/mach-tegra/nvrm/dispatch/nvrm_transport_dispatch.c b/arch/arm/mach-tegra/nvrm/dispatch/nvrm_transport_dispatch.c
new file mode 100644
index 000000000000..a37c39d2d8ae
--- /dev/null
+++ b/arch/arm/mach-tegra/nvrm/dispatch/nvrm_transport_dispatch.c
@@ -0,0 +1,657 @@
+
+#define NV_IDL_IS_DISPATCH
+
+/*
+ * Copyright (c) 2010 NVIDIA Corporation.
+ * 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 the NVIDIA Corporation 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 HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "nvcommon.h"
+#include "nvos.h"
+#include "nvassert.h"
+#include "nvreftrack.h"
+#include "nvidlcmd.h"
+#include "nvrm_transport.h"
+
+#define OFFSET( s, e ) (NvU32)(void *)(&(((s*)0)->e))
+
+
+typedef struct NvRmTransportRecvMsg_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmTransportHandle hTransport;
+    void* pMessageBuffer;
+    NvU32 MaxSize;
+} NV_ALIGN(4) NvRmTransportRecvMsg_in;
+
+typedef struct NvRmTransportRecvMsg_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmTransportRecvMsg_inout;
+
+typedef struct NvRmTransportRecvMsg_out_t
+{
+    NvError ret_;
+    NvU32 pMessageSize;
+} NV_ALIGN(4) NvRmTransportRecvMsg_out;
+
+typedef struct NvRmTransportRecvMsg_params_t
+{
+    NvRmTransportRecvMsg_in in;
+    NvRmTransportRecvMsg_inout inout;
+    NvRmTransportRecvMsg_out out;
+} NvRmTransportRecvMsg_params;
+
+typedef struct NvRmTransportSendMsgInLP0_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmTransportHandle hPort;
+    void* message;
+    NvU32 MessageSize;
+} NV_ALIGN(4) NvRmTransportSendMsgInLP0_in;
+
+typedef struct NvRmTransportSendMsgInLP0_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmTransportSendMsgInLP0_inout;
+
+typedef struct NvRmTransportSendMsgInLP0_out_t
+{
+    NvError ret_;
+} NV_ALIGN(4) NvRmTransportSendMsgInLP0_out;
+
+typedef struct NvRmTransportSendMsgInLP0_params_t
+{
+    NvRmTransportSendMsgInLP0_in in;
+    NvRmTransportSendMsgInLP0_inout inout;
+    NvRmTransportSendMsgInLP0_out out;
+} NvRmTransportSendMsgInLP0_params;
+
+typedef struct NvRmTransportSendMsg_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmTransportHandle hTransport;
+    void* pMessageBuffer;
+    NvU32 MessageSize;
+    NvU32 TimeoutMS;
+} NV_ALIGN(4) NvRmTransportSendMsg_in;
+
+typedef struct NvRmTransportSendMsg_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmTransportSendMsg_inout;
+
+typedef struct NvRmTransportSendMsg_out_t
+{
+    NvError ret_;
+} NV_ALIGN(4) NvRmTransportSendMsg_out;
+
+typedef struct NvRmTransportSendMsg_params_t
+{
+    NvRmTransportSendMsg_in in;
+    NvRmTransportSendMsg_inout inout;
+    NvRmTransportSendMsg_out out;
+} NvRmTransportSendMsg_params;
+
+typedef struct NvRmTransportSetQueueDepth_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmTransportHandle hTransport;
+    NvU32 MaxQueueDepth;
+    NvU32 MaxMessageSize;
+} NV_ALIGN(4) NvRmTransportSetQueueDepth_in;
+
+typedef struct NvRmTransportSetQueueDepth_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmTransportSetQueueDepth_inout;
+
+typedef struct NvRmTransportSetQueueDepth_out_t
+{
+    NvError ret_;
+} NV_ALIGN(4) NvRmTransportSetQueueDepth_out;
+
+typedef struct NvRmTransportSetQueueDepth_params_t
+{
+    NvRmTransportSetQueueDepth_in in;
+    NvRmTransportSetQueueDepth_inout inout;
+    NvRmTransportSetQueueDepth_out out;
+} NvRmTransportSetQueueDepth_params;
+
+typedef struct NvRmTransportConnect_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmTransportHandle hTransport;
+    NvU32 TimeoutMS;
+} NV_ALIGN(4) NvRmTransportConnect_in;
+
+typedef struct NvRmTransportConnect_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmTransportConnect_inout;
+
+typedef struct NvRmTransportConnect_out_t
+{
+    NvError ret_;
+} NV_ALIGN(4) NvRmTransportConnect_out;
+
+typedef struct NvRmTransportConnect_params_t
+{
+    NvRmTransportConnect_in in;
+    NvRmTransportConnect_inout inout;
+    NvRmTransportConnect_out out;
+} NvRmTransportConnect_params;
+
+typedef struct NvRmTransportWaitForConnect_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmTransportHandle hTransport;
+    NvU32 TimeoutMS;
+} NV_ALIGN(4) NvRmTransportWaitForConnect_in;
+
+typedef struct NvRmTransportWaitForConnect_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmTransportWaitForConnect_inout;
+
+typedef struct NvRmTransportWaitForConnect_out_t
+{
+    NvError ret_;
+} NV_ALIGN(4) NvRmTransportWaitForConnect_out;
+
+typedef struct NvRmTransportWaitForConnect_params_t
+{
+    NvRmTransportWaitForConnect_in in;
+    NvRmTransportWaitForConnect_inout inout;
+    NvRmTransportWaitForConnect_out out;
+} NvRmTransportWaitForConnect_params;
+
+typedef struct NvRmTransportDeInit_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmDeviceHandle hRmDevice;
+} NV_ALIGN(4) NvRmTransportDeInit_in;
+
+typedef struct NvRmTransportDeInit_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmTransportDeInit_inout;
+
+typedef struct NvRmTransportDeInit_out_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmTransportDeInit_out;
+
+typedef struct NvRmTransportDeInit_params_t
+{
+    NvRmTransportDeInit_in in;
+    NvRmTransportDeInit_inout inout;
+    NvRmTransportDeInit_out out;
+} NvRmTransportDeInit_params;
+
+typedef struct NvRmTransportInit_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmDeviceHandle hRmDevice;
+} NV_ALIGN(4) NvRmTransportInit_in;
+
+typedef struct NvRmTransportInit_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmTransportInit_inout;
+
+typedef struct NvRmTransportInit_out_t
+{
+    NvError ret_;
+} NV_ALIGN(4) NvRmTransportInit_out;
+
+typedef struct NvRmTransportInit_params_t
+{
+    NvRmTransportInit_in in;
+    NvRmTransportInit_inout inout;
+    NvRmTransportInit_out out;
+} NvRmTransportInit_params;
+
+typedef struct NvRmTransportClose_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmTransportHandle hTransport;
+} NV_ALIGN(4) NvRmTransportClose_in;
+
+typedef struct NvRmTransportClose_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmTransportClose_inout;
+
+typedef struct NvRmTransportClose_out_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmTransportClose_out;
+
+typedef struct NvRmTransportClose_params_t
+{
+    NvRmTransportClose_in in;
+    NvRmTransportClose_inout inout;
+    NvRmTransportClose_out out;
+} NvRmTransportClose_params;
+
+typedef struct NvRmTransportGetPortName_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmTransportHandle hTransport;
+    NvU8  * PortName;
+    NvU32 PortNameSize;
+} NV_ALIGN(4) NvRmTransportGetPortName_in;
+
+typedef struct NvRmTransportGetPortName_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmTransportGetPortName_inout;
+
+typedef struct NvRmTransportGetPortName_out_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmTransportGetPortName_out;
+
+typedef struct NvRmTransportGetPortName_params_t
+{
+    NvRmTransportGetPortName_in in;
+    NvRmTransportGetPortName_inout inout;
+    NvRmTransportGetPortName_out out;
+} NvRmTransportGetPortName_params;
+
+typedef struct NvRmTransportOpen_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmDeviceHandle hRmDevice;
+    char * pPortName_data;
+    NvU32 pPortName_len;
+    NvOsSemaphoreHandle RecvMessageSemaphore;
+} NV_ALIGN(4) NvRmTransportOpen_in;
+
+typedef struct NvRmTransportOpen_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmTransportOpen_inout;
+
+typedef struct NvRmTransportOpen_out_t
+{
+    NvError ret_;
+    NvRmTransportHandle phTransport;
+} NV_ALIGN(4) NvRmTransportOpen_out;
+
+typedef struct NvRmTransportOpen_params_t
+{
+    NvRmTransportOpen_in in;
+    NvRmTransportOpen_inout inout;
+    NvRmTransportOpen_out out;
+} NvRmTransportOpen_params;
+
+static NvError NvRmTransportRecvMsg_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmTransportRecvMsg_in *p_in;
+    NvRmTransportRecvMsg_out *p_out;
+    void*  pMessageBuffer = NULL;
+
+    p_in = (NvRmTransportRecvMsg_in *)InBuffer;
+    p_out = (NvRmTransportRecvMsg_out *)((NvU8 *)OutBuffer + OFFSET(NvRmTransportRecvMsg_params, out) - OFFSET(NvRmTransportRecvMsg_params, inout));
+
+    if( p_in->MaxSize && p_in->pMessageBuffer )
+    {
+        pMessageBuffer = (void*  )NvOsAlloc( p_in->MaxSize );
+        if( !pMessageBuffer )
+        {
+            err_ = NvError_InsufficientMemory;
+            goto clean;
+        }
+    }
+
+    p_out->ret_ = NvRmTransportRecvMsg( p_in->hTransport, pMessageBuffer, p_in->MaxSize, &p_out->pMessageSize );
+
+    if(p_in->pMessageBuffer && pMessageBuffer)
+    {
+        err_ = NvOsCopyOut( p_in->pMessageBuffer, pMessageBuffer, p_in->MaxSize );
+        if( err_ != NvSuccess )
+        {
+            err_ = NvError_BadParameter;
+        }
+    }
+clean:
+    NvOsFree( pMessageBuffer );
+    return err_;
+}
+
+static NvError NvRmTransportSendMsgInLP0_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmTransportSendMsgInLP0_in *p_in;
+    NvRmTransportSendMsgInLP0_out *p_out;
+    void*  message = NULL;
+
+    p_in = (NvRmTransportSendMsgInLP0_in *)InBuffer;
+    p_out = (NvRmTransportSendMsgInLP0_out *)((NvU8 *)OutBuffer + OFFSET(NvRmTransportSendMsgInLP0_params, out) - OFFSET(NvRmTransportSendMsgInLP0_params, inout));
+
+    if( p_in->MessageSize && p_in->message )
+    {
+        message = (void*  )NvOsAlloc( p_in->MessageSize );
+        if( !message )
+        {
+            err_ = NvError_InsufficientMemory;
+            goto clean;
+        }
+        if( p_in->message )
+        {
+            err_ = NvOsCopyIn( message, p_in->message, p_in->MessageSize );
+            if( err_ != NvSuccess )
+            {
+                err_ = NvError_BadParameter;
+                goto clean;
+            }
+        }
+    }
+
+    p_out->ret_ = NvRmTransportSendMsgInLP0( p_in->hPort, message, p_in->MessageSize );
+
+clean:
+    NvOsFree( message );
+    return err_;
+}
+
+static NvError NvRmTransportSendMsg_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmTransportSendMsg_in *p_in;
+    NvRmTransportSendMsg_out *p_out;
+    void*  pMessageBuffer = NULL;
+
+    p_in = (NvRmTransportSendMsg_in *)InBuffer;
+    p_out = (NvRmTransportSendMsg_out *)((NvU8 *)OutBuffer + OFFSET(NvRmTransportSendMsg_params, out) - OFFSET(NvRmTransportSendMsg_params, inout));
+
+    if( p_in->MessageSize && p_in->pMessageBuffer )
+    {
+        pMessageBuffer = (void*  )NvOsAlloc( p_in->MessageSize );
+        if( !pMessageBuffer )
+        {
+            err_ = NvError_InsufficientMemory;
+            goto clean;
+        }
+        if( p_in->pMessageBuffer )
+        {
+            err_ = NvOsCopyIn( pMessageBuffer, p_in->pMessageBuffer, p_in->MessageSize );
+            if( err_ != NvSuccess )
+            {
+                err_ = NvError_BadParameter;
+                goto clean;
+            }
+        }
+    }
+
+    p_out->ret_ = NvRmTransportSendMsg( p_in->hTransport, pMessageBuffer, p_in->MessageSize, p_in->TimeoutMS );
+
+clean:
+    NvOsFree( pMessageBuffer );
+    return err_;
+}
+
+static NvError NvRmTransportSetQueueDepth_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmTransportSetQueueDepth_in *p_in;
+    NvRmTransportSetQueueDepth_out *p_out;
+
+    p_in = (NvRmTransportSetQueueDepth_in *)InBuffer;
+    p_out = (NvRmTransportSetQueueDepth_out *)((NvU8 *)OutBuffer + OFFSET(NvRmTransportSetQueueDepth_params, out) - OFFSET(NvRmTransportSetQueueDepth_params, inout));
+
+
+    p_out->ret_ = NvRmTransportSetQueueDepth( p_in->hTransport, p_in->MaxQueueDepth, p_in->MaxMessageSize );
+
+    return err_;
+}
+
+static NvError NvRmTransportConnect_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmTransportConnect_in *p_in;
+    NvRmTransportConnect_out *p_out;
+
+    p_in = (NvRmTransportConnect_in *)InBuffer;
+    p_out = (NvRmTransportConnect_out *)((NvU8 *)OutBuffer + OFFSET(NvRmTransportConnect_params, out) - OFFSET(NvRmTransportConnect_params, inout));
+
+
+    p_out->ret_ = NvRmTransportConnect( p_in->hTransport, p_in->TimeoutMS );
+
+    return err_;
+}
+
+static NvError NvRmTransportWaitForConnect_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmTransportWaitForConnect_in *p_in;
+    NvRmTransportWaitForConnect_out *p_out;
+
+    p_in = (NvRmTransportWaitForConnect_in *)InBuffer;
+    p_out = (NvRmTransportWaitForConnect_out *)((NvU8 *)OutBuffer + OFFSET(NvRmTransportWaitForConnect_params, out) - OFFSET(NvRmTransportWaitForConnect_params, inout));
+
+
+    p_out->ret_ = NvRmTransportWaitForConnect( p_in->hTransport, p_in->TimeoutMS );
+
+    return err_;
+}
+
+static NvError NvRmTransportDeInit_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmTransportDeInit_in *p_in;
+
+    p_in = (NvRmTransportDeInit_in *)InBuffer;
+
+
+    NvRmTransportDeInit( p_in->hRmDevice );
+
+    return err_;
+}
+
+static NvError NvRmTransportInit_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmTransportInit_in *p_in;
+    NvRmTransportInit_out *p_out;
+
+    p_in = (NvRmTransportInit_in *)InBuffer;
+    p_out = (NvRmTransportInit_out *)((NvU8 *)OutBuffer + OFFSET(NvRmTransportInit_params, out) - OFFSET(NvRmTransportInit_params, inout));
+
+
+    p_out->ret_ = NvRmTransportInit( p_in->hRmDevice );
+
+    return err_;
+}
+
+static NvError NvRmTransportClose_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmTransportClose_in *p_in;
+
+    p_in = (NvRmTransportClose_in *)InBuffer;
+
+
+    NvRmTransportClose( p_in->hTransport );
+
+    return err_;
+}
+
+static NvError NvRmTransportGetPortName_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmTransportGetPortName_in *p_in;
+    NvU8  *PortName = NULL;
+
+    p_in = (NvRmTransportGetPortName_in *)InBuffer;
+
+    if( p_in->PortNameSize && p_in->PortName )
+    {
+        PortName = (NvU8  *)NvOsAlloc( p_in->PortNameSize * sizeof( NvU8  ) );
+        if( !PortName )
+        {
+            err_ = NvError_InsufficientMemory;
+            goto clean;
+        }
+        if( p_in->PortName )
+        {
+            err_ = NvOsCopyIn( PortName, p_in->PortName, p_in->PortNameSize * sizeof( NvU8  ) );
+            if( err_ != NvSuccess )
+            {
+                err_ = NvError_BadParameter;
+                goto clean;
+            }
+        }
+    }
+
+    NvRmTransportGetPortName( p_in->hTransport, PortName, p_in->PortNameSize );
+
+    if(p_in->PortName && PortName)
+    {
+        err_ = NvOsCopyOut( p_in->PortName, PortName, p_in->PortNameSize * sizeof( NvU8  ) );
+        if( err_ != NvSuccess )
+        {
+            err_ = NvError_BadParameter;
+        }
+    }
+clean:
+    NvOsFree( PortName );
+    return err_;
+}
+
+static NvError NvRmTransportOpen_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmTransportOpen_in *p_in;
+    NvRmTransportOpen_out *p_out;
+    char *pPortName = NULL;
+    NvOsSemaphoreHandle RecvMessageSemaphore = NULL;
+
+    p_in = (NvRmTransportOpen_in *)InBuffer;
+    p_out = (NvRmTransportOpen_out *)((NvU8 *)OutBuffer + OFFSET(NvRmTransportOpen_params, out) - OFFSET(NvRmTransportOpen_params, inout));
+
+    if( p_in->pPortName_len )
+    {
+        pPortName = NvOsAlloc( p_in->pPortName_len );
+        if( !pPortName )
+        {
+            err_ = NvError_InsufficientMemory;
+            goto clean;
+        }
+        err_ = NvOsCopyIn( pPortName, p_in->pPortName_data, p_in->pPortName_len );
+        if( err_ != NvSuccess )
+        {
+            err_ = NvError_BadParameter;
+            goto clean;
+        }
+        if( pPortName[p_in->pPortName_len - 1] != 0 )
+        {
+            err_ = NvError_BadParameter;
+            goto clean;
+        }
+    }
+    if( p_in->RecvMessageSemaphore )
+    {
+        err_ = NvOsSemaphoreUnmarshal( p_in->RecvMessageSemaphore, &RecvMessageSemaphore );
+        if( err_ != NvSuccess )
+        {
+            err_ = NvError_BadParameter;
+            goto clean;
+        }
+    }
+
+    p_out->ret_ = NvRmTransportOpen( p_in->hRmDevice, pPortName, RecvMessageSemaphore, &p_out->phTransport );
+
+clean:
+    NvOsFree( pPortName );
+    NvOsSemaphoreDestroy( RecvMessageSemaphore );
+    return err_;
+}
+
+NvError nvrm_transport_Dispatch( NvU32 function, void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx );
+NvError nvrm_transport_Dispatch( NvU32 function, void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+
+    switch( function ) {
+    case 10:
+        err_ = NvRmTransportRecvMsg_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    case 9:
+        err_ = NvRmTransportSendMsgInLP0_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    case 8:
+        err_ = NvRmTransportSendMsg_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    case 7:
+        err_ = NvRmTransportSetQueueDepth_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    case 6:
+        err_ = NvRmTransportConnect_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    case 5:
+        err_ = NvRmTransportWaitForConnect_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    case 4:
+        err_ = NvRmTransportDeInit_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    case 3:
+        err_ = NvRmTransportInit_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    case 2:
+        err_ = NvRmTransportClose_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    case 1:
+        err_ = NvRmTransportGetPortName_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    case 0:
+        err_ = NvRmTransportOpen_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    default:
+        err_ = NvError_BadParameter;
+        break;
+    }
+
+    return err_;
+}
diff --git a/arch/arm/mach-tegra/nvrm/dispatch/nvrm_xpc_dispatch.c b/arch/arm/mach-tegra/nvrm/dispatch/nvrm_xpc_dispatch.c
new file mode 100644
index 000000000000..16b98ede32e0
--- /dev/null
+++ b/arch/arm/mach-tegra/nvrm/dispatch/nvrm_xpc_dispatch.c
@@ -0,0 +1,348 @@
+
+#define NV_IDL_IS_DISPATCH
+
+/*
+ * Copyright (c) 2010 NVIDIA Corporation.
+ * 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 the NVIDIA Corporation 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 HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "nvcommon.h"
+#include "nvos.h"
+#include "nvassert.h"
+#include "nvreftrack.h"
+#include "nvidlcmd.h"
+#include "nvrm_xpc.h"
+
+#define OFFSET( s, e ) (NvU32)(void *)(&(((s*)0)->e))
+
+
+typedef struct NvRmXpcModuleRelease_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmModuleID modId;
+} NV_ALIGN(4) NvRmXpcModuleRelease_in;
+
+typedef struct NvRmXpcModuleRelease_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmXpcModuleRelease_inout;
+
+typedef struct NvRmXpcModuleRelease_out_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmXpcModuleRelease_out;
+
+typedef struct NvRmXpcModuleRelease_params_t
+{
+    NvRmXpcModuleRelease_in in;
+    NvRmXpcModuleRelease_inout inout;
+    NvRmXpcModuleRelease_out out;
+} NvRmXpcModuleRelease_params;
+
+typedef struct NvRmXpcModuleAcquire_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmModuleID modId;
+} NV_ALIGN(4) NvRmXpcModuleAcquire_in;
+
+typedef struct NvRmXpcModuleAcquire_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmXpcModuleAcquire_inout;
+
+typedef struct NvRmXpcModuleAcquire_out_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmXpcModuleAcquire_out;
+
+typedef struct NvRmXpcModuleAcquire_params_t
+{
+    NvRmXpcModuleAcquire_in in;
+    NvRmXpcModuleAcquire_inout inout;
+    NvRmXpcModuleAcquire_out out;
+} NvRmXpcModuleAcquire_params;
+
+typedef struct NvRmXpcInitArbSemaSystem_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmDeviceHandle hDevice;
+} NV_ALIGN(4) NvRmXpcInitArbSemaSystem_in;
+
+typedef struct NvRmXpcInitArbSemaSystem_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmXpcInitArbSemaSystem_inout;
+
+typedef struct NvRmXpcInitArbSemaSystem_out_t
+{
+    NvError ret_;
+} NV_ALIGN(4) NvRmXpcInitArbSemaSystem_out;
+
+typedef struct NvRmXpcInitArbSemaSystem_params_t
+{
+    NvRmXpcInitArbSemaSystem_in in;
+    NvRmXpcInitArbSemaSystem_inout inout;
+    NvRmXpcInitArbSemaSystem_out out;
+} NvRmXpcInitArbSemaSystem_params;
+
+typedef struct NvRmPrivXpcGetMessage_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmPrivXpcMessageHandle hXpcMessage;
+} NV_ALIGN(4) NvRmPrivXpcGetMessage_in;
+
+typedef struct NvRmPrivXpcGetMessage_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmPrivXpcGetMessage_inout;
+
+typedef struct NvRmPrivXpcGetMessage_out_t
+{
+    NvU32 ret_;
+} NV_ALIGN(4) NvRmPrivXpcGetMessage_out;
+
+typedef struct NvRmPrivXpcGetMessage_params_t
+{
+    NvRmPrivXpcGetMessage_in in;
+    NvRmPrivXpcGetMessage_inout inout;
+    NvRmPrivXpcGetMessage_out out;
+} NvRmPrivXpcGetMessage_params;
+
+typedef struct NvRmPrivXpcSendMessage_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmPrivXpcMessageHandle hXpcMessage;
+    NvU32 data;
+} NV_ALIGN(4) NvRmPrivXpcSendMessage_in;
+
+typedef struct NvRmPrivXpcSendMessage_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmPrivXpcSendMessage_inout;
+
+typedef struct NvRmPrivXpcSendMessage_out_t
+{
+    NvError ret_;
+} NV_ALIGN(4) NvRmPrivXpcSendMessage_out;
+
+typedef struct NvRmPrivXpcSendMessage_params_t
+{
+    NvRmPrivXpcSendMessage_in in;
+    NvRmPrivXpcSendMessage_inout inout;
+    NvRmPrivXpcSendMessage_out out;
+} NvRmPrivXpcSendMessage_params;
+
+typedef struct NvRmPrivXpcDestroy_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmPrivXpcMessageHandle hXpcMessage;
+} NV_ALIGN(4) NvRmPrivXpcDestroy_in;
+
+typedef struct NvRmPrivXpcDestroy_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmPrivXpcDestroy_inout;
+
+typedef struct NvRmPrivXpcDestroy_out_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmPrivXpcDestroy_out;
+
+typedef struct NvRmPrivXpcDestroy_params_t
+{
+    NvRmPrivXpcDestroy_in in;
+    NvRmPrivXpcDestroy_inout inout;
+    NvRmPrivXpcDestroy_out out;
+} NvRmPrivXpcDestroy_params;
+
+typedef struct NvRmPrivXpcCreate_in_t
+{
+    NvU32 package_;
+    NvU32 function_;
+    NvRmDeviceHandle hDevice;
+} NV_ALIGN(4) NvRmPrivXpcCreate_in;
+
+typedef struct NvRmPrivXpcCreate_inout_t
+{
+    NvU32 dummy_;
+} NV_ALIGN(4) NvRmPrivXpcCreate_inout;
+
+typedef struct NvRmPrivXpcCreate_out_t
+{
+    NvError ret_;
+    NvRmPrivXpcMessageHandle phXpcMessage;
+} NV_ALIGN(4) NvRmPrivXpcCreate_out;
+
+typedef struct NvRmPrivXpcCreate_params_t
+{
+    NvRmPrivXpcCreate_in in;
+    NvRmPrivXpcCreate_inout inout;
+    NvRmPrivXpcCreate_out out;
+} NvRmPrivXpcCreate_params;
+
+static NvError NvRmXpcModuleRelease_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmXpcModuleRelease_in *p_in;
+
+    p_in = (NvRmXpcModuleRelease_in *)InBuffer;
+
+
+    NvRmXpcModuleRelease( p_in->modId );
+
+    return err_;
+}
+
+static NvError NvRmXpcModuleAcquire_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmXpcModuleAcquire_in *p_in;
+
+    p_in = (NvRmXpcModuleAcquire_in *)InBuffer;
+
+
+    NvRmXpcModuleAcquire( p_in->modId );
+
+    return err_;
+}
+
+static NvError NvRmXpcInitArbSemaSystem_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmXpcInitArbSemaSystem_in *p_in;
+    NvRmXpcInitArbSemaSystem_out *p_out;
+
+    p_in = (NvRmXpcInitArbSemaSystem_in *)InBuffer;
+    p_out = (NvRmXpcInitArbSemaSystem_out *)((NvU8 *)OutBuffer + OFFSET(NvRmXpcInitArbSemaSystem_params, out) - OFFSET(NvRmXpcInitArbSemaSystem_params, inout));
+
+
+    p_out->ret_ = NvRmXpcInitArbSemaSystem( p_in->hDevice );
+
+    return err_;
+}
+
+static NvError NvRmPrivXpcGetMessage_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmPrivXpcGetMessage_in *p_in;
+    NvRmPrivXpcGetMessage_out *p_out;
+
+    p_in = (NvRmPrivXpcGetMessage_in *)InBuffer;
+    p_out = (NvRmPrivXpcGetMessage_out *)((NvU8 *)OutBuffer + OFFSET(NvRmPrivXpcGetMessage_params, out) - OFFSET(NvRmPrivXpcGetMessage_params, inout));
+
+
+    p_out->ret_ = NvRmPrivXpcGetMessage( p_in->hXpcMessage );
+
+    return err_;
+}
+
+static NvError NvRmPrivXpcSendMessage_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmPrivXpcSendMessage_in *p_in;
+    NvRmPrivXpcSendMessage_out *p_out;
+
+    p_in = (NvRmPrivXpcSendMessage_in *)InBuffer;
+    p_out = (NvRmPrivXpcSendMessage_out *)((NvU8 *)OutBuffer + OFFSET(NvRmPrivXpcSendMessage_params, out) - OFFSET(NvRmPrivXpcSendMessage_params, inout));
+
+
+    p_out->ret_ = NvRmPrivXpcSendMessage( p_in->hXpcMessage, p_in->data );
+
+    return err_;
+}
+
+static NvError NvRmPrivXpcDestroy_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmPrivXpcDestroy_in *p_in;
+
+    p_in = (NvRmPrivXpcDestroy_in *)InBuffer;
+
+
+    NvRmPrivXpcDestroy( p_in->hXpcMessage );
+
+    return err_;
+}
+
+static NvError NvRmPrivXpcCreate_dispatch_( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+    NvRmPrivXpcCreate_in *p_in;
+    NvRmPrivXpcCreate_out *p_out;
+
+    p_in = (NvRmPrivXpcCreate_in *)InBuffer;
+    p_out = (NvRmPrivXpcCreate_out *)((NvU8 *)OutBuffer + OFFSET(NvRmPrivXpcCreate_params, out) - OFFSET(NvRmPrivXpcCreate_params, inout));
+
+
+    p_out->ret_ = NvRmPrivXpcCreate( p_in->hDevice, &p_out->phXpcMessage );
+
+    return err_;
+}
+
+NvError nvrm_xpc_Dispatch( NvU32 function, void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx );
+NvError nvrm_xpc_Dispatch( NvU32 function, void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
+{
+    NvError err_ = NvSuccess;
+
+    switch( function ) {
+    case 6:
+        err_ = NvRmXpcModuleRelease_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    case 5:
+        err_ = NvRmXpcModuleAcquire_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    case 4:
+        err_ = NvRmXpcInitArbSemaSystem_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    case 3:
+        err_ = NvRmPrivXpcGetMessage_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    case 2:
+        err_ = NvRmPrivXpcSendMessage_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    case 1:
+        err_ = NvRmPrivXpcDestroy_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    case 0:
+        err_ = NvRmPrivXpcCreate_dispatch_( InBuffer, InSize, OutBuffer, OutSize, Ctx );
+        break;
+    default:
+        err_ = NvError_BadParameter;
+        break;
+    }
+
+    return err_;
+}