Linux: Close spinlock device after gate is stopped
[ipc/ipcdev.git] / linux / src / daemon / GateHWSpinlock.c
1 /*
2  * Copyright (c) 2013-2014, Texas Instruments Incorporated
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * *  Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  *
12  * *  Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * *  Neither the name of Texas Instruments Incorporated nor the names of
17  *    its contributors may be used to endorse or promote products derived
18  *    from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
33 /*
34  *  ======== GateHWSpinlock.c ========
35  */
37 /* Standard headers */
38 #include <ti/ipc/Std.h>
40 /* Utilities & OSAL headers */
41 #include <ti/ipc/MultiProc.h>
42 #include <ti/ipc/GateMP.h>
44 #include <GateHWSpinlock.h>
46 #include <IGateProvider.h>
48 /*
49  * TODO: does this belong in ti/ipc/Std.h? We should consider getting rid of
50  *       error blocks from the GateMutex.h interface.
51  */
52 typedef UInt32            Error_Block;
53 #include <GateMutex.h>
55 /* Module level headers */
56 #include <_lad.h>
58 /* Linux headers */
59 #include <assert.h>
60 #include <fcntl.h>
61 #include <string.h>
62 #include <stdlib.h>
63 #include <sys/mman.h>
64 #include <sys/stat.h>
66 /* =============================================================================
67  * Structures & Enums
68  * =============================================================================
69  */
70 /* GateHWSpinlock Module Local State */
71 typedef struct {
72     Int32                           fd;         /* spinlock device handle */
73     UInt32 *                        baseAddr;   /* base addr lock registers */
74     GateMutex_Handle                gmHandle;   /* handle to gate mutex */
75 } GateHWSpinlock_Module_State;
77 /* GateHWSpinlock instance object */
78 struct GateHWSpinlock_Object {
79     IGateProvider_SuperObject; /* For inheritance from IGateProvider */
80     UInt                        lockNum;
81     UInt                        nested;
82     IGateProvider_Handle        localGate;
83     int                         token;  /* HWSpinlock token */
84 };
87 /* =============================================================================
88  * Globals
89  * =============================================================================
90  */
91 GateHWSpinlock_Config _GateHWSpinlock_cfgParams;
93 static GateHWSpinlock_Module_State GateHWSpinlock_state =
94 {
95     .fd = -1,
96     .baseAddr = NULL,
97     .gmHandle = NULL
98 };
100 static GateHWSpinlock_Module_State *Mod = &GateHWSpinlock_state;
102 static GateHWSpinlock_Params GateHWSpinlock_defInstParams =
104     .resourceId = 0,
105     .openFlag   = FALSE,
106     .regionId   = 0,
107     .sharedAddr = NULL
108 };
110 /* =============================================================================
111  * APIS
112  * =============================================================================
113  */
114 /*
115  *  Function to start the GateHWSpinlock module.
116  */
117 Int32 GateHWSpinlock_start(Void)
119     Int32               status = GateHWSpinlock_S_SUCCESS;
120     UInt32              dst;
122     Mod->fd = open ("/dev/mem", O_RDWR | O_SYNC);
123     if (Mod->fd < 0){
124         LOG0("GateHWSpinlock_start: failed to open the /dev/mem");
125         status = GateHWSpinlock_E_OSFAILURE;
126     }
128     /* map the hardware lock registers into the local address space */
129     if (status == GateHWSpinlock_S_SUCCESS) {
130         dst = (UInt32)mmap(NULL, _GateHWSpinlock_cfgParams.size,
131                             (PROT_READ | PROT_WRITE),
132                             (MAP_SHARED), Mod->fd,
133                             (off_t)_GateHWSpinlock_cfgParams.baseAddr);
135         if (dst == (UInt32)MAP_FAILED) {
136             LOG0("GateHWSpinlock_start: Memory map failed")
137             status = GateHWSpinlock_E_OSFAILURE;
138             close(Mod->fd);
139             Mod->fd = -1;
140         }
141         else {
142             Mod->baseAddr = (UInt32 *)(dst + _GateHWSpinlock_cfgParams.offset);
143             status = GateHWSpinlock_S_SUCCESS;
144         }
145     }
147     /* create GateMutex for local protection*/
148     if (status == GateHWSpinlock_S_SUCCESS) {
149         Mod->gmHandle = GateMutex_create(NULL, NULL);
151         if (Mod->gmHandle == NULL) {
152             LOG0("GateHWSpinlock_start: GateMutex create failed")
153             status = GateHWSpinlock_E_FAIL;
154             GateHWSpinlock_stop();
155         }
156     }
158     return (status);
161 /*
162  *  Function to stop the GateHWSpinlock module.
163  */
164 Int GateHWSpinlock_stop(Void)
166     Int32               status = GateHWSpinlock_S_SUCCESS;
168     /* delete GateMutex */
169     if (Mod->gmHandle != NULL) {
170         status = GateMutex_delete(&Mod->gmHandle);
171     }
173     /* release lock register mapping */
174     if (Mod->baseAddr != NULL) {
175         munmap((void *)_GateHWSpinlock_cfgParams.baseAddr,
176            _GateHWSpinlock_cfgParams.size);
177     }
179     /* close the spinlock device file */
180     if (Mod->fd >= 0) {
181         close(Mod->fd);
182         Mod->fd = -1;
183     }
185     return(status);
188 /*
189  *  Initialize parameter structure
190  */
191 Void GateHWSpinlock_Params_init(GateHWSpinlock_Params *params)
193     assert(params != NULL);
195     memcpy(params, &GateHWSpinlock_defInstParams,
196         sizeof(GateHWSpinlock_Params));
199 /*
200  * Create a GateHWSpinlock instance
201  */
202 /* TODO: change the function to accept a local gate. Do this on all platforms */
203 GateHWSpinlock_Handle GateHWSpinlock_create(GateHWSpinlock_LocalProtect
204     localProtect, const GateHWSpinlock_Params * params)
206     GateHWSpinlock_Object * obj = (GateHWSpinlock_Object *)calloc(1,
207         sizeof (GateHWSpinlock_Object));
209     if (!obj) {
210         LOG0("GateHWSpinlock_create: memory allocation failure")
211         return NULL;
212     }
214     IGateProvider_ObjectInitializer(obj, GateHWSpinlock);
215     /* TODO: handle more local protection types */
216     obj->localGate = (IGateProvider_Handle)Mod->gmHandle;
217     obj->lockNum = params->resourceId;
218     obj->nested = 0;
220     return (GateHWSpinlock_Handle)obj;
223 /*
224  * Delete a GateHWSpinlock instance
225  */
226 Int GateHWSpinlock_delete (GateHWSpinlock_Handle * handle)
228     GateHWSpinlock_Object * obj;
229     Int  status = GateHWSpinlock_S_SUCCESS;
231     if (handle == NULL) {
232         return GateHWSpinlock_E_INVALIDARG;
233     }
234     if (*handle == NULL) {
235         return GateHWSpinlock_E_INVALIDARG;
236     }
238     obj = (GateHWSpinlock_Object *)(*handle);
240     free(obj);
241     *handle = NULL;
243     return (status);
246 /*
247  *  Enter a GateHWSpinlock instance
248  */
249 IArg GateHWSpinlock_enter(GateHWSpinlock_Object *obj)
251     volatile UInt32 *baseAddr = Mod->baseAddr;
252     IArg key;
254     key = IGateProvider_enter(obj->localGate);
256     /* if gate already entered, just return with current key */
257     obj->nested++;
258     if (obj->nested > 1) {
259         return(key);
260     }
262     /* enter the spinlock */
263     while (1) {
264         /* read the spinlock, returns non-zero when we get it */
265         if (baseAddr[obj->lockNum] == 0) {
266             break;
267         }
268         obj->nested--;
269         IGateProvider_leave(obj->localGate, key);
270         key = IGateProvider_enter(obj->localGate);
271         obj->nested++; /* re-nest the gate */
272     }
274     return (key);
277 /*
278  *  Leave a GateHWSpinlock instance
279  */
280 Int GateHWSpinlock_leave(GateHWSpinlock_Object *obj, IArg key)
282     volatile UInt32 *baseAddr = Mod->baseAddr;
284     obj->nested--;
286     /* release the spinlock if not nested */
287     if (obj->nested == 0) {
288         baseAddr[obj->lockNum] = 0;
289     }
291     IGateProvider_leave(obj->localGate, key);
293     return GateHWSpinlock_S_SUCCESS;