msm_cvp_buf.c 30 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
  4. */
  5. #include <linux/pid.h>
  6. #include <linux/fdtable.h>
  7. #include <linux/rcupdate.h>
  8. #include <linux/fs.h>
  9. #include <linux/dma-buf.h>
  10. #include <linux/sched/task.h>
  11. #include <linux/version.h>
  12. #include "msm_cvp_common.h"
  13. #include "cvp_hfi_api.h"
  14. #include "msm_cvp_debug.h"
  15. #include "msm_cvp_core.h"
  16. #include "msm_cvp_dsp.h"
  17. #define CLEAR_USE_BITMAP(idx, inst) \
  18. do { \
  19. clear_bit(idx, &inst->dma_cache.usage_bitmap); \
  20. dprintk(CVP_MEM, "clear %x bit %d dma_cache bitmap 0x%llx\n", \
  21. hash32_ptr(inst->session), smem->bitmap_index, \
  22. inst->dma_cache.usage_bitmap); \
  23. } while (0)
  24. #define SET_USE_BITMAP(idx, inst) \
  25. do { \
  26. set_bit(idx, &inst->dma_cache.usage_bitmap); \
  27. dprintk(CVP_MEM, "Set %x bit %d dma_cache bitmap 0x%llx\n", \
  28. hash32_ptr(inst->session), idx, \
  29. inst->dma_cache.usage_bitmap); \
  30. } while (0)
  31. int print_smem(u32 tag, const char *str, struct msm_cvp_inst *inst,
  32. struct msm_cvp_smem *smem)
  33. {
  34. if (!(tag & msm_cvp_debug))
  35. return 0;
  36. if (!inst || !smem) {
  37. dprintk(CVP_ERR, "Invalid inst 0x%llx or smem 0x%llx\n",
  38. inst, smem);
  39. return -EINVAL;
  40. }
  41. if (smem->dma_buf) {
  42. dprintk(tag,
  43. "%s: %x : %s size %d flags %#x iova %#x idx %d ref %d",
  44. str, hash32_ptr(inst->session), smem->dma_buf->name,
  45. smem->size, smem->flags, smem->device_addr,
  46. smem->bitmap_index, smem->refcount);
  47. }
  48. return 0;
  49. }
  50. static void print_internal_buffer(u32 tag, const char *str,
  51. struct msm_cvp_inst *inst, struct cvp_internal_buf *cbuf)
  52. {
  53. if (!(tag & msm_cvp_debug) || !inst || !cbuf)
  54. return;
  55. if (cbuf->smem->dma_buf) {
  56. dprintk(tag,
  57. "%s: %x : fd %d off %d %s size %d iova %#x",
  58. str, hash32_ptr(inst->session), cbuf->fd,
  59. cbuf->offset, cbuf->smem->dma_buf->name, cbuf->size,
  60. cbuf->smem->device_addr);
  61. } else {
  62. dprintk(tag,
  63. "%s: %x : idx %2d fd %d off %d size %d iova %#x",
  64. str, hash32_ptr(inst->session), cbuf->fd,
  65. cbuf->offset, cbuf->size, cbuf->smem->device_addr);
  66. }
  67. }
  68. void print_cvp_buffer(u32 tag, const char *str, struct msm_cvp_inst *inst,
  69. struct cvp_internal_buf *cbuf)
  70. {
  71. dprintk(tag, "%s addr: %x size %u\n", str,
  72. cbuf->smem->device_addr, cbuf->size);
  73. }
  74. static void _log_smem(struct inst_snapshot *snapshot, struct msm_cvp_inst *inst,
  75. struct msm_cvp_smem *smem, bool logging)
  76. {
  77. if (print_smem(CVP_ERR, "bufdump", inst, smem))
  78. return;
  79. if (!logging || !snapshot)
  80. return;
  81. if (snapshot && snapshot->smem_index < MAX_ENTRIES) {
  82. struct smem_data *s;
  83. s = &snapshot->smem_log[snapshot->smem_index];
  84. snapshot->smem_index++;
  85. s->size = smem->size;
  86. s->flags = smem->flags;
  87. s->device_addr = smem->device_addr;
  88. s->bitmap_index = smem->bitmap_index;
  89. s->refcount = atomic_read(&smem->refcount);
  90. }
  91. }
  92. static void _log_buf(struct inst_snapshot *snapshot, enum smem_prop prop,
  93. struct msm_cvp_inst *inst, struct cvp_internal_buf *cbuf,
  94. bool logging)
  95. {
  96. struct cvp_buf_data *buf = NULL;
  97. u32 index;
  98. print_cvp_buffer(CVP_ERR, "bufdump", inst, cbuf);
  99. if (!logging)
  100. return;
  101. if (snapshot) {
  102. if (prop == SMEM_ADSP && snapshot->dsp_index < MAX_ENTRIES) {
  103. index = snapshot->dsp_index;
  104. buf = &snapshot->dsp_buf_log[index];
  105. snapshot->dsp_index++;
  106. } else if (prop == SMEM_PERSIST &&
  107. snapshot->persist_index < MAX_ENTRIES) {
  108. index = snapshot->persist_index;
  109. buf = &snapshot->persist_buf_log[index];
  110. snapshot->persist_index++;
  111. }
  112. if (buf) {
  113. buf->device_addr = cbuf->smem->device_addr;
  114. buf->size = cbuf->size;
  115. }
  116. }
  117. }
  118. void print_client_buffer(u32 tag, const char *str,
  119. struct msm_cvp_inst *inst, struct eva_kmd_buffer *cbuf)
  120. {
  121. if (!(tag & msm_cvp_debug) || !inst || !cbuf)
  122. return;
  123. dprintk(tag,
  124. "%s: %x : idx %2d fd %d off %d size %d type %d flags 0x%x\n",
  125. str, hash32_ptr(inst->session), cbuf->index, cbuf->fd,
  126. cbuf->offset, cbuf->size, cbuf->type, cbuf->flags);
  127. }
  128. static bool __is_buf_valid(struct msm_cvp_inst *inst,
  129. struct eva_kmd_buffer *buf)
  130. {
  131. struct cvp_hal_session *session;
  132. struct cvp_internal_buf *cbuf = NULL;
  133. bool found = false;
  134. if (!inst || !inst->core || !buf) {
  135. dprintk(CVP_ERR, "%s: invalid params\n", __func__);
  136. return false;
  137. }
  138. if (buf->fd < 0) {
  139. dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
  140. return false;
  141. }
  142. if (buf->offset) {
  143. dprintk(CVP_ERR,
  144. "%s: offset is deprecated, set to 0.\n",
  145. __func__);
  146. return false;
  147. }
  148. session = (struct cvp_hal_session *)inst->session;
  149. mutex_lock(&inst->cvpdspbufs.lock);
  150. list_for_each_entry(cbuf, &inst->cvpdspbufs.list, list) {
  151. if (cbuf->fd == buf->fd) {
  152. if (cbuf->size != buf->size) {
  153. dprintk(CVP_ERR, "%s: buf size mismatch\n",
  154. __func__);
  155. mutex_unlock(&inst->cvpdspbufs.lock);
  156. return false;
  157. }
  158. found = true;
  159. break;
  160. }
  161. }
  162. mutex_unlock(&inst->cvpdspbufs.lock);
  163. if (found) {
  164. print_internal_buffer(CVP_ERR, "duplicate", inst, cbuf);
  165. return false;
  166. }
  167. return true;
  168. }
  169. static struct file *msm_cvp_fget(unsigned int fd, struct task_struct *task,
  170. fmode_t mask, unsigned int refs)
  171. {
  172. struct files_struct *files = task->files;
  173. struct file *file;
  174. if (!files)
  175. return NULL;
  176. rcu_read_lock();
  177. loop:
  178. #if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 13, 0))
  179. file = fcheck_files(files, fd);
  180. #else
  181. file = files_lookup_fd_rcu(files, fd);
  182. #endif
  183. if (file) {
  184. /* File object ref couldn't be taken.
  185. * dup2() atomicity guarantee is the reason
  186. * we loop to catch the new file (or NULL pointer)
  187. */
  188. if (file->f_mode & mask)
  189. file = NULL;
  190. else if (!get_file_rcu_many(file, refs))
  191. goto loop;
  192. }
  193. rcu_read_unlock();
  194. return file;
  195. }
  196. static struct dma_buf *cvp_dma_buf_get(struct file *file, int fd,
  197. struct task_struct *task)
  198. {
  199. if (file->f_op != gfa_cv.dmabuf_f_op) {
  200. dprintk(CVP_WARN, "fd doesn't refer to dma_buf\n");
  201. return ERR_PTR(-EINVAL);
  202. }
  203. return file->private_data;
  204. }
  205. int msm_cvp_map_buf_dsp(struct msm_cvp_inst *inst, struct eva_kmd_buffer *buf)
  206. {
  207. int rc = 0;
  208. struct cvp_internal_buf *cbuf = NULL;
  209. struct msm_cvp_smem *smem = NULL;
  210. struct dma_buf *dma_buf = NULL;
  211. struct file *file;
  212. if (!__is_buf_valid(inst, buf))
  213. return -EINVAL;
  214. if (!inst->task)
  215. return -EINVAL;
  216. file = msm_cvp_fget(buf->fd, inst->task, FMODE_PATH, 1);
  217. if (file == NULL) {
  218. dprintk(CVP_WARN, "%s fail to get file from fd\n", __func__);
  219. return -EINVAL;
  220. }
  221. dma_buf = cvp_dma_buf_get(
  222. file,
  223. buf->fd,
  224. inst->task);
  225. if (dma_buf == ERR_PTR(-EINVAL)) {
  226. dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
  227. rc = -EINVAL;
  228. goto exit;
  229. }
  230. dprintk(CVP_MEM, "dma_buf from internal %llu\n", dma_buf);
  231. cbuf = kmem_cache_zalloc(cvp_driver->buf_cache, GFP_KERNEL);
  232. if (!cbuf) {
  233. rc = -ENOMEM;
  234. goto exit;
  235. }
  236. smem = kmem_cache_zalloc(cvp_driver->smem_cache, GFP_KERNEL);
  237. if (!smem) {
  238. rc = -ENOMEM;
  239. goto exit;
  240. }
  241. smem->dma_buf = dma_buf;
  242. smem->bitmap_index = MAX_DMABUF_NUMS;
  243. dprintk(CVP_MEM, "%s: dma_buf = %llx\n", __func__, dma_buf);
  244. rc = msm_cvp_map_smem(inst, smem, "map dsp");
  245. if (rc) {
  246. print_client_buffer(CVP_ERR, "map failed", inst, buf);
  247. goto exit;
  248. }
  249. cbuf->smem = smem;
  250. cbuf->fd = buf->fd;
  251. cbuf->size = buf->size;
  252. cbuf->offset = buf->offset;
  253. cbuf->ownership = CLIENT;
  254. cbuf->index = buf->index;
  255. buf->reserved[0] = (uint32_t)smem->device_addr;
  256. mutex_lock(&inst->cvpdspbufs.lock);
  257. list_add_tail(&cbuf->list, &inst->cvpdspbufs.list);
  258. mutex_unlock(&inst->cvpdspbufs.lock);
  259. return rc;
  260. exit:
  261. fput(file);
  262. if (smem) {
  263. if (smem->device_addr) {
  264. msm_cvp_unmap_smem(inst, smem, "unmap dsp");
  265. msm_cvp_smem_put_dma_buf(smem->dma_buf);
  266. }
  267. kmem_cache_free(cvp_driver->smem_cache, smem);
  268. }
  269. if (cbuf)
  270. kmem_cache_free(cvp_driver->buf_cache, cbuf);
  271. return rc;
  272. }
  273. int msm_cvp_unmap_buf_dsp(struct msm_cvp_inst *inst, struct eva_kmd_buffer *buf)
  274. {
  275. int rc = 0;
  276. bool found;
  277. struct cvp_internal_buf *cbuf;
  278. struct cvp_hal_session *session;
  279. if (!inst || !inst->core || !buf) {
  280. dprintk(CVP_ERR, "%s: invalid params\n", __func__);
  281. return -EINVAL;
  282. }
  283. session = (struct cvp_hal_session *)inst->session;
  284. if (!session) {
  285. dprintk(CVP_ERR, "%s: invalid session\n", __func__);
  286. return -EINVAL;
  287. }
  288. mutex_lock(&inst->cvpdspbufs.lock);
  289. found = false;
  290. list_for_each_entry(cbuf, &inst->cvpdspbufs.list, list) {
  291. if (cbuf->fd == buf->fd) {
  292. found = true;
  293. break;
  294. }
  295. }
  296. mutex_unlock(&inst->cvpdspbufs.lock);
  297. if (!found) {
  298. print_client_buffer(CVP_ERR, "invalid", inst, buf);
  299. return -EINVAL;
  300. }
  301. if (cbuf->smem->device_addr) {
  302. msm_cvp_unmap_smem(inst, cbuf->smem, "unmap dsp");
  303. msm_cvp_smem_put_dma_buf(cbuf->smem->dma_buf);
  304. }
  305. mutex_lock(&inst->cvpdspbufs.lock);
  306. list_del(&cbuf->list);
  307. mutex_unlock(&inst->cvpdspbufs.lock);
  308. kmem_cache_free(cvp_driver->smem_cache, cbuf->smem);
  309. kmem_cache_free(cvp_driver->buf_cache, cbuf);
  310. return rc;
  311. }
  312. void msm_cvp_cache_operations(struct msm_cvp_smem *smem, u32 type,
  313. u32 offset, u32 size)
  314. {
  315. enum smem_cache_ops cache_op;
  316. if (msm_cvp_cacheop_disabled)
  317. return;
  318. if (!smem) {
  319. dprintk(CVP_ERR, "%s: invalid params\n", __func__);
  320. return;
  321. }
  322. switch (type) {
  323. case EVA_KMD_BUFTYPE_INPUT:
  324. cache_op = SMEM_CACHE_CLEAN;
  325. break;
  326. case EVA_KMD_BUFTYPE_OUTPUT:
  327. cache_op = SMEM_CACHE_INVALIDATE;
  328. break;
  329. default:
  330. cache_op = SMEM_CACHE_CLEAN_INVALIDATE;
  331. }
  332. dprintk(CVP_MEM,
  333. "%s: cache operation enabled for dma_buf: %llx, cache_op: %d, offset: %d, size: %d\n",
  334. __func__, smem->dma_buf, cache_op, offset, size);
  335. msm_cvp_smem_cache_operations(smem->dma_buf, cache_op, offset, size);
  336. }
  337. static struct msm_cvp_smem *msm_cvp_session_find_smem(struct msm_cvp_inst *inst,
  338. struct dma_buf *dma_buf)
  339. {
  340. struct msm_cvp_smem *smem;
  341. int i;
  342. if (inst->dma_cache.nr > MAX_DMABUF_NUMS)
  343. return NULL;
  344. mutex_lock(&inst->dma_cache.lock);
  345. for (i = 0; i < inst->dma_cache.nr; i++)
  346. if (inst->dma_cache.entries[i]->dma_buf == dma_buf) {
  347. SET_USE_BITMAP(i, inst);
  348. smem = inst->dma_cache.entries[i];
  349. smem->bitmap_index = i;
  350. atomic_inc(&smem->refcount);
  351. /*
  352. * If we find it, it means we already increased
  353. * refcount before, so we put it to avoid double
  354. * incremental.
  355. */
  356. msm_cvp_smem_put_dma_buf(smem->dma_buf);
  357. mutex_unlock(&inst->dma_cache.lock);
  358. print_smem(CVP_MEM, "found", inst, smem);
  359. return smem;
  360. }
  361. mutex_unlock(&inst->dma_cache.lock);
  362. return NULL;
  363. }
  364. static int msm_cvp_session_add_smem(struct msm_cvp_inst *inst,
  365. struct msm_cvp_smem *smem)
  366. {
  367. unsigned int i;
  368. struct msm_cvp_smem *smem2;
  369. mutex_lock(&inst->dma_cache.lock);
  370. if (inst->dma_cache.nr < MAX_DMABUF_NUMS) {
  371. inst->dma_cache.entries[inst->dma_cache.nr] = smem;
  372. SET_USE_BITMAP(inst->dma_cache.nr, inst);
  373. smem->bitmap_index = inst->dma_cache.nr;
  374. inst->dma_cache.nr++;
  375. i = smem->bitmap_index;
  376. } else {
  377. i = find_first_zero_bit(&inst->dma_cache.usage_bitmap,
  378. MAX_DMABUF_NUMS);
  379. if (i < MAX_DMABUF_NUMS) {
  380. smem2 = inst->dma_cache.entries[i];
  381. msm_cvp_unmap_smem(inst, smem2, "unmap cpu");
  382. msm_cvp_smem_put_dma_buf(smem2->dma_buf);
  383. kmem_cache_free(cvp_driver->smem_cache, smem2);
  384. inst->dma_cache.entries[i] = smem;
  385. smem->bitmap_index = i;
  386. SET_USE_BITMAP(i, inst);
  387. } else {
  388. dprintk(CVP_WARN, "%s: not enough memory\n", __func__);
  389. mutex_unlock(&inst->dma_cache.lock);
  390. return -ENOMEM;
  391. }
  392. }
  393. atomic_inc(&smem->refcount);
  394. mutex_unlock(&inst->dma_cache.lock);
  395. dprintk(CVP_MEM, "Add entry %d into cache\n", i);
  396. return 0;
  397. }
  398. static struct msm_cvp_smem *msm_cvp_session_get_smem(struct msm_cvp_inst *inst,
  399. struct cvp_buf_type *buf)
  400. {
  401. int rc = 0, found = 1;
  402. struct msm_cvp_smem *smem = NULL;
  403. struct dma_buf *dma_buf = NULL;
  404. if (buf->fd < 0) {
  405. dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
  406. return NULL;
  407. }
  408. dma_buf = msm_cvp_smem_get_dma_buf(buf->fd);
  409. if (!dma_buf) {
  410. dprintk(CVP_ERR, "%s: Invalid fd = %d", __func__, buf->fd);
  411. return NULL;
  412. }
  413. smem = msm_cvp_session_find_smem(inst, dma_buf);
  414. if (!smem) {
  415. found = 0;
  416. smem = kmem_cache_zalloc(cvp_driver->smem_cache, GFP_KERNEL);
  417. if (!smem)
  418. return NULL;
  419. smem->dma_buf = dma_buf;
  420. smem->bitmap_index = MAX_DMABUF_NUMS;
  421. rc = msm_cvp_map_smem(inst, smem, "map cpu");
  422. if (rc)
  423. goto exit;
  424. if (buf->size > smem->size || buf->size > smem->size - buf->offset) {
  425. dprintk(CVP_ERR, "%s: invalid offset %d or size %d for a new entry\n",
  426. __func__, buf->offset, buf->size);
  427. goto exit2;
  428. }
  429. rc = msm_cvp_session_add_smem(inst, smem);
  430. if (rc && rc != -ENOMEM)
  431. goto exit2;
  432. }
  433. if (buf->size > smem->size || buf->size > smem->size - buf->offset) {
  434. dprintk(CVP_ERR, "%s: invalid offset %d or size %d\n",
  435. __func__, buf->offset, buf->size);
  436. if (found) {
  437. mutex_lock(&inst->dma_cache.lock);
  438. atomic_dec(&smem->refcount);
  439. mutex_unlock(&inst->dma_cache.lock);
  440. return NULL;
  441. }
  442. goto exit2;
  443. }
  444. return smem;
  445. exit2:
  446. msm_cvp_unmap_smem(inst, smem, "unmap cpu");
  447. exit:
  448. msm_cvp_smem_put_dma_buf(dma_buf);
  449. kmem_cache_free(cvp_driver->smem_cache, smem);
  450. smem = NULL;
  451. return smem;
  452. }
  453. static u32 msm_cvp_map_user_persist_buf(struct msm_cvp_inst *inst,
  454. struct cvp_buf_type *buf)
  455. {
  456. u32 iova = 0;
  457. struct msm_cvp_smem *smem = NULL;
  458. struct cvp_internal_buf *pbuf;
  459. if (!inst) {
  460. dprintk(CVP_ERR, "%s: invalid params\n", __func__);
  461. return -EINVAL;
  462. }
  463. pbuf = kmem_cache_zalloc(cvp_driver->buf_cache, GFP_KERNEL);
  464. if (!pbuf)
  465. return 0;
  466. smem = msm_cvp_session_get_smem(inst, buf);
  467. if (!smem)
  468. goto exit;
  469. smem->flags |= SMEM_PERSIST;
  470. pbuf->smem = smem;
  471. pbuf->fd = buf->fd;
  472. pbuf->size = buf->size;
  473. pbuf->offset = buf->offset;
  474. pbuf->ownership = CLIENT;
  475. mutex_lock(&inst->persistbufs.lock);
  476. list_add_tail(&pbuf->list, &inst->persistbufs.list);
  477. mutex_unlock(&inst->persistbufs.lock);
  478. print_internal_buffer(CVP_MEM, "map persist", inst, pbuf);
  479. iova = smem->device_addr + buf->offset;
  480. return iova;
  481. exit:
  482. kmem_cache_free(cvp_driver->buf_cache, pbuf);
  483. return 0;
  484. }
  485. u32 msm_cvp_map_frame_buf(struct msm_cvp_inst *inst,
  486. struct cvp_buf_type *buf,
  487. struct msm_cvp_frame *frame)
  488. {
  489. u32 iova = 0;
  490. struct msm_cvp_smem *smem = NULL;
  491. u32 nr;
  492. u32 type;
  493. if (!inst || !frame) {
  494. dprintk(CVP_ERR, "%s: invalid params\n", __func__);
  495. return 0;
  496. }
  497. nr = frame->nr;
  498. if (nr == MAX_FRAME_BUFFER_NUMS) {
  499. dprintk(CVP_ERR, "%s: max frame buffer reached\n", __func__);
  500. return 0;
  501. }
  502. smem = msm_cvp_session_get_smem(inst, buf);
  503. if (!smem)
  504. return 0;
  505. frame->bufs[nr].fd = buf->fd;
  506. frame->bufs[nr].smem = smem;
  507. frame->bufs[nr].size = buf->size;
  508. frame->bufs[nr].offset = buf->offset;
  509. print_internal_buffer(CVP_MEM, "map cpu", inst, &frame->bufs[nr]);
  510. frame->nr++;
  511. type = EVA_KMD_BUFTYPE_INPUT | EVA_KMD_BUFTYPE_OUTPUT;
  512. msm_cvp_cache_operations(smem, type, buf->offset, buf->size);
  513. iova = smem->device_addr + buf->offset;
  514. return iova;
  515. }
  516. static void msm_cvp_unmap_frame_buf(struct msm_cvp_inst *inst,
  517. struct msm_cvp_frame *frame)
  518. {
  519. u32 i;
  520. u32 type;
  521. struct msm_cvp_smem *smem = NULL;
  522. struct cvp_internal_buf *buf;
  523. type = EVA_KMD_BUFTYPE_OUTPUT;
  524. for (i = 0; i < frame->nr; ++i) {
  525. buf = &frame->bufs[i];
  526. smem = buf->smem;
  527. msm_cvp_cache_operations(smem, type, buf->offset, buf->size);
  528. if (smem->bitmap_index >= MAX_DMABUF_NUMS) {
  529. /* smem not in dmamap cache */
  530. msm_cvp_unmap_smem(inst, smem, "unmap cpu");
  531. dma_heap_buffer_free(smem->dma_buf);
  532. kmem_cache_free(cvp_driver->smem_cache, smem);
  533. buf->smem = NULL;
  534. } else {
  535. mutex_lock(&inst->dma_cache.lock);
  536. if (atomic_dec_and_test(&smem->refcount)) {
  537. CLEAR_USE_BITMAP(smem->bitmap_index, inst);
  538. print_smem(CVP_MEM, "Map dereference",
  539. inst, smem);
  540. }
  541. mutex_unlock(&inst->dma_cache.lock);
  542. }
  543. }
  544. kmem_cache_free(cvp_driver->frame_cache, frame);
  545. }
  546. void msm_cvp_unmap_frame(struct msm_cvp_inst *inst, u64 ktid)
  547. {
  548. struct msm_cvp_frame *frame, *dummy1;
  549. bool found;
  550. if (!inst) {
  551. dprintk(CVP_ERR, "%s: invalid params\n", __func__);
  552. return;
  553. }
  554. ktid &= (FENCE_BIT - 1);
  555. dprintk(CVP_MEM, "%s: (%#x) unmap frame %llu\n",
  556. __func__, hash32_ptr(inst->session), ktid);
  557. found = false;
  558. mutex_lock(&inst->frames.lock);
  559. list_for_each_entry_safe(frame, dummy1, &inst->frames.list, list) {
  560. if (frame->ktid == ktid) {
  561. found = true;
  562. list_del(&frame->list);
  563. break;
  564. }
  565. }
  566. mutex_unlock(&inst->frames.lock);
  567. if (found)
  568. msm_cvp_unmap_frame_buf(inst, frame);
  569. else
  570. dprintk(CVP_WARN, "%s frame %llu not found!\n", __func__, ktid);
  571. }
  572. int msm_cvp_unmap_user_persist(struct msm_cvp_inst *inst,
  573. struct eva_kmd_hfi_packet *in_pkt,
  574. unsigned int offset, unsigned int buf_num)
  575. {
  576. struct cvp_hfi_cmd_session_hdr *cmd_hdr;
  577. struct cvp_internal_buf *pbuf, *dummy;
  578. u64 ktid;
  579. int rc = 0;
  580. struct msm_cvp_smem *smem = NULL;
  581. if (!offset || !buf_num)
  582. return rc;
  583. cmd_hdr = (struct cvp_hfi_cmd_session_hdr *)in_pkt;
  584. ktid = cmd_hdr->client_data.kdata & (FENCE_BIT - 1);
  585. mutex_lock(&inst->persistbufs.lock);
  586. list_for_each_entry_safe(pbuf, dummy, &inst->persistbufs.list, list) {
  587. if (pbuf->ktid == ktid && pbuf->ownership == CLIENT) {
  588. list_del(&pbuf->list);
  589. smem = pbuf->smem;
  590. dprintk(CVP_MEM, "unmap persist: %x %d %d %#x",
  591. hash32_ptr(inst->session), pbuf->fd,
  592. pbuf->size, smem->device_addr);
  593. if (smem->bitmap_index >= MAX_DMABUF_NUMS) {
  594. /* smem not in dmamap cache */
  595. msm_cvp_unmap_smem(inst, smem,
  596. "unmap cpu");
  597. dma_heap_buffer_free(smem->dma_buf);
  598. kmem_cache_free(
  599. cvp_driver->smem_cache,
  600. smem);
  601. pbuf->smem = NULL;
  602. } else {
  603. mutex_lock(&inst->dma_cache.lock);
  604. if (atomic_dec_and_test(&smem->refcount))
  605. CLEAR_USE_BITMAP(
  606. smem->bitmap_index,
  607. inst);
  608. mutex_unlock(&inst->dma_cache.lock);
  609. }
  610. kmem_cache_free(cvp_driver->buf_cache, pbuf);
  611. }
  612. }
  613. mutex_unlock(&inst->persistbufs.lock);
  614. return rc;
  615. }
  616. int msm_cvp_mark_user_persist(struct msm_cvp_inst *inst,
  617. struct eva_kmd_hfi_packet *in_pkt,
  618. unsigned int offset, unsigned int buf_num)
  619. {
  620. struct cvp_hfi_cmd_session_hdr *cmd_hdr;
  621. struct cvp_internal_buf *pbuf, *dummy;
  622. u64 ktid;
  623. struct cvp_buf_type *buf;
  624. int i, rc = 0;
  625. if (!offset || !buf_num)
  626. return 0;
  627. cmd_hdr = (struct cvp_hfi_cmd_session_hdr *)in_pkt;
  628. ktid = atomic64_inc_return(&inst->core->kernel_trans_id);
  629. ktid &= (FENCE_BIT - 1);
  630. cmd_hdr->client_data.kdata = ktid;
  631. for (i = 0; i < buf_num; i++) {
  632. buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
  633. offset += sizeof(*buf) >> 2;
  634. if (buf->fd < 0 || !buf->size)
  635. continue;
  636. mutex_lock(&inst->persistbufs.lock);
  637. list_for_each_entry_safe(pbuf, dummy, &inst->persistbufs.list,
  638. list) {
  639. if (pbuf->ownership == CLIENT) {
  640. if (pbuf->fd == buf->fd &&
  641. pbuf->size == buf->size)
  642. buf->fd = pbuf->smem->device_addr;
  643. rc = 1;
  644. break;
  645. }
  646. }
  647. mutex_unlock(&inst->persistbufs.lock);
  648. if (!rc) {
  649. dprintk(CVP_ERR, "%s No persist buf %d found\n",
  650. __func__, buf->fd);
  651. rc = -EFAULT;
  652. break;
  653. }
  654. pbuf->ktid = ktid;
  655. rc = 0;
  656. }
  657. return rc;
  658. }
  659. int msm_cvp_map_user_persist(struct msm_cvp_inst *inst,
  660. struct eva_kmd_hfi_packet *in_pkt,
  661. unsigned int offset, unsigned int buf_num)
  662. {
  663. struct cvp_buf_type *buf;
  664. int i;
  665. u32 iova;
  666. if (!offset || !buf_num)
  667. return 0;
  668. for (i = 0; i < buf_num; i++) {
  669. buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
  670. offset += sizeof(*buf) >> 2;
  671. if (buf->fd < 0 || !buf->size)
  672. continue;
  673. iova = msm_cvp_map_user_persist_buf(inst, buf);
  674. if (!iova) {
  675. dprintk(CVP_ERR,
  676. "%s: buf %d register failed.\n",
  677. __func__, i);
  678. return -EINVAL;
  679. }
  680. buf->fd = iova;
  681. }
  682. return 0;
  683. }
  684. int msm_cvp_map_frame(struct msm_cvp_inst *inst,
  685. struct eva_kmd_hfi_packet *in_pkt,
  686. unsigned int offset, unsigned int buf_num)
  687. {
  688. struct cvp_buf_type *buf;
  689. int i;
  690. u32 iova;
  691. u64 ktid;
  692. struct msm_cvp_frame *frame;
  693. struct cvp_hfi_cmd_session_hdr *cmd_hdr;
  694. if (!offset || !buf_num)
  695. return 0;
  696. cmd_hdr = (struct cvp_hfi_cmd_session_hdr *)in_pkt;
  697. ktid = atomic64_inc_return(&inst->core->kernel_trans_id);
  698. ktid &= (FENCE_BIT - 1);
  699. cmd_hdr->client_data.kdata = ktid;
  700. frame = kmem_cache_zalloc(cvp_driver->frame_cache, GFP_KERNEL);
  701. if (!frame)
  702. return -ENOMEM;
  703. frame->ktid = ktid;
  704. frame->nr = 0;
  705. frame->pkt_type = cmd_hdr->packet_type;
  706. for (i = 0; i < buf_num; i++) {
  707. buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
  708. offset += sizeof(*buf) >> 2;
  709. if (buf->fd < 0 || !buf->size)
  710. continue;
  711. iova = msm_cvp_map_frame_buf(inst, buf, frame);
  712. if (!iova) {
  713. dprintk(CVP_ERR,
  714. "%s: buf %d register failed.\n",
  715. __func__, i);
  716. msm_cvp_unmap_frame_buf(inst, frame);
  717. return -EINVAL;
  718. }
  719. buf->fd = iova;
  720. }
  721. mutex_lock(&inst->frames.lock);
  722. list_add_tail(&frame->list, &inst->frames.list);
  723. mutex_unlock(&inst->frames.lock);
  724. dprintk(CVP_MEM, "%s: map frame %llu\n", __func__, ktid);
  725. return 0;
  726. }
  727. int msm_cvp_session_deinit_buffers(struct msm_cvp_inst *inst)
  728. {
  729. int rc = 0, i;
  730. struct cvp_internal_buf *cbuf, *dummy;
  731. struct msm_cvp_frame *frame, *dummy1;
  732. struct msm_cvp_smem *smem;
  733. struct cvp_hal_session *session;
  734. session = (struct cvp_hal_session *)inst->session;
  735. mutex_lock(&inst->frames.lock);
  736. list_for_each_entry_safe(frame, dummy1, &inst->frames.list, list) {
  737. list_del(&frame->list);
  738. msm_cvp_unmap_frame_buf(inst, frame);
  739. }
  740. mutex_unlock(&inst->frames.lock);
  741. mutex_lock(&inst->dma_cache.lock);
  742. for (i = 0; i < inst->dma_cache.nr; i++) {
  743. smem = inst->dma_cache.entries[i];
  744. if (atomic_read(&smem->refcount) == 0) {
  745. print_smem(CVP_MEM, "free", inst, smem);
  746. } else if (!(smem->flags & SMEM_PERSIST)) {
  747. print_smem(CVP_WARN, "in use", inst, smem);
  748. }
  749. msm_cvp_unmap_smem(inst, smem, "unmap cpu");
  750. msm_cvp_smem_put_dma_buf(smem->dma_buf);
  751. kmem_cache_free(cvp_driver->smem_cache, smem);
  752. inst->dma_cache.entries[i] = NULL;
  753. }
  754. mutex_unlock(&inst->dma_cache.lock);
  755. mutex_lock(&inst->cvpdspbufs.lock);
  756. list_for_each_entry_safe(cbuf, dummy, &inst->cvpdspbufs.list, list) {
  757. print_internal_buffer(CVP_MEM, "remove dspbufs", inst, cbuf);
  758. if (cbuf->ownership == CLIENT) {
  759. rc = cvp_dsp_deregister_buffer(hash32_ptr(session),
  760. cbuf->fd, cbuf->smem->dma_buf->size, cbuf->size,
  761. cbuf->offset, cbuf->index,
  762. (uint32_t)cbuf->smem->device_addr);
  763. if (rc)
  764. dprintk(CVP_ERR,
  765. "%s: failed dsp deregistration fd=%d rc=%d",
  766. __func__, cbuf->fd, rc);
  767. msm_cvp_unmap_smem(inst, cbuf->smem, "unmap dsp");
  768. msm_cvp_smem_put_dma_buf(cbuf->smem->dma_buf);
  769. } else if (cbuf->ownership == DSP) {
  770. rc = cvp_dsp_fastrpc_unmap(inst->process_id, cbuf);
  771. if (rc)
  772. dprintk(CVP_ERR,
  773. "%s: failed to unmap buf from DSP\n",
  774. __func__);
  775. rc = cvp_release_dsp_buffers(inst, cbuf);
  776. if (rc)
  777. dprintk(CVP_ERR,
  778. "%s Fail to free buffer 0x%x\n",
  779. __func__, rc);
  780. }
  781. list_del(&cbuf->list);
  782. kmem_cache_free(cvp_driver->buf_cache, cbuf);
  783. }
  784. mutex_unlock(&inst->cvpdspbufs.lock);
  785. return rc;
  786. }
  787. void msm_cvp_print_inst_bufs(struct msm_cvp_inst *inst, bool log)
  788. {
  789. struct cvp_internal_buf *buf;
  790. struct msm_cvp_core *core;
  791. struct inst_snapshot *snap = NULL;
  792. int i;
  793. core = list_first_entry(&cvp_driver->cores, struct msm_cvp_core, list);
  794. if (log && core->log.snapshot_index < 16) {
  795. snap = &core->log.snapshot[core->log.snapshot_index];
  796. snap->session = inst->session;
  797. core->log.snapshot_index++;
  798. }
  799. if (!inst) {
  800. dprintk(CVP_ERR, "%s - invalid param %pK\n",
  801. __func__, inst);
  802. return;
  803. }
  804. dprintk(CVP_ERR, "active session cmd %d\n", inst->cur_cmd_type);
  805. dprintk(CVP_ERR,
  806. "---Buffer details for inst: %pK of type: %d---\n",
  807. inst, inst->session_type);
  808. mutex_lock(&inst->dma_cache.lock);
  809. dprintk(CVP_ERR, "dma cache: %d\n", inst->dma_cache.nr);
  810. if (inst->dma_cache.nr <= MAX_DMABUF_NUMS)
  811. for (i = 0; i < inst->dma_cache.nr; i++)
  812. _log_smem(snap, inst, inst->dma_cache.entries[i], log);
  813. mutex_unlock(&inst->dma_cache.lock);
  814. mutex_lock(&inst->cvpdspbufs.lock);
  815. dprintk(CVP_ERR, "dsp buffer list:\n");
  816. list_for_each_entry(buf, &inst->cvpdspbufs.list, list)
  817. _log_buf(snap, SMEM_ADSP, inst, buf, log);
  818. mutex_unlock(&inst->cvpdspbufs.lock);
  819. mutex_lock(&inst->persistbufs.lock);
  820. dprintk(CVP_ERR, "persist buffer list:\n");
  821. list_for_each_entry(buf, &inst->persistbufs.list, list)
  822. _log_buf(snap, SMEM_PERSIST, inst, buf, log);
  823. mutex_unlock(&inst->persistbufs.lock);
  824. }
  825. struct cvp_internal_buf *cvp_allocate_arp_bufs(struct msm_cvp_inst *inst,
  826. u32 buffer_size)
  827. {
  828. struct cvp_internal_buf *buf;
  829. struct msm_cvp_list *buf_list;
  830. u32 smem_flags = SMEM_UNCACHED;
  831. int rc = 0;
  832. if (!inst) {
  833. dprintk(CVP_ERR, "%s Invalid input\n", __func__);
  834. return NULL;
  835. }
  836. buf_list = &inst->persistbufs;
  837. if (!buffer_size)
  838. return NULL;
  839. /* PERSIST buffer requires secure mapping
  840. * Disable and wait for hyp_assign available
  841. */
  842. smem_flags |= SMEM_SECURE | SMEM_NON_PIXEL;
  843. buf = kmem_cache_zalloc(cvp_driver->buf_cache, GFP_KERNEL);
  844. if (!buf) {
  845. dprintk(CVP_ERR, "%s Out of memory\n", __func__);
  846. goto fail_kzalloc;
  847. }
  848. buf->smem = kmem_cache_zalloc(cvp_driver->smem_cache, GFP_KERNEL);
  849. if (!buf->smem) {
  850. dprintk(CVP_ERR, "%s Out of memory\n", __func__);
  851. goto fail_kzalloc;
  852. }
  853. buf->smem->flags = smem_flags;
  854. rc = msm_cvp_smem_alloc(buffer_size, 1, 0,
  855. &(inst->core->resources), buf->smem);
  856. if (rc) {
  857. dprintk(CVP_ERR, "Failed to allocate ARP memory\n");
  858. goto err_no_mem;
  859. }
  860. buf->size = buf->smem->size;
  861. buf->type = HFI_BUFFER_INTERNAL_PERSIST_1;
  862. buf->ownership = DRIVER;
  863. mutex_lock(&buf_list->lock);
  864. list_add_tail(&buf->list, &buf_list->list);
  865. mutex_unlock(&buf_list->lock);
  866. return buf;
  867. err_no_mem:
  868. kmem_cache_free(cvp_driver->buf_cache, buf);
  869. fail_kzalloc:
  870. return NULL;
  871. }
  872. int cvp_release_arp_buffers(struct msm_cvp_inst *inst)
  873. {
  874. struct msm_cvp_smem *smem;
  875. struct list_head *ptr, *next;
  876. struct cvp_internal_buf *buf;
  877. int rc = 0;
  878. struct msm_cvp_core *core;
  879. struct cvp_hfi_device *hdev;
  880. if (!inst) {
  881. dprintk(CVP_ERR, "Invalid instance pointer = %pK\n", inst);
  882. return -EINVAL;
  883. }
  884. core = inst->core;
  885. if (!core) {
  886. dprintk(CVP_ERR, "Invalid core pointer = %pK\n", core);
  887. return -EINVAL;
  888. }
  889. hdev = core->device;
  890. if (!hdev) {
  891. dprintk(CVP_ERR, "Invalid device pointer = %pK\n", hdev);
  892. return -EINVAL;
  893. }
  894. dprintk(CVP_MEM, "release persist buffer!\n");
  895. mutex_lock(&inst->persistbufs.lock);
  896. /* Workaround for FW: release buffer means release all */
  897. if (inst->state <= MSM_CVP_CLOSE_DONE) {
  898. rc = call_hfi_op(hdev, session_release_buffers,
  899. (void *)inst->session);
  900. if (!rc) {
  901. mutex_unlock(&inst->persistbufs.lock);
  902. rc = wait_for_sess_signal_receipt(inst,
  903. HAL_SESSION_RELEASE_BUFFER_DONE);
  904. if (rc)
  905. dprintk(CVP_WARN,
  906. "%s: wait for signal failed, rc %d\n",
  907. __func__, rc);
  908. mutex_lock(&inst->persistbufs.lock);
  909. } else {
  910. dprintk(CVP_WARN, "Fail to send Rel prst buf\n");
  911. }
  912. }
  913. list_for_each_safe(ptr, next, &inst->persistbufs.list) {
  914. buf = list_entry(ptr, struct cvp_internal_buf, list);
  915. smem = buf->smem;
  916. if (!smem) {
  917. dprintk(CVP_ERR, "%s invalid smem\n", __func__);
  918. mutex_unlock(&inst->persistbufs.lock);
  919. return -EINVAL;
  920. }
  921. list_del(&buf->list);
  922. if (buf->ownership == DRIVER) {
  923. dprintk(CVP_MEM,
  924. "%s: %x : fd %d %s size %d",
  925. "free arp", hash32_ptr(inst->session), buf->fd,
  926. smem->dma_buf->name, buf->size);
  927. msm_cvp_smem_free(smem);
  928. kmem_cache_free(cvp_driver->smem_cache, smem);
  929. }
  930. buf->smem = NULL;
  931. kmem_cache_free(cvp_driver->buf_cache, buf);
  932. }
  933. mutex_unlock(&inst->persistbufs.lock);
  934. return rc;
  935. }
  936. int cvp_allocate_dsp_bufs(struct msm_cvp_inst *inst,
  937. struct cvp_internal_buf *buf,
  938. u32 buffer_size,
  939. u32 secure_type)
  940. {
  941. u32 smem_flags = SMEM_UNCACHED;
  942. int rc = 0;
  943. if (!inst) {
  944. dprintk(CVP_ERR, "%s Invalid input\n", __func__);
  945. return -EINVAL;
  946. }
  947. if (!buf)
  948. return -EINVAL;
  949. if (!buffer_size)
  950. return -EINVAL;
  951. switch (secure_type) {
  952. case 0:
  953. break;
  954. case 1:
  955. smem_flags |= SMEM_SECURE | SMEM_PIXEL;
  956. break;
  957. case 2:
  958. smem_flags |= SMEM_SECURE | SMEM_NON_PIXEL;
  959. break;
  960. default:
  961. dprintk(CVP_ERR, "%s Invalid secure_type %d\n",
  962. __func__, secure_type);
  963. return -EINVAL;
  964. }
  965. dprintk(CVP_MEM, "%s smem_flags 0x%x\n", __func__, smem_flags);
  966. buf->smem = kmem_cache_zalloc(cvp_driver->smem_cache, GFP_KERNEL);
  967. if (!buf->smem) {
  968. dprintk(CVP_ERR, "%s Out of memory\n", __func__);
  969. goto fail_kzalloc_smem_cache;
  970. }
  971. buf->smem->flags = smem_flags;
  972. rc = msm_cvp_smem_alloc(buffer_size, 1, 0,
  973. &(inst->core->resources), buf->smem);
  974. if (rc) {
  975. dprintk(CVP_ERR, "Failed to allocate ARP memory\n");
  976. goto err_no_mem;
  977. }
  978. dprintk(CVP_MEM, "%s dma_buf %pK\n", __func__, buf->smem->dma_buf);
  979. buf->size = buf->smem->size;
  980. buf->type = HFI_BUFFER_INTERNAL_PERSIST_1;
  981. buf->ownership = DSP;
  982. return rc;
  983. err_no_mem:
  984. kmem_cache_free(cvp_driver->smem_cache, buf->smem);
  985. fail_kzalloc_smem_cache:
  986. return rc;
  987. }
  988. int cvp_release_dsp_buffers(struct msm_cvp_inst *inst,
  989. struct cvp_internal_buf *buf)
  990. {
  991. struct msm_cvp_smem *smem;
  992. int rc = 0;
  993. if (!inst) {
  994. dprintk(CVP_ERR, "Invalid instance pointer = %pK\n", inst);
  995. return -EINVAL;
  996. }
  997. if (!buf) {
  998. dprintk(CVP_ERR, "Invalid buffer pointer = %pK\n", inst);
  999. return -EINVAL;
  1000. }
  1001. smem = buf->smem;
  1002. if (!smem) {
  1003. dprintk(CVP_ERR, "%s invalid smem\n", __func__);
  1004. return -EINVAL;
  1005. }
  1006. if (buf->ownership == DSP) {
  1007. dprintk(CVP_MEM,
  1008. "%s: %x : fd %x %s size %d",
  1009. __func__, hash32_ptr(inst->session), buf->fd,
  1010. smem->dma_buf->name, buf->size);
  1011. msm_cvp_smem_free(smem);
  1012. kmem_cache_free(cvp_driver->smem_cache, smem);
  1013. } else {
  1014. dprintk(CVP_ERR,
  1015. "%s: wrong owner %d %x : fd %x %s size %d",
  1016. __func__, buf->ownership, hash32_ptr(inst->session),
  1017. buf->fd, smem->dma_buf->name, buf->size);
  1018. }
  1019. return rc;
  1020. }
  1021. int msm_cvp_register_buffer(struct msm_cvp_inst *inst,
  1022. struct eva_kmd_buffer *buf)
  1023. {
  1024. struct cvp_hfi_device *hdev;
  1025. struct cvp_hal_session *session;
  1026. struct msm_cvp_inst *s;
  1027. int rc = 0;
  1028. if (!inst || !inst->core || !buf) {
  1029. dprintk(CVP_ERR, "%s: invalid params\n", __func__);
  1030. return -EINVAL;
  1031. }
  1032. if (!buf->index)
  1033. return 0;
  1034. s = cvp_get_inst_validate(inst->core, inst);
  1035. if (!s)
  1036. return -ECONNRESET;
  1037. inst->cur_cmd_type = EVA_KMD_REGISTER_BUFFER;
  1038. session = (struct cvp_hal_session *)inst->session;
  1039. if (!session) {
  1040. dprintk(CVP_ERR, "%s: invalid session\n", __func__);
  1041. rc = -EINVAL;
  1042. goto exit;
  1043. }
  1044. hdev = inst->core->device;
  1045. print_client_buffer(CVP_HFI, "register", inst, buf);
  1046. rc = msm_cvp_map_buf_dsp(inst, buf);
  1047. dprintk(CVP_DSP, "%s: fd %d, iova 0x%x\n", __func__,
  1048. buf->fd, buf->reserved[0]);
  1049. exit:
  1050. inst->cur_cmd_type = 0;
  1051. cvp_put_inst(s);
  1052. return rc;
  1053. }
  1054. int msm_cvp_unregister_buffer(struct msm_cvp_inst *inst,
  1055. struct eva_kmd_buffer *buf)
  1056. {
  1057. struct msm_cvp_inst *s;
  1058. int rc = 0;
  1059. if (!inst || !inst->core || !buf) {
  1060. dprintk(CVP_ERR, "%s: invalid params\n", __func__);
  1061. return -EINVAL;
  1062. }
  1063. if (!buf->index)
  1064. return 0;
  1065. s = cvp_get_inst_validate(inst->core, inst);
  1066. if (!s)
  1067. return -ECONNRESET;
  1068. inst->cur_cmd_type = EVA_KMD_UNREGISTER_BUFFER;
  1069. print_client_buffer(CVP_HFI, "unregister", inst, buf);
  1070. rc = msm_cvp_unmap_buf_dsp(inst, buf);
  1071. inst->cur_cmd_type = 0;
  1072. cvp_put_inst(s);
  1073. return rc;
  1074. }