adsprpc_socket.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (c) 2022-2023, Qualcomm Innovation Center, Inc. All rights reserved.
  4. */
  5. /* For debug only. Uncomment these blocks to log on every VERIFY statement */
  6. /*
  7. * #ifndef VERIFY_PRINT_ERROR
  8. * #define VERIFY_PRINT_ERROR
  9. * #endif
  10. */
  11. /*
  12. * #ifndef VERIFY_PRINT_INFO
  13. * #define VERIFY_PRINT_INFO
  14. * #endif
  15. * #define VERIFY_IPRINTF(format, ...) pr_info(format, ##__VA_ARGS__)
  16. */
  17. #include <linux/uaccess.h>
  18. #include <linux/qrtr.h>
  19. #include <linux/mutex.h>
  20. #include <net/sock.h>
  21. #include "fastrpc_trace.h"
  22. #include <linux/workqueue.h>
  23. #include "adsprpc_shared.h"
  24. // Registered QRTR service ID
  25. #define FASTRPC_REMOTE_SERVER_SERVICE_ID 5012
  26. /*
  27. * Fastrpc remote server instance ID bit-map:
  28. *
  29. * bits 0-1 : channel ID
  30. * bits 2-7 : reserved
  31. * bits 8-9 : remote domains (SECURE_PD, GUEST_OS)
  32. * bits 10-31 : reserved
  33. */
  34. #define REMOTE_DOMAIN_INSTANCE_INDEX (8)
  35. #define GET_SERVER_INSTANCE(remote_domain, cid) \
  36. ((remote_domain << REMOTE_DOMAIN_INSTANCE_INDEX) | cid)
  37. #define GET_CID_FROM_SERVER_INSTANCE(remote_server_instance) \
  38. (remote_server_instance & 0x3)
  39. // Maximun received fastprc packet size
  40. #define FASTRPC_SOCKET_RECV_SIZE sizeof(union rsp)
  41. union rsp {
  42. struct smq_invoke_rsp rsp;
  43. struct smq_invoke_rspv2 rsp2;
  44. struct smq_notif_rspv3 rsp3;
  45. };
  46. enum fastrpc_remote_domains_id {
  47. SECURE_PD = 0,
  48. GUEST_OS = 1,
  49. MAX_REMOTE_ID = SECURE_PD + 1,
  50. };
  51. struct fastrpc_socket {
  52. struct socket *sock; // Socket used to communicate with remote domain
  53. struct sockaddr_qrtr local_sock_addr; // Local socket address on kernel side
  54. struct sockaddr_qrtr remote_sock_addr; // Remote socket address on remote domain side
  55. struct mutex socket_mutex; // Mutex for socket synchronization
  56. void *recv_buf; // Received packet buffer
  57. };
  58. struct frpc_transport_session_control {
  59. struct fastrpc_socket frpc_socket; // Fastrpc socket data structure
  60. uint32_t remote_server_instance; // Unique remote server instance ID
  61. bool remote_server_online; // Flag to indicate remote server status
  62. struct work_struct work; // work for handling incoming messages
  63. struct workqueue_struct *wq; // workqueue to post @work on
  64. };
  65. struct remote_domain_configuration {
  66. int channel_id;
  67. int remote_domain;
  68. };
  69. /**
  70. * glist_session_ctrl
  71. * Static list containing socket session information for all remote domains.
  72. */
  73. static struct frpc_transport_session_control *glist_session_ctrl[NUM_CHANNELS][MAX_REMOTE_ID];
  74. static const struct remote_domain_configuration configurations[] = {
  75. {
  76. .channel_id = CDSP_DOMAIN_ID,
  77. .remote_domain = SECURE_PD,
  78. },
  79. };
  80. int fastrpc_set_tvm_remote_domain(struct fastrpc_file *fl, struct fastrpc_ioctl_init *init)
  81. {
  82. int err = 0;
  83. char *proc_name = NULL;
  84. fl->tvm_remote_domain = GUEST_OS;
  85. if (init->file) {
  86. if (!init->filelen)
  87. goto bail;
  88. proc_name = kzalloc(init->filelen + 1, GFP_KERNEL);
  89. VERIFY(err, !IS_ERR_OR_NULL(proc_name));
  90. if (err) {
  91. err = -ENOMEM;
  92. goto bail;
  93. }
  94. err = copy_from_user((void *)proc_name,
  95. (void __user *)init->file, init->filelen);
  96. if (err) {
  97. err = -EFAULT;
  98. goto bail;
  99. }
  100. if (!strcmp(proc_name, "securepd"))
  101. fl->tvm_remote_domain = SECURE_PD;
  102. }
  103. bail:
  104. kfree(proc_name);
  105. return err;
  106. }
  107. /**
  108. * verify_transport_device()
  109. * @cid: Channel ID.
  110. * @tvm_remote_domain: Remote domain on TVM.
  111. *
  112. * Obtain remote session information given channel ID and tvm_remote_domain
  113. * and verify that socket has been created and remote server is up.
  114. *
  115. * Return: 0 on success or negative errno value on failure.
  116. */
  117. inline int verify_transport_device(int cid, int tvm_remote_domain)
  118. {
  119. int remote_domain, err = 0;
  120. struct frpc_transport_session_control *session_control = NULL;
  121. remote_domain = tvm_remote_domain;
  122. VERIFY(err, remote_domain >= 0 && remote_domain < MAX_REMOTE_ID);
  123. if (err) {
  124. err = -ECHRNG;
  125. goto bail;
  126. }
  127. session_control = glist_session_ctrl[cid][remote_domain];
  128. VERIFY(err, session_control);
  129. if (err) {
  130. err = -ECHRNG;
  131. goto bail;
  132. }
  133. mutex_lock(&session_control->frpc_socket.socket_mutex);
  134. VERIFY(err, session_control->frpc_socket.sock);
  135. VERIFY(err, session_control->remote_server_online);
  136. if (err) {
  137. err = -EPIPE;
  138. mutex_unlock(&session_control->frpc_socket.socket_mutex);
  139. goto bail;
  140. }
  141. mutex_unlock(&session_control->frpc_socket.socket_mutex);
  142. bail:
  143. return err;
  144. }
  145. static void fastrpc_recv_new_server(struct frpc_transport_session_control *session_control,
  146. unsigned int service, unsigned int instance,
  147. unsigned int node, unsigned int port)
  148. {
  149. uint32_t remote_server_instance = session_control->remote_server_instance;
  150. int32_t err = 0;
  151. /* Ignore EOF marker */
  152. if (!node && !port) {
  153. err = -EINVAL;
  154. goto bail;
  155. }
  156. if (service != FASTRPC_REMOTE_SERVER_SERVICE_ID ||
  157. instance != remote_server_instance) {
  158. err = -ENOMSG;
  159. goto bail;
  160. }
  161. mutex_lock(&session_control->frpc_socket.socket_mutex);
  162. session_control->frpc_socket.remote_sock_addr.sq_family = AF_QIPCRTR;
  163. session_control->frpc_socket.remote_sock_addr.sq_node = node;
  164. session_control->frpc_socket.remote_sock_addr.sq_port = port;
  165. session_control->remote_server_online = true;
  166. mutex_unlock(&session_control->frpc_socket.socket_mutex);
  167. ADSPRPC_INFO("Remote server is up: remote ID (0x%x), node %u, port %u",
  168. remote_server_instance, node, port);
  169. bail:
  170. if (err != -EINVAL && err) {
  171. ADSPRPC_WARN("Ignoring ctrl packet: service id %u, instance id %u, err %d",
  172. service, instance, err);
  173. }
  174. }
  175. static void fastrpc_recv_del_server(struct frpc_transport_session_control *session_control,
  176. unsigned int node, unsigned int port)
  177. {
  178. uint32_t remote_server_instance = session_control->remote_server_instance;
  179. int32_t err = 0;
  180. int32_t cid = 0;
  181. /* Ignore EOF marker */
  182. if (!node && !port) {
  183. err = -EINVAL;
  184. goto bail;
  185. }
  186. if (node != session_control->frpc_socket.remote_sock_addr.sq_node ||
  187. port != session_control->frpc_socket.remote_sock_addr.sq_port) {
  188. err = -ENOMSG;
  189. goto bail;
  190. }
  191. mutex_lock(&session_control->frpc_socket.socket_mutex);
  192. session_control->frpc_socket.remote_sock_addr.sq_node = 0;
  193. session_control->frpc_socket.remote_sock_addr.sq_port = 0;
  194. session_control->remote_server_online = false;
  195. mutex_unlock(&session_control->frpc_socket.socket_mutex);
  196. cid = GET_CID_FROM_SERVER_INSTANCE(remote_server_instance);
  197. ADSPRPC_INFO("Remote server is down: remote ID (0x%x)", remote_server_instance);
  198. fastrpc_restart_drivers(cid);
  199. bail:
  200. if (err != -EINVAL && err)
  201. ADSPRPC_WARN("Ignoring ctrl packet: node %u, port %u, err %d", node, port, err);
  202. }
  203. /**
  204. * fastrpc_recv_ctrl_pkt()
  205. * @session_control: Data structure that contains information related to socket and
  206. * remote server availability.
  207. * @buf: Control packet.
  208. * @len: Control packet length.
  209. *
  210. * Handle control packet status notifications from remote domain.
  211. */
  212. static void fastrpc_recv_ctrl_pkt(struct frpc_transport_session_control *session_control,
  213. const void *buf, size_t len)
  214. {
  215. const struct qrtr_ctrl_pkt *pkt = buf;
  216. if (len < sizeof(struct qrtr_ctrl_pkt)) {
  217. ADSPRPC_WARN("Ignoring short control packet (%d bytes)", len);
  218. return;
  219. }
  220. switch (le32_to_cpu(pkt->cmd)) {
  221. case QRTR_TYPE_NEW_SERVER:
  222. fastrpc_recv_new_server(session_control,
  223. le32_to_cpu(pkt->server.service),
  224. le32_to_cpu(pkt->server.instance),
  225. le32_to_cpu(pkt->server.node),
  226. le32_to_cpu(pkt->server.port));
  227. break;
  228. case QRTR_TYPE_DEL_SERVER:
  229. fastrpc_recv_del_server(session_control,
  230. le32_to_cpu(pkt->server.node),
  231. le32_to_cpu(pkt->server.port));
  232. break;
  233. default:
  234. ADSPRPC_WARN("Ignoring unknown ctrl packet with size %zu", len);
  235. }
  236. }
  237. /**
  238. * fastrpc_socket_callback_wq()
  239. * @work: workqueue structure for incoming socket packets
  240. *
  241. * Callback function to receive responses that were posted on workqueue.
  242. * We expect to receive control packets with remote domain status notifications or
  243. * RPC data packets from remote domain.
  244. */
  245. static void fastrpc_socket_callback_wq(struct work_struct *work)
  246. {
  247. int32_t err = 0, cid = -1, bytes_rx = 0;
  248. uint32_t remote_server_instance = (uint32_t)-1;
  249. bool ignore_err = false;
  250. struct kvec msg = {0};
  251. struct sockaddr_qrtr remote_sock_addr = {0};
  252. struct msghdr remote_server = {0};
  253. struct frpc_transport_session_control *session_control = NULL;
  254. __u32 sq_node = 0, sq_port = 0;
  255. session_control = container_of(work, struct frpc_transport_session_control, work);
  256. VERIFY(err, session_control);
  257. if (err) {
  258. err = -EFAULT;
  259. goto bail;
  260. }
  261. remote_server.msg_name = &remote_sock_addr;
  262. remote_server.msg_namelen = sizeof(remote_sock_addr);
  263. msg.iov_base = session_control->frpc_socket.recv_buf;
  264. msg.iov_len = FASTRPC_SOCKET_RECV_SIZE;
  265. remote_server_instance = session_control->remote_server_instance;
  266. for (;;) {
  267. trace_fastrpc_msg("socket_callback_ready: begin");
  268. err = kernel_recvmsg(session_control->frpc_socket.sock, &remote_server, &msg, 1,
  269. msg.iov_len, MSG_DONTWAIT);
  270. if (err == -EAGAIN) {
  271. ignore_err = true;
  272. goto bail;
  273. }
  274. if (err < 0)
  275. goto bail;
  276. bytes_rx = err;
  277. err = 0;
  278. sq_node = remote_sock_addr.sq_node;
  279. sq_port = remote_sock_addr.sq_port;
  280. if (sq_node == session_control->frpc_socket.local_sock_addr.sq_node &&
  281. sq_port == QRTR_PORT_CTRL) {
  282. fastrpc_recv_ctrl_pkt(session_control,
  283. session_control->frpc_socket.recv_buf,
  284. bytes_rx);
  285. } else {
  286. cid = GET_CID_FROM_SERVER_INSTANCE(remote_server_instance);
  287. VERIFY(err, VALID_FASTRPC_CID(cid));
  288. if (err) {
  289. err = -ECHRNG;
  290. goto bail;
  291. }
  292. fastrpc_handle_rpc_response(msg.iov_base, msg.iov_len, cid);
  293. }
  294. trace_fastrpc_msg("socket_callback_ready: end");
  295. }
  296. bail:
  297. if (!ignore_err && err < 0) {
  298. ADSPRPC_ERR(
  299. "invalid response data %pK (rx %d bytes), buffer len %d from remote ID (0x%x) err %d\n",
  300. msg.iov_base, bytes_rx, msg.iov_len, remote_server_instance, err);
  301. }
  302. }
  303. /**
  304. * fastrpc_socket_callback()
  305. * @sk: Sock data structure with information related to the callback response.
  306. *
  307. * Callback function to receive responses from socket layer.
  308. * Responses are posted on workqueue to be process.
  309. */
  310. static void fastrpc_socket_callback(struct sock *sk)
  311. {
  312. int32_t err = 0;
  313. struct frpc_transport_session_control *session_control = NULL;
  314. trace_fastrpc_msg("socket_callback: begin");
  315. VERIFY(err, sk);
  316. if (err) {
  317. err = -EFAULT;
  318. goto bail;
  319. }
  320. rcu_read_lock();
  321. session_control = rcu_dereference_sk_user_data(sk);
  322. if (session_control)
  323. queue_work(session_control->wq, &session_control->work);
  324. rcu_read_unlock();
  325. bail:
  326. if (err < 0)
  327. ADSPRPC_ERR("invalid sock received, err %d", err);
  328. trace_fastrpc_msg("socket_callback: end");
  329. }
  330. /**
  331. * fastrpc_transport_send()
  332. * @cid: Channel ID.
  333. * @rpc_msg: RPC message to send to remote domain.
  334. * @rpc_msg_size: RPC message size.
  335. * @tvm_remote_domain: Remote domain on TVM.
  336. *
  337. * Send RPC message to remote domain. Depending on tvm_remote_domain flag message will be
  338. * sent to one of the remote domains on remote subsystem.
  339. * Depending on the channel ID and remote domain, a corresponding socket is retrieved
  340. * from glist_session_ctrl and is use to send RPC message.
  341. *
  342. * Return: 0 on success or negative errno value on failure.
  343. */
  344. int fastrpc_transport_send(int cid, void *rpc_msg, uint32_t rpc_msg_size, int tvm_remote_domain)
  345. {
  346. int err = 0, remote_domain;
  347. struct fastrpc_socket *frpc_socket = NULL;
  348. struct frpc_transport_session_control *session_control = NULL;
  349. struct msghdr remote_server = {0};
  350. struct kvec msg = {0};
  351. remote_domain = tvm_remote_domain;
  352. VERIFY(err, remote_domain >= 0 && remote_domain < MAX_REMOTE_ID);
  353. if (err) {
  354. err = -ECHRNG;
  355. goto bail;
  356. }
  357. session_control = glist_session_ctrl[cid][remote_domain];
  358. VERIFY(err, session_control);
  359. if (err) {
  360. err = -ECHRNG;
  361. goto bail;
  362. }
  363. frpc_socket = &session_control->frpc_socket;
  364. remote_server.msg_name = &frpc_socket->remote_sock_addr;
  365. remote_server.msg_namelen = sizeof(frpc_socket->remote_sock_addr);
  366. msg.iov_base = rpc_msg;
  367. msg.iov_len = rpc_msg_size;
  368. mutex_lock(&frpc_socket->socket_mutex);
  369. VERIFY(err, frpc_socket->sock);
  370. VERIFY(err, session_control->remote_server_online);
  371. if (err) {
  372. err = -EPIPE;
  373. mutex_unlock(&frpc_socket->socket_mutex);
  374. goto bail;
  375. }
  376. err = kernel_sendmsg(frpc_socket->sock, &remote_server, &msg, 1, msg.iov_len);
  377. if (err > 0)
  378. err = 0;
  379. mutex_unlock(&frpc_socket->socket_mutex);
  380. bail:
  381. return err;
  382. }
  383. /**
  384. * create_socket()
  385. * @session_control: Data structure that contains information related to socket and
  386. * remote server availability.
  387. *
  388. * Initializes and creates a kernel socket.
  389. *
  390. * Return: pointer to a socket on success or negative errno value on failure.
  391. */
  392. static struct socket *create_socket(struct frpc_transport_session_control *session_control)
  393. {
  394. int err = 0;
  395. struct socket *sock = NULL;
  396. struct fastrpc_socket *frpc_socket = NULL;
  397. err = sock_create_kern(&init_net, AF_QIPCRTR, SOCK_DGRAM,
  398. PF_QIPCRTR, &sock);
  399. if (err < 0) {
  400. ADSPRPC_ERR("sock_create_kern failed with err %d\n", err);
  401. goto bail;
  402. }
  403. frpc_socket = &session_control->frpc_socket;
  404. err = kernel_getsockname(sock, (struct sockaddr *)&frpc_socket->local_sock_addr);
  405. if (err < 0) {
  406. sock_release(sock);
  407. ADSPRPC_ERR("kernel_getsockname failed with err %d\n", err);
  408. goto bail;
  409. }
  410. rcu_assign_sk_user_data(sock->sk, session_control);
  411. sock->sk->sk_data_ready = fastrpc_socket_callback;
  412. sock->sk->sk_error_report = fastrpc_socket_callback;
  413. bail:
  414. if (err < 0)
  415. return ERR_PTR(err);
  416. else
  417. return sock;
  418. }
  419. /**
  420. * register_remote_server_notifications()
  421. * @frpc_socket: Socket to send message to register for remote service notifications.
  422. * @remote_server_instance: ID to uniquely identify remote server
  423. *
  424. * Register socket to receive status notifications from remote service
  425. * using remote service ID FASTRPC_REMOTE_SERVER_SERVICE_ID and instance ID.
  426. *
  427. * Return: 0 on success or negative errno value on failure.
  428. */
  429. static int register_remote_server_notifications(struct fastrpc_socket *frpc_socket,
  430. uint32_t remote_server_instance)
  431. {
  432. struct qrtr_ctrl_pkt pkt = {0};
  433. struct sockaddr_qrtr sq = {0};
  434. struct msghdr remote_server = {0};
  435. struct kvec msg = { &pkt, sizeof(pkt) };
  436. int err = 0;
  437. memset(&pkt, 0, sizeof(pkt));
  438. pkt.cmd = cpu_to_le32(QRTR_TYPE_NEW_LOOKUP);
  439. pkt.server.service = cpu_to_le32(FASTRPC_REMOTE_SERVER_SERVICE_ID);
  440. pkt.server.instance = cpu_to_le32(remote_server_instance);
  441. sq.sq_family = frpc_socket->local_sock_addr.sq_family;
  442. sq.sq_node = frpc_socket->local_sock_addr.sq_node;
  443. sq.sq_port = QRTR_PORT_CTRL;
  444. remote_server.msg_name = &sq;
  445. remote_server.msg_namelen = sizeof(sq);
  446. err = kernel_sendmsg(frpc_socket->sock, &remote_server, &msg, 1, sizeof(pkt));
  447. if (err < 0)
  448. goto bail;
  449. bail:
  450. if (err < 0)
  451. ADSPRPC_ERR("failed to send lookup registration: %d\n", err);
  452. return err;
  453. }
  454. inline void fastrpc_transport_session_init(int cid, char *subsys)
  455. {
  456. }
  457. inline void fastrpc_transport_session_deinit(int cid)
  458. {
  459. }
  460. int fastrpc_wait_for_transport_interrupt(int cid, unsigned int flags)
  461. {
  462. return 0;
  463. }
  464. void fastrpc_rproc_trace_events(const char *name, const char *event,
  465. const char *subevent)
  466. {
  467. }
  468. /**
  469. * fastrpc_transport_init() - Initialize sockets for fastrpc driver.
  470. *
  471. * Initialize and create all sockets that are enabled from all channels
  472. * and remote domains.
  473. * Traverse array configurations and initialize session on glist_session_ctrl if remote
  474. * domain is enabled.
  475. *
  476. * Return: 0 on success or negative errno value on failure.
  477. */
  478. int fastrpc_transport_init(void)
  479. {
  480. int err = 0, cid = -1, ii = 0, remote_domain = -1;
  481. struct socket *sock = NULL;
  482. struct fastrpc_socket *frpc_socket = NULL;
  483. struct frpc_transport_session_control *session_control = NULL;
  484. struct workqueue_struct *wq = NULL;
  485. for (ii = 0; ii < ARRAY_SIZE(configurations); ii++) {
  486. session_control = kzalloc(sizeof(*session_control), GFP_KERNEL);
  487. VERIFY(err, NULL != session_control);
  488. if (err) {
  489. err = -ENOMEM;
  490. goto bail;
  491. }
  492. cid = configurations[ii].channel_id;
  493. remote_domain = configurations[ii].remote_domain;
  494. VERIFY(err, remote_domain < MAX_REMOTE_ID);
  495. if (err) {
  496. err = -ECHRNG;
  497. goto bail;
  498. }
  499. VERIFY(err, VALID_FASTRPC_CID(cid));
  500. if (err) {
  501. err = -ECHRNG;
  502. goto bail;
  503. }
  504. session_control->remote_server_online = false;
  505. frpc_socket = &session_control->frpc_socket;
  506. mutex_init(&frpc_socket->socket_mutex);
  507. sock = create_socket(session_control);
  508. if (IS_ERR_OR_NULL(sock)) {
  509. err = PTR_ERR(sock);
  510. goto bail;
  511. }
  512. frpc_socket->sock = sock;
  513. frpc_socket->recv_buf = kzalloc(FASTRPC_SOCKET_RECV_SIZE, GFP_KERNEL);
  514. if (!frpc_socket->recv_buf) {
  515. err = -ENOMEM;
  516. goto bail;
  517. }
  518. INIT_WORK(&session_control->work, fastrpc_socket_callback_wq);
  519. wq = alloc_workqueue("fastrpc_msg_handler", WQ_UNBOUND|WQ_HIGHPRI, 0);
  520. if (!wq) {
  521. err = -ENOMEM;
  522. goto bail;
  523. }
  524. session_control->wq = wq;
  525. session_control->remote_server_instance = GET_SERVER_INSTANCE(remote_domain, cid);
  526. err = register_remote_server_notifications(frpc_socket,
  527. session_control->remote_server_instance);
  528. if (err < 0)
  529. goto bail;
  530. glist_session_ctrl[cid][remote_domain] = session_control;
  531. ADSPRPC_INFO("Created and registered socket for remote server (service ID %u, instance ID 0x%x)\n",
  532. FASTRPC_REMOTE_SERVER_SERVICE_ID, session_control->remote_server_instance);
  533. }
  534. err = 0;
  535. bail:
  536. if (err)
  537. ADSPRPC_ERR("fastrpc_socket_init failed with err %d\n", err);
  538. return err;
  539. }
  540. /**
  541. * fastrpc_transport_deinit() - Deinitialize sockets for fastrpc driver.
  542. *
  543. * Deinitialize and release all sockets that are enabled from all channels
  544. * and remote domains.
  545. * Traverse array configurations and deinitialize corresponding session from
  546. * glist_session_ctrl.
  547. */
  548. void fastrpc_transport_deinit(void)
  549. {
  550. int ii = 0, cid = -1, remote_domain = -1, err = 0;
  551. struct fastrpc_socket *frpc_socket = NULL;
  552. struct frpc_transport_session_control *session_control = NULL;
  553. for (ii = 0; ii < ARRAY_SIZE(configurations); ii++) {
  554. cid = configurations[ii].channel_id;
  555. remote_domain = configurations[ii].remote_domain;
  556. VERIFY(err, remote_domain < MAX_REMOTE_ID);
  557. if (err) {
  558. err = -ECHRNG;
  559. goto bail;
  560. }
  561. VERIFY(err, VALID_FASTRPC_CID(cid));
  562. if (err) {
  563. err = -ECHRNG;
  564. goto bail;
  565. }
  566. session_control = glist_session_ctrl[cid][remote_domain];
  567. if (!session_control)
  568. continue;
  569. frpc_socket = &session_control->frpc_socket;
  570. if (frpc_socket->sock)
  571. sock_release(frpc_socket->sock);
  572. if (session_control->wq)
  573. destroy_workqueue(session_control->wq);
  574. kfree(frpc_socket->recv_buf);
  575. frpc_socket->recv_buf = NULL;
  576. frpc_socket->sock = NULL;
  577. mutex_destroy(&frpc_socket->socket_mutex);
  578. kfree(session_control);
  579. glist_session_ctrl[cid][remote_domain] = NULL;
  580. }
  581. bail:
  582. if (err)
  583. ADSPRPC_ERR("fastrpc_socket_deinit failed with err %d\n", err);
  584. }