drivers/misc/mediatek/trustzone/kree_mem.c

   1
   2 #include <trustzone/kree/mem.h>
   3 #include <trustzone/kree/system.h>
   4 #include <trustzone/tz_cross/ta_mem.h>
   5 #include <linux/mm.h>
   6
   7
   8 #define DBG_KREE_MEM
   9
  10 // notiec: handle type is the same
  11 static inline TZ_RESULT _allocFunc (uint32_t cmd, KREE_SESSION_HANDLE session,
  12     uint32_t *mem_handle, uint32_t alignment, uint32_t size, char *dbg)
  13 {
  14     MTEEC_PARAM p[4];
  15     TZ_RESULT ret;
  16
  17     if ((session == 0) || (mem_handle == NULL) || (size == 0))
  18     {
  19         return TZ_RESULT_ERROR_BAD_PARAMETERS;
  20     }
  21
  22     p[0].value.a = alignment;
  23     p[1].value.a = size;
  24     ret = KREE_TeeServiceCall(session, cmd,
  25             TZ_ParamTypes3( TZPT_VALUE_INPUT, TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT), p);
  26     if (ret != TZ_RESULT_SUCCESS)
  27     {
  28 #ifdef DBG_KREE_MEM
  29         printk("[kree] %s Error: %d\n", dbg, ret);
  30 #endif
  31         return ret;
  32     }
  33
  34     *mem_handle = (KREE_SECUREMEM_HANDLE) p[2].value.a;
  35
  36     return TZ_RESULT_SUCCESS;
  37 }
  38
  39 static inline TZ_RESULT _handleOpFunc (uint32_t cmd, KREE_SESSION_HANDLE session, uint32_t mem_handle, char *dbg)
  40 {
  41     MTEEC_PARAM p[4];
  42     TZ_RESULT ret;
  43
  44     if ((session == 0) || (mem_handle == 0))
  45     {
  46         return TZ_RESULT_ERROR_BAD_PARAMETERS;
  47     }
  48
  49     p[0].value.a = (uint32_t) mem_handle;
  50     ret = KREE_TeeServiceCall(session, cmd,
  51             TZ_ParamTypes1( TZPT_VALUE_INPUT), p);
  52     if (ret < 0)
  53     {
  54 #ifdef DBG_KREE_MEM
  55         printk("[kree] %s Error: %d\n", dbg, ret);
  56 #endif
  57         return ret;
  58     }
  59
  60     return TZ_RESULT_SUCCESS;
  61 }
  62
  63 static inline TZ_RESULT _handleOpFunc_1 (uint32_t cmd, KREE_SESSION_HANDLE session, uint32_t mem_handle, uint32_t *count, char *dbg)
  64 {
  65     MTEEC_PARAM p[4];
  66     TZ_RESULT ret;
  67
  68     if ((session == 0) || (mem_handle == 0) || (count == NULL))
  69     {
  70         return TZ_RESULT_ERROR_BAD_PARAMETERS;
  71     }
  72
  73     p[0].value.a = (uint32_t) mem_handle;
  74     ret = KREE_TeeServiceCall(session, cmd,
  75             TZ_ParamTypes2( TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT), p);
  76     if (ret < 0)
  77     {
  78 #ifdef DBG_KREE_MEM
  79         printk("[kree] %s Error: %d\n", dbg, ret);
  80 #endif
  81         *count = 0;
  82         return ret;
  83     }
  84
  85     *count = p[1].value.a;
  86
  87     return TZ_RESULT_SUCCESS;
  88 }
  89
  90
  91 TZ_RESULT kree_register_sharedmem (KREE_SESSION_HANDLE session, KREE_SHAREDMEM_HANDLE *mem_handle,
  92     uint32_t start, uint32_t size, uint32_t map_p)
  93 {
  94     MTEEC_PARAM p[4];
  95     TZ_RESULT ret;
  96
  97     p[0].value.a = start;
  98     p[1].value.a = size;
  99     p[2].value.a = map_p;
 100     ret = KREE_TeeServiceCall(session, TZCMD_MEM_SHAREDMEM_REG,
 101             TZ_ParamTypes4(TZPT_VALUE_INPUT, TZPT_VALUE_INPUT, TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT), p);
 102     if (ret != TZ_RESULT_SUCCESS)
 103     {
 104         *mem_handle = 0;
 105         return ret;
 106     }
 107
 108     *mem_handle = p[3].value.a;
 109
 110     return TZ_RESULT_SUCCESS;
 111 }
 112
 113 TZ_RESULT kree_unregister_sharedmem (KREE_SESSION_HANDLE session, KREE_SHAREDMEM_HANDLE mem_handle)
 114 {
 115     MTEEC_PARAM p[4];
 116     TZ_RESULT ret;
 117
 118     p[0].value.a = (uint32_t) mem_handle;
 119     ret = KREE_TeeServiceCall(session, TZCMD_MEM_SHAREDMEM_UNREG,
 120             TZ_ParamTypes1(TZPT_VALUE_INPUT), p);
 121     if (ret != TZ_RESULT_SUCCESS)
 122     {
 123         return ret;
 124     }
 125
 126     return TZ_RESULT_SUCCESS;
 127 }
 128
 129 /* APIs
 130 */
 131 TZ_RESULT KREE_RegisterSharedmem (KREE_SESSION_HANDLE session,
 132     KREE_SHAREDMEM_HANDLE *shm_handle, KREE_SHAREDMEM_PARAM *param)
 133 {
 134     TZ_RESULT ret;
 135
 136     if ((session == 0) || (shm_handle == NULL) || (param->buffer == NULL) || (param->size == 0))
 137     {
 138         return TZ_RESULT_ERROR_BAD_PARAMETERS;
 139     }
 140
 141     // only for kmalloc
 142     if (((uint32_t) param->buffer >= PAGE_OFFSET) &&
 143      ((uint32_t) param->buffer < (uint32_t) high_memory))
 144     {
 145         ret = kree_register_sharedmem (session, shm_handle, (uint32_t) param->buffer, (uint32_t) param->size, 0); // set 0 for no remap...
 146         if (ret != TZ_RESULT_SUCCESS)
 147         {
 148 #ifdef DBG_KREE_MEM
 149             printk("[kree] KREE_RegisterSharedmem Error: %d\n", ret);
 150 #endif
 151             return ret;
 152         }
 153     }
 154     else
 155     {
 156         printk("[kree] KREE_RegisterSharedmem Error: support kmalloc only!!!\n");
 157         return TZ_RESULT_ERROR_NOT_IMPLEMENTED;
 158     }
 159
 160     return TZ_RESULT_SUCCESS;
 161 }
 162
 163 TZ_RESULT KREE_UnregisterSharedmem (KREE_SESSION_HANDLE session, KREE_SHAREDMEM_HANDLE shm_handle)
 164 {
 165     TZ_RESULT ret;
 166
 167     if ((session == 0) || (shm_handle == 0))
 168     {
 169         return TZ_RESULT_ERROR_BAD_PARAMETERS;
 170     }
 171
 172     ret = kree_unregister_sharedmem (session, shm_handle);
 173     if (ret < 0)
 174     {
 175 #ifdef DBG_KREE_MEM
 176         printk("[kree] KREE_UnregisterSharedmem Error: %d\n", ret);
 177 #endif
 178         return ret;
 179     }
 180
 181     return TZ_RESULT_SUCCESS;
 182 }
 183
 184 TZ_RESULT KREE_AllocSecuremem (KREE_SESSION_HANDLE session,
 185     KREE_SECUREMEM_HANDLE *mem_handle, uint32_t alignment, uint32_t size)
 186 {
 187     TZ_RESULT ret;
 188
 189     ret = _allocFunc (TZCMD_MEM_SECUREMEM_ALLOC, session, mem_handle, alignment, size, "KREE_AllocSecuremem");
 190
 191     return ret;
 192 }
 193
 194 TZ_RESULT KREE_ReferenceSecuremem (KREE_SESSION_HANDLE session, KREE_SECUREMEM_HANDLE mem_handle)
 195 {
 196     TZ_RESULT ret;
 197
 198     ret = _handleOpFunc (TZCMD_MEM_SECUREMEM_REF, session, mem_handle, "KREE_ReferenceSecuremem");
 199
 200     return ret;
 201 }
 202
 203 TZ_RESULT KREE_UnreferenceSecuremem (KREE_SESSION_HANDLE session, KREE_SECUREMEM_HANDLE mem_handle)
 204 {
 205     TZ_RESULT ret;
 206     uint32_t count = 0;
 207
 208     ret = _handleOpFunc_1 (TZCMD_MEM_SECUREMEM_UNREF, session, mem_handle, &count, "KREE_UnreferenceSecuremem");
 209 #ifdef DBG_KREE_MEM
 210     printk ("KREE_UnreferenceSecuremem: count = 0x%x\n", count);
 211 #endif
 212
 213     return ret;
 214 }
 215
 216 TZ_RESULT KREE_AllocSecurechunkmem (KREE_SESSION_HANDLE session,
 217     KREE_SECUREMEM_HANDLE *cm_handle, uint32_t alignment, uint32_t size)
 218 {
 219     TZ_RESULT ret;
 220
 221     ret = _allocFunc (TZCMD_MEM_SECURECM_ALLOC, session, cm_handle, alignment, size, "KREE_AllocSecurechunkmem");
 222
 223     return ret;
 224 }
 225
 226 TZ_RESULT KREE_ReferenceSecurechunkmem (KREE_SESSION_HANDLE session, KREE_SECURECM_HANDLE cm_handle)
 227 {
 228     TZ_RESULT ret;
 229
 230     ret = _handleOpFunc (TZCMD_MEM_SECURECM_REF, session, cm_handle, "KREE_ReferenceSecurechunkmem");
 231
 232     return ret;
 233 }
 234
 235 TZ_RESULT KREE_UnreferenceSecurechunkmem (KREE_SESSION_HANDLE session, KREE_SECURECM_HANDLE cm_handle)
 236 {
 237     TZ_RESULT ret;
 238     uint32_t count = 0;
 239
 240     ret = _handleOpFunc_1 (TZCMD_MEM_SECURECM_UNREF, session, cm_handle, &count, "KREE_UnreferenceSecurechunkmem");
 241 #ifdef DBG_KREE_MEM
 242         printk ("KREE_UnreferenceSecurechunkmem: count = 0x%x\n", count);
 243 #endif
 244
 245     return ret;
 246 }
 247
 248 TZ_RESULT KREE_ReadSecurechunkmem (KREE_SESSION_HANDLE session, uint32_t offset, uint32_t size, void *buffer)
 249 {
 250     MTEEC_PARAM p[4];
 251     TZ_RESULT ret;
 252
 253     if ((session == 0) || (size == 0))
 254     {
 255         return TZ_RESULT_ERROR_BAD_PARAMETERS;
 256     }
 257
 258     p[0].value.a = offset;
 259     p[1].value.a = size;
 260     p[2].mem.buffer = buffer;
 261     p[2].mem.size = size; // fix me!!!!
 262     ret = KREE_TeeServiceCall(session, TZCMD_MEM_SECURECM_READ,
 263             TZ_ParamTypes3(TZPT_VALUE_INPUT, TZPT_VALUE_INPUT, TZPT_MEM_OUTPUT), p);
 264     if (ret != TZ_RESULT_SUCCESS)
 265     {
 266 #ifdef DBG_KREE_MEM
 267         printk("[kree] KREE_ReadSecurechunkmem Error: %d\n", ret);
 268 #endif
 269         return ret;
 270     }
 271
 272     return TZ_RESULT_SUCCESS;
 273 }
 274
 275 TZ_RESULT KREE_WriteSecurechunkmem (KREE_SESSION_HANDLE session, uint32_t offset, uint32_t size, void *buffer)
 276 {
 277     MTEEC_PARAM p[4];
 278     TZ_RESULT ret;
 279
 280     if ((session == 0) || (size == 0))
 281     {
 282         return TZ_RESULT_ERROR_BAD_PARAMETERS;
 283     }
 284
 285     p[0].value.a = offset;
 286     p[1].value.a = size;
 287     p[2].mem.buffer = buffer;
 288     p[2].mem.size = size; // fix me!!!!
 289     ret = KREE_TeeServiceCall(session, TZCMD_MEM_SECURECM_WRITE,
 290             TZ_ParamTypes3(TZPT_VALUE_INPUT, TZPT_VALUE_INPUT, TZPT_MEM_INPUT), p);
 291     if (ret != TZ_RESULT_SUCCESS)
 292     {
 293 #ifdef DBG_KREE_MEM
 294         printk("[kree] KREE_WriteSecurechunkmem Error: %d\n", ret);
 295 #endif
 296         return ret;
 297     }
 298
 299     return TZ_RESULT_SUCCESS;
 300 }
 301
 302
 303 TZ_RESULT KREE_GetSecurechunkReleaseSize (KREE_SESSION_HANDLE session, uint32_t *size)
 304 {
 305     MTEEC_PARAM p[4];
 306     TZ_RESULT ret;
 307
 308     ret = KREE_TeeServiceCall(session, TZCMD_MEM_SECURECM_RSIZE, TZ_ParamTypes1(TZPT_VALUE_OUTPUT), p);
 309     if (ret != TZ_RESULT_SUCCESS)
 310     {
 311 #ifdef DBG_KREE_MEM
 312         printk("[kree] KREE_GetSecurechunkReleaseSize Error: %d\n", ret);
 313 #endif
 314         return ret;
 315     }
 316
 317     *size = p[0].value.a;
 318
 319     return TZ_RESULT_SUCCESS;
 320 }
 321
 322 TZ_RESULT KREE_GetTEETotalSize (KREE_SESSION_HANDLE session, uint32_t *size)
 323 {
 324     MTEEC_PARAM p[4];
 325     TZ_RESULT ret;
 326
 327     ret = KREE_TeeServiceCall(session, TZCMD_MEM_TOTAL_SIZE, TZ_ParamTypes1(TZPT_VALUE_OUTPUT), p);
 328     if (ret != TZ_RESULT_SUCCESS)
 329     {
 330 #ifdef DBG_KREE_MEM
 331         printk("[kree] KREE_GetTEETotalSize Error: %d\n", ret);
 332 #endif
 333         return ret;
 334     }
 335
 336     *size = p[0].value.a;
 337
 338     return TZ_RESULT_SUCCESS;
 339 }
 340