1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
/*
* Copyright (C) 2010-2011 ARM Limited. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @file ump_frontend.c
*
* This file implements the user space API of the UMP API.
* It relies heavily on a arch backend to do the communication with the UMP device driver.
*/
#include <ump/ump.h>
#include "ump_internal.h"
#include "ump_arch.h"
#include <ump/ump_debug.h>
#include <ump/ump_osu.h>
UMP_API_EXPORT ump_result ump_open(void)
{
return ump_arch_open();
}
UMP_API_EXPORT void ump_close(void)
{
ump_arch_close();
}
UMP_API_EXPORT ump_secure_id ump_secure_id_get(ump_handle memh)
{
ump_mem * mem = (ump_mem*)memh;
UMP_DEBUG_ASSERT(UMP_INVALID_MEMORY_HANDLE != memh, ("Handle is invalid"));
UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != mem->secure_id, ("Secure ID is inavlid"));
UMP_DEBUG_ASSERT(0 < mem->ref_count, ("Reference count too low"));
UMP_DEBUG_ASSERT(0 < mem->size, ("Memory size of passed handle too low"));
return mem->secure_id;
}
UMP_API_EXPORT ump_handle ump_handle_create_from_secure_id(ump_secure_id secure_id)
{
unsigned long size;
UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != secure_id, ("Secure ID is invalid"));
size = ump_arch_size_get(secure_id);
if (0 != size)
{
unsigned long cookie;
/*
* The UMP memory which the secure_id referes to could now be deleted and re-created
* since we don't have any references to it yet. The mapping below will however fail if
* we have supplied incorrect size, so we are safe.
*/
void * mapping = ump_arch_map(secure_id, size, UMP_CACHE_DISABLE, &cookie);
if (NULL != mapping)
{
ump_mem * mem = _ump_osu_calloc(1, sizeof(*mem));
if (NULL != mem)
{
mem->secure_id = secure_id;
mem->mapped_mem = mapping;
mem->size = size;
mem->cookie = cookie;
mem->is_cached = 1; /* Is set to actually check in the ump_cpu_msync_now() function */
_ump_osu_lock_auto_init(&mem->ref_lock, 0, 0, 0);
UMP_DEBUG_ASSERT(NULL != mem->ref_lock, ("Failed to initialize lock\n"));
mem->ref_count = 1;
/* This is called only to set the cache settings in this handle */
ump_cpu_msync_now((ump_handle)mem, UMP_MSYNC_READOUT_CACHE_ENABLED, NULL, 0);
UMP_DEBUG_PRINT(4, ("UMP handle created for ID %u of size %lu, mapped into address 0x%08lx", mem->secure_id, mem->size, (unsigned long)mem->mapped_mem));
return (ump_handle)mem;
}
ump_arch_unmap(mapping, size, cookie);
}
}
UMP_DEBUG_PRINT(2, ("UMP handle creation failed for ID %u", secure_id));
return UMP_INVALID_MEMORY_HANDLE;
}
UMP_API_EXPORT unsigned long ump_size_get(ump_handle memh)
{
ump_mem * mem = (ump_mem*)memh;
UMP_DEBUG_ASSERT(UMP_INVALID_MEMORY_HANDLE != memh, ("Handle is invalid"));
UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != mem->secure_id, ("Secure ID is inavlid"));
UMP_DEBUG_ASSERT(0 < mem->ref_count, ("Reference count too low"));
UMP_DEBUG_ASSERT(0 < mem->size, ("Memory size of passed handle too low"));
return mem->size;
}
UMP_API_EXPORT void ump_read(void *dst, ump_handle srch, unsigned long offset, unsigned long length)
{
ump_mem * src = (ump_mem*)srch;
UMP_DEBUG_ASSERT(UMP_INVALID_MEMORY_HANDLE != srch, ("Handle is invalid"));
UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != src->secure_id, ("Secure ID is inavlid"));
UMP_DEBUG_ASSERT(0 < src->ref_count, ("Reference count too low"));
UMP_DEBUG_ASSERT(0 < src->size, ("Memory size of passed handle too low"));
UMP_DEBUG_ASSERT(NULL != src->mapped_mem, ("UMP Memory is not mapped"));
UMP_DEBUG_ASSERT((src->size) >= (offset + length), ("Requested read beyond end of UMP memory"));
_ump_osu_memcpy(dst,(char*)(src->mapped_mem) + offset, length);
}
UMP_API_EXPORT void ump_write(ump_handle dsth, unsigned long offset, const void *src, unsigned long length)
{
ump_mem * dst = (ump_mem*)dsth;
UMP_DEBUG_ASSERT(UMP_INVALID_MEMORY_HANDLE != dsth, ("Handle is invalid"));
UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != dst->secure_id, ("Secure ID is inavlid"));
UMP_DEBUG_ASSERT(0 < dst->ref_count, ("Reference count too low"));
UMP_DEBUG_ASSERT(0 < dst->size, ("Memory size of passed handle too low"));
UMP_DEBUG_ASSERT(NULL != dst->mapped_mem, ("UMP Memory is not mapped"));
UMP_DEBUG_ASSERT((dst->size) >= (offset + length), ("Requested write beyond end of UMP memory"));
_ump_osu_memcpy((char*)(dst->mapped_mem) + offset, src, length);
}
UMP_API_EXPORT void* ump_mapped_pointer_get(ump_handle memh)
{
ump_mem * mem = (ump_mem*)memh;
UMP_DEBUG_ASSERT(UMP_INVALID_MEMORY_HANDLE != memh, ("Handle is invalid"));
UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != mem->secure_id, ("Secure ID is inavlid"));
UMP_DEBUG_ASSERT(0 < mem->ref_count, ("Reference count too low"));
UMP_DEBUG_ASSERT(0 < mem->size, ("Memory size of passed handle too low"));
UMP_DEBUG_ASSERT(NULL != mem->mapped_mem, ("Error in mapping pointer (not mapped)"));
return mem->mapped_mem;
}
UMP_API_EXPORT void ump_mapped_pointer_release(ump_handle memh)
{
UMP_DEBUG_ASSERT(UMP_INVALID_MEMORY_HANDLE != memh, ("Handle is invalid"));
UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != ((ump_mem*)memh)->secure_id, ("Secure ID is inavlid"));
UMP_DEBUG_ASSERT(0 < ((ump_mem*)memh)->ref_count, ("Reference count too low"));
UMP_DEBUG_ASSERT(0 < ((ump_mem*)memh)->size, ("Memory size of passed handle too low"));
UMP_DEBUG_ASSERT(NULL != ((ump_mem*)memh)->mapped_mem, ("Error in mapping pointer (not mapped)"));
/* noop, cos we map in the pointer when handle is created, and unmap it when handle is destroyed */
}
UMP_API_EXPORT void ump_reference_add(ump_handle memh)
{
ump_mem * mem = (ump_mem*)memh;
UMP_DEBUG_ASSERT(UMP_INVALID_MEMORY_HANDLE != memh, ("Handle is invalid"));
UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != mem->secure_id, ("Secure ID is inavlid"));
UMP_DEBUG_ASSERT(0 < mem->ref_count, ("Reference count too low"));
UMP_DEBUG_ASSERT(0 < mem->size, ("Memory size of passed handle too low"));
_ump_osu_lock_wait(mem->ref_lock, _UMP_OSU_LOCKMODE_RW);
mem->ref_count += 1;
_ump_osu_lock_signal(mem->ref_lock, _UMP_OSU_LOCKMODE_RW);
}
UMP_API_EXPORT void ump_reference_release(ump_handle memh)
{
ump_mem * mem = (ump_mem*)memh;
UMP_DEBUG_ASSERT(UMP_INVALID_MEMORY_HANDLE != memh, ("Handle is invalid"));
UMP_DEBUG_ASSERT(UMP_INVALID_SECURE_ID != ((ump_mem*)mem)->secure_id, ("Secure ID is inavlid"));
UMP_DEBUG_ASSERT(0 < (((ump_mem*)mem)->ref_count), ("Reference count too low"));
UMP_DEBUG_ASSERT(0 < ((ump_mem*)mem)->size, ("Memory size of passed handle too low"));
UMP_DEBUG_ASSERT(NULL != ((ump_mem*)mem)->mapped_mem, ("Error in mapping pointer (not mapped)"));
_ump_osu_lock_wait(mem->ref_lock, _UMP_OSU_LOCKMODE_RW);
mem->ref_count -= 1;
if (0 == mem->ref_count)
{
/* Remove memory mapping, which holds our only reference towards the UMP kernel space driver */
ump_arch_unmap(mem->mapped_mem, mem->size, mem->cookie);
_ump_osu_lock_signal(mem->ref_lock, _UMP_OSU_LOCKMODE_RW);
/* Free the lock protecting the reference count */
_ump_osu_lock_term(mem->ref_lock);
/* Free the memory for this handle */
_ump_osu_free(mem);
} else {
_ump_osu_lock_signal(mem->ref_lock, _UMP_OSU_LOCKMODE_RW);
}
}
|
