jdi.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875
  1. // SPDX-License-Identifier: LGPL-2.1 OR BSD-3-Clause
  2. /*
  3. * Copyright (c) 2018, Chips&Media
  4. * All rights reserved.
  5. *
  6. * Redistribution and use in source and binary forms, with or without
  7. * modification, are permitted provided that the following conditions are met:
  8. *
  9. * 1. Redistributions of source code must retain the above copyright notice, this
  10. * list of conditions and the following disclaimer.
  11. * 2. Redistributions in binary form must reproduce the above copyright notice,
  12. * this list of conditions and the following disclaimer in the documentation
  13. * and/or other materials provided with the distribution.
  14. *
  15. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  16. * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  17. * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  18. * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
  19. * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  20. * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  21. * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  22. * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  24. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25. */
  26. #if defined(linux) || defined(__linux) || defined(ANDROID)
  27. #include <ctype.h>
  28. #include <stdio.h>
  29. #include <stdlib.h>
  30. #include <string.h>
  31. #include <stdarg.h>
  32. #include <unistd.h>
  33. #ifdef _KERNEL_
  34. #include <linux/delay.h>
  35. #endif
  36. #include <signal.h> /* SIGIO */
  37. #include <fcntl.h> /* fcntl */
  38. #include <pthread.h>
  39. #include <sys/mman.h> /* mmap */
  40. #include <sys/ioctl.h> /* fopen/fread */
  41. #include <sys/errno.h> /* fopen/fread */
  42. #include <sys/types.h>
  43. #include <sys/time.h>
  44. #include <termios.h>
  45. #include "driver/jpu.h"
  46. #include "../jdi.h"
  47. #include "jpulog.h"
  48. #include "jputypes.h"
  49. #include "regdefine.h"
  50. #define JPU_DEVICE_NAME "/dev/jpu"
  51. #define JDI_INSTANCE_POOL_SIZE sizeof(jpu_instance_pool_t)
  52. #define JDI_INSTANCE_POOL_TOTAL_SIZE (JDI_INSTANCE_POOL_SIZE + sizeof(MUTEX_HANDLE)*JDI_NUM_LOCK_HANDLES)
  53. typedef pthread_mutex_t MUTEX_HANDLE;
  54. #endif /* CNM_FPGA_PLATFORM */
  55. /***********************************************************************************
  56. *
  57. ***********************************************************************************/
  58. #define JDI_DRAM_PHYSICAL_BASE 0x00
  59. #define JDI_DRAM_PHYSICAL_SIZE (64*1024*1024)
  60. #define JDI_SYSTEM_ENDIAN JDI_LITTLE_ENDIAN
  61. #define JPU_REG_SIZE 0x300
  62. #define JDI_NUM_LOCK_HANDLES 4
  63. typedef struct jpudrv_buffer_pool_t
  64. {
  65. jpudrv_buffer_t jdb;
  66. BOOL inuse;
  67. } jpudrv_buffer_pool_t;
  68. typedef struct {
  69. Int32 jpu_fd;
  70. jpu_instance_pool_t* pjip;
  71. Int32 task_num;
  72. Int32 clock_state;
  73. jpudrv_buffer_t jdb_register;
  74. jpudrv_buffer_pool_t jpu_buffer_pool[MAX_JPU_BUFFER_POOL];
  75. Int32 jpu_buffer_pool_count;
  76. void* jpu_mutex;
  77. } jdi_info_t;
  78. static jdi_info_t s_jdi_info;
  79. static Int32 swap_endian(BYTE* data, Uint32 len, Uint32 endian);
  80. void jdi_flush_ddr(unsigned long start,unsigned long size,unsigned char flag)
  81. {
  82. jdi_info_t *jdi;
  83. jpudrv_flush_cache_t cache_info;
  84. jdi = &s_jdi_info;
  85. cache_info.start = start;
  86. cache_info.size = size;
  87. cache_info.flag = flag;
  88. ioctl(jdi->jpu_fd, JDI_IOCTL_FLUSH_DCACHE, &cache_info);
  89. }
  90. int jdi_probe()
  91. {
  92. int ret;
  93. ret = jdi_init();
  94. jdi_release();
  95. return ret;
  96. }
  97. /* @return number of tasks.
  98. */
  99. int jdi_get_task_num()
  100. {
  101. jdi_info_t *jdi;
  102. jdi = &s_jdi_info;
  103. if (jdi->jpu_fd == -1 || jdi->jpu_fd == 0x00) {
  104. return 0;
  105. }
  106. return jdi->task_num;
  107. }
  108. int jdi_init()
  109. {
  110. jdi_info_t *jdi;
  111. int i;
  112. jdi = &s_jdi_info;
  113. if (jdi->jpu_fd != -1 && jdi->jpu_fd != 0x00)
  114. {
  115. jdi_lock();
  116. jdi->task_num++;
  117. jdi_unlock();
  118. return 0;
  119. }
  120. #ifdef ANDROID
  121. system("/system/lib/modules/load_android.sh");
  122. #endif /* ANDROID */
  123. jdi->jpu_fd = open(JPU_DEVICE_NAME, O_RDWR);
  124. if (jdi->jpu_fd < 0) {
  125. JLOG(ERR, "[JDI] Can't open jpu driver. [error=%s]. try to load jpu driver first \n", strerror(errno));
  126. return -1;
  127. }
  128. memset(jdi->jpu_buffer_pool, 0x00, sizeof(jpudrv_buffer_pool_t)*MAX_JPU_BUFFER_POOL);
  129. if (!jdi_get_instance_pool()) {
  130. JLOG(ERR, "[JDI] fail to create instance pool for saving context \n");
  131. goto ERR_JDI_INIT;
  132. }
  133. if (jdi->pjip->instance_pool_inited == FALSE) {
  134. Uint32* pCodecInst;
  135. pthread_mutexattr_t mutexattr;
  136. pthread_mutexattr_init(&mutexattr);
  137. pthread_mutexattr_setpshared(&mutexattr, PTHREAD_PROCESS_SHARED);
  138. #if defined(ANDROID) || !defined(PTHREAD_MUTEX_ROBUST_NP)
  139. #else
  140. /* If a process or a thread is terminated abnormally,
  141. * pthread_mutexattr_setrobust_np(attr, PTHREAD_MUTEX_ROBUST_NP) makes
  142. * next onwer call pthread_mutex_lock() without deadlock.
  143. */
  144. pthread_mutexattr_setrobust_np(&mutexattr, PTHREAD_MUTEX_ROBUST_NP);
  145. #endif
  146. pthread_mutex_init((MUTEX_HANDLE *)jdi->jpu_mutex, &mutexattr);
  147. for( i = 0; i < MAX_NUM_INSTANCE; i++) {
  148. pCodecInst = (Uint32*)jdi->pjip->jpgInstPool[i];
  149. pCodecInst[1] = i; // indicate instIndex of CodecInst
  150. pCodecInst[0] = 0; // indicate inUse of CodecInst
  151. }
  152. jdi->pjip->instance_pool_inited = TRUE;
  153. }
  154. if (ioctl(jdi->jpu_fd, JDI_IOCTL_GET_REGISTER_INFO, &jdi->jdb_register) < 0)
  155. {
  156. JLOG(ERR, "[JDI] fail to get host interface register\n");
  157. goto ERR_JDI_INIT;
  158. }
  159. jdi->jdb_register.virt_addr = (unsigned long)mmap(NULL, jdi->jdb_register.size, PROT_READ | PROT_WRITE, MAP_SHARED, jdi->jpu_fd, jdi->jdb_register.phys_addr);
  160. if (jdi->jdb_register.virt_addr == (unsigned long)MAP_FAILED) {
  161. JLOG(ERR, "[JDI] fail to map jpu registers \n");
  162. goto ERR_JDI_INIT;
  163. }
  164. JLOG(INFO, "[JDI] map jdb_register virtaddr=0x%lx, size=%d\n", jdi->jdb_register.virt_addr, jdi->jdb_register.size);
  165. jdi_set_clock_gate(1);
  166. if (jdi_lock() < 0)
  167. {
  168. JLOG(ERR, "[JDI] fail to handle lock function\n");
  169. goto ERR_JDI_INIT;
  170. }
  171. jdi->task_num++;
  172. jdi_unlock();
  173. JLOG(INFO, "[JDI] success to init driver \n");
  174. return 0;
  175. ERR_JDI_INIT:
  176. jdi_unlock();
  177. jdi_release();
  178. return -1;
  179. }
  180. int jdi_release()
  181. {
  182. jdi_info_t *jdi;
  183. jdi = &s_jdi_info;
  184. if (!jdi || jdi->jpu_fd == -1 || jdi->jpu_fd == 0x00) {
  185. return 0;
  186. }
  187. if (jdi_lock() < 0) {
  188. JLOG(ERR, "[JDI] fail to handle lock function\n");
  189. return -1;
  190. }
  191. if (jdi->task_num == 0) {
  192. JLOG(ERR, "[JDI] %s:%d task_num is 0\n", __FUNCTION__, __LINE__);
  193. jdi_unlock();
  194. return 0;
  195. }
  196. jdi->task_num--;
  197. if (jdi->task_num > 0) {// means that the opened instance remains
  198. jdi_unlock();
  199. return 0;
  200. }
  201. if (jdi->jdb_register.virt_addr) {
  202. if (munmap((void *)jdi->jdb_register.virt_addr, jdi->jdb_register.size) < 0) { //lint !e511
  203. JLOG(ERR, "%s:%d failed to munmap\n", __FUNCTION__, __LINE__);
  204. }
  205. }
  206. memset(&jdi->jdb_register, 0x00, sizeof(jpudrv_buffer_t));
  207. jdi_unlock();
  208. if (jdi->jpu_fd != -1 && jdi->jpu_fd != 0x00) {
  209. if (jdi->pjip != NULL) {
  210. if (munmap((void*)jdi->pjip, JDI_INSTANCE_POOL_TOTAL_SIZE) < 0) {
  211. JLOG(ERR, "%s:%d failed to munmap\n", __FUNCTION__, __LINE__);
  212. }
  213. }
  214. close(jdi->jpu_fd);
  215. }
  216. memset(jdi, 0x00, sizeof(jdi_info_t));
  217. return 0;
  218. }
  219. jpu_instance_pool_t *jdi_get_instance_pool()
  220. {
  221. jdi_info_t *jdi;
  222. jpudrv_buffer_t jdb;
  223. jdi = &s_jdi_info;
  224. if(!jdi || jdi->jpu_fd == -1 || jdi->jpu_fd == 0x00 )
  225. return NULL;
  226. memset(&jdb, 0x00, sizeof(jpudrv_buffer_t));
  227. if (!jdi->pjip) {
  228. jdb.size = JDI_INSTANCE_POOL_TOTAL_SIZE;
  229. if (ioctl(jdi->jpu_fd, JDI_IOCTL_GET_INSTANCE_POOL, &jdb) < 0) {
  230. JLOG(ERR, "[JDI] fail to allocate get instance pool physical space=%d\n", (int)jdb.size);
  231. return NULL;
  232. }
  233. jdb.virt_addr = (unsigned long)mmap(NULL, jdb.size, PROT_READ | PROT_WRITE, MAP_SHARED, jdi->jpu_fd, 0);
  234. if (jdb.virt_addr == (unsigned long)MAP_FAILED) {
  235. JLOG(ERR, "[JDI] fail to map instance pool phyaddr=0x%lx, size = %d\n", (int)jdb.phys_addr, (int)jdb.size);
  236. return NULL;
  237. }
  238. jdi->pjip = (jpu_instance_pool_t *)jdb.virt_addr;//lint !e511
  239. //change the pointer of jpu_mutex to at end pointer of jpu_instance_pool_t to assign at allocated position.
  240. jdi->jpu_mutex = (void *)((unsigned long)jdi->pjip + JDI_INSTANCE_POOL_SIZE); //lint !e511
  241. JLOG(INFO, "[JDI] instance pool physaddr=%p, virtaddr=%p, base=%p, size=%d\n", jdb.phys_addr, jdb.virt_addr, jdb.base, jdb.size);
  242. }
  243. return (jpu_instance_pool_t *)jdi->pjip;
  244. }
  245. int jdi_open_instance(unsigned long inst_idx)
  246. {
  247. jdi_info_t *jdi;
  248. jpudrv_inst_info_t inst_info;
  249. jdi = &s_jdi_info;
  250. if(!jdi || jdi->jpu_fd == -1 || jdi->jpu_fd == 0x00)
  251. return -1;
  252. inst_info.inst_idx = inst_idx;
  253. if (ioctl(jdi->jpu_fd, JDI_IOCTL_OPEN_INSTANCE, &inst_info) < 0)
  254. {
  255. JLOG(ERR, "[JDI] fail to deliver open instance num inst_idx=%d\n", (int)inst_idx);
  256. return -1;
  257. }
  258. jdi->pjip->jpu_instance_num = inst_info.inst_open_count;
  259. return 0;
  260. }
  261. int jdi_close_instance(unsigned long inst_idx)
  262. {
  263. jdi_info_t *jdi;
  264. jpudrv_inst_info_t inst_info;
  265. jdi = &s_jdi_info;
  266. if(!jdi || jdi->jpu_fd == -1 || jdi->jpu_fd == 0x00)
  267. return -1;
  268. inst_info.inst_idx = inst_idx;
  269. if (ioctl(jdi->jpu_fd, JDI_IOCTL_CLOSE_INSTANCE, &inst_info) < 0)
  270. {
  271. JLOG(ERR, "[JDI] fail to deliver open instance num inst_idx=%d\n", (int)inst_idx);
  272. return -1;
  273. }
  274. jdi->pjip->jpu_instance_num = inst_info.inst_open_count;
  275. return 0;
  276. }
  277. int jdi_get_instance_num()
  278. {
  279. jdi_info_t *jdi;
  280. jdi = &s_jdi_info;
  281. if(!jdi || jdi->jpu_fd == -1 || jdi->jpu_fd == 0x00)
  282. return -1;
  283. return jdi->pjip->jpu_instance_num;
  284. }
  285. int jdi_hw_reset()
  286. {
  287. jdi_info_t *jdi;
  288. jdi = &s_jdi_info;
  289. if(!jdi || jdi->jpu_fd == -1 || jdi->jpu_fd == 0x00)
  290. return -1;
  291. return ioctl(jdi->jpu_fd, JDI_IOCTL_RESET, 0);
  292. }
  293. static void restore_mutex_in_dead(MUTEX_HANDLE *mutex)
  294. {
  295. int mutex_value;
  296. if (!mutex)
  297. return;
  298. #if defined(ANDROID)
  299. mutex_value = mutex->value;
  300. #else
  301. memcpy(&mutex_value, mutex, sizeof(mutex_value));
  302. #endif
  303. if (mutex_value == (int)0xdead10cc) // destroy by device driver
  304. {
  305. pthread_mutexattr_t mutexattr;
  306. pthread_mutexattr_init(&mutexattr);
  307. pthread_mutexattr_setpshared(&mutexattr, PTHREAD_PROCESS_SHARED);
  308. pthread_mutex_init(mutex, &mutexattr);
  309. }
  310. }
  311. int jdi_lock()
  312. {
  313. jdi_info_t *jdi = &s_jdi_info;
  314. if(!jdi || jdi->jpu_fd == -1 || jdi->jpu_fd == 0x00) {
  315. JLOG(ERR, "%s:%d JDI handle isn't initialized\n", __FUNCTION__, __LINE__);
  316. return -1;
  317. }
  318. #if defined(ANDROID) || !defined(PTHREAD_MUTEX_ROBUST_NP)
  319. restore_mutex_in_dead((MUTEX_HANDLE *)jdi->jpu_mutex);
  320. pthread_mutex_lock((MUTEX_HANDLE*)jdi->jpu_mutex);
  321. #else
  322. if (pthread_mutex_lock(&jdi->jpu_mutex) != 0) {
  323. JLOG(ERR, "%s:%d failed to pthread_mutex_locK\n", __FUNCTION__, __LINE__);
  324. return -1;
  325. }
  326. #endif
  327. return 0;//lint !e454
  328. }
  329. void jdi_unlock()
  330. {
  331. jdi_info_t *jdi;
  332. jdi = &s_jdi_info;
  333. if(!jdi || jdi->jpu_fd <= 0)
  334. return;
  335. pthread_mutex_unlock((MUTEX_HANDLE *)jdi->jpu_mutex);//lint !e455
  336. }
  337. void jdi_write_register(unsigned long addr, unsigned long data)
  338. {
  339. jdi_info_t *jdi;
  340. unsigned long *reg_addr;
  341. jdi = &s_jdi_info;
  342. if(!jdi || jdi->jpu_fd == -1 || jdi->jpu_fd == 0x00)
  343. return;
  344. reg_addr = (unsigned long *)(addr + (unsigned long)jdi->jdb_register.virt_addr);
  345. *(volatile unsigned int *)reg_addr = data;
  346. }
  347. unsigned long jdi_read_register(unsigned long addr)
  348. {
  349. jdi_info_t *jdi;
  350. unsigned long *reg_addr;
  351. jdi = &s_jdi_info;
  352. if(!jdi || jdi->jpu_fd == -1 || jdi->jpu_fd == 0x00)
  353. return (unsigned int)-1;
  354. reg_addr = (unsigned long *)(addr + (unsigned long)jdi->jdb_register.virt_addr);
  355. return *(volatile unsigned int *)reg_addr;
  356. }
  357. int jdi_write_memory(unsigned long addr, unsigned char *data, int len, int endian)
  358. {
  359. jdi_info_t *jdi;
  360. jpudrv_buffer_t jdb;
  361. Uint32 offset;
  362. Uint32 i;
  363. jdi = &s_jdi_info;
  364. if(!jdi || jdi->jpu_fd==-1 || jdi->jpu_fd == 0x00)
  365. return -1;
  366. memset(&jdb, 0x00, sizeof(jpudrv_buffer_t));
  367. for (i=0; i<MAX_JPU_BUFFER_POOL; i++)
  368. {
  369. if (jdi->jpu_buffer_pool[i].inuse == 1)
  370. {
  371. jdb = jdi->jpu_buffer_pool[i].jdb;
  372. if (addr >= jdb.phys_addr && addr < (jdb.phys_addr + jdb.size)) {
  373. break;
  374. }
  375. }
  376. }
  377. if (i == MAX_JPU_BUFFER_POOL) {
  378. JLOG(ERR, "%s NOT FOUND ADDRESS: %#lx\n", __FUNCTION__, addr);
  379. return -1;
  380. }
  381. if (!jdb.size) {
  382. JLOG(ERR, "address 0x%08x is not mapped address!!!\n", (int)addr);
  383. return -1;
  384. }
  385. offset = addr - (unsigned long)jdb.phys_addr;
  386. swap_endian(data, len, endian);
  387. memcpy((void *)((unsigned long)jdb.virt_addr+offset), data, len);
  388. jdi_flush_ddr((unsigned long )(jdb.phys_addr+offset),len,1);
  389. return len;
  390. }
  391. int jdi_read_memory(unsigned long addr, unsigned char *data, int len, int endian)
  392. {
  393. jdi_info_t *jdi;
  394. jpudrv_buffer_t jdb;
  395. unsigned long offset;
  396. int i;
  397. jdi = &s_jdi_info;
  398. if(!jdi || jdi->jpu_fd==-1 || jdi->jpu_fd == 0x00)
  399. return -1;
  400. memset(&jdb, 0x00, sizeof(jpudrv_buffer_t));
  401. for (i=0; i<MAX_JPU_BUFFER_POOL; i++)
  402. {
  403. if (jdi->jpu_buffer_pool[i].inuse == 1)
  404. {
  405. jdb = jdi->jpu_buffer_pool[i].jdb;
  406. if (addr >= jdb.phys_addr && addr < (jdb.phys_addr + jdb.size))
  407. break;
  408. }
  409. }
  410. if (len == 0) {
  411. return 0;
  412. }
  413. if (!jdb.size)
  414. return -1;
  415. offset = addr - (unsigned long)jdb.phys_addr;
  416. jdi_flush_ddr((unsigned long )(jdb.phys_addr+offset),len,1);
  417. memcpy(data, (const void *)((unsigned long)jdb.virt_addr+offset), len);
  418. swap_endian(data, len, endian);
  419. return len;
  420. }
  421. int jdi_attach_dma_memory(jpu_buffer_t *vb)
  422. {
  423. jdi_info_t *jdi;
  424. int i;
  425. jpudrv_buffer_t jdb;
  426. jdi = &s_jdi_info;
  427. if(!jdi || jdi->jpu_fd==-1 || jdi->jpu_fd == 0x00)
  428. return -1;
  429. memset(&jdb, 0x00, sizeof(jpudrv_buffer_t));
  430. jdb.virt_addr = vb->virt_addr;
  431. if (ioctl(jdi->jpu_fd, JDI_IOCTL_GET_PHYSICAL_MEMORY, &jdb) < 0)
  432. {
  433. JLOG(ERR, "[JDI] fail to jdi_allocate_dma_memory size=%d\n", vb->size);
  434. return -1;
  435. }
  436. vb->phys_addr = (unsigned long)jdb.phys_addr;
  437. vb->base = (unsigned long)jdb.base;
  438. jdi_lock();
  439. for (i=0; i<MAX_JPU_BUFFER_POOL; i++)
  440. {
  441. if (jdi->jpu_buffer_pool[i].inuse == 0)
  442. {
  443. jdi->jpu_buffer_pool[i].jdb = jdb;
  444. jdi->jpu_buffer_pool_count++;
  445. jdi->jpu_buffer_pool[i].inuse = 1;
  446. break;
  447. }
  448. }
  449. jdi_unlock();
  450. JLOG(INFO, "[JDI] jdi_attach_dma_memory, physaddr=%p, virtaddr=%p~%p, size=%d\n",
  451. vb->phys_addr, vb->virt_addr, vb->virt_addr + vb->size, vb->size);
  452. return 0;
  453. }
  454. int jdi_allocate_dma_memory(jpu_buffer_t *vb)
  455. {
  456. jdi_info_t *jdi;
  457. int i;
  458. jpudrv_buffer_t jdb;
  459. jdi = &s_jdi_info;
  460. if(!jdi || jdi->jpu_fd==-1 || jdi->jpu_fd == 0x00)
  461. return -1;
  462. memset(&jdb, 0x00, sizeof(jpudrv_buffer_t));
  463. jdb.size = vb->size;
  464. if (ioctl(jdi->jpu_fd, JDI_IOCTL_ALLOCATE_PHYSICAL_MEMORY, &jdb) < 0)
  465. {
  466. JLOG(ERR, "[JDI] fail to jdi_allocate_dma_memory size=%d\n", vb->size);
  467. return -1;
  468. }
  469. vb->phys_addr = (unsigned long)jdb.phys_addr;
  470. vb->base = (unsigned long)jdb.base;
  471. //map to virtual address
  472. jdb.virt_addr = (unsigned long)mmap(NULL, jdb.size, PROT_READ | PROT_WRITE, MAP_SHARED, jdi->jpu_fd, MEM2SYS(jdb.phys_addr));
  473. if (jdb.virt_addr == (unsigned long)MAP_FAILED) {
  474. memset(vb, 0x00, sizeof(jpu_buffer_t));
  475. return -1;
  476. }
  477. vb->virt_addr = jdb.virt_addr;
  478. jdi_lock();
  479. for (i=0; i<MAX_JPU_BUFFER_POOL; i++)
  480. {
  481. if (jdi->jpu_buffer_pool[i].inuse == 0)
  482. {
  483. jdi->jpu_buffer_pool[i].jdb = jdb;
  484. jdi->jpu_buffer_pool_count++;
  485. jdi->jpu_buffer_pool[i].inuse = 1;
  486. break;
  487. }
  488. }
  489. jdi_unlock();
  490. JLOG(INFO, "[JDI] jdi_allocate_dma_memory, physaddr=%p, virtaddr=%p~%p, size=%d\n",
  491. vb->phys_addr, vb->virt_addr, vb->virt_addr + vb->size, vb->size);
  492. return 0;
  493. }
  494. void jdi_free_dma_memory(jpu_buffer_t *vb)
  495. {
  496. jdi_info_t *jdi;
  497. int i;
  498. jpudrv_buffer_t jdb;
  499. jdi = &s_jdi_info;
  500. if(!vb || !jdi || jdi->jpu_fd==-1 || jdi->jpu_fd == 0x00)
  501. return;
  502. if (vb->size == 0)
  503. return ;
  504. memset(&jdb, 0x00, sizeof(jpudrv_buffer_t));
  505. jdi_lock();
  506. for (i=0; i<MAX_JPU_BUFFER_POOL; i++) {
  507. if (jdi->jpu_buffer_pool[i].jdb.phys_addr == vb->phys_addr) {
  508. jdi->jpu_buffer_pool[i].inuse = 0;
  509. jdi->jpu_buffer_pool_count--;
  510. jdb = jdi->jpu_buffer_pool[i].jdb;
  511. break;
  512. }
  513. }
  514. jdi_unlock();
  515. if (!jdb.size)
  516. {
  517. JLOG(ERR, "[JDI] invalid buffer to free address = 0x%lx\n", (int)jdb.virt_addr);
  518. return ;
  519. }
  520. ioctl(jdi->jpu_fd, JDI_IOCTL_FREE_PHYSICALMEMORY, &jdb);
  521. if (munmap((void *)jdb.virt_addr, jdb.size) != 0) {
  522. JLOG(ERR, "[JDI] fail to jdi_free_dma_memory virtial address = 0x%lx\n", (int)jdb.virt_addr);
  523. }
  524. memset(vb, 0, sizeof(jpu_buffer_t));
  525. }
  526. int jdi_set_clock_gate(int enable)
  527. {
  528. jdi_info_t *jdi = NULL;
  529. int ret;
  530. jdi = &s_jdi_info;
  531. if(!jdi || jdi->jpu_fd==-1 || jdi->jpu_fd == 0x00)
  532. return -1;
  533. jdi->clock_state = enable;
  534. ret = ioctl(jdi->jpu_fd, JDI_IOCTL_SET_CLOCK_GATE, &enable);
  535. return ret;
  536. }
  537. int jdi_get_clock_gate()
  538. {
  539. jdi_info_t *jdi;
  540. int ret;
  541. jdi = &s_jdi_info;
  542. if(!jdi || jdi->jpu_fd==-1 || jdi->jpu_fd == 0x00)
  543. return -1;
  544. ret = jdi->clock_state;
  545. return ret;
  546. }
  547. int jdi_wait_inst_ctrl_busy(int timeout, unsigned int addr_flag_reg, unsigned int flag)
  548. {
  549. Int64 elapse, cur;
  550. unsigned int data_flag_reg;
  551. struct timeval tv;
  552. int retry_count;
  553. tv.tv_sec = 0;
  554. tv.tv_usec = 0;
  555. gettimeofday(&tv, NULL);
  556. elapse = tv.tv_sec*1000 + tv.tv_usec/1000;
  557. while(1)
  558. {
  559. data_flag_reg = jdi_read_register(addr_flag_reg);
  560. if (((data_flag_reg >> 4)&0xf) == flag)
  561. break;
  562. gettimeofday(&tv, NULL);
  563. cur = tv.tv_sec * 1000 + tv.tv_usec / 1000;
  564. if (timeout > 0 && (cur - elapse) > timeout)
  565. {
  566. for (retry_count=0; retry_count<10; retry_count++) {
  567. JLOG(ERR, "[VDI] jdi_wait_inst_ctrl_busy timeout, 0x%x=0x%lx\n", addr_flag_reg, jdi_read_register(addr_flag_reg));
  568. }
  569. return -1;
  570. }
  571. }
  572. return 0;
  573. }
  574. int jdi_wait_interrupt(int timeout, unsigned int addr_int_reason, unsigned long instIdx)
  575. {
  576. int intr_reason = 0;
  577. jdi_info_t *jdi;
  578. int ret;
  579. jpudrv_intr_info_t intr_info;
  580. jdi = &s_jdi_info;
  581. if(!jdi || jdi->jpu_fd <= 0)
  582. return -1;
  583. intr_info.timeout = timeout;
  584. intr_info.intr_reason = 0;
  585. intr_info.inst_idx = instIdx;
  586. ret = ioctl(jdi->jpu_fd, JDI_IOCTL_WAIT_INTERRUPT, (void*)&intr_info);
  587. if (ret != 0)
  588. return -1;
  589. intr_reason = intr_info.intr_reason;
  590. return intr_reason;
  591. }
  592. void jdi_log(int cmd, int step, int inst)
  593. {
  594. Int32 i;
  595. switch(cmd)
  596. {
  597. case JDI_LOG_CMD_PICRUN:
  598. if (step == 1) //
  599. JLOG(INFO, "\n**PIC_RUN INST=%d start\n", inst);
  600. else
  601. JLOG(INFO, "\n**PIC_RUN INST=%d end \n", inst);
  602. break;
  603. case JDI_LOG_CMD_INIT:
  604. if (step == 1) //
  605. JLOG(INFO, "\n**INIT INST=%d start\n", inst);
  606. else
  607. JLOG(INFO, "\n**INIT INST=%d end \n", inst);
  608. break;
  609. case JDI_LOG_CMD_RESET:
  610. if (step == 1) //
  611. JLOG(INFO, "\n**RESET INST=%d start\n", inst);
  612. else
  613. JLOG(INFO, "\n**RESET INST=%d end \n", inst);
  614. break;
  615. case JDI_LOG_CMD_PAUSE_INST_CTRL:
  616. if (step == 1) //
  617. JLOG(INFO, "\n**PAUSE INST_CTRL INST=%d start\n", inst);
  618. else
  619. JLOG(INFO, "\n**PAUSE INST_CTRL INST=%d end\n", inst);
  620. break;
  621. }
  622. for (i=(inst*NPT_REG_SIZE); i<=((inst*NPT_REG_SIZE)+0x250); i=i+16)
  623. {
  624. JLOG(INFO, "0x%04xh: 0x%08x 0x%08x 0x%08x 0x%08x\n", i,
  625. jdi_read_register(i), jdi_read_register(i+4),
  626. jdi_read_register(i+8), jdi_read_register(i+0xc));
  627. }
  628. JLOG(INFO, "0x%04xh: 0x%08x 0x%08x 0x%08x 0x%08x\n", NPT_PROC_BASE,
  629. jdi_read_register(NPT_PROC_BASE+0x00), jdi_read_register(NPT_PROC_BASE+4),
  630. jdi_read_register(NPT_PROC_BASE+8), jdi_read_register(NPT_PROC_BASE+0xc));
  631. }
  632. static void SwapByte(Uint8* data, Uint32 len)
  633. {
  634. Uint8 temp;
  635. Uint32 i;
  636. for (i=0; i<len; i+=2) {
  637. temp = data[i];
  638. data[i] = data[i+1];
  639. data[i+1] = temp;
  640. }
  641. }
  642. static void SwapWord(Uint8* data, Uint32 len)
  643. {
  644. Uint16 temp;
  645. Uint16* ptr = (Uint16*)data;
  646. Int32 i, size = len/sizeof(Uint16);
  647. for (i=0; i<size; i+=2) {
  648. temp = ptr[i];
  649. ptr[i] = ptr[i+1];
  650. ptr[i+1] = temp;
  651. }
  652. }
  653. static void SwapDword(Uint8* data, Uint32 len)
  654. {
  655. Uint32 temp;
  656. Uint32* ptr = (Uint32*)data;
  657. Int32 i, size = len/sizeof(Uint32);
  658. for (i=0; i<size; i+=2) {
  659. temp = ptr[i];
  660. ptr[i] = ptr[i+1];
  661. ptr[i+1] = temp;
  662. }
  663. }
  664. Int32 swap_endian(BYTE* data, Uint32 len, Uint32 endian)
  665. {
  666. Uint8 endianMask[8] = { // endianMask : [2] - 4byte unit swap
  667. 0x00, 0x07, 0x04, 0x03, // [1] - 2byte unit swap
  668. 0x06, 0x05, 0x02, 0x01 // [0] - 1byte unit swap
  669. };
  670. Uint8 targetEndian;
  671. Uint8 systemEndian;
  672. Uint8 changes;
  673. BOOL byteSwap=FALSE, wordSwap=FALSE, dwordSwap=FALSE;
  674. if (endian > 7) {
  675. JLOG(ERR, "Invalid endian mode: %d, expected value: 0~7\n", endian);
  676. return -1;
  677. }
  678. targetEndian = endianMask[endian];
  679. systemEndian = endianMask[JDI_SYSTEM_ENDIAN];
  680. changes = targetEndian ^ systemEndian;
  681. byteSwap = changes & 0x01 ? TRUE : FALSE;
  682. wordSwap = changes & 0x02 ? TRUE : FALSE;
  683. dwordSwap = changes & 0x04 ? TRUE : FALSE;
  684. if (byteSwap == TRUE) SwapByte(data, len);
  685. if (wordSwap == TRUE) SwapWord(data, len);
  686. if (dwordSwap == TRUE) SwapDword(data, len);
  687. return changes == 0 ? 0 : 1;
  688. }