开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
camera.cpp
资源名称：SMDK2440.rar　[点击查看]
上传用户：qiulin1960
上传日期：2013-10-16
资源大小：2844k
文件大小：42k
源码类别：

Windows CE

开发平台：

Windows_Unix

camera.cpp：源码内容
  2. #include <windows.h>
  4. #include <nkintr.h>
  5. #include <oalintr.h>
  6. //#include <p2.h>
  7. #include <pm.h>
  8. #include "pmplatform.h"
  10. #include "s2440.h"
  11. #include "camif.h"
  12. #include "camera.h"
  14. #define MSG_EN_1 0
  15. #define MSG_EN_2 0
  16. //#define RETAILMSG(a,b) RETAILMSG(1,b)
  18. #define DOTNET_DRIVER 1 // 0:PPC, 1:CE.NET
  20. #define CAPTURE_TIME 30
  21. #define DISPLAY_SCHEDULE 0
  23. #define U8 unsigned char
  24. #define U16 unsigned short
  25. #define U32 unsigned int
  27. #define PORT_A 1
  28. #define PORT_B 0
  30. // Added 25 May 2004 for debug
  31. #ifdef DEBUG
  32. #define ZONE_INIT 1
  33. #define ZONE_THREAD 1
  34. #endif
  36. #define YCbCrtoR(Y,Cb,Cr) (1000*Y + 1540*(Cr-128))/1000
  37. #define YCbCrtoG(Y,Cb,Cr) (1000*Y - 459*(Cb-128) - 183*(Cr-128))/1000
  38. #define YCbCrtoB(Y,Cb,Cr) (1000*Y + 1856*(Cb-128))/1000
  40. volatile IOPreg  *s2440IOP = (IOPreg *)IOP_BASE;
  41. volatile CAMreg  *s2440CAM = (CAMreg *)CAM_BASE;
  42. volatile INTreg  *s2440INT = (INTreg *)INT_BASE;
  43. volatile CLKPWRreg *s2440PWR = (CLKPWRreg *)CLKPWR_BASE;
  44. volatile IICreg *s2440IIC = (IICreg *)IIC_BASE;;
  46. unsigned int DisplayTime = INFINITE;
  47. //unsigned char DisplayEnable=0;
  48. unsigned char buffer_num=0xff; // ping pong buffer
  50. unsigned char image_size = 2; // 1: QCIF, 2:CIF (default)
  52. //#define DRIVER_PREVIEW_ENABLE 2 // 0: onTimeTek, 1: Preview, 2:Samsung Camcorder
  53. unsigned char DRIVER_PREVIEW_ENABLE = 2; // 0: onTimeTek, 1: Preview, 2:Samsung Camcorder
  55. unsigned int frame_count=0; // for MPEG4
  56. DWORD Tick_GET_FRAME_CUR;
  57. DWORD Tick_GET_FRAME_PREV;
  58. DWORD Tick_COPY_FRAME;
  60. HANDLE CameraThread;
  61. HANDLE CameraEvent;
  62. static BOOL mInitialized = FALSE;
  64. unsigned char codec_flag=0;
  65. unsigned char rgb_flag=0;
  66. unsigned int y_address,cb_address,cr_address;
  67. unsigned int rgb_address;
  68. extern void Camera_Initialize();
  69. extern volatile IOPreg *s2440IOP;
  70. extern volatile IICreg *s2440IIC;
  72. void Virtual_Alloc(); // Virtual allocation
  73. void Camera_Clock(unsigned char divide); // set default value
  74. void Camif_Capture(int cap_a, int cap_b); // A port, B port
  75. void Display_Cam_Image(U32 pos_x, U32 pos_y, U32 size_x, U32 size_y, U8 port);
  76. void Copy_Cam_Image(U8 * pBufOut, U32 size_x, U32 size_y, U8 port);
  77. void Samsung_camcoder(U8 *pBufOut);
  78. void Samsung_camcoder_pr(U8 *pBufOut);
  79. void Buffer_codec_info_update();
  80. void Buffer_preview_info_update();
  81. BOOL Cam_Init();
  82. BOOL CamClockOn(BOOL bOnOff);
  83. //void CamCaptureStart(U32 mode);
  85. void CamInit(U32 CoDstWidth, U32 CoDstHeight, U32 PrDstWidth, U32 PrDstHeight, 
  86. U32 WinHorOffset, U32 WinVerOffset,  U32 CoFrameBuffer, U32 PrFrameBuffer);
  88. DWORD CameraCaptureThread(void);
  89. BOOL InitInterruptThread();
  91. CEDEVICE_POWER_STATE m_Dx;
  93. #ifdef DEBUG
  94. DBGPARAM dpCurSettings = {
  95.     TEXT("CAMERA"), {
  96.         TEXT("0"),TEXT("1"),TEXT("2"),TEXT("3"),
  97.         TEXT("4"),TEXT("5"),TEXT("6"),TEXT("7"),
  98.         TEXT("8"),TEXT("9"),TEXT("10"),TEXT("11"),
  99.         TEXT("12"),TEXT("Function"),TEXT("Init"),TEXT("Error")},
  100.     0x8000  // Errors only, by default
  101. }; 
  102. #endif
  105. static void Delay(USHORT count)
  106. {
  107. volatile int i, j = 0;
  108. volatile static int loop = S2440FCLK/100000;
  110. for(;count > 0;count--)
  111. for(i=0;i < loop; i++) { j++; }
  112. }
  115. /********************************************************
  116.  CalculateBurstSize - Calculate the busrt lengths
  117.  
  118.  Description:
  119.  - dstHSize: the number of the byte of H Size.
  120.  
  121. */
  122. void CalculateBurstSize(unsigned int hSize,unsigned int *mainBurstSize,unsigned int *remainedBurstSize)
  123. {
  124. unsigned int tmp;
  125. tmp=(hSize/4)%16;
  126. switch(tmp) {
  127. case 0:
  128. *mainBurstSize=16;
  129. *remainedBurstSize=16;
  130. break;
  131. case 4:
  132. *mainBurstSize=16;
  133. *remainedBurstSize=4;
  134. break;
  135. case 8:
  136. *mainBurstSize=16;
  137. *remainedBurstSize=8;
  138. break;
  139. default: 
  140. tmp=(hSize/4)%8;
  141. switch(tmp) {
  142. case 0:
  143. *mainBurstSize=8;
  144. *remainedBurstSize=8;
  145. break;
  146. case 4:
  147. *mainBurstSize=8;
  148. *remainedBurstSize=4;
  149. default:
  150. *mainBurstSize=4;
  151. tmp=(hSize/4)%4;
  152. *remainedBurstSize= (tmp) ? tmp: 4;
  153. break;
  154. }
  155. break;
  156. }          
  157. }
  159. /********************************************************
  160.  CalculatePrescalerRatioShift - none
  161.  
  162.  Description:
  163.  - none
  164.  
  165. */
  166. void CalculatePrescalerRatioShift(unsigned int SrcSize, unsigned int DstSize, unsigned int *ratio,unsigned int *shift)
  167. {
  168. if(SrcSize>=64*DstSize) {
  169. // Uart_Printf("ERROR: out of the prescaler range: SrcSize/DstSize = %d(< 64)rn",SrcSize/DstSize);
  170. while(1);
  171. }
  172. else if(SrcSize>=32*DstSize) {
  173. *ratio=32;
  174. *shift=5;
  175. }
  176. else if(SrcSize>=16*DstSize) {
  177. *ratio=16;
  178. *shift=4;
  179. }
  180. else if(SrcSize>=8*DstSize) {
  181. *ratio=8;
  182. *shift=3;
  183. }
  184. else if(SrcSize>=4*DstSize) {
  185. *ratio=4;
  186. *shift=2;
  187. }
  188. else if(SrcSize>=2*DstSize) {
  189. *ratio=2;
  190. *shift=1;
  191. }
  192. else {
  193. *ratio=1;
  194. *shift=0;
  195. }    
  196. }
  198. void Camera_Clock(unsigned char divide)
  199. {
  200. unsigned int camclk;
  202. // Set camera clock for camera processor
  203. s2440PWR->rCAMDIVN = (s2440PWR->rCAMDIVN & ~(0x1f)) | (1<<4) | (divide & 0xf); // CAMCLK is divided..
  204. camclk = 48000000/(((s2440PWR->rCAMDIVN&0xf) + 1)*2);
  206. RETAILMSG(1,(TEXT("CAM clock:%drn"),camclk));
  207. }
  209. /*
  210. void CamCaptureStart(unsigned int mode)
  211. { 
  212. if(mode&CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT) {
  213. s2440CAM->rCICOSCCTRL|=CAM_CODEC_SACLER_START_BIT;
  214. }
  216. if(mode&CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT) {
  217. s2440CAM->rCIPRSCCTRL|=CAM_PVIEW_SACLER_START_BIT;
  218. }
  219.     
  220. s2440CAM->rCIIMGCPT|=(CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT|mode);
  221. }
  222. */
  224. void Camif_Capture(int cap_a, int cap_b)
  225. {
  226. //RETAILMSG(1,(_T("Camif_Capture(%d, %d)rn"), cap_a, cap_b));
  227. // S3C2440A
  229. s2440CAM->rCIIMGCPT &= ~(CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT);
  231. if(cap_b == CAPTURE_ON) 
  232. {
  233. //Codec capture start
  234. s2440CAM->rCICOSCCTRL |=(CAM_CODEC_SACLER_START_BIT);
  235. s2440CAM->rCIIMGCPT |=(CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT)|(CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT);
  236. } 
  237. else if (cap_b == CAPTURE_OFF)
  238. {
  239. s2440CAM->rCICOSCCTRL &= ~(CAM_CODEC_SACLER_START_BIT);
  240. s2440CAM->rCIIMGCPT &= ~(CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT);
  241. }
  243. if(cap_a == CAPTURE_ON) 
  244. {  
  245. // Preview capture Start
  246. s2440CAM->rCIPRSCCTRL |=(CAM_PVIEW_SACLER_START_BIT);
  247. s2440CAM->rCIIMGCPT |=(CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT)|(CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT);
  248. }
  249. else if (cap_a == CAPTURE_OFF)
  250. {
  251. s2440CAM->rCIPRSCCTRL &= ~(CAM_PVIEW_SACLER_START_BIT);
  252. s2440CAM->rCIIMGCPT &= ~(CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT);
  253. }
  255. if ((cap_a == CAPTURE_ON) || (cap_b == CAPTURE_ON))
  256. {
  257. s2440CAM->rCIIMGCPT |= (CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT);
  258. }
  260. }
  262. DWORD CameraCaptureThread(void)
  263. {
  264. unsigned char tmp=0;
  265. static unsigned int time,old_time;
  266. static unsigned int cam_intr;
  268. while(1)
  269. {
  270. WaitForSingleObject(CameraEvent, DisplayTime);
  272. RETAILMSG(MSG_EN_1,(_T("CameraCaptureThread(%d)++rn"), frame_count));
  274. #if 0
  275. if (frame_count <= 2) {
  276. frame_count++;
  277. // Enable camera interrupt
  278. s2440INT->rINTSUBMSK &= ~(BIT_SUB_CAM_P|BIT_SUB_CAM_C);
  279. s2440INT->rINTMSK &= ~BIT_CAM;
  281. continue;
  282. }
  283. #endif
  285. //if( DisplayEnable )
  286. {
  288. frame_count++;
  290. if (s2440INT->rINTSUBMSK & BIT_SUB_CAM_C)
  291. {
  292. cam_intr = BIT_SUB_CAM_C;
  293. //RETAILMSG(1,(_T("CAM_C, ts %drn"), GetTickCount()));
  294. }
  295. else if (s2440INT->rINTSUBMSK & BIT_SUB_CAM_P)
  296. {
  297. cam_intr = BIT_SUB_CAM_P;
  298. //RETAILMSG(1,(_T("CAM_P, ts %drn"), GetTickCount()));
  299. }
  302. // EINT20 to measure time
  303. // s2440IOP->rGPGDAT |= (1<<12);
  304. // time = GetTickCount();
  305. // RETAILMSG(1,(TEXT("+time:%drn"),(time - old_time)));
  307. // delay for capture
  308. //Sleep(CAPTURE_TIME); // polling mode
  310. // display the image
  311. if ((DRIVER_PREVIEW_ENABLE == 1) & (cam_intr == BIT_SUB_CAM_P))
  312. Display_Cam_Image(64, 64, QCIF_XSIZE, QCIF_YSIZE, PORT_A);
  314. //else if (DRIVER_PREVIEW_ENABLE == 2)
  315. if (cam_intr == BIT_SUB_CAM_C)
  316. {
  317. Buffer_codec_info_update();
  318. }
  320. if (cam_intr == BIT_SUB_CAM_P)
  321. {
  322. Buffer_preview_info_update();
  323. }
  325. // Enable camera interrupt
  326. s2440INT->rINTSUBMSK &= ~(BIT_SUB_CAM_P|BIT_SUB_CAM_C);
  327. s2440INT->rINTMSK &= ~BIT_CAM;
  329. /*
  330. if (DRIVER_PREVIEW_ENABLE == 1)
  331. Camif_Capture(CAPTURE_ON, CAPTURE_OFF);
  332. else if (DRIVER_PREVIEW_ENABLE == 2)
  333. Camif_Capture(CAPTURE_OFF, CAPTURE_ON);
  334. */
  336. // EINT20 to measure time
  337. // s2440IOP->rGPGDAT &= ~(1<<12);
  338. // old_time = GetTickCount();
  339. // RETAILMSG(1,(TEXT("-time:%drn"),(old_time-time)));
  341. }
  342. }
  343. }
  347. void Virtual_Alloc()
  348. {
  350.     // GPIO Virtual alloc
  351. s2440IOP = (volatile IOPreg *) VirtualAlloc(0,sizeof(IOPreg),MEM_RESERVE, PAGE_NOACCESS);
  352. if(s2440IOP == NULL) {
  353. RETAILMSG(1,(TEXT("For s2440IOP: VirtualAlloc failed!rn")));
  354. }
  355. else {
  356. if(!VirtualCopy((PVOID)s2440IOP,(PVOID)(IOP_BASE),sizeof(IOPreg),PAGE_READWRITE | PAGE_NOCACHE )) {
  357. RETAILMSG(1,(TEXT("For s2440IOP: VirtualCopy failed!rn")));
  358. }
  359. }
  360.     // IIC Virtual alloc
  361. s2440IIC = (volatile IICreg *) VirtualAlloc(0,sizeof(IICreg),MEM_RESERVE, PAGE_NOACCESS);
  362. if(s2440IIC == NULL) {
  363. RETAILMSG(1,(TEXT("For s2440IIC: VirtualAlloc failed!rn")));
  364. }
  365. else {
  366. if(!VirtualCopy((PVOID)s2440IIC,(PVOID)(IIC_BASE),sizeof(IICreg),PAGE_READWRITE | PAGE_NOCACHE )) {
  367. RETAILMSG(1,(TEXT("For s2440IIC: VirtualCopy failed!rn")));
  368. }
  369. }
  371.     // Camera Virtual alloc
  372. s2440CAM = (volatile CAMreg *) VirtualAlloc(0,sizeof(CAMreg),MEM_RESERVE, PAGE_NOACCESS);
  373. if(s2440CAM == NULL) {
  374. RETAILMSG(1,(TEXT("For s2440CAM: VirtualAlloc failed!rn")));
  375. }
  376. else {
  377. if(!VirtualCopy((PVOID)s2440CAM,(PVOID)(CAM_BASE),sizeof(CAMreg),PAGE_READWRITE | PAGE_NOCACHE )) {
  378. RETAILMSG(1,(TEXT("For s2440CAM: VirtualCopy failed!rn")));
  379. }
  380. }
  382. // Interrupt Virtual alloc
  383. s2440INT = (volatile INTreg *) VirtualAlloc(0,sizeof(INTreg),MEM_RESERVE, PAGE_NOACCESS);
  384. if(s2440INT == NULL) {
  385. RETAILMSG(1,(TEXT("For s2440INT: VirtualAlloc failed!rn")));
  386. }
  387. else {
  388. if(!VirtualCopy((PVOID)s2440INT,(PVOID)(INT_BASE),sizeof(INTreg),PAGE_READWRITE | PAGE_NOCACHE )) {
  389. RETAILMSG(1,(TEXT("For s2440INT: VirtualCopy failed!rn")));
  390. }
  391. }
  392. // PWM clock Virtual alloc
  393. s2440PWR = (volatile CLKPWRreg *) VirtualAlloc(0,sizeof(CLKPWRreg),MEM_RESERVE, PAGE_NOACCESS);
  394. if(s2440PWR == NULL) {
  395. RETAILMSG(1,(TEXT("For s2440PWR: VirtualAlloc failed!rn")));
  396. }
  397. else {
  398. if(!VirtualCopy((PVOID)s2440PWR,(PVOID)(CLKPWR_BASE),sizeof(CLKPWRreg),PAGE_READWRITE | PAGE_NOCACHE )) {
  399. RETAILMSG(1,(TEXT("For s2440PWR: VirtualCopy failed!rn")));
  400. }
  401. }
  402. }
  404. void Display_Cam_Image(U32 pos_x, U32 pos_y, U32 size_x, U32 size_y, U8 port)
  405. {
  406. U8 *buffer_rgb;
  407. U32 y;
  408. int temp;
  410. //unsigned short *ptr = (unsigned short *)(FRAMEBUF_BASE+0x5dc0);
  412. static unsigned short transfer_data[QCIF_XSIZE*QCIF_YSIZE];
  413. static unsigned int time,old_time;
  415. //RETAILMSG(1,(_T("Display_Cam_Image()rn")));
  417. // if (port)
  418. {
  419. temp = (s2440CAM->rCIPRSTATUS>>26)&3;
  420. temp = (temp + 2) % 4;
  422. switch (temp)
  423. {
  424. case 0:
  425. buffer_rgb = (U8 *)s2440CAM->rCIPRCLRSA1;
  426. break;
  427. case 1:
  428. buffer_rgb = (U8 *)s2440CAM->rCIPRCLRSA2;
  429. break;
  430. case 2:
  431. buffer_rgb = (U8 *)s2440CAM->rCIPRCLRSA3;
  432. break;
  433. case 3:
  434. buffer_rgb = (U8 *)s2440CAM->rCIPRCLRSA4;
  435. break;
  436. default :
  437. buffer_rgb = (U8 *)s2440CAM->rCIPRCLRSA1;
  438. break;
  439. }
  440. }
  441. RETAILMSG(MSG_EN_1,(_T("preview buf index = %drn"), temp));
  443. #if (DOTNET_DRIVER)
  444. SetKMode(TRUE);
  445. #endif
  447. buffer_rgb += VIRTUAL_OFFSET;
  449. // time = GetTickCount();
  450. // RETAILMSG(1,(TEXT("+:%drn"),(time - old_time)));
  453. #if 1
  454. for (y=0;y<(size_y-2);y++) // YCbCr 4:2:0 format
  455. {
  456. //memcpy((void *)(FRAMEBUF_BASE+0x5e00+y*240*2),(void *)buffer_rgb,(QCIF_XSIZE)*2);
  457. memcpy((void *)(FRAMEBUF_BASE+ (240*pos_y + pos_x) + y*240*2),(void *)buffer_rgb,(QCIF_XSIZE)*2);
  458. buffer_rgb += (QCIF_XSIZE*2);
  459. }
  460. #endif
  462. #if (DOTNET_DRIVER)
  463. SetKMode(FALSE);
  464. #endif
  466. // old_time = GetTickCount();
  467. // RETAILMSG(1,(TEXT("-:%drn"),(old_time - time)));
  469. }
  473. BOOL WINAPI  
  474. DllEntry(HANDLE hinstDLL, 
  475. DWORD dwReason, 
  476. LPVOID /* lpvReserved */)
  477. {
  478. switch(dwReason)
  479. {
  480. case DLL_PROCESS_ATTACH:
  481. DEBUGREGISTER((HINSTANCE)hinstDLL);
  482. DEBUGMSG(ZONE_INIT,(TEXT("CAMERA: DLL_PROCESS_ATTACHrn")));
  483. return TRUE;
  484. case DLL_THREAD_ATTACH:
  485. DEBUGMSG(ZONE_THREAD,(TEXT("CAMERA: DLL_THREAD_ATTACHrn")));
  486. break;
  487. case DLL_THREAD_DETACH:
  488. DEBUGMSG(ZONE_THREAD,(TEXT("CAMERA: DLL_THREAD_DETACHrn")));
  489. break;
  490. case DLL_PROCESS_DETACH:
  491. DEBUGMSG(ZONE_INIT,(TEXT("CAMERA: DLL_PROCESS_DETACHrn")));
  492. break;
  493. #ifdef UNDER_CE
  494. case DLL_PROCESS_EXITING:
  495. DEBUGMSG(ZONE_INIT,(TEXT("CAMERA: DLL_PROCESS_EXITINGrn")));
  496. break;
  497. case DLL_SYSTEM_STARTED:
  498. DEBUGMSG(ZONE_INIT,(TEXT("CAMERA: DLL_SYSTEM_STARTEDrn")));
  499. break;
  500. #endif
  501. }
  503. return TRUE;
  504. }
  506. //-----------------------------------------------------------------------------
  507. //-----------------------------------------------------------------------------
  508. BOOL CIS_Deinit(DWORD hDeviceContext)
  509. {
  510. BOOL bRet = TRUE;
  512. RETAILMSG(1,(TEXT("CAMERA: CIS_Deinitrn")));
  514. s2440INT->rINTMSK |= BIT_CAM;
  515. s2440INT->rINTSUBMSK |= (BIT_SUB_CAM_P|BIT_SUB_CAM_C);
  516. Camif_Capture(CAPTURE_OFF, CAPTURE_OFF);
  517. //DisplayEnable = 0;
  518. DRIVER_PREVIEW_ENABLE = 2;
  520. CloseHandle(CameraThread);
  522. VirtualFree((void*)s2440IOP, sizeof(IOPreg), MEM_RELEASE);
  523. VirtualFree((void*)s2440CAM, sizeof(CAMreg), MEM_RELEASE);
  524. VirtualFree((void*)s2440INT, sizeof(INTreg), MEM_RELEASE);
  525. VirtualFree((void*)s2440PWR, sizeof(CLKPWRreg), MEM_RELEASE);
  526. VirtualFree((void*)s2440IIC, sizeof(IICreg), MEM_RELEASE);
  528. return TRUE;
  529. } 
  533. BOOL InitInterruptThread()
  534. {
  535. DWORD         threadID;                         // thread ID
  536. BOOL bSuccess;
  538.     CameraEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  539.     
  540.     if (!CameraEvent)
  541.     {
  542.      return FALSE;
  543.     }
  545. bSuccess = InterruptInitialize(SYSINTR_CAM, CameraEvent, NULL, 0);
  546.     if (!bSuccess) 
  547.     {
  548.         RETAILMSG(1,(TEXT("Fail to initialize camera interrupt eventrn")));
  549.         return FALSE;
  550.     }    
  552.     CameraThread = CreateThread(NULL,
  553.                                  0,
  554.                                  (LPTHREAD_START_ROUTINE)CameraCaptureThread,
  555.                                  0,
  556.                                  0,
  557.                                  &threadID);
  558.     
  559.     if (NULL == CameraThread ) {
  560.      RETAILMSG(1,(TEXT("Create Camera Thread Failrn")));
  561.     }
  563. RETAILMSG(1,(_T("CAMERA.DLL::InterruptThread Initialized.rn")));
  564. return TRUE;
  565. }
  568. BOOL CamClockOn(BOOL bOnOff)
  569. {
  570. // Camera clock
  571. if (!bOnOff)
  572. s2440PWR->rCLKCON &= ~(1<<19); // Camera clock disable
  574. s2440PWR->rCLKCON |= (1<<19); // Camera clock enable
  575. Camera_Clock(CAM_CLK_DIV);
  576. RETAILMSG(1,(_T("CamClockOn = %drn"), bOnOff));
  578. Delay(1000);
  580. return TRUE;
  581. }
  583. BOOL CamGpioInit()
  584. {
  585. s2440IOP->rGPJCON = 0x2aaaaaa;
  586. s2440IOP->rGPJDAT = 0;
  587. s2440IOP->rGPJUP = 0x1fff;
  589. return TRUE;
  590. }
  592. void CAM_IF_Reset()
  593. {
  594. // This functin is used on power handler operation.
  595. // So, you should not use Kernel API functions as like as "Sleep()".
  597. //
  598. // Camera (FIMC2.0) I/F Reset
  599. //
  601. //s2440CAM->rCTRL_C = (1<<19); // 2440X
  602. s2440CAM->rCIGCTRL |= (1<<31);
  603. // Don't modify this delay time
  604. RETAILMSG(1,(TEXT("Camera I/F Resetrn")));
  605. Delay(100);
  606. //s2440CAM->rCTRL_C = (0<<19);
  607. s2440CAM->rCIGCTRL &= ~(1<<31);
  608. // Wait for Camera module initialization
  609. Delay(1000);
  610. }
  612. void Camera_Module_Reset()
  613. {
  614. //s2440CAM->rCTRL_C = (1<<19); // 2440X
  615. s2440CAM->rCIGCTRL |= (1<<30);
  616. // Don't modify this delay time
  617. RETAILMSG(1,(TEXT("Camera Module Resetrn")));
  618. //Delay(10);
  619. Sleep(1);
  621. //s2440CAM->rCTRL_C = (0<<19);
  622. s2440CAM->rCIGCTRL &= ~(1<<30);
  623. // Wait for Camera module initialization
  624. //Delay(100);
  625. Sleep(10);
  627. // Samsung Camera need delay time between camera clock enable and camera reset.
  628. //RETAILMSG(1,(TEXT("You need delay timern")));
  629. //Delay(1000);
  630. Sleep(10);
  631. }
  633. BOOL Cam_Init()
  634. {
  635.     //
  636.     // 1. Camera IO setup
  637.     //
  638. CamGpioInit();
  641. // 2. Camera i/f reset
  642.     CAM_IF_Reset();
  644.     //
  645.     // 3. Camera Clock setup
  646.     //
  647. CamClockOn(TRUE);
  649. // 4. Camera Module Reset
  650. Camera_Module_Reset();
  653. // 5. set register of camera module through IIC 
  654. Camera_Initialize();
  656. // to check time
  657. s2440IOP->rGPGCON &= ~(0x3<<24);
  658. s2440IOP->rGPGCON |= (0x1<<24); // EINT20
  660. if (image_size == 1)
  661. CamInit(QCIF_XSIZE, QCIF_YSIZE, QCIF_XSIZE, QCIF_YSIZE, 112, 20, COPIFRAMEBUFFER_B, COPIFRAMEBUFFER_A);
  662. else if (image_size == 2)
  663. CamInit(CIF_XSIZE, CIF_YSIZE, QCIF_XSIZE, QCIF_YSIZE, 112, 20, COPIFRAMEBUFFER_B, COPIFRAMEBUFFER_A);
  665. //RETAILMSG(1,(_T("CamInit().. donern")));
  666. return TRUE;
  667. }
  670. DWORD CIS_Init(DWORD dwContext)
  671. {
  672. // 1. Virtual Alloc
  673. Virtual_Alloc();
  675. Cam_Init();
  677. if (!InitInterruptThread())
  678. {
  679.         RETAILMSG(1,(TEXT("Fail to initialize camera interrupt eventrn")));
  680.         return FALSE;
  681.     }    
  683. m_Dx = (_CEDEVICE_POWER_STATE)D0;
  684. DevicePowerNotify(_T("CIS1:"),(_CEDEVICE_POWER_STATE)D0, POWER_NAME);
  686. mInitialized = TRUE;
  687. return TRUE;
  688. }
  690. //-----------------------------------------------------------------------------
  691. //-----------------------------------------------------------------------------
  692. BOOL CIS_IOControl(DWORD hOpenContext, 
  693.    DWORD dwCode, 
  694.    PBYTE pBufIn, 
  695.    DWORD dwLenIn, 
  696.    PBYTE pBufOut, 
  697.    DWORD dwLenOut, 
  698.    PDWORD pdwActualOut)
  699. {
  700.     BOOL RetVal = TRUE;
  701.     DWORD dwErr = ERROR_SUCCESS;    
  702. static unsigned int time=0,old_time=0;
  704. switch (dwCode)
  705. {
  707. //-----------------------------------------------------------------------------------------
  708. case IOCTL_POWER_CAPABILITIES: 
  709.         {
  710.             PPOWER_CAPABILITIES ppc;
  711. RETAILMSG(1, (TEXT("CIS: IOCTL_POWER_CAPABILITIESrn")));   
  712.             
  713. if ( !pdwActualOut || !pBufOut || (dwLenOut < sizeof(POWER_CAPABILITIES)) ) {
  714.                 RetVal = FALSE;
  715.                 dwErr = ERROR_INVALID_PARAMETER;
  716.                 break;
  717.             }
  719.             ppc = (PPOWER_CAPABILITIES)pBufOut;
  720.             
  721.             memset(ppc, 0, sizeof(POWER_CAPABILITIES));
  723.             // support D0, D4 
  724.             ppc->DeviceDx = 0x11;
  726.             // Report our power consumption in uAmps rather than mWatts. 
  727.             ppc->Flags = POWER_CAP_PREFIX_MICRO | POWER_CAP_UNIT_AMPS;
  728.             
  729. // 25 m = 25000 uA
  730.             // TODO: find out a more accurate value
  731. ppc->Power[D0] = 25000;
  732.             
  733.             *pdwActualOut = sizeof(POWER_CAPABILITIES);
  734.         } break;
  736. case IOCTL_POWER_SET: 
  737.         {
  738.             CEDEVICE_POWER_STATE NewDx;
  740.             if ( !pdwActualOut || !pBufOut || (dwLenOut < sizeof(CEDEVICE_POWER_STATE)) ) {
  741.                 RetVal = FALSE;
  742.                 dwErr = ERROR_INVALID_PARAMETER;
  743.                 break;
  744.             }
  745.             
  746.             NewDx = *(PCEDEVICE_POWER_STATE)pBufOut;
  748.             if ( VALID_DX(NewDx) ) {
  749.                 switch ( NewDx ) {
  750.                 case D0:
  751.                     if (m_Dx != D0) {
  752.                         CIS_PowerUp(hOpenContext);
  753.                         m_Dx = D0;
  754.                     }
  755.                     break;
  757.                 default:
  758.                     if (m_Dx != (_CEDEVICE_POWER_STATE)D4) {
  759.                         CIS_PowerDown(hOpenContext);
  760.                         m_Dx = (_CEDEVICE_POWER_STATE)D4;
  761.                     }
  762.                     break;
  763.                 }
  765.                 // return our state
  766.                 *(PCEDEVICE_POWER_STATE)pBufOut = m_Dx;
  768.                 RETAILMSG(1, (TEXT("CIS: IOCTL_POWER_SET: D%u rn"), NewDx));
  770.                 *pdwActualOut = sizeof(CEDEVICE_POWER_STATE);
  771.             } else {
  772.                 RetVal = FALSE;
  773.                 dwErr = ERROR_INVALID_PARAMETER;
  774.             }
  775.             
  776.         } break;
  778.         case IOCTL_POWER_GET: 
  780.             if ( !pdwActualOut || !pBufOut || (dwLenOut < sizeof(CEDEVICE_POWER_STATE)) ) {
  781.                 RetVal = FALSE;
  782.                 dwErr = ERROR_INVALID_PARAMETER;
  783.                 break;
  784.             }
  786. *(PCEDEVICE_POWER_STATE)pBufOut = m_Dx;
  788.             RETAILMSG(1, (TEXT("CIS: IOCTL_POWER_GET: D%u rn"), m_Dx));
  790.             *pdwActualOut = sizeof(CEDEVICE_POWER_STATE);
  791.         break;
  793. //-----------------------------------------------------------------------------------------
  795. case IOCTL_CAM_SHOW :
  796. // Charlie. Show Menu
  797. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_SHOW(%x)rn"),dwLenIn));
  798. break;
  800. case IOCTL_CAM_HIDE :
  801. // Charlie. Close display window
  802. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_HIDErn")));
  803. break;
  805. case IOCTL_CAM_SETPOS : 
  806. time = GetTickCount();
  807. // RETAILMSG(MSG_EN_1,(TEXT("Capture time:%d msecrn"), (time-old_time)));
  808. RETAILMSG(MSG_EN_1,(TEXT("Capture time:%d msecrn"), (time)));
  809. old_time = time;
  810. break;
  812. case CAM_IOCTL_MOVIE_START: // for MPEG4
  813. case IOCTL_CAM_CONT : 
  814. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_CONTrn")));
  815. // Charlie. Play
  816. //DisplayEnable = 1;
  818. // Enable camera interrupt
  819. s2440INT->rINTMSK &= ~BIT_CAM;
  820. s2440INT->rINTSUBMSK &= ~(BIT_SUB_CAM_P|BIT_SUB_CAM_C);
  822. #if 0
  823. if (DRIVER_PREVIEW_ENABLE == 1)
  824. {
  825. Camif_Capture(CAPTURE_ON, CAPTURE_OFF);
  826. } 
  827. else if (DRIVER_PREVIEW_ENABLE == 2)
  828. {
  829. Camif_Capture(CAPTURE_OFF, CAPTURE_ON);
  830. }
  831. #else
  832. Camif_Capture(CAPTURE_ON, CAPTURE_ON);
  833. #endif
  835. //DisplayTime = DISPLAY_SCHEDULE; // polling mode
  836. //SetEvent(CameraEvent);
  838. s2440IOP->rGPGCON &= ~(0x3<<24);
  839. s2440IOP->rGPGCON |= (0x1<<24); // EINT20
  840. frame_count = 0; // for MPEG4
  841. break;
  843. case CAM_IOCTL_MOVIE_STOP: // for MPEG4
  844. case IOCTL_CAM_STOP : 
  845. // Charlie. Stop
  846. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_STOPrn")));
  847. // Disable camera interrupt
  848. s2440INT->rINTMSK |= BIT_CAM;
  849. s2440INT->rINTSUBMSK |= (BIT_SUB_CAM_P|BIT_SUB_CAM_C);
  850. if (s2440INT->rINTPND & BIT_CAM) s2440INT->rINTPND |= BIT_CAM;
  851. s2440INT->rSRCPND |= BIT_CAM;
  852. s2440INT->rSUBSRCPND |= (BIT_SUB_CAM_P|BIT_SUB_CAM_C);
  853. Camif_Capture(CAPTURE_OFF, CAPTURE_OFF);
  854. //DisplayEnable = 0;
  855. DRIVER_PREVIEW_ENABLE = 2;
  856. DisplayTime = INFINITE;
  857. break;
  859. // for MPEG4
  860. case CAM_IOCTL_GET_LATEST_FRAME:
  861. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:CAM_IOCTL_GET_LATEST_FRAMErn")));
  862. //RETAILMSG(MSG_EN_1,(TEXT("pBufIn = 0x%xrn"), pBufIn));
  863. //RETAILMSG(MSG_EN_1,(TEXT("no function available, TBDrn")));
  864. if (frame_count < 2) {
  865. RETAILMSG(1,(TEXT("CAMERA:CAM_IOCTL_GET_LATEST_FRAME - frame not available!!!rn")));
  866. return false;
  867. }
  868. Tick_GET_FRAME_PREV = Tick_GET_FRAME_CUR;
  869. Tick_GET_FRAME_CUR = GetTickCount();
  870. Copy_Cam_Image(pBufOut, QCIF_XSIZE, QCIF_YSIZE, PORT_A);
  871. break;
  873. case CAM_IOCTL_SAMSUNG_CAM: // ID=0x520
  874. RETAILMSG(MSG_EN_1,(_T("CAM_IOCTL_SAMSUNG_CAMrn")));
  875. Samsung_camcoder(pBufOut);
  876. break;
  878. case CAM_IOCTL_SAMSUNG_CAM_PR: // ID=0x522
  879. RETAILMSG(MSG_EN_1,(_T("CAM_IOCTL_SAMSUNG_CAM_PRrn")));
  880. Samsung_camcoder_pr(pBufOut);
  881. break;
  883. case CAM_IOCTL_SAMSUNG_PREVIEW_START : // ID=0x523
  884. DRIVER_PREVIEW_ENABLE = 1;
  885. RETAILMSG(MSG_EN_1,(_T("CAM_IOCTL_SAMSUNG_PREVIEW_START(%x)rn"),*pBufOut, DRIVER_PREVIEW_ENABLE));
  886. break;
  888. case CAM_IOCTL_SAMSUNG_PREVIEW_STOP : // ID=0x524
  889. DRIVER_PREVIEW_ENABLE = 2;
  890. RETAILMSG(MSG_EN_1,(_T("CAM_IOCTL_SAMSUNG_PREVIEW_STOP(%x)rn"),*pBufOut, DRIVER_PREVIEW_ENABLE));
  891. break;
  893. case IOCTL_CAM_SETGAMMA :
  894. if( *pBufOut == 1 ){
  895. DRIVER_PREVIEW_ENABLE = 1;
  896. }
  897. else if( *pBufOut == 2 ){
  898. DRIVER_PREVIEW_ENABLE = 2;
  899. }
  900. RETAILMSG(MSG_EN_1,(_T("IOCTL_CAM_SETGAMMA:*pBufOut(%x):DRIVER_PREVIEW_ENABLE(%x)rn"),*pBufOut, DRIVER_PREVIEW_ENABLE));
  901. break;
  903. case CAM_IOCTL_IMAGE_SIZE: // ID=0x521
  904. if( *pBufOut == 1 ){
  905. image_size = 1;
  906. }
  907. else if( *pBufOut == 2 ){
  908. image_size = 2;
  909. }
  910. RETAILMSG(MSG_EN_1,(TEXT("image_size:%d,0x%x,0x%xrn"),image_size,pBufOut,*pBufOut));
  912. s2440INT->rINTMSK |= BIT_CAM;
  913. s2440INT->rINTSUBMSK |= (BIT_SUB_CAM_P|BIT_SUB_CAM_C);
  914. Camif_Capture(CAPTURE_OFF, CAPTURE_OFF);
  916. if (image_size == 1)
  917. CamInit(QCIF_XSIZE, QCIF_YSIZE, QCIF_XSIZE, QCIF_YSIZE, 112, 20, COPIFRAMEBUFFER_B, COPIFRAMEBUFFER_A);
  918. else if (image_size == 2)
  919. CamInit(CIF_XSIZE, CIF_YSIZE, QCIF_XSIZE, QCIF_YSIZE, 112, 20, COPIFRAMEBUFFER_B, COPIFRAMEBUFFER_A);
  921. break;
  923. case IOCTL_CAM_COPY :
  924. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_COPY(dwLenIn:%x)rn"), dwLenIn));
  925. break;
  927. case IOCTL_CAM_SETCOLKEY :
  928. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_SETCOLKEYrn")));
  929. break;
  931. case IOCTL_CAM_SETALPHA :
  932. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_SETALPHArn")));
  933. break;
  935. case IOCTL_CAM_GETINFO :
  936. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_GETINFOrn")));
  937. break;
  939. case IOCTL_CAM_SETSCALE :
  940. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_SETSCALErn")));
  941. break;
  943. case IOCTL_CAM_SETHUE :
  944. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_SETHUErn")));
  945. break;
  946. #if 0
  947. case IOCTL_CAM_SETGAMMA :
  948. // Get which ping -pong buffer have data
  949. //DisplayEnable = 0;
  950. Sleep(200);
  951. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_BUFFER:%drn"),buffer_num));
  952. break;
  953. #endif
  954. case IOCTL_CAM_SETWBCOORD : 
  955. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_SETWBCOORDrn")));
  956. break;
  958. case IOCTL_CAM_SETAELIMIT :
  959. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_SETAELIMITrn")));
  960. break;
  962. case IOCTL_CAM_SETADCOFS :
  963. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_SETADCOFSrn")));
  964. break;
  966. case IOCTL_CAM_SETWBGAIN :
  967. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_SETWBGAINrn")));
  968. break;
  970. case IOCTL_CAM_SETCBCRGAIN :
  971. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_SETCBCRGAINrn")));
  972. break;
  974. case IOCTL_CAM_SETLEGAIN :
  975. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_SETLEGAINrn")));
  976. break;
  978. case IOCTL_CAM_SETBRIGHTNESS :
  979. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_SETBRIGHTNESSrn")));
  980. break;
  982. case IOCTL_CAM_SETCLIP :
  983. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_SETCLIPrn")));
  984. break;
  986. case IOCTL_CAM_SETSLICELMT :
  987. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_SETSLICELMTrn")));
  988. break;
  990. case IOCTL_CAM_WBACCLMT :
  991. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_WBACCLMTrn")));
  992. break;
  994. case IOCTL_CAM_CSEDGELMT :
  995. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_CSEDGELMTrn")));
  996. break;
  998. case IOCTL_CAM_ENVINT :
  999. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_ENVINTrn")));
  1000. break;
  1002. case IOCTL_CAM_DISVINT :
  1003. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_DISVINTrn")));
  1004. break;
  1006. case IOCTL_CAM_SETCAMERA :
  1007. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:IOCTL_CAM_SETCAMERArn")));
  1009. /*
  1010. RETAILMSG(MSG_EN_1,(_T("---------------------------------------rn")));
  1011. RETAILMSG(MSG_EN_1,(_T("ImgCptEn_PRSC = %drn"), (s2440CAM->rCIPRSTATUS>>21)&0x1));
  1012. RETAILMSG(MSG_EN_1,(_T("PrScalerStart = %drn"), (s2440CAM->rCIPRSCCTRL>>15)&0x1));
  1013. RETAILMSG(MSG_EN_1,(_T("---------------------------------------rn")));
  1014. RETAILMSG(MSG_EN_1,(_T("CoScalerStart  = %drn"), (s2440CAM->rCICOSCCTRL>>15)&0x1));
  1015. RETAILMSG(MSG_EN_1,(_T("VSYNC          = %drn"), (s2440CAM->rCICOSTATUS>>28)&0x1));
  1016. RETAILMSG(MSG_EN_1,(_T("ImgCptEn_Camif = %drn"), (s2440CAM->rCICOSTATUS>>22)&0x1));
  1017. RETAILMSG(MSG_EN_1,(_T("ImgCptEn_CoSC  = %drn"), (s2440CAM->rCICOSTATUS>>21)&0x1));
  1018. RETAILMSG(MSG_EN_1,(_T("VSYNC_A  = %drn"), (s2440CAM->rCICOSTATUS>>20)&0x1));
  1019. RETAILMSG(MSG_EN_1,(_T("VSYNC_B  = %drn"), (s2440CAM->rCICOSTATUS>>19)&0x1));
  1020. RETAILMSG(MSG_EN_1,(_T("---------------------------------------rn")));
  1021. RETAILMSG(MSG_EN_1,(_T("ImgCptEn      = %drn"), (s2440CAM->rCIIMGCPT>>31)&0x1));
  1022. RETAILMSG(MSG_EN_1,(_T("ImgCptEn_CoSc = %drn"), (s2440CAM->rCIIMGCPT>>30)&0x1));
  1023. RETAILMSG(MSG_EN_1,(_T("ImgCptEn_PrSc = %drn"), (s2440CAM->rCIIMGCPT>>29)&0x1));
  1024. RETAILMSG(MSG_EN_1,(_T("----------------- %d ----------------------rn"), mInitialized));
  1025. SetEvent(CameraEvent);
  1026. */
  1027. break;
  1029. default : 
  1030. RETAILMSG(MSG_EN_1,(TEXT("CAMERA:Ioctl code = 0x%xrn"), dwCode));
  1031. return FALSE;
  1033. }
  1034. return TRUE;
  1035. } 
  1037. //-----------------------------------------------------------------------------
  1038. //-----------------------------------------------------------------------------
  1039. DWORD CIS_Open(DWORD hDeviceContext, DWORD AccessCode, DWORD ShareMode)
  1040. {
  1041. RETAILMSG(1,(TEXT("CAMERA: CIS_Openrn")));
  1043. DRIVER_PREVIEW_ENABLE = 2;
  1045. return TRUE;
  1046. } 
  1048. //-----------------------------------------------------------------------------
  1049. //-----------------------------------------------------------------------------
  1050. BOOL CIS_Close(DWORD hOpenContext)
  1051. {
  1052. RETAILMSG(1,(TEXT("CAMERA: CIS_Closern")));
  1053. return TRUE;
  1054. } 
  1056. //-----------------------------------------------------------------------------
  1057. //-----------------------------------------------------------------------------
  1058. void CIS_PowerDown(DWORD hDeviceContext)
  1059. {
  1060. RETAILMSG(1,(TEXT("CAMERA: CIS_PowerDownrn")));
  1062. m_Dx = (_CEDEVICE_POWER_STATE)D4;
  1064. Camif_Capture(CAPTURE_OFF, CAPTURE_OFF);
  1066. CamClockOn(FALSE);
  1068. //RETAILMSG(1,(TEXT("CAMERA: CIS_PowerDown, m_Dx = D%u, init %d rn"), m_Dx, mInitialized));
  1069. } 
  1071. //-----------------------------------------------------------------------------
  1072. //-----------------------------------------------------------------------------
  1073. void CIS_PowerUp(DWORD hDeviceContext)
  1074. {
  1075. RETAILMSG(1,(TEXT("CAMERA: CIS_PowerUprn")));
  1077. m_Dx = (_CEDEVICE_POWER_STATE)D0;
  1079.     //
  1080.     // 1. Camera IO setup
  1081.     //
  1082. CamGpioInit();
  1084. //
  1085.     // 2. Camera Clock setup
  1086.     //
  1087. CamClockOn(TRUE);
  1089. // 3. Camera i/f reset
  1090.     CAM_IF_Reset();
  1092. if (image_size == 1)
  1093. CamInit(QCIF_XSIZE, QCIF_YSIZE, QCIF_XSIZE, QCIF_YSIZE, 112, 20, COPIFRAMEBUFFER_B, COPIFRAMEBUFFER_A);
  1094. else if (image_size == 2)
  1095. CamInit(CIF_XSIZE, CIF_YSIZE, QCIF_XSIZE, QCIF_YSIZE, 112, 20, COPIFRAMEBUFFER_B, COPIFRAMEBUFFER_A);
  1097. RETAILMSG(1,(TEXT("CAMERA: CIS_PowerUp, m_Dx = D%urn"), m_Dx));
  1098. } 
  1100. //-----------------------------------------------------------------------------
  1101. //-----------------------------------------------------------------------------
  1102. DWORD CIS_Read(DWORD hOpenContext, LPVOID pBuffer, DWORD Count)
  1103. {
  1104. RETAILMSG(1,(TEXT("CAMERA: CIS_Readrn")));
  1105. return TRUE;
  1106. } 
  1108. //-----------------------------------------------------------------------------
  1109. //-----------------------------------------------------------------------------
  1110. DWORD CIS_Seek(DWORD hOpenContext, long Amount, DWORD Type)
  1111. {
  1112. RETAILMSG(1,(TEXT("CAMERA: CIS_Seekrn")));
  1113. return 0;
  1114. } 
  1116. //-----------------------------------------------------------------------------
  1117. //-----------------------------------------------------------------------------
  1118. DWORD CIS_Write(DWORD hOpenContext, LPCVOID pSourceBytes, DWORD NumberOfBytes)
  1119. {
  1120. RETAILMSG(1,(TEXT("CAMERA: CIS_Writern")));
  1121. return 0;
  1122. }
  1124. // for MPEG4
  1125. void Copy_Cam_Image(U8 *pBufOut, U32 size_x, U32 size_y, U8 port)
  1126. {
  1127. U8 *buffer_y, *buffer_cb, *buffer_cr;
  1128. U32 Y_size, C_size, P_size;
  1129. int temp;
  1130. U8 *pImage;
  1131. static unsigned int frame_timestamp_prev = GetTickCount();
  1132. static int frame_bank_prev = -1;
  1133. YUVINFO yuvinfo;
  1135. RETAILMSG(MSG_EN_1,(_T("Copy_Cam_Imagern")));
  1137. //s2440IOP->rGPFDAT &= ~(1<<6);
  1139. pImage = pBufOut;
  1141. if (image_size == 1) // QCIF
  1142. Y_size = QCIF_XSIZE*QCIF_YSIZE;
  1143. else if (image_size == 2) // CIF
  1144. Y_size = CIF_XSIZE*CIF_YSIZE;
  1146. C_size = Y_size/4;
  1147. P_size = Y_size + C_size*2;
  1149. {
  1150. temp = (s2440CAM->rCICOSTATUS>>26)&3;
  1151. temp = (temp + 2) % 4;
  1153. RETAILMSG(MSG_EN_1,(_T("Copy_Cam_Image %drn"), temp));
  1155. switch (temp)
  1156. {
  1157. case 0:
  1158. buffer_y = (U8 *)s2440CAM->rCICOYSA1;
  1159. buffer_cb = (U8 *)s2440CAM->rCICOCBSA1;
  1160. buffer_cr = (U8 *)s2440CAM->rCICOCRSA1;
  1161. break;
  1162. case 1:
  1163. buffer_y = (U8 *)s2440CAM->rCICOYSA2;
  1164. buffer_cb = (U8 *)s2440CAM->rCICOCBSA2;
  1165. buffer_cr = (U8 *)s2440CAM->rCICOCRSA2;
  1166. break;
  1167. case 2:
  1168. buffer_y = (U8 *)s2440CAM->rCICOYSA3;
  1169. buffer_cb = (U8 *)s2440CAM->rCICOCBSA3;
  1170. buffer_cr = (U8 *)s2440CAM->rCICOCRSA3;
  1171. break;
  1172. case 3:
  1173. buffer_y = (U8 *)s2440CAM->rCICOYSA4;
  1174. buffer_cb = (U8 *)s2440CAM->rCICOCBSA4;
  1175. buffer_cr = (U8 *)s2440CAM->rCICOCRSA4;
  1176. break;
  1177. default :
  1178. buffer_y = (U8 *)s2440CAM->rCICOYSA1;
  1179. buffer_cb = (U8 *)s2440CAM->rCICOCBSA1;
  1180. buffer_cr = (U8 *)s2440CAM->rCICOCRSA1;
  1181. break;
  1182. }
  1183. } 
  1185. #if (DOTNET_DRIVER)
  1186. SetKMode(TRUE);
  1187. #endif
  1189. buffer_y += VIRTUAL_ADDR_OFFSET;
  1190. buffer_cb += VIRTUAL_ADDR_OFFSET;
  1191. buffer_cr += VIRTUAL_ADDR_OFFSET;
  1193. RETAILMSG(MSG_EN_1,(_T("buffer_y = 0x%xrn"), buffer_y));
  1194. RETAILMSG(MSG_EN_1,(_T("buffer_cb = 0x%xrn"), buffer_cb));
  1195. RETAILMSG(MSG_EN_1,(_T("buffer_cr = 0x%xrn"), buffer_cr));
  1197. if (image_size == 1) // QCIF
  1198. {
  1199. yuvinfo.frame_width = QCIF_XSIZE;
  1200. yuvinfo.frame_height = QCIF_YSIZE;
  1201. }
  1202. else if (image_size == 2) // CIF
  1203. {
  1204. yuvinfo.frame_width = CIF_XSIZE;
  1205. yuvinfo.frame_height = CIF_YSIZE;
  1206. }
  1208. if (temp == frame_bank_prev) yuvinfo.frame_stamp = frame_timestamp_prev;
  1209. else 
  1210. {
  1211. yuvinfo.frame_stamp = GetTickCount();
  1212. frame_timestamp_prev = yuvinfo.frame_stamp;
  1213. frame_bank_prev = temp;
  1214. }
  1216. RETAILMSG(MSG_EN_1,(_T("pBufOut 0 offset = 0x%xrn"), pImage));
  1217. memcpy(pImage, &yuvinfo, sizeof(YUVINFO));
  1218. pImage += sizeof(YUVINFO);
  1220. RETAILMSG(MSG_EN_1,(_T("pBufOut Y = 0x%xrn"), pImage));
  1221. memcpy(pImage, buffer_y, Y_size);
  1222. pImage += (Y_size);
  1224. RETAILMSG(MSG_EN_1,(_T("pBufOut cb = 0x%xrn"), pImage));
  1225. memcpy(pImage, buffer_cb, C_size);
  1226. pImage += C_size;
  1227. RETAILMSG(MSG_EN_1,(_T("pBufOut cr = 0x%xrn"), pImage));
  1228. memcpy(pImage, buffer_cr, C_size);
  1229. // pBufOut += (size_x*size_y)/4;
  1232. #if (DOTNET_DRIVER)
  1233. SetKMode(FALSE);
  1234. #endif
  1237. // RETAILMSG(MSG_EN_1,(TEXT("1:buffer_y:0x%x,buffer_cb:0x%x,buffer_cr:0x%xrn"),buffer_y,buffer_cb,buffer_cr));
  1239. //s2440IOP->rGPFDAT |= (1<<6);
  1241. Tick_COPY_FRAME = GetTickCount();
  1243. RETAILMSG(MSG_EN_1,(_T("COPY_Tick = %drn"), (Tick_COPY_FRAME-Tick_GET_FRAME_CUR)));
  1244. RETAILMSG(MSG_EN_1,(_T("Frame_Tick = %drn"), (Tick_GET_FRAME_CUR-Tick_GET_FRAME_PREV)));
  1246. // RETAILMSG(1,(_T("Tick_COPY_FRAME = %drn"), Tick_COPY_FRAME));
  1247. // RETAILMSG(1,(_T("Tick_GET_FRAME_PREV = %drn"), Tick_GET_FRAME_PREV));
  1248. // RETAILMSG(1,(_T("Tick_GET_FRAME_CUR = %drn"), Tick_GET_FRAME_CUR));
  1251. }
  1253. void Samsung_camcoder(U8 *pBufOut)
  1254. {
  1255. U8 *pImage;
  1256. PINGPONG caminfo;
  1258. pImage = pBufOut;
  1260. if( codec_flag )
  1261. {
  1262. caminfo.flag = 1;
  1263. caminfo.y_address = y_address;
  1264. caminfo.cb_address = cb_address;
  1265. caminfo.cr_address = cr_address;
  1267. memcpy(pImage, &caminfo, sizeof(PINGPONG));
  1268. codec_flag = 0;
  1269. }
  1270. }
  1272. void Samsung_camcoder_pr(U8 *pBufOut)
  1273. {
  1274. U8 *pImage;
  1275. PINGPONG_PR prinfo;
  1277. pImage = pBufOut;
  1279. if ( rgb_flag )
  1280. {
  1281. prinfo.flag = 1;
  1282. prinfo.rgb_address = rgb_address;
  1283. memcpy(pImage, &prinfo, sizeof(PINGPONG_PR));
  1284. rgb_flag = 0;
  1285. }
  1286. }
  1288. void Buffer_codec_info_update()
  1289. {
  1290. U32 Y_size, C_size, P_size;
  1291. int temp;
  1292. unsigned int buffer_y, buffer_cb, buffer_cr;
  1294. if ( image_size == 1 )
  1295. Y_size = QCIF_XSIZE*QCIF_YSIZE;
  1296. else if ( image_size == 2 )
  1297. Y_size = CIF_XSIZE*CIF_YSIZE;
  1299. C_size = Y_size/4;
  1300. P_size = Y_size + C_size*2;
  1302. temp = (s2440CAM->rCICOSTATUS>>26)&3;
  1303. temp = (temp + 2) % 4;
  1305. RETAILMSG(MSG_EN_2,(_T("codec index = %d, size %drn"), temp, image_size));
  1307. switch (temp)
  1308. {
  1309. case 0:
  1310. buffer_y = s2440CAM->rCICOYSA1;
  1311. buffer_cb = s2440CAM->rCICOCBSA1;
  1312. buffer_cr = s2440CAM->rCICOCRSA1;
  1313. break;
  1314. case 1:
  1315. buffer_y = s2440CAM->rCICOYSA2;
  1316. buffer_cb = s2440CAM->rCICOCBSA2;
  1317. buffer_cr = s2440CAM->rCICOCRSA2;
  1318. break;
  1319. case 2:
  1320. buffer_y = s2440CAM->rCICOYSA3;
  1321. buffer_cb = s2440CAM->rCICOCBSA3;
  1322. buffer_cr = s2440CAM->rCICOCRSA3;
  1323. break;
  1324. case 3:
  1325. buffer_y = s2440CAM->rCICOYSA4;
  1326. buffer_cb = s2440CAM->rCICOCBSA4;
  1327. buffer_cr = s2440CAM->rCICOCRSA4;
  1328. break;
  1329. default :
  1330. buffer_y = s2440CAM->rCICOYSA1;
  1331. buffer_cb = s2440CAM->rCICOCBSA1;
  1332. buffer_cr = s2440CAM->rCICOCRSA1;
  1333. break;
  1334. }
  1336. buffer_y += VIRTUAL_ADDR_OFFSET;
  1337. buffer_cb += VIRTUAL_ADDR_OFFSET;
  1338. buffer_cr += VIRTUAL_ADDR_OFFSET;
  1339. #if 0
  1340. RETAILMSG(MSG_EN_1,(_T("buffer_y = 0x%xrn"), buffer_y));
  1341. RETAILMSG(MSG_EN_1,(_T("buffer_cb = 0x%xrn"), buffer_cb));
  1342. RETAILMSG(MSG_EN_1,(_T("buffer_cr = 0x%xrn"), buffer_cr));
  1343. #endif
  1344. if( codec_flag ) RETAILMSG(MSG_EN_1,(_T("Buffer is not readrn")));
  1345. codec_flag = 1;
  1346. y_address = buffer_y;
  1347. cb_address = buffer_cb;
  1348. cr_address = buffer_cr;
  1349. }
  1352. void Buffer_preview_info_update()
  1353. {
  1354. // U32 Y_size;
  1355. int temp;
  1356. unsigned int buffer_rgb;
  1358. /*
  1359. if ( image_size == 1 )
  1360. Y_size = QCIF_XSIZE*QCIF_YSIZE;
  1361. else if ( image_size == 2 )
  1362. Y_size = CIF_XSIZE*CIF_YSIZE;
  1363. */
  1365. temp = (s2440CAM->rCIPRSTATUS>>26)&3;
  1366. temp = (temp + 2) % 4;
  1368. RETAILMSG(MSG_EN_2,(_T("preview index = %d, size %drn"), temp, image_size));
  1370. switch (temp)
  1371. {
  1372. case 0:
  1373. buffer_rgb = s2440CAM->rCIPRCLRSA1;
  1374. break;
  1375. case 1:
  1376. buffer_rgb = s2440CAM->rCIPRCLRSA2;
  1377. break;
  1378. case 2:
  1379. buffer_rgb = s2440CAM->rCIPRCLRSA3;
  1380. break;
  1381. case 3:
  1382. buffer_rgb = s2440CAM->rCIPRCLRSA4;
  1383. break;
  1384. default :
  1385. buffer_rgb = s2440CAM->rCIPRCLRSA1;
  1386. break;
  1387. }
  1389. buffer_rgb += VIRTUAL_ADDR_OFFSET;
  1390. #if 0
  1391. RETAILMSG(MSG_EN_1,(_T("buffer_rgb = 0x%xrn"), buffer_rgb));
  1392. #endif
  1393. if( rgb_flag ) RETAILMSG(MSG_EN_1,(_T("Buffer is not readrn")));
  1394. rgb_flag = 1;
  1395. rgb_address = buffer_rgb;
  1396. }
  1399. void CamInit(U32 CoDstWidth, U32 CoDstHeight, U32 PrDstWidth, U32 PrDstHeight, 
  1400. U32 WinHorOffset, U32 WinVerOffset,  U32 CoFrameBuffer, U32 PrFrameBuffer)
  1401. {
  1402. U32 WinOfsEn;
  1403. U32 divisor, multiplier;
  1404. U32 MainBurstSizeY, RemainedBurstSizeY, MainBurstSizeC, RemainedBurstSizeC, MainBurstSizeRGB, RemainedBurstSizeRGB;
  1405. U32 H_Shift, V_Shift, PreHorRatio, PreVerRatio, MainHorRatio, MainVerRatio;
  1406. U32 SrcWidth, SrcHeight;
  1407. U32 ScaleUp_H_Co, ScaleUp_V_Co, ScaleUp_H_Pr, ScaleUp_V_Pr;
  1409. //constant for calculating codec dma address
  1410. if(CAM_CODEC_OUTPUT)
  1411. divisor=2; //CCIR-422
  1412. else
  1413. divisor=4; //CCIR-420
  1415. //constant for calculating preview dma address
  1416. if(CAM_PVIEW_OUTPUT)
  1417. multiplier=4;
  1418. else
  1419. multiplier=2;
  1421. if(WinHorOffset==0 && WinVerOffset==0)
  1422. WinOfsEn=0;
  1423. else
  1424. WinOfsEn=1;
  1426. SrcWidth=CAM_SRC_HSIZE-WinHorOffset*2;
  1427. SrcHeight=CAM_SRC_VSIZE-WinVerOffset*2;
  1429. if(SrcWidth>=CoDstWidth) ScaleUp_H_Co=0; //down
  1430. else ScaleUp_H_Co=1; //up
  1432. if(SrcHeight>=CoDstHeight) ScaleUp_V_Co=0;
  1433. else ScaleUp_V_Co=1;
  1435. if(SrcWidth>=PrDstWidth) ScaleUp_H_Pr=0; //down
  1436. else ScaleUp_H_Pr=1; //up
  1438. if(SrcHeight>=PrDstHeight) ScaleUp_V_Pr=0;
  1439. else ScaleUp_V_Pr=1;
  1441. ////////////////// common control setting
  1442. s2440CAM->rCIGCTRL |= (1<<26)|(0<<27); // inverse PCLK, test pattern
  1443. s2440CAM->rCIWDOFST = (1<<30)|(0xf<<12); // clear overflow 
  1444. s2440CAM->rCIWDOFST = 0;
  1445. s2440CAM->rCIWDOFST=(WinOfsEn<<31)|(WinHorOffset<<16)|(WinVerOffset);
  1446. s2440CAM->rCISRCFMT=(CAM_ITU601<<31)|(0<<30)|(0<<29)|(CAM_SRC_HSIZE<<16)|(CAM_ORDER_YCBYCR<<14)|(CAM_SRC_VSIZE);
  1447. //s2440CAM->rCISRCFMT=(CAM_ITU656<<31)|(0<<30)|(0<<29)|(CAM_SRC_HSIZE<<16)|(CAM_ORDER_CBYCRY<<14)|(CAM_SRC_VSIZE);
  1449. ////////////////// codec port setting
  1450. s2440CAM->rCICOYSA1=CoFrameBuffer;
  1451. s2440CAM->rCICOYSA2=s2440CAM->rCICOYSA1+CoDstWidth*CoDstHeight+2*CoDstWidth*CoDstHeight/divisor;
  1452. s2440CAM->rCICOYSA3=s2440CAM->rCICOYSA2+CoDstWidth*CoDstHeight+2*CoDstWidth*CoDstHeight/divisor;
  1453. s2440CAM->rCICOYSA4=s2440CAM->rCICOYSA3+CoDstWidth*CoDstHeight+2*CoDstWidth*CoDstHeight/divisor;
  1455. s2440CAM->rCICOCBSA1=s2440CAM->rCICOYSA1+CoDstWidth*CoDstHeight;
  1456. s2440CAM->rCICOCBSA2=s2440CAM->rCICOYSA2+CoDstWidth*CoDstHeight;
  1457. s2440CAM->rCICOCBSA3=s2440CAM->rCICOYSA3+CoDstWidth*CoDstHeight;
  1458. s2440CAM->rCICOCBSA4=s2440CAM->rCICOYSA4+CoDstWidth*CoDstHeight;
  1460. s2440CAM->rCICOCRSA1=s2440CAM->rCICOCBSA1+CoDstWidth*CoDstHeight/divisor;
  1461. s2440CAM->rCICOCRSA2=s2440CAM->rCICOCBSA2+CoDstWidth*CoDstHeight/divisor;
  1462. s2440CAM->rCICOCRSA3=s2440CAM->rCICOCBSA3+CoDstWidth*CoDstHeight/divisor;
  1463. s2440CAM->rCICOCRSA4=s2440CAM->rCICOCBSA4+CoDstWidth*CoDstHeight/divisor;
  1464.     
  1465. s2440CAM->rCICOTRGFMT=(CAM_CODEC_IN_422<<31)|(CAM_CODEC_OUTPUT<<30)|(CoDstWidth<<16)|(CAM_FLIP_NORMAL<<14)|(CoDstHeight);
  1467. CalculateBurstSize(CoDstWidth, &MainBurstSizeY, &RemainedBurstSizeY);
  1468. CalculateBurstSize(CoDstWidth/2, &MainBurstSizeC, &RemainedBurstSizeC);
  1469. s2440CAM->rCICOCTRL=(MainBurstSizeY<<19)|(RemainedBurstSizeY<<14)|(MainBurstSizeC<<9)|(RemainedBurstSizeC<<4);
  1471. CalculatePrescalerRatioShift(SrcWidth, CoDstWidth, &PreHorRatio, &H_Shift);
  1472. CalculatePrescalerRatioShift(SrcHeight, CoDstHeight, &PreVerRatio, &V_Shift);
  1473. MainHorRatio=(SrcWidth<<8)/(CoDstWidth<<H_Shift);
  1474. MainVerRatio=(SrcHeight<<8)/(CoDstHeight<<V_Shift);
  1475.     
  1476. s2440CAM->rCICOSCPRERATIO=((10-H_Shift-V_Shift)<<28)|(PreHorRatio<<16)|(PreVerRatio);
  1477. s2440CAM->rCICOSCPREDST=((SrcWidth/PreHorRatio)<<16)|(SrcHeight/PreVerRatio); 
  1478. s2440CAM->rCICOSCCTRL=(CAM_SCALER_BYPASS_OFF<<31)|(ScaleUp_H_Co<<30)|(ScaleUp_V_Co<<29)|(MainHorRatio<<16)|(MainVerRatio);
  1480. s2440CAM->rCICOTAREA=CoDstWidth*CoDstHeight;
  1482. ///////////////// preview port setting
  1483. s2440CAM->rCIPRCLRSA1=PrFrameBuffer;
  1484. s2440CAM->rCIPRCLRSA2=s2440CAM->rCIPRCLRSA1+PrDstWidth*PrDstHeight*multiplier;
  1485. s2440CAM->rCIPRCLRSA3=s2440CAM->rCIPRCLRSA2+PrDstWidth*PrDstHeight*multiplier;
  1486. s2440CAM->rCIPRCLRSA4=s2440CAM->rCIPRCLRSA3+PrDstWidth*PrDstHeight*multiplier;
  1488. s2440CAM->rCIPRTRGFMT=(PrDstWidth<<16)|(CAM_FLIP_NORMAL<<14)|(PrDstHeight);
  1490. if (CAM_PVIEW_OUTPUT==CAM_RGB24B)
  1491. CalculateBurstSize(PrDstWidth*4, &MainBurstSizeRGB, &RemainedBurstSizeRGB);
  1492. else // RGB16B
  1493. CalculateBurstSize(PrDstWidth*2, &MainBurstSizeRGB, &RemainedBurstSizeRGB);
  1494.     s2440CAM->rCIPRCTRL=(MainBurstSizeRGB<<19)|(RemainedBurstSizeRGB<<14);
  1496. CalculatePrescalerRatioShift(SrcWidth, PrDstWidth, &PreHorRatio, &H_Shift);
  1497. CalculatePrescalerRatioShift(SrcHeight, PrDstHeight, &PreVerRatio, &V_Shift);
  1498. MainHorRatio=(SrcWidth<<8)/(PrDstWidth<<H_Shift);
  1499. MainVerRatio=(SrcHeight<<8)/(PrDstHeight<<V_Shift);
  1500. s2440CAM->rCIPRSCPRERATIO=((10-H_Shift-V_Shift)<<28)|(PreHorRatio<<16)|(PreVerRatio);  
  1501. s2440CAM->rCIPRSCPREDST=((SrcWidth/PreHorRatio)<<16)|(SrcHeight/PreVerRatio);
  1502. s2440CAM->rCIPRSCCTRL=(1<<31)|(CAM_RGB16B<<30)|(ScaleUp_H_Pr<<29)|(ScaleUp_V_Pr<<28)|(MainHorRatio<<16)|(MainVerRatio);
  1503.     
  1504. s2440CAM->rCIPRTAREA= PrDstWidth*PrDstHeight;
  1505. }