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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
i34.c
资源名称：dvd-munitions.tar.gz　[点击查看]
上传用户：aoeyumen
上传日期：2007-01-06
资源大小：3329k
文件大小：21k
源码类别：

DVD

开发平台：

Unix_Linux

i34.c：源码内容
  1. /* -*- linux-c -*- --------------------------------------------------------- *  
  2.  * This module is an interface to the ZORAN zr367x0 dvd decoder chip.
  3.  *
  4.  * Copyright (C) 1999 David Barth <dbarth@besancon.net>
  5.  *
  6.  * This program is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU General Public License
  8.  * as published by the Free Software Foundation; either version 2
  9.  * of the License, or (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  *
  20.  */
  22. #ifndef __KERNEL__
  23. #define __KERNEL__
  24. #endif
  25. #ifndef MODULE
  26. #define MODULE
  27. #endif
  29. #include <linux/module.h>
  30. #include <linux/delay.h>
  31. #include <linux/errno.h>
  32. #include <linux/kernel.h>
  33. #include <linux/mm.h>
  34. #include <linux/poll.h>
  35. #include <asm/io.h>
  36. #include <linux/sched.h>
  37. #include <linux/videodev2.h>
  38. #include <linux/proc_fs.h>
  39. #include "mgavideo.h"
  40. #include "i34.h"
  42. #define dprintk     if (debug) printk
  44. static int debug = 1;    /* insmod parameter */
  45. static int reset = 1; /* insmod parameter */
  47. #if LINUX_VERSION_CODE >= 0x020100
  48. MODULE_PARM(debug,"i");
  49. MODULE_PARM(reset,"i");
  50. #endif
  52. static struct mga_dev *host;
  55. #define I34_STATE_NO_UCODE 0 /* indicates that no microcode has been downloaded so far */
  57. static int state = 0; /* internal state */
  59. static u8 ucode_buffer[16384]; /* buffer holding ucode to download into the chipset */
  60. static u16 ucode_length = 0; /* length of the ucode inside the buffer */
  61. static u16 ucode_wmark = 0; /* number of bytes written to the chipset
  62.    needed so that we can zero-pad ucode when downloading
  63.    a new ucode */
  65. /****************************************************************************
  66.  * DVD/MPEG Add-on board     *
  67.  ****************************************************************************/
  69. /* main registers */
  70. #define ZR_PARAM_ADDR 0x0
  71. #define ZR_PARAM_DATA 0x1
  72. #define ZR_ISR 0x2
  73. #define ZR_STATUS0 0x3
  74. #define ZR_HOSTCMD 0x3
  75. #define ZR_STATUS1 0x4
  76. #define ZR_STATUS2 0x5
  77. #define ZR_DEVICE_ID 0x7
  78. #define ZR_ADP_DATA 0x8
  79. #define ZR_ADP_STATUS 0x8
  80. #define ZR_SYS_CLOCK 0x9
  81. #define ZR_NAV_DATA 0xA
  82. #define ZR_RESERVED1 0xB
  83. #define ZR_SUBPICBUF 0xC
  84. #define ZR_VIDEOBUF 0xD
  85. #define ZR_AUDIOBUF 0xE
  86. #define ZR_RESERVED2 0xF
  88. /* indirect registers */
  89. #define ZR_SYSCONFIG 0x00
  90. #define ZR_VIDCONFIG 0x01
  91. #define ZR_SDCONFIG 0x02
  92. #define ZR_DVPGEN1 0x03
  93. #define ZR_DVPGEN2 0x04
  94. #define ZR_DVPGEN3 0x05
  95. #define ZR_COLORV 0x08
  96. #define ZR_COLORY 0x09
  97. #define ZR_COLORU 0x0A
  98. #define ZR_VIDOUT 0x10
  99. #define ZR_HTOTAL 0x11
  100. #define ZR_VTOTAL 0x12
  101. #define ZR_HSYNCSIZE 0x13
  102. #define ZR_VSYNCSIZE 0x14
  103. #define ZR_CBHSTART 0x15
  104. #define ZR_CBVSTART 0x16
  105. #define ZR_CBHEND 0x17
  106. #define ZR_CBVEND 0x18
  107. #define ZR_ACTIVESTARTX 0x19
  108. #define ZR_ACTIVESTARTY 0x1A
  109. #define ZR_ACTIVEENDX 0x1B
  110. #define ZR_ACTIVEENDY 0x1C
  111. #define ZR_ACTIVESIZEX 0x1D
  112. #define ZR_ACTIVESIZEY 0x1E
  114. #define ZR_IMAGESTARTX 0x19
  115. #define ZR_IMAGESTARTY 0x1A
  116. #define ZR_IMAGEENDX 0x1B
  117. #define ZR_IMAGEENDY 0x1C
  118. #define ZR_IMAGESIZEX 0x1D
  119. #define ZR_IMAGESIZEY 0x1E
  120. #define ZR_CAPTIONOFFSET 0x1F
  121. #define ZR_STARTDISPLAY  0x20
  122. #define ZR_OSDSWITCH 0x2D
  123. #define ZR_PLAYBACKMODE 0x41
  124. #define ZR_AUDSID 0x42
  125. #define ZR_VIDSID 0x43
  126. #define ZR_SPSID 0x44
  127. #define ZR_AUDPORTDELAY 0x45
  128. #define ZR_VIDPORTDELAY 0x46
  129. #define ZR_VIDTOLERANCE 0x47
  130. #define ZR_VIDSYNCMODE 0x48
  131. #define ZR_AUTOSCALING 0x50
  132. #define ZR_AUTOPANSCAN 0x68
  133. #define ZR_BACKGROUNDSWITCH 0x6B
  134. #define ZR_INITFILE_1 0xF0
  135. #define ZR_INITFILE_2 0xF1
  136. #define ZR_INITFILE_3 0xF2
  137. #define ZR_INITFILE_4 0xF3
  138. #define ZR_MICROCODE 0xFD
  140. static u16 shadow_register[0xff]; // Warning: not all registers are 2 bytes long
  141. // but it's enough for those we're interested in
  143. u16 I34_Read(struct mga_dev *mga, u8 reg) {
  144. codec_reset(mga);
  145. codec_read(mga, reg);
  146. codec_exec(mga);
  147. return __swab16(codec_getw(mga));
  148. }
  150. void I34_Write(struct mga_dev *mga, u8 reg, u16 data) {
  151. codec_reset(mga);
  152. codec_write(mga, reg, __swab16(data));
  153. codec_exec(mga);
  154. }
  156. /* see table 32 p. 79 for the protocol to access the indirect address space */
  157. u16 I34_ParameterRead(struct mga_dev *mga, u8 addr) {
  158. codec_reset(mga);
  159. /* addr. in the l.s. bits, m.s. bits must be 0 */
  160. codec_write(mga, ZR_PARAM_ADDR, __swab16(addr));
  161. codec_read(mga, ZR_PARAM_DATA);
  162. codec_exec(mga);
  163. shadow_register[addr] = __swab16(codec_getw(mga));
  164. return shadow_register[addr];
  165. }
  167. void I34_ParameterWrite(struct mga_dev *mga, u8 addr, u16 data) {
  168. shadow_register[addr] = data;
  169. codec_reset(mga);
  170. codec_write(mga, ZR_PARAM_ADDR, __swab16(addr));
  171. codec_write(mga, ZR_PARAM_DATA, __swab16(data));
  172. codec_exec(mga);
  173. }
  175. void I34_ParameterWriteSeq(struct mga_dev *mga, u8 addr, u8* buf, u32 len) {
  176. u32 i;
  178. codec_reset(mga);
  179. codec_write(mga, ZR_PARAM_ADDR, __swab16(addr));
  180. /* multiple read/writes witout modifying the Parameter Address Register */
  181. if (buf == 0) {
  182. for (i=0; i<len; i+=2) // we count the buffer size in bytes, but write a _word_ at a time
  183. codec_write(mga, ZR_PARAM_DATA, 0);
  184.   
  185. } else {
  186. for (i=0; i<len; i+=2)
  187. codec_write(mga, ZR_PARAM_DATA, __swab16(*(((u16 *)buf)++)));
  189. }
  190. codec_exec(mga);
  191. }
  193. int I34_State(struct mga_dev *mga, int *s) {
  194. *s = (I34_Read(mga, ZR_STATUS0) >> 10);
  195. return 0;
  196. }
  198. int I34_Command(struct mga_dev *mga, u16 cmd) {
  199. /* p. 100 ZR HB: check that the host is ready to receive a new command */
  200. u16 status1 = I34_Read(mga, ZR_STATUS1);
  201. u16 hcready = (status1 >> 8) & 0x80;
  202. if (hcready) {
  203. I34_Write(mga, ZR_HOSTCMD, cmd);
  204. return 0;
  205. } else {
  206. I34_Write(mga, ZR_HOSTCMD, cmd);
  207. dprintk("I34: host is not ready to receive commands (%#4.4x)n", status1);
  208. return -EBUSY;
  209. }
  210. }
  213. /* new form: returns an error status and passes the actual result via a pointer */
  214. int I34_ReadInterruptStatus(struct mga_dev *mga, u16 *status) {
  215. *status = I34_Read(mga, ZR_ISR);
  216. return 1;
  217. }
  219. void I34_SetPar_bits(struct mga_dev *mga, u16 addr, u16 or, u16 and) {
  220. // the windows driver uses a shadow register that recalls
  221. // the last read value of the register...
  222. u16 value = (shadow_register[addr] & ~and) | or;
  223. I34_ParameterWrite(mga, addr, value);
  224. }
  226. #define I34_WaitMicroSecond(a) udelay(a)
  228. void I34_ResetPin(struct mga_dev *mga) {
  230. if (reset == 0) return;
  232. codec_miscctl_func1(mga, reset);
  233. I34_WaitMicroSecond(160);
  234. codec_I34_reset(mga);
  235. codec_miscctl(mga, 0x0f, 0xf9);
  236. }
  238. int I34_Reset(struct mga_dev *mga) {
  239. u16 i, isr;
  241. dprintk("I34: Resetn");
  243. I34_ResetPin(mga);
  245. for (i=0; i<5000; i++) {
  246. if (!I34_ReadInterruptStatus(mga, &isr)) {
  247. return 0;
  248. }
  249. #ifdef BYTEORDERHACK
  250. if ((isr & 0x1800) == 0x1800) {
  252. mga->little_endian_codec = 0;
  253. dprintk("I34_Reset ISR = 0x%4.4x Codec big-endian after resetn", isr);
  254. I34_ParameterWrite(mga, 0x0F3, 0xA0);
  255. I34_ParameterWrite(mga, 0x0F3, 0x88);
  256. return 1;
  257. } else if ((isr & 0x18) == 0x18) {
  258. mga->little_endian_codec = 1;
  259. dprintk("I34_Reset ISR = 0x%4.4x Codec little-endian after resetn", isr);
  260. I34_ParameterWrite(mga, 0x0F3, 0xA0);
  261. I34_ParameterWrite(mga, 0x0F3, 0x88);
  262. return 1;
  263. }
  264. #else
  265. if ((isr & 0x1800) == 0x1800) {
  266. I34_ParameterWrite(mga, 0x0F3, 0xA0);
  267. I34_ParameterWrite(mga, 0x0F3, 0x88);
  268. return 1;
  269. }
  270. #endif
  271. I34_WaitMicroSecond(100);
  272. }
  273. dprintk("PLL's NOT locked ---> 0x%4.4xn", isr);
  274. return 0;
  275. }
  277. int I34_Detect(struct mga_dev *mga) {
  278. u32 id;
  280. #ifdef BYTEORDERHACK
  281. mga->little_endian_codec = 0; /* assume the codec is bigendian */
  282. #endif
  284. I34_Reset(mga);
  285. id = I34_Read(mga, ZR_DEVICE_ID);
  286. /* we should obtain: 0x34 m.s. bits, rev in l.s. bits p. 112 ZR HB */
  287. /* warning: this test is arch. dependent ! */
  288. #ifndef __LITTLE_ENDIAN
  289. #error FIX ME
  290. #else
  291. if (((id>>8) & 0xFF) == 0x34) {
  292. dprintk("I34: found chipset rev 0x%2.2x)n", id & 0xFF);
  293. return 1;
  294. } else {
  295. dprintk("I34: too bad, codec said 0x%4.4xn", id);
  296. return 0;
  297. }
  298. #endif
  299. }
  301. int I34_ColorKey(struct mga_dev* mga, struct ColorKey *ck)
  302. {
  303. I34_ParameterWrite(mga, ZR_COLORV, ck->v);
  304. I34_ParameterWrite(mga, ZR_COLORU, ck->y);
  305. I34_ParameterWrite(mga, ZR_COLORY, ck->u);
  306. return 0;
  307. }
  309. static struct VideoStandard pal1 = { // was unk_28E0
  310. 1, // VidFPS => PAL
  311. 0, // ??
  312. 0, // FieldSel
  313. 0, // ??
  314. 864, // HTotal
  315. 625, // VTotal
  316. 64, // HSyncSize
  317. 6, // VSyncSize
  318. 142, // ActiveStartX
  319. 14, // ActiveStartY
  320. 860, // ActiveEndX
  321. 310, // ActiveEndY
  322. 720,  // ActiveSizeX
  323. 288, // ActiveSizeY
  324. 0x4006 // VidConfig
  325. };
  327. static struct VideoStandard ntsc1 = { // was unk_2900
  328. 0, // VidFPS => NTSC
  329. 0, // ??
  330. 0, // FieldSel
  331. 0, // ??
  332. 858, // HTotal
  333. 525, // VTotal
  334. 64, // HSyncSize
  335. 6, // VSyncSize
  336. 136, // ActiveStartX
  337. 14, // ActiveStartY
  338. 856, // ActiveEndX
  339. 260, // ActiveEndY
  340. 720,  // ActiveSizeX
  341. 240, // ActiveSizeY
  342. 0x4006 // VidConfig <=> Video8, Sync8, PixLim
  343. };
  345. static struct VideoStandard pal2 = { // was unk_3930
  346. 1, // VidFPS => PAL
  347. 0, // ??
  348. 0, // FieldSel
  349. 0, // ??
  350. 864, // HTotal
  351. 625, // VTotal
  352. 64, // HSyncSize
  353. 6, // VSyncSize
  354. 142, // ActiveStartX
  355. 16, // ActiveStartY
  356. 862, // ActiveEndX
  357. 310, // ActiveEndY
  358. 720,  // ActiveSizeX
  359. 288, // ActiveSizeY
  360. 0x4006 // VidConfig
  361. };
  363. static struct VideoStandard ntsc2 = { // was unk_2900
  364. 0, // VidFPS => NTSC
  365. 0, // ??
  366. 0, // FieldSel
  367. 0, // ??
  368. 858, // HTotal
  369. 525, // VTotal
  370. 64, // HSyncSize
  371. 6, // VSyncSize
  372. 136, // ActiveStartX
  373. 16, // ActiveStartY
  374. 856, // ActiveEndX
  375. 352, // ActiveEndY
  376. 720,  // ActiveSizeX
  377. 240, // ActiveSizeY
  378. 0x4006 // VidConfig <=> Video8, Sync8, PixLim
  379. };
  382. /* this is pure guess (but works somehow...) */
  383. static struct CompositeBlankSync cbs1 = {
  384. 6,  // HStart
  385. 2,  // VStart;
  386. 857, // HEnd;
  387. 261 // VEnd;
  388. };
  390. static struct ColorKey ckBlank = {
  391. 0,
  392. 0x80,
  393. 0x80
  394. };
  397. int I34_LoadVideoStandard(struct mga_dev *mga, struct VideoStandard *vs) {
  398. I34_ParameterWrite(mga, ZR_VIDOUT, vs->FieldSel | vs->VidFPS);
  399. I34_ParameterWrite(mga, ZR_HTOTAL, vs->HTotal);
  400. I34_ParameterWrite(mga, ZR_VTOTAL, vs->VTotal);
  401. I34_ParameterWrite(mga, ZR_HSYNCSIZE, vs->HSyncSize);
  402. I34_ParameterWrite(mga, ZR_VSYNCSIZE, vs->VSyncSize);
  403. I34_ParameterWrite(mga, ZR_ACTIVESTARTX, vs->ActiveStartX);
  404. I34_ParameterWrite(mga, ZR_ACTIVESTARTY, vs->ActiveStartY);
  405. I34_ParameterWrite(mga, ZR_ACTIVEENDX, vs->ActiveEndX);
  406. I34_ParameterWrite(mga, ZR_ACTIVEENDY, vs->ActiveEndY);
  407. I34_ParameterWrite(mga, ZR_ACTIVESIZEX, vs->ActiveSizeX);
  408. I34_ParameterWrite(mga, ZR_ACTIVESIZEY, vs->ActiveSizeY);
  409. I34_ParameterWrite(mga, ZR_VIDCONFIG, vs->VidConfig);
  411. return 0;
  412. }
  414. int I34_OutputVideoStandard(struct mga_dev *mga, int standard) {
  415. struct VideoStandard *vs;
  417. switch(standard) {
  418. case I34_NTSC:
  419. vs = &ntsc1;
  420. break;
  421. case I34_NTSC_ALT:
  422. vs = &ntsc2;
  423. break;
  424. case I34_PAL:
  425. vs = &pal1;
  426. break;
  427. case I34_PAL_ALT:
  428. default:
  429. vs = &pal2;
  430. break;
  431.     
  432. }
  434. /*  if (standard == 0 || standard == -1) {
  435.     vs = &ntsc2;
  436.     } else if (standard == 1) {
  437.     vs = &pal1;
  438.     } else 
  439.     return 0;
  440. */
  442. return I34_LoadVideoStandard(mga, vs);
  443. }
  445. int I34_CompositeBlankSync(struct mga_dev *mga, struct CompositeBlankSync *cb) {
  446. I34_ParameterWrite(mga, ZR_CBHSTART, cb->CBHStart);
  447. I34_ParameterWrite(mga, ZR_CBVSTART, cb->CBVStart);
  448. I34_ParameterWrite(mga, ZR_CBHEND, cb->CBHEnd);
  449. I34_ParameterWrite(mga, ZR_CBVEND, cb->CBVEnd);
  451. return 0;
  452. }
  454. int I34_StartDisplay(struct mga_dev *mga) {
  455. I34_ParameterWrite(mga, ZR_PLAYBACKMODE, 0);
  456. I34_SetPar_bits(mga, ZR_BACKGROUNDSWITCH, 1, 1);
  457. I34_ParameterWrite(mga, ZR_AUTOSCALING, 1<<15);
  458. I34_ParameterWrite(mga, ZR_AUTOPANSCAN, 1);
  459. I34_ParameterWrite(mga, ZR_OSDSWITCH, 0);        
  460. I34_ParameterWrite(mga, ZR_AUDPORTDELAY, 0);
  461. I34_ParameterWrite(mga, ZR_VIDPORTDELAY, 0);
  462. I34_ParameterWrite(mga, ZR_VIDTOLERANCE, 0);
  463. /* validate the new video parameters */
  464. I34_ParameterWrite(mga, ZR_STARTDISPLAY, 1);
  465. return 0;
  466. }
  468. /* this function progressively fills the ucode buffer prior to downloading */
  469. /* length = size of the new chunk to add in the buffer
  470.    or 0 to reset to the start of the ucode buffer
  471. */
  472. int I34_MicrocodeRead(struct mga_dev *mga, struct i34_ucode_chunk *chunk) {
  474. if ((ucode_length + chunk->length) >= 16384) return -EINVAL;
  476. memcpy(chunk->buffer, ucode_buffer + ucode_length, chunk->length);
  477. ucode_length += chunk->length;
  478. return 0;
  479. }
  482. /* example calls :
  484.      in ADPBoot
  485.       I34_MicrocodeRead(1, 2, offset unk_210, dword ptr [ebp+8])
  486.       I34_MicrocodeRead(edi, 0x3c, offset unk_4c8, dword ptr [ebp+8])
  488.      in DVPMicrocodeDownload
  489. result = I34_MicrocodeRead(1, 2, offset unk_2888, dword ptr [ebp+8])
  490. result = I34_MicrocodeRead(0, 0x3c, result, dword ptr [ebp+8])
  491. I34_ParameterWriteSeq(0xFD, 0, buf);
  493.      in LoadSlotMachine
  494. I34_MicrocodeRead(1, 2, offset unk_4C8, 0x0103)
  495. I34_MicrocodeRead(0, 0x3c, esi, edi)
  497.      in LoadDRAMMapping
  498. I34_MicrocodeRead(1, 0x3c, offset unk_4C8, 0x0104)
  500.    */  
  502. int I34_DVPMicrocodeDownload(struct mga_dev *mga) {
  504. if (ucode_length == 0) return 0;
  505.  
  506. /* In the general case, we should store the size of the last microcode
  507.    and zero-pad it to 16384, and then upload the new code */
  508. if (ucode_wmark != 0)
  509. I34_ParameterWriteSeq(mga, 0xfd, 0, 16384 - ucode_wmark);
  511. dprintk("I34: trying to upload %d bytes into the chipsetn", ucode_length);
  512. I34_ParameterWriteSeq(mga, ZR_MICROCODE, ucode_buffer, ucode_length);
  514. return 1;
  515. /* I need to down/upload : 340EDVD.DVP 340EAC3.ADP & ZI34SLT1.PRG */
  516. }
  518. int I34_Init(struct mga_dev *mga) {
  520. /* According to Annex C p. 248 of the ZR36710 Handbook */
  522. dprintk("I34_initn");
  523. /* Stage 1 : Reset */
  524. if (!I34_Detect(mga)) return -ENODEV;
  526. /* Stage 2 : I/O Port Configuration */
  527. /* SDRAM, Host Bus Port */
  528. I34_ParameterWrite(mga, ZR_SYSCONFIG, 0x1408); // CodeSource = HostBus; Decryption = enable
  529. I34_SetPar_bits(mga, 0xA0, 0x80, 0x80); // ??
  530. I34_SetPar_bits(mga, 0xA0, 0x00, 0x80);
  531. I34_SetPar_bits(mga, 0xA0, 0x0F, 0x0F);
  532. I34_SetPar_bits(mga, 0xA4, 0x00, 0x40);
  533. I34_SetPar_bits(mga, 0xA4, 0x01, 0x07);
  534. I34_ParameterWrite(mga, ZR_SDCONFIG, 0);
  536. return 0;
  538. /* Audio Port */
  539. /* tricky, so I leave it at defaults value for now... */
  541. /* Video Port */
  542. /* mga video-in is an 8-bits bus (Appendix A1.5) */
  543. I34_OutputVideoStandard(mga, I34_NTSC);
  545. I34_CompositeBlankSync(mga, &cbs1);
  546. I34_ColorKey(mga, &ckBlank);
  547. I34_ParameterWrite(mga, ZR_STARTDISPLAY, 1);
  548. I34_SetPar_bits(mga, ZR_BACKGROUNDSWITCH, 1, 1);
  550. /* Stage 3 :  OSD and Preparation for Decoding*/
  551. /* OSD */
  552. I34_ParameterWrite(mga, ZR_OSDSWITCH, 0);        
  554. /* Microcode uploading - DVP and ADP*/
  555. /* we first need to zero-pad the 16384 bytes of the microcode prior to loading a new one */
  556. // I34_ParameterWriteClean(mga, ZR_MICROCODE, 0x0000, 16384);
  557. // dprintk("I34: uploading %d bytes of microcoden", sizeof(microcode));
  558. // I34_ParameterWrite_buffer(mga, ZR_MICROCODE, (u16*)microcode, sizeof(microcode));
  560. I34_StartDisplay(mga);
  562. /* TEST */
  563. I34_Command(mga, I34_CMD_START); /* START */
  564. I34_Command(mga, I34_CMD_END | 1); /* END and display bgnd color */
  568. /* Stage  :  */
  569. /* Stage  :  */
  571. /* Stage  :  */
  572. /* 0 since no bistream is decoded yet (p. 91 ZR-HB) */
  573. I34_ParameterWrite(mga, ZR_AUDPORTDELAY, 0);
  574. I34_ParameterWrite(mga, ZR_VIDPORTDELAY, 0);
  575. I34_ParameterWrite(mga, ZR_VIDTOLERANCE, 0);
  577. /* Stage  :  */
  578. /* Stage  :  */
  579. /* Stage  :  */
  580. /* Stage  :  */
  581. /* Stage  :  */
  582. /* Stage  :  */
  583. /* Stage  :  */
  584. /* Stage  :  */
  585. /* Stage  :  */
  586. /* Stage  :  */
  588. return 0;
  589. }
  591. int codec_read_info(char *buf, char **start, off_t offset, int len, int unused) {
  592. u16 data;
  593.         struct mga_dev* mga = host;
  595. if (host == NULL) return 0;
  597. len = 0;
  598. len += sprintf(buf + len, "Zoran codec interfacen");
  600. data = I34_ParameterRead(mga, ZR_VIDCONFIG);
  601. len += sprintf(buf + len, "VidConfig: 0x%4.4xnn", data);
  603. len += sprintf(buf + len, "PARAM_ADDR %#4.4xn", I34_Read(mga, ZR_PARAM_ADDR));
  604. len += sprintf(buf + len, "PARAM_DATA %#4.4xn", I34_Read(mga, ZR_PARAM_DATA));
  605. len += sprintf(buf + len, "ISR        %#4.4xn", I34_Read(mga, ZR_ISR));
  606. data = I34_Read(mga, ZR_STATUS0);
  607. len += sprintf(buf + len, "STATUS0    %#4.4x (c-state 0x%x)n",
  608.        data, data >> 10);
  609. len += sprintf(buf + len, "STATUS1    %#4.4xn", I34_Read(mga, ZR_STATUS1));
  610. len += sprintf(buf + len, "STATUS2    %#4.4xn", I34_Read(mga, ZR_STATUS2));
  611. len += sprintf(buf + len, "DEV_ID     %#4.4xn", I34_Read(mga, ZR_DEVICE_ID));
  612. len += sprintf(buf + len, "ADP_STATUS %#4.4xn", I34_Read(mga, ZR_ADP_STATUS));
  613. len += sprintf(buf + len, "SYS_CLOCK  %#4.4xn", I34_Read(mga, ZR_SYS_CLOCK));
  614. len += sprintf(buf + len, "NAV_DATA   %#4.4xn", I34_Read(mga, ZR_NAV_DATA));
  615. len += sprintf(buf + len, "RESERVED1  %#4.4xn", I34_Read(mga, ZR_RESERVED1));
  616. len += sprintf(buf + len, "SUBPICBUF  %#4.4xn", I34_Read(mga, ZR_SUBPICBUF));
  617. len += sprintf(buf + len, "VIDEOBUF   %#4.4xn", I34_Read(mga, ZR_VIDEOBUF));
  618. len += sprintf(buf + len, "AUDIOBUF   %#4.4xn", I34_Read(mga, ZR_AUDIOBUF));
  619. len += sprintf(buf + len, "RESERVED2  %#4.4xn", I34_Read(mga, ZR_RESERVED2));
  622. return len;
  623. }
  625. struct proc_dir_entry codec_proc_entry = {
  626.         0,                 /* low_ino: the inode -- dynamic */
  627.         8, "mgacodec",     /* len of name and name */
  628.         S_IFREG | S_IRUGO, /* mode */
  629.         1, 0, 0,           /* nlinks, owner, group */
  630.         0, NULL,           /* size - unused; operations -- use default */
  631.         &codec_read_info,  /* function used to read data */
  632.         /* nothing more */
  633. };
  636. int I34_ioctl(struct mga_dev *mga, unsigned int cmd, void *arg)
  637. {
  638. // dprintk("I34: ioctl %d, arg=%pn", _IOC_NR(cmd), arg);
  639. switch(cmd) {
  640. case I34_IOCSUCODE:
  641. {
  642. return I34_MicrocodeRead(mga, (struct i34_ucode_chunk *)arg);
  643. }
  644. case I34_IOCSVIDEOSTD:
  645. {
  646. return I34_OutputVideoStandard(mga, (int)arg);
  647. }
  648. case I34_IOCSVDSTDCST:
  649. {
  650. return I34_LoadVideoStandard(mga, (struct VideoStandard *)arg);
  651. }
  652. case I34_IOCSCOLORKEY:
  653. {
  654. return I34_ColorKey(mga, (struct ColorKey *)arg);
  655. }
  656. case I34_IOCSCBSYNC:
  657. {
  658. return I34_CompositeBlankSync(mga, (struct CompositeBlankSync *)arg);
  659. }
  660. case I34_IOCGSTATE:
  661. {
  662.         return I34_State(mga, (int *)arg);
  663. }
  664. case I34_IOCTSTRTDSPL:
  665. {
  666. return I34_StartDisplay(mga);
  667. }
  668. case I34_IOCTCMD:
  669. {
  670. return I34_Command(mga, (int)arg);
  671. }
  672. case I34_IOCTINIT:
  673. {
  674. return I34_Init(mga);
  675. }
  676. default:    
  677. return -ENOIOCTLCMD;
  678. }
  679. }
  682. /****************************************************************************
  683. * linux kernel module api
  684. ****************************************************************************/
  685. #ifdef MODULE
  686. int init_module(void)
  687. #else
  688. int i34_init(void)
  689. #endif
  690. {
  691. /* Be sure that the mgavideo module is loaded */
  692. /* I should take a look at get_module_symbol ... */
  693. if ((host = mgavideo_get_codec()) == NULL)
  694. return -ENODEV;
  696.   //  if (!I34_Detect(host))
  697.   //    return -ENODEV;
  699.   //  I34_Init(host);
  700. proc_register(&proc_root, &codec_proc_entry);
  702. return 0;
  703. }
  705. #ifdef MODULE
  706. void cleanup_module(void)
  707. {
  708. proc_unregister(&proc_root, codec_proc_entry.low_ino);
  709. }
  710. #endif
  713. /******************************************************************************/
  715. /*int I34_ResetOrig(struct mga_dev *mga, u16 param1, u16 param2) {
  716.   u16 i, isr;
  718.   dprintk("I34: Resetn");
  720.   if (!(I34_ResetPin(mga, param1))) {
  721.   dprintk("I34: 23 FALSE regn");
  722.   return 0;
  723.   }  
  725.   for (i = 1000; i>0; i--)
  726.   I34_WaitMicroSecond(500);
  728.   if (param1 == 1) {
  729.   for (i=0; i<0x1388; i++) {
  730.   if (!I34_ReadInterruptStatus(mga, &isr)) {
  731.   dprintk("I34: 24 FALSE regn");
  732.   return 0;
  733.   }
  734.   if ((isr & 0x1800) != 0x1800) {
  735.   I34_ParameterWrite(mga, 0xA0, 0x0F3);
  736.   I34_ParameterWrite(mga, 0x88, 0x0F3);
  737.   return 1;
  738.   }
  739.   I34_WaitMicroSecond(100);
  740.   }
  741.   dprintk("PLL's NOT locked ---> 0x%4.4x", isr);
  742.   return 0;
  744.   } else {
  745.   if (param2 == 1)
  746.   // I34_Init(mga);
  747.   return 1;
  748.   }
  749.   return 0;
  750.   }
  751. */
  753. /* ******************************************************************
  754.    Explanation: 
  755.    I frankly don't know how to reliably reset this ^*&#@ !
  756.    This 2-phase sequence _seems_ to succeed in unlocking the card
  757.    and placing it in a state suitable for further operations.
  758.    But who knows if it will work for you.
  759.    _Please_ report any success or failure with the corresponding
  760.    rev number or the answer of the codec.
  761.    ****************************************************************** */
  763. /* taken verbatim from mgallx64 */
  764. /* writeb(codecen, mga->ctrl + CODECCTL);
  765.    writeb(readb(mga->ctrl + CODECCTL + 3) & 0xfb, mga->ctrl + CODECCTL + 3);
  766.    writeb(~codecen, mga->ctrl + CODECCTL);
  767.    mdelay(160); */
  769. /* this one is from Mike's zr36060 driver */
  770. /* writeb(codecen, mga->ctrl + CODECCTL);
  771.    writeb(readb(mga->ctrl + CODECCTL + 3) | 0x40, mga->ctrl + CODECCTL + 3);
  772.    writeb(readb(mga->ctrl + CODECCTL + 3) & ~0x40, mga->ctrl + CODECCTL + 3);
  773.    writeb(~codecen, mga->ctrl + CODECCTL);
  774.    mdelay(160); */
  776. /* writeb(codecen, mga->ctrl + CODECCTL);
  777.    u8 misc;
  778.    u8 value = 0x98;
  779.    misc = ~((value & 0x9f) | (~value & 0x60)) & 0xff;
  780.    writeb(misc, mga->ctrl + CODECCTL + 3);
  781.    writeb(~codecen, mga->ctrl + CODECCTL);
  782.    mdelay(160); */
  784. /* od -vtx1 340edvd.dvp | cut -d" " -f2- | sed -e 's/ /,0x/g' | sed -e's/^/,0x/g' | sed -e 's/$/,/g | sed -e 's/^,//g' > 340edvd.inc '
  785.    do not forget to suppress the last line of the resulting file
  786. */