core.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2018 Linaro Limited
  4. */
  5. #include <common.h>
  6. #include <dm.h>
  7. #include <log.h>
  8. #include <malloc.h>
  9. #include <tee.h>
  10. #include <linux/arm-smccc.h>
  11. #include <linux/err.h>
  12. #include <linux/io.h>
  13. #include "optee_smc.h"
  14. #include "optee_msg.h"
  15. #include "optee_private.h"
  16. #define PAGELIST_ENTRIES_PER_PAGE \
  17. ((OPTEE_MSG_NONCONTIG_PAGE_SIZE / sizeof(u64)) - 1)
  18. typedef void (optee_invoke_fn)(unsigned long, unsigned long, unsigned long,
  19. unsigned long, unsigned long, unsigned long,
  20. unsigned long, unsigned long,
  21. struct arm_smccc_res *);
  22. struct optee_pdata {
  23. optee_invoke_fn *invoke_fn;
  24. };
  25. struct rpc_param {
  26. u32 a0;
  27. u32 a1;
  28. u32 a2;
  29. u32 a3;
  30. u32 a4;
  31. u32 a5;
  32. u32 a6;
  33. u32 a7;
  34. };
  35. /**
  36. * reg_pair_to_ptr() - Make a pointer of 2 32-bit values
  37. * @reg0: High bits of the pointer
  38. * @reg1: Low bits of the pointer
  39. *
  40. * Returns the combined result, note that if a pointer is 32-bit wide @reg0
  41. * will be discarded.
  42. */
  43. static void *reg_pair_to_ptr(u32 reg0, u32 reg1)
  44. {
  45. return (void *)(ulong)(((u64)reg0 << 32) | reg1);
  46. }
  47. /**
  48. * reg_pair_from_64() - Split a 64-bit value into two 32-bit values
  49. * @reg0: High bits of @val
  50. * @reg1: Low bits of @val
  51. * @val: The value to split
  52. */
  53. static void reg_pair_from_64(u32 *reg0, u32 *reg1, u64 val)
  54. {
  55. *reg0 = val >> 32;
  56. *reg1 = val;
  57. }
  58. /**
  59. * optee_alloc_and_init_page_list() - Provide page list of memory buffer
  60. * @buf: Start of buffer
  61. * @len: Length of buffer
  62. * @phys_buf_ptr Physical pointer with coded offset to page list
  63. *
  64. * Secure world doesn't share mapping with Normal world (U-Boot in this case)
  65. * so physical pointers are needed when sharing pointers.
  66. *
  67. * Returns a pointer page list on success or NULL on failure
  68. */
  69. void *optee_alloc_and_init_page_list(void *buf, ulong len, u64 *phys_buf_ptr)
  70. {
  71. const unsigned int page_size = OPTEE_MSG_NONCONTIG_PAGE_SIZE;
  72. const phys_addr_t page_mask = page_size - 1;
  73. u8 *buf_base;
  74. unsigned int page_offset;
  75. unsigned int num_pages;
  76. unsigned int list_size;
  77. unsigned int n;
  78. void *page_list;
  79. struct {
  80. u64 pages_list[PAGELIST_ENTRIES_PER_PAGE];
  81. u64 next_page_data;
  82. } *pages_data;
  83. /*
  84. * A Memory buffer is described in chunks of 4k. The list of
  85. * physical addresses has to be represented by a physical pointer
  86. * too and a single list has to start at a 4k page and fit into
  87. * that page. In order to be able to describe large memory buffers
  88. * these 4k pages carrying physical addresses are linked together
  89. * in a list. See OPTEE_MSG_ATTR_NONCONTIG in
  90. * drivers/tee/optee/optee_msg.h for more information.
  91. */
  92. page_offset = (ulong)buf & page_mask;
  93. num_pages = roundup(page_offset + len, page_size) / page_size;
  94. list_size = DIV_ROUND_UP(num_pages, PAGELIST_ENTRIES_PER_PAGE) *
  95. page_size;
  96. page_list = memalign(page_size, list_size);
  97. if (!page_list)
  98. return NULL;
  99. pages_data = page_list;
  100. buf_base = (u8 *)rounddown((ulong)buf, page_size);
  101. n = 0;
  102. while (num_pages) {
  103. pages_data->pages_list[n] = virt_to_phys(buf_base);
  104. n++;
  105. buf_base += page_size;
  106. num_pages--;
  107. if (n == PAGELIST_ENTRIES_PER_PAGE) {
  108. pages_data->next_page_data =
  109. virt_to_phys(pages_data + 1);
  110. pages_data++;
  111. n = 0;
  112. }
  113. }
  114. *phys_buf_ptr = virt_to_phys(page_list) | page_offset;
  115. return page_list;
  116. }
  117. static void optee_get_version(struct udevice *dev,
  118. struct tee_version_data *vers)
  119. {
  120. struct tee_version_data v = {
  121. .gen_caps = TEE_GEN_CAP_GP | TEE_GEN_CAP_REG_MEM,
  122. };
  123. *vers = v;
  124. }
  125. static int get_msg_arg(struct udevice *dev, uint num_params,
  126. struct tee_shm **shmp, struct optee_msg_arg **msg_arg)
  127. {
  128. int rc;
  129. struct optee_msg_arg *ma;
  130. rc = __tee_shm_add(dev, OPTEE_MSG_NONCONTIG_PAGE_SIZE, NULL,
  131. OPTEE_MSG_GET_ARG_SIZE(num_params), TEE_SHM_ALLOC,
  132. shmp);
  133. if (rc)
  134. return rc;
  135. ma = (*shmp)->addr;
  136. memset(ma, 0, OPTEE_MSG_GET_ARG_SIZE(num_params));
  137. ma->num_params = num_params;
  138. *msg_arg = ma;
  139. return 0;
  140. }
  141. static int to_msg_param(struct optee_msg_param *msg_params, uint num_params,
  142. const struct tee_param *params)
  143. {
  144. uint n;
  145. for (n = 0; n < num_params; n++) {
  146. const struct tee_param *p = params + n;
  147. struct optee_msg_param *mp = msg_params + n;
  148. switch (p->attr) {
  149. case TEE_PARAM_ATTR_TYPE_NONE:
  150. mp->attr = OPTEE_MSG_ATTR_TYPE_NONE;
  151. memset(&mp->u, 0, sizeof(mp->u));
  152. break;
  153. case TEE_PARAM_ATTR_TYPE_VALUE_INPUT:
  154. case TEE_PARAM_ATTR_TYPE_VALUE_OUTPUT:
  155. case TEE_PARAM_ATTR_TYPE_VALUE_INOUT:
  156. mp->attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT + p->attr -
  157. TEE_PARAM_ATTR_TYPE_VALUE_INPUT;
  158. mp->u.value.a = p->u.value.a;
  159. mp->u.value.b = p->u.value.b;
  160. mp->u.value.c = p->u.value.c;
  161. break;
  162. case TEE_PARAM_ATTR_TYPE_MEMREF_INPUT:
  163. case TEE_PARAM_ATTR_TYPE_MEMREF_OUTPUT:
  164. case TEE_PARAM_ATTR_TYPE_MEMREF_INOUT:
  165. mp->attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT + p->attr -
  166. TEE_PARAM_ATTR_TYPE_MEMREF_INPUT;
  167. mp->u.rmem.shm_ref = (ulong)p->u.memref.shm;
  168. mp->u.rmem.size = p->u.memref.size;
  169. mp->u.rmem.offs = p->u.memref.shm_offs;
  170. break;
  171. default:
  172. return -EINVAL;
  173. }
  174. }
  175. return 0;
  176. }
  177. static int from_msg_param(struct tee_param *params, uint num_params,
  178. const struct optee_msg_param *msg_params)
  179. {
  180. uint n;
  181. struct tee_shm *shm;
  182. for (n = 0; n < num_params; n++) {
  183. struct tee_param *p = params + n;
  184. const struct optee_msg_param *mp = msg_params + n;
  185. u32 attr = mp->attr & OPTEE_MSG_ATTR_TYPE_MASK;
  186. switch (attr) {
  187. case OPTEE_MSG_ATTR_TYPE_NONE:
  188. p->attr = TEE_PARAM_ATTR_TYPE_NONE;
  189. memset(&p->u, 0, sizeof(p->u));
  190. break;
  191. case OPTEE_MSG_ATTR_TYPE_VALUE_INPUT:
  192. case OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT:
  193. case OPTEE_MSG_ATTR_TYPE_VALUE_INOUT:
  194. p->attr = TEE_PARAM_ATTR_TYPE_VALUE_INPUT + attr -
  195. OPTEE_MSG_ATTR_TYPE_VALUE_INPUT;
  196. p->u.value.a = mp->u.value.a;
  197. p->u.value.b = mp->u.value.b;
  198. p->u.value.c = mp->u.value.c;
  199. break;
  200. case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT:
  201. case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:
  202. case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:
  203. p->attr = TEE_PARAM_ATTR_TYPE_MEMREF_INPUT + attr -
  204. OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
  205. p->u.memref.size = mp->u.rmem.size;
  206. shm = (struct tee_shm *)(ulong)mp->u.rmem.shm_ref;
  207. if (!shm) {
  208. p->u.memref.shm_offs = 0;
  209. p->u.memref.shm = NULL;
  210. break;
  211. }
  212. p->u.memref.shm_offs = mp->u.rmem.offs;
  213. p->u.memref.shm = shm;
  214. break;
  215. default:
  216. return -EINVAL;
  217. }
  218. }
  219. return 0;
  220. }
  221. static void handle_rpc(struct udevice *dev, struct rpc_param *param,
  222. void *page_list)
  223. {
  224. struct tee_shm *shm;
  225. switch (OPTEE_SMC_RETURN_GET_RPC_FUNC(param->a0)) {
  226. case OPTEE_SMC_RPC_FUNC_ALLOC:
  227. if (!__tee_shm_add(dev, OPTEE_MSG_NONCONTIG_PAGE_SIZE, NULL,
  228. param->a1, TEE_SHM_ALLOC | TEE_SHM_REGISTER,
  229. &shm)) {
  230. reg_pair_from_64(&param->a1, &param->a2,
  231. virt_to_phys(shm->addr));
  232. /* "cookie" */
  233. reg_pair_from_64(&param->a4, &param->a5, (ulong)shm);
  234. } else {
  235. param->a1 = 0;
  236. param->a2 = 0;
  237. param->a4 = 0;
  238. param->a5 = 0;
  239. }
  240. break;
  241. case OPTEE_SMC_RPC_FUNC_FREE:
  242. shm = reg_pair_to_ptr(param->a1, param->a2);
  243. tee_shm_free(shm);
  244. break;
  245. case OPTEE_SMC_RPC_FUNC_FOREIGN_INTR:
  246. break;
  247. case OPTEE_SMC_RPC_FUNC_CMD:
  248. shm = reg_pair_to_ptr(param->a1, param->a2);
  249. optee_suppl_cmd(dev, shm, page_list);
  250. break;
  251. default:
  252. break;
  253. }
  254. param->a0 = OPTEE_SMC_CALL_RETURN_FROM_RPC;
  255. }
  256. static u32 call_err_to_res(u32 call_err)
  257. {
  258. switch (call_err) {
  259. case OPTEE_SMC_RETURN_OK:
  260. return TEE_SUCCESS;
  261. default:
  262. return TEE_ERROR_BAD_PARAMETERS;
  263. }
  264. }
  265. static u32 do_call_with_arg(struct udevice *dev, struct optee_msg_arg *arg)
  266. {
  267. struct optee_pdata *pdata = dev_get_platdata(dev);
  268. struct rpc_param param = { .a0 = OPTEE_SMC_CALL_WITH_ARG };
  269. void *page_list = NULL;
  270. reg_pair_from_64(&param.a1, &param.a2, virt_to_phys(arg));
  271. while (true) {
  272. struct arm_smccc_res res;
  273. pdata->invoke_fn(param.a0, param.a1, param.a2, param.a3,
  274. param.a4, param.a5, param.a6, param.a7, &res);
  275. free(page_list);
  276. page_list = NULL;
  277. if (OPTEE_SMC_RETURN_IS_RPC(res.a0)) {
  278. param.a0 = res.a0;
  279. param.a1 = res.a1;
  280. param.a2 = res.a2;
  281. param.a3 = res.a3;
  282. handle_rpc(dev, &param, &page_list);
  283. } else {
  284. /*
  285. * In case we've accessed RPMB to serve an RPC
  286. * request we need to restore the previously
  287. * selected partition as the caller may expect it
  288. * to remain unchanged.
  289. */
  290. optee_suppl_rpmb_release(dev);
  291. return call_err_to_res(res.a0);
  292. }
  293. }
  294. }
  295. static int optee_close_session(struct udevice *dev, u32 session)
  296. {
  297. int rc;
  298. struct tee_shm *shm;
  299. struct optee_msg_arg *msg_arg;
  300. rc = get_msg_arg(dev, 0, &shm, &msg_arg);
  301. if (rc)
  302. return rc;
  303. msg_arg->cmd = OPTEE_MSG_CMD_CLOSE_SESSION;
  304. msg_arg->session = session;
  305. do_call_with_arg(dev, msg_arg);
  306. tee_shm_free(shm);
  307. return 0;
  308. }
  309. static int optee_open_session(struct udevice *dev,
  310. struct tee_open_session_arg *arg,
  311. uint num_params, struct tee_param *params)
  312. {
  313. int rc;
  314. struct tee_shm *shm;
  315. struct optee_msg_arg *msg_arg;
  316. rc = get_msg_arg(dev, num_params + 2, &shm, &msg_arg);
  317. if (rc)
  318. return rc;
  319. msg_arg->cmd = OPTEE_MSG_CMD_OPEN_SESSION;
  320. /*
  321. * Initialize and add the meta parameters needed when opening a
  322. * session.
  323. */
  324. msg_arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT |
  325. OPTEE_MSG_ATTR_META;
  326. msg_arg->params[1].attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT |
  327. OPTEE_MSG_ATTR_META;
  328. memcpy(&msg_arg->params[0].u.value, arg->uuid, sizeof(arg->uuid));
  329. memcpy(&msg_arg->params[1].u.value, arg->uuid, sizeof(arg->clnt_uuid));
  330. msg_arg->params[1].u.value.c = arg->clnt_login;
  331. rc = to_msg_param(msg_arg->params + 2, num_params, params);
  332. if (rc)
  333. goto out;
  334. arg->ret = do_call_with_arg(dev, msg_arg);
  335. if (arg->ret) {
  336. arg->ret_origin = TEE_ORIGIN_COMMS;
  337. goto out;
  338. }
  339. if (from_msg_param(params, num_params, msg_arg->params + 2)) {
  340. arg->ret = TEE_ERROR_COMMUNICATION;
  341. arg->ret_origin = TEE_ORIGIN_COMMS;
  342. /* Close session again to avoid leakage */
  343. optee_close_session(dev, msg_arg->session);
  344. goto out;
  345. }
  346. arg->session = msg_arg->session;
  347. arg->ret = msg_arg->ret;
  348. arg->ret_origin = msg_arg->ret_origin;
  349. out:
  350. tee_shm_free(shm);
  351. return rc;
  352. }
  353. static int optee_invoke_func(struct udevice *dev, struct tee_invoke_arg *arg,
  354. uint num_params, struct tee_param *params)
  355. {
  356. struct tee_shm *shm;
  357. struct optee_msg_arg *msg_arg;
  358. int rc;
  359. rc = get_msg_arg(dev, num_params, &shm, &msg_arg);
  360. if (rc)
  361. return rc;
  362. msg_arg->cmd = OPTEE_MSG_CMD_INVOKE_COMMAND;
  363. msg_arg->func = arg->func;
  364. msg_arg->session = arg->session;
  365. rc = to_msg_param(msg_arg->params, num_params, params);
  366. if (rc)
  367. goto out;
  368. arg->ret = do_call_with_arg(dev, msg_arg);
  369. if (arg->ret) {
  370. arg->ret_origin = TEE_ORIGIN_COMMS;
  371. goto out;
  372. }
  373. if (from_msg_param(params, num_params, msg_arg->params)) {
  374. arg->ret = TEE_ERROR_COMMUNICATION;
  375. arg->ret_origin = TEE_ORIGIN_COMMS;
  376. goto out;
  377. }
  378. arg->ret = msg_arg->ret;
  379. arg->ret_origin = msg_arg->ret_origin;
  380. out:
  381. tee_shm_free(shm);
  382. return rc;
  383. }
  384. static int optee_shm_register(struct udevice *dev, struct tee_shm *shm)
  385. {
  386. struct tee_shm *shm_arg;
  387. struct optee_msg_arg *msg_arg;
  388. void *pl;
  389. u64 ph_ptr;
  390. int rc;
  391. rc = get_msg_arg(dev, 1, &shm_arg, &msg_arg);
  392. if (rc)
  393. return rc;
  394. pl = optee_alloc_and_init_page_list(shm->addr, shm->size, &ph_ptr);
  395. if (!pl) {
  396. rc = -ENOMEM;
  397. goto out;
  398. }
  399. msg_arg->cmd = OPTEE_MSG_CMD_REGISTER_SHM;
  400. msg_arg->params->attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT |
  401. OPTEE_MSG_ATTR_NONCONTIG;
  402. msg_arg->params->u.tmem.buf_ptr = ph_ptr;
  403. msg_arg->params->u.tmem.shm_ref = (ulong)shm;
  404. msg_arg->params->u.tmem.size = shm->size;
  405. if (do_call_with_arg(dev, msg_arg) || msg_arg->ret)
  406. rc = -EINVAL;
  407. free(pl);
  408. out:
  409. tee_shm_free(shm_arg);
  410. return rc;
  411. }
  412. static int optee_shm_unregister(struct udevice *dev, struct tee_shm *shm)
  413. {
  414. struct tee_shm *shm_arg;
  415. struct optee_msg_arg *msg_arg;
  416. int rc;
  417. rc = get_msg_arg(dev, 1, &shm_arg, &msg_arg);
  418. if (rc)
  419. return rc;
  420. msg_arg->cmd = OPTEE_MSG_CMD_UNREGISTER_SHM;
  421. msg_arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
  422. msg_arg->params[0].u.rmem.shm_ref = (ulong)shm;
  423. if (do_call_with_arg(dev, msg_arg) || msg_arg->ret)
  424. rc = -EINVAL;
  425. tee_shm_free(shm_arg);
  426. return rc;
  427. }
  428. static const struct tee_driver_ops optee_ops = {
  429. .get_version = optee_get_version,
  430. .open_session = optee_open_session,
  431. .close_session = optee_close_session,
  432. .invoke_func = optee_invoke_func,
  433. .shm_register = optee_shm_register,
  434. .shm_unregister = optee_shm_unregister,
  435. };
  436. static bool is_optee_api(optee_invoke_fn *invoke_fn)
  437. {
  438. struct arm_smccc_res res;
  439. invoke_fn(OPTEE_SMC_CALLS_UID, 0, 0, 0, 0, 0, 0, 0, &res);
  440. return res.a0 == OPTEE_MSG_UID_0 && res.a1 == OPTEE_MSG_UID_1 &&
  441. res.a2 == OPTEE_MSG_UID_2 && res.a3 == OPTEE_MSG_UID_3;
  442. }
  443. static void print_os_revision(struct udevice *dev, optee_invoke_fn *invoke_fn)
  444. {
  445. union {
  446. struct arm_smccc_res smccc;
  447. struct optee_smc_call_get_os_revision_result result;
  448. } res = {
  449. .result = {
  450. .build_id = 0
  451. }
  452. };
  453. invoke_fn(OPTEE_SMC_CALL_GET_OS_REVISION, 0, 0, 0, 0, 0, 0, 0,
  454. &res.smccc);
  455. if (res.result.build_id)
  456. dev_info(dev, "OP-TEE: revision %lu.%lu (%08lx)\n",
  457. res.result.major, res.result.minor,
  458. res.result.build_id);
  459. else
  460. dev_info(dev, "OP-TEE: revision %lu.%lu\n",
  461. res.result.major, res.result.minor);
  462. }
  463. static bool api_revision_is_compatible(optee_invoke_fn *invoke_fn)
  464. {
  465. union {
  466. struct arm_smccc_res smccc;
  467. struct optee_smc_calls_revision_result result;
  468. } res;
  469. invoke_fn(OPTEE_SMC_CALLS_REVISION, 0, 0, 0, 0, 0, 0, 0, &res.smccc);
  470. return res.result.major == OPTEE_MSG_REVISION_MAJOR &&
  471. (int)res.result.minor >= OPTEE_MSG_REVISION_MINOR;
  472. }
  473. static bool exchange_capabilities(optee_invoke_fn *invoke_fn, u32 *sec_caps)
  474. {
  475. union {
  476. struct arm_smccc_res smccc;
  477. struct optee_smc_exchange_capabilities_result result;
  478. } res;
  479. invoke_fn(OPTEE_SMC_EXCHANGE_CAPABILITIES,
  480. OPTEE_SMC_NSEC_CAP_UNIPROCESSOR, 0, 0, 0, 0, 0, 0,
  481. &res.smccc);
  482. if (res.result.status != OPTEE_SMC_RETURN_OK)
  483. return false;
  484. *sec_caps = res.result.capabilities;
  485. return true;
  486. }
  487. /* Simple wrapper functions to be able to use a function pointer */
  488. static void optee_smccc_smc(unsigned long a0, unsigned long a1,
  489. unsigned long a2, unsigned long a3,
  490. unsigned long a4, unsigned long a5,
  491. unsigned long a6, unsigned long a7,
  492. struct arm_smccc_res *res)
  493. {
  494. arm_smccc_smc(a0, a1, a2, a3, a4, a5, a6, a7, res);
  495. }
  496. static void optee_smccc_hvc(unsigned long a0, unsigned long a1,
  497. unsigned long a2, unsigned long a3,
  498. unsigned long a4, unsigned long a5,
  499. unsigned long a6, unsigned long a7,
  500. struct arm_smccc_res *res)
  501. {
  502. arm_smccc_hvc(a0, a1, a2, a3, a4, a5, a6, a7, res);
  503. }
  504. static optee_invoke_fn *get_invoke_func(struct udevice *dev)
  505. {
  506. const char *method;
  507. debug("optee: looking for conduit method in DT.\n");
  508. method = ofnode_get_property(dev->node, "method", NULL);
  509. if (!method) {
  510. debug("optee: missing \"method\" property\n");
  511. return ERR_PTR(-ENXIO);
  512. }
  513. if (!strcmp("hvc", method))
  514. return optee_smccc_hvc;
  515. else if (!strcmp("smc", method))
  516. return optee_smccc_smc;
  517. debug("optee: invalid \"method\" property: %s\n", method);
  518. return ERR_PTR(-EINVAL);
  519. }
  520. static int optee_ofdata_to_platdata(struct udevice *dev)
  521. {
  522. struct optee_pdata *pdata = dev_get_platdata(dev);
  523. pdata->invoke_fn = get_invoke_func(dev);
  524. if (IS_ERR(pdata->invoke_fn))
  525. return PTR_ERR(pdata->invoke_fn);
  526. return 0;
  527. }
  528. static int optee_probe(struct udevice *dev)
  529. {
  530. struct optee_pdata *pdata = dev_get_platdata(dev);
  531. u32 sec_caps;
  532. if (!is_optee_api(pdata->invoke_fn)) {
  533. debug("%s: OP-TEE api uid mismatch\n", __func__);
  534. return -ENOENT;
  535. }
  536. print_os_revision(dev, pdata->invoke_fn);
  537. if (!api_revision_is_compatible(pdata->invoke_fn)) {
  538. debug("%s: OP-TEE api revision mismatch\n", __func__);
  539. return -ENOENT;
  540. }
  541. /*
  542. * OP-TEE can use both shared memory via predefined pool or as
  543. * dynamic shared memory provided by normal world. To keep things
  544. * simple we're only using dynamic shared memory in this driver.
  545. */
  546. if (!exchange_capabilities(pdata->invoke_fn, &sec_caps) ||
  547. !(sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)) {
  548. debug("%s: OP-TEE capabilities mismatch\n", __func__);
  549. return -ENOENT;
  550. }
  551. return 0;
  552. }
  553. static const struct udevice_id optee_match[] = {
  554. { .compatible = "linaro,optee-tz" },
  555. {},
  556. };
  557. U_BOOT_DRIVER(optee) = {
  558. .name = "optee",
  559. .id = UCLASS_TEE,
  560. .of_match = optee_match,
  561. .ofdata_to_platdata = optee_ofdata_to_platdata,
  562. .probe = optee_probe,
  563. .ops = &optee_ops,
  564. .platdata_auto_alloc_size = sizeof(struct optee_pdata),
  565. .priv_auto_alloc_size = sizeof(struct optee_private),
  566. };