QNX IPC: Vayu - Add DSP1 MMU1 Programming
[ipc/ipcdev.git] / qnx / src / ipc3x_dev / ti / syslink / family / common / vayu / vayudsp / VAYUDspPhyShmem.c
1 /*
2  *  @file   VAYUDspPhyShmem.c
3  *
4  *  @brief      Shared memory physical interface file for VAYUDSP.
5  *
6  *              This module is responsible for handling boot-related hardware-
7  *              specific operations.
8  *              The implementation is specific to VAYUDSP.
9  *
10  *
11  *  ============================================================================
12  *
13  *  Copyright (c) 2013, Texas Instruments Incorporated
14  *
15  *  Redistribution and use in source and binary forms, with or without
16  *  modification, are permitted provided that the following conditions
17  *  are met:
18  *
19  *  *  Redistributions of source code must retain the above copyright
20  *     notice, this list of conditions and the following disclaimer.
21  *
22  *  *  Redistributions in binary form must reproduce the above copyright
23  *     notice, this list of conditions and the following disclaimer in the
24  *     documentation and/or other materials provided with the distribution.
25  *
26  *  *  Neither the name of Texas Instruments Incorporated nor the names of
27  *     its contributors may be used to endorse or promote products derived
28  *     from this software without specific prior written permission.
29  *
30  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
31  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
32  *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
33  *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
34  *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
35  *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
36  *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
37  *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
38  *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
39  *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
40  *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
41  *  Contact information for paper mail:
42  *  Texas Instruments
43  *  Post Office Box 655303
44  *  Dallas, Texas 75265
45  *  Contact information:
46  *  http://www-k.ext.ti.com/sc/technical-support/product-information-centers.htm?
47  *  DCMP=TIHomeTracking&HQS=Other+OT+home_d_contact
48  *  ============================================================================
49  *
50  */
54 /* Standard headers */
55 #include <ti/syslink/Std.h>
57 /* OSAL and utils */
58 #include <ti/syslink/utils/Memory.h>
60 #include <ti/syslink/utils/Trace.h>
62 /* Module headers */
63 #include <_ProcDefs.h>
64 #include <Processor.h>
67 /* Hardware Abstraction Layer headers */
68 #include <VAYUDspHal.h>
69 #include <VAYUDspHalBoot.h>
70 #include <VAYUDspHalReset.h>
71 #include <VAYUDspPhyShmem.h>
72 #include <VAYUDspHalMmu.h>
75 #if defined (__cplusplus)
76 extern "C" {
77 #endif
80 /* =============================================================================
81  *  Macros and types
82  * =============================================================================
83  */
86 /* =============================================================================
87  * APIs called by VAYUDSPPROC module
88  * =============================================================================
89  */
90 /*!
91  *  @brief      Function to initialize Shared Driver/device.
92  *
93  *  @param      halObj  Pointer to the HAL object
94  *
95  *  @sa         VAYUDSP_phyShmemExit
96  *              Memory_map
97  */
98 Int
99 VAYUDSP_phyShmemInit (Ptr halObj)
101     Int                  status    = PROCESSOR_SUCCESS;
102     VAYUDSP_HalObject *  halObject = NULL;
103     Memory_MapInfo       mapInfo;
105     GT_1trace (curTrace, GT_ENTER, "VAYUDSP_phyShmemInit", halObj);
107     GT_assert (curTrace,(halObj != NULL));
109     halObject = (VAYUDSP_HalObject *) halObj;
111     mapInfo.src = DSP_BOOT_ADDR;
112     mapInfo.size = DSP_BOOT_ADDR_SIZE;
113     mapInfo.isCached = FALSE;
115     status = Memory_map (&mapInfo);
117     if (status < 0) {
118         GT_setFailureReason (curTrace,
119                              GT_4CLASS,
120                              "VAYUDSP_phyShmemInit",
121                              status,
122                              "Failure in Memory_map for MMU base registers");
123         halObject->generalCtrlBase = 0;
124     }
125     else {
126         halObject->generalCtrlBase = mapInfo.dst;
127     }
129     mapInfo.src      = DSP_BOOT_STAT;
130     mapInfo.size     = DSP_BOOT_STAT_SIZE;
131     mapInfo.isCached = FALSE;
132     status = Memory_map (&mapInfo);
133     if (status < 0) {
134         GT_setFailureReason (curTrace,
135                              GT_4CLASS,
136                              "VAYUDSP_phyShmemInit",
137                              status,
138                              "Failure in Memory_map for MMU base registers");
139         halObject->bootStatBase = 0;
140     }
141     else {
142         halObject->bootStatBase = mapInfo.dst;
143     }
145     mapInfo.src      = L2_RAM_CLK_ENABLE;
146     mapInfo.size     = L2_RAM_CLK_ENABLE_SIZE;
147     mapInfo.isCached = FALSE;
148     status = Memory_map (&mapInfo);
149     if (status < 0) {
150         GT_setFailureReason (curTrace,
151                              GT_4CLASS,
152                              "VAYUDSP_phyShmemInit",
153                              status,
154                              "Failure in Memory_map for MMU base registers");
155         halObject->l2ClkBase = 0;
156     }
157     else {
158         halObject->l2ClkBase = mapInfo.dst;
159     }
161     mapInfo.src      = CM_BASE_ADDR;
162     mapInfo.size     = CM_SIZE;
163     mapInfo.isCached = FALSE;
164     status = Memory_map (&mapInfo);
165     if (status < 0) {
166         GT_setFailureReason (curTrace,
167                              GT_4CLASS,
168                              "VAYUDSP_phyShmemInit",
169                              status,
170                              "Failure in Memory_map for MMU base registers");
171         halObject->cmBase = 0;
172     }
173     else {
174         halObject->cmBase = mapInfo.dst;
175     }
177     mapInfo.src      = PRM_BASE_ADDR;
178     mapInfo.size     = PRM_SIZE;
179     mapInfo.isCached = FALSE;
180     status = Memory_map (&mapInfo);
181     if (status < 0) {
182         GT_setFailureReason (curTrace,
183                              GT_4CLASS,
184                              "VAYUDSP_phyShmemInit",
185                              status,
186                              "Failure in Memory_map for MMU base registers");
187         halObject->prmBase = 0;
188     }
189     else {
190         halObject->prmBase = mapInfo.dst;
191     }
193     mapInfo.src      = MMU0_BASE;
194     mapInfo.size     = MMU0_SIZE;
195     mapInfo.isCached = FALSE;
196     status = Memory_map (&mapInfo);
197     if (status < 0) {
198         GT_setFailureReason (curTrace,
199                              GT_4CLASS,
200                              "VAYUDSP_phyShmemInit",
201                              status,
202                              "Failure in Memory_map for MMU0 base registers");
203         halObject->mmu0Base = 0;
204     }
205     else {
206         halObject->mmu0Base = mapInfo.dst;
207     }
209     mapInfo.src      = MMU1_BASE;
210     mapInfo.size     = MMU1_SIZE;
211     mapInfo.isCached = FALSE;
212     status = Memory_map (&mapInfo);
213     if (status < 0) {
214         GT_setFailureReason (curTrace,
215                              GT_4CLASS,
216                              "VAYUDSP_phyShmemInit",
217                              status,
218                              "Failure in Memory_map for MMU1 base registers");
219         halObject->mmu1Base = 0;
220     }
221     else {
222         halObject->mmu1Base = mapInfo.dst;
223     }
225     mapInfo.src      = DSP_SYS_MMU_CONFIG_BASE;
226     mapInfo.size     = DSP_SYS_MMU_CONFIG_SIZE;
227     mapInfo.isCached = FALSE;
228     status = Memory_map (&mapInfo);
229     if (status < 0) {
230         GT_setFailureReason (curTrace,
231                              GT_4CLASS,
232                              "VAYUDSP_phyShmemInit",
233                              status,
234                              "Failure in Memory_map for SYS MMU base registers");
235         halObject->mmuSysBase = 0;
236     }
237     else {
238         halObject->mmuSysBase = mapInfo.dst;
239     }
241     mapInfo.src      = CTRL_MODULE_BASE;
242     mapInfo.size     = CTRL_MODULE_SIZE;
243     mapInfo.isCached = FALSE;
244     status = Memory_map (&mapInfo);
245     if (status < 0) {
246         GT_setFailureReason (curTrace,
247                              GT_4CLASS,
248                              "VAYUDSP_phyShmemInit",
249                              status,
250                              "Failure in Memory_map for Ctrl Module base registers");
251         halObject->ctrlModBase = 0;
252     }
253     else {
254         halObject->ctrlModBase = mapInfo.dst;
255     }
257     GT_1trace(curTrace, GT_LEAVE, "<-- VAYUDSP_phyShmemInit: 0x%x", status);
259     /*! @retval PROCESSOR_SUCCESS Operation successful */
260     return status;
264 /*!
265  *  @brief      Function to finalize Shared Driver/device.
266  *
267  *  @param      halObj  Pointer to the HAL object
268  *
269  *  @sa         VAYUDSP_phyShmemInit
270  *              Memory_Unmap
271  */
272 Int
273 VAYUDSP_phyShmemExit (Ptr halObj)
275     Int                  status    = PROCESSOR_SUCCESS;
276     VAYUDSP_HalObject *  halObject = NULL;
277     Memory_UnmapInfo     unmapInfo;
279     GT_1trace (curTrace, GT_ENTER, "VAYUDSP_phyShmemExit", halObj);
281     GT_assert (curTrace, (halObj != NULL));
283     halObject = (VAYUDSP_HalObject *) halObj;
285     unmapInfo.addr = halObject->ctrlModBase;
286     unmapInfo.size = CTRL_MODULE_SIZE;
287     unmapInfo.isCached = FALSE;
288     if (unmapInfo.addr != 0) {
289         status = Memory_unmap (&unmapInfo);
290         if (status < 0) {
291             GT_setFailureReason (curTrace,
292                               GT_4CLASS,
293                               "VAYUDSP_phyShmemExit",
294                               status,
295                               "Failure in Memory_Unmap for Ctrl Module base registers");
296         }
297         halObject->ctrlModBase = 0 ;
298     }
300     unmapInfo.addr = halObject->mmu1Base;
301     unmapInfo.size = MMU1_SIZE;
302     unmapInfo.isCached = FALSE;
303     if (unmapInfo.addr != 0) {
304         status = Memory_unmap (&unmapInfo);
305         if (status < 0) {
306             GT_setFailureReason (curTrace,
307                               GT_4CLASS,
308                               "VAYUDSP_phyShmemExit",
309                               status,
310                               "Failure in Memory_Unmap for MMU base registers");
311         }
312         halObject->mmu1Base = 0 ;
313     }
315     unmapInfo.addr = halObject->mmu0Base;
316     unmapInfo.size = MMU0_SIZE;
317     unmapInfo.isCached = FALSE;
318     if (unmapInfo.addr != 0) {
319         status = Memory_unmap (&unmapInfo);
320         if (status < 0) {
321             GT_setFailureReason (curTrace,
322                               GT_4CLASS,
323                               "VAYUDSP_phyShmemExit",
324                               status,
325                               "Failure in Memory_Unmap for MMU base registers");
326         }
327         halObject->mmu0Base = 0 ;
328     }
330     unmapInfo.addr = halObject->mmuSysBase;
331     unmapInfo.size = DSP_SYS_MMU_CONFIG_SIZE;
332     unmapInfo.isCached = FALSE;
333     if (unmapInfo.addr != 0) {
334         status = Memory_unmap (&unmapInfo);
335         if (status < 0) {
336             GT_setFailureReason (curTrace,
337                               GT_4CLASS,
338                               "VAYUDSP_phyShmemExit",
339                               status,
340                               "Failure in Memory_Unmap for SYS MMU base registers");
341         }
342         halObject->mmuSysBase = 0 ;
343     }
345     unmapInfo.addr = halObject->cmBase;
346     unmapInfo.size = CM_SIZE;
347     unmapInfo.isCached = FALSE;
348     if (unmapInfo.addr != 0) {
349         status = Memory_unmap (&unmapInfo);
350         if (status < 0) {
351             GT_setFailureReason (curTrace,
352                               GT_4CLASS,
353                               "VAYUDSP_phyShmemExit",
354                               status,
355                               "Failure in Memory_Unmap for CM base registers");
356         }
357         halObject->cmBase = 0 ;
358     }
360     unmapInfo.addr = halObject->prmBase;
361     unmapInfo.size = PRM_SIZE;
362     unmapInfo.isCached = FALSE;
363     if (unmapInfo.addr != 0) {
364         status = Memory_unmap (&unmapInfo);
365         if (status < 0) {
366             GT_setFailureReason (curTrace,
367                               GT_4CLASS,
368                               "VAYUDSP_phyShmemExit",
369                               status,
370                               "Failure in Memory_Unmap for MMU base registers");
371         }
372         halObject->prmBase = 0 ;
373     }
375     unmapInfo.addr = halObject->l2ClkBase;
376     unmapInfo.size = L2_RAM_CLK_ENABLE_SIZE;
377     unmapInfo.isCached = FALSE;
378     if (unmapInfo.addr != 0) {
379         status = Memory_unmap (&unmapInfo);
380         if (status < 0) {
381             GT_setFailureReason (curTrace,
382                               GT_4CLASS,
383                               "VAYUDSP_phyShmemExit",
384                               status,
385                               "Failure in Memory_Unmap for MMU base registers");
386         }
387         halObject->l2ClkBase = 0 ;
388     }
390     unmapInfo.addr = halObject->bootStatBase;
391     unmapInfo.size = DSP_BOOT_STAT_SIZE;
392     unmapInfo.isCached = FALSE;
393     if (unmapInfo.addr != 0) {
394         status = Memory_unmap (&unmapInfo);
395         if (status < 0) {
396             GT_setFailureReason (curTrace,
397                               GT_4CLASS,
398                               "VAYUDSP_phyShmemExit",
399                               status,
400                               "Failure in Memory_Unmap for MMU base registers");
401         }
402         halObject->bootStatBase = 0 ;
403     }
405     unmapInfo.addr = halObject->generalCtrlBase;
406     unmapInfo.size = DSP_BOOT_ADDR_SIZE;
407     unmapInfo.isCached = FALSE;
408     if (unmapInfo.addr != 0) {
409         status = Memory_unmap (&unmapInfo);
410         if (status < 0) {
411             GT_setFailureReason (curTrace,
412                               GT_4CLASS,
413                               "VAYUDSP_phyShmemExit",
414                               status,
415                               "Failure in Memory_Unmap for MMU base registers");
416         }
417         halObject->generalCtrlBase = 0 ;
418     }
421     GT_1trace (curTrace, GT_LEAVE, "VAYUDSP_phyShmemExit",status);
423     /*! @retval PROCESSOR_SUCCESS Operation successful */
424     return status;
428 #if defined (__cplusplus)
431 #endif