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

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

DVD

开发平台：

Unix_Linux

zr36060.c：源码内容
  1. /*
  2.  * for the Matrox Marvel G200 and Rainbow Runner-G series
  3.  *
  4.  * This module is an interface to the ZR3606 jpeg codec chip.
  5.  *
  6.  * Copyright (C) 1999  Mike Bernson <mike@mlb.org>
  7.  *
  8.  * This program is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU General Public License
  10.  * as published by the Free Software Foundation; either version 2
  11.  * of the License, or (at your option) any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21.  *
  22.  *
  23.  *****************************************************************************
  24.  */
  25. #ifndef __KERNEL__
  26. #define __KERNEL__
  27. #endif
  28. #ifndef MODULE
  29. #define MODULE
  30. #endif
  32. #include <linux/module.h>
  33. #include <linux/delay.h>
  34. #include <linux/errno.h>
  35. #include <linux/kernel.h>
  36. #include <asm/io.h>
  37. #include <linux/i2c.h>
  38. #include "mgavideo.h"
  39. #include "zr36060.h"
  41. #define dprintk     if (debug) printk
  43. #define XGENIOCTRL      0x2a
  44. #define XGENIODATA      0x2b
  47. static int debug = 1; /* insmod parameter */
  49. /****************************************************************************
  50. * linux kernel module api
  51. ****************************************************************************/
  52. #ifdef MODULE
  53. int init_module(void)
  54. #else
  55. int zr36060_init(void)
  56. #endif
  57. {
  59. return 0;
  60. }
  62. #ifdef MODULE
  63. void cleanup_module(void)
  64. {
  65. }
  66. #endif
  68. #ifdef NEVER
  69. static void
  70. zr36060_codechostptr(struct codec *codec, int size)
  71. {
  72. writew(zr->codechostptr, size/8);
  73. }
  74. #endif
  75. static int
  76. zr36060_load_memory(struct codec *codec) 
  77. {
  78. int i;
  79. char status;
  80. char data[1];
  82. data[0] = 0x80;
  83. codec->codec_write_memory(codec, data, 0, 1);
  85. for(i=0; i < 1000; i++) {
  86. codec->codec_read_memory(codec, &status, 1, 1);
  88. if ((status & 0x80) == 0) {
  89. return 0;
  90. }
  91. udelay(10);
  92. }
  94. printk("zr36060: load from memory did not complete status=0x%xn",
  95. status);
  96. return -1;
  97.  }
  100. static u8 SOF[19] = {
  101. 0xff, 0xc0, /* Start of frame marker */
  102. 0x00, 0x11, /* Length of this segment */
  103. 0x08, /* Precision */
  104. 240/8, 240&0xff, /* number of lines */
  105. 704/8, 704&0xff, /* line length */
  106. 3, /* number of components */
  107. 0, 0x21, 0, /* Y component */
  108. 1, 0x11, 1, /* U component */
  109. 2, 0x11, 1 /* V component */
  110. };
  112. static u8 SOS[] = {
  113. 0xff, 0xda, /* start of Scan marker */
  114. 0x00, 0x0c, /* lenght of this segment */
  115. 0x03, /* number of components */
  116. 0x00, 0x00, /* Y component */
  117. 0x01, 0x11, /* U component */
  118. 0x02, 0x11, /* V component */
  119. 0x00, 0x3f, 0x00 /* constant */
  120. };
  122. static u8 DRI[] = {
  123. 0xff, 0xdd, /* define Restart Interval */
  124. 0x00, 0x04, /* length of this segment */
  125. 0x00, 0x08, /* lenght of restart interval in mcu units */
  126. };
  128. static u8 DQT[] = {
  129. 0xff, 0xdb, /* DQT marker */
  130. 0x00, 0x84, /* DQT length */
  131. 0x00, /* table ID 0 */
  132. 0x10, 0x0b, 0x0c, 0x0e, 0x0c, 0x0a, 0x10, 0x0e,
  133. 0x0d, 0x0e, 0x12, 0x11, 0x10, 0x13, 0x18, 0x28,
  134. 0x1a, 0x18, 0x16, 0x16, 0x18, 0x31, 0x23, 0x25,
  135. 0x1d, 0x28, 0x3a, 0x33, 0x3d, 0x3c, 0x39, 0x33,
  136. 0x38, 0x37, 0x40, 0x48, 0x5c, 0x4e, 0x40, 0x44,
  137. 0x57, 0x45, 0x37, 0x38, 0x50, 0x6d, 0x51, 0x57,
  138. 0x5f, 0x62, 0x67, 0x68, 0x67, 0x3e, 0x4d, 0x71,
  139. 0x79, 0x70, 0x64, 0x78, 0x5c, 0x65, 0x67, 0x63,
  140. 0x01, /* table ID 1 */
  141. 0x11, 0x12, 0x12, 0x18, 0x15, 0x18, 0x2f, 0x1a,
  142. 0x1a, 0x2f, 0x63, 0x42, 0x38, 0x42, 0x63, 0x63,
  143. 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
  144. 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
  145. 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
  146. 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
  147. 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
  148. 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63
  149. };
  151. static u8 DHT[] = {
  152.       0xff, 0xc4,   /* DHT marker */
  153.       0x01, 0xa2,   /* DHT length */
  154.       0x00,      /* table class 0, ID 0 */
  155.       0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, /* # codes of length 1..8 */
  156.       0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* # codes of length 8..16 */
  157.       0x00,                  /* values for codes of length 2 */
  158.       0x01, 0x02, 0x03, 0x04, 0x05,         /* values for codes of length 3 */
  159.       0x06,                  /* values for codes of length 4 */
  160.       0x07,                  /* values for codes of length 5 */
  161.       0x08,                  /* values for codes of length 6 */
  162.       0x09,                  /* values for codes of length 7 */
  163.       0x0a,                  /* values for codes of length 8 */
  164.       0x0b,                  /* values for codes of length 9 */
  165.       0x01,      /* table class 0, ID 1 */
  166.       0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,   /* # codes of length 1..8 */
  167.       0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,   /* # codes of length 9..16 */
  168.       0x00, 0x01, 0x02,            /* values for codes of length 2 */
  169.       0x03,                  /* values for codes of length 3 */
  170.       0x04,                  /* values for codes of length 4 */
  171.       0x05,                  /* values for codes of length 5 */
  172.       0x06,                  /* values for codes of length 6 */
  173.       0x07,                  /* values for codes of length 7 */
  174.       0x08,                  /* values for codes of length 8 */
  175.       0x09,                  /* values for codes of length 9 */
  176.       0x0a,                  /* values for codes of length 10 */
  177.       0x0b,                  /* values for codes of length 11 */
  178.       0x10,
  179.       0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03,
  180.       0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7d,
  181.       0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
  182.       0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
  183.       0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
  184.       0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
  185.       0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
  186.       0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
  187.       0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
  188.       0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
  189.       0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
  190.       0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
  191.       0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
  192.       0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
  193.       0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
  194.       0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
  195.       0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
  196.       0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
  197.       0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
  198.       0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
  199.       0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
  200.       0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
  201.       0xf9, 0xfa, 0x11, 0x00, 0x02, 0x01, 0x02, 0x04,
  202.       0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00,
  203.       0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11,
  204.       0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51,
  205.       0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08,
  206.       0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23,
  207.       0x33, 0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1, 0x0a,
  208.       0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18,
  209.       0x19, 0x1a, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x35,
  210.       0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45,
  211.       0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55,
  212.       0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65,
  213.       0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75,
  214.       0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84,
  215.       0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93,
  216.       0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2,
  217.       0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa,
  218.       0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
  219.       0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8,
  220.       0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
  221.       0xd8, 0xd9, 0xda, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6,
  222.       0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4, 0xf5,
  223.       0xf6, 0xf7, 0xf8, 0xf9, 0xfa
  224. };
  226. static u8 APP[] = {
  227.       0xff, 0xe0, /* APP marker */
  228.       0x00, 0x02, /* APP length */
  229.       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  230.       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  231.       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  232.       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  233.       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  234.       0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  235. };
  237. static u8 COM[] = {
  238.       0xff, 0xfe, /* COM marker */
  239.       0x00, 0x02, /* COM length */
  240.       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  241.       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  242.       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  243.       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  244.       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  245.       0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  246. };
  249. static int
  250. zr36060_memory(struct codec *codec, int width, int height, 
  251. int compress_mode, int quality)
  252. {
  253. u8 sof[19];
  254. u8 data[96];
  255. u32 size;
  257. data[0] = 0x01;
  258. codec->codec_write_memory(codec, data, 0, 1);
  260. data[0x02] = 0x01; /* slave mode, 8 bit buss */
  261. if (compress_mode) {
  262. data[0x03] = 0xa4; /* compress pass, variable scaling */
  263. } else {
  264. data[0x03] = 0x00; /* decompress pass */
  265. }
  266. data[0x04] = 0x00; /* reserved */
  267. data[0x05] = 0xff; /* max block code volume in bits (510) */
  268. data[0x06] = 0x38; /* Marks DRI, DQT, DHT */
  270. data[0x07] = 0x00; /* interrupts none */
  271. size = (width * height) * 16;
  272. size = (size * quality) / 400;
  274. if (size < 8192)
  275. size = 8192;
  277. if ((size * 2)> ((256 * 1024) * 7))
  278. size = (256 * 1024 * 7);
  280. data[0x09] = (size >> 24) & 0xff;
  281. data[0x0a] = (size >> 16) & 0xff;
  282. data[0x0b] = (size >> 8) & 0xff;
  283. data[0x0c] = size & 0xff;
  285. data[0x11] = 0x01; /* Scale Factor 1:1 */
  286. data[0x12] = 0x00;
  288. data[0x13] = 0xff; /* Allocation factor Must be 0xffffff */
  289. data[0x14] = 0xff;
  290. data[0x15] = 0xff;
  292. data[0x24] = 0x00; /* Test Control Must be 0x0000 */
  293. data[0x25] = 0x00;
  295. data[0x30] = 0x40;
  296. data[0x31] = 0x21;
  297. data[0x32] = 0x00; /* No scaling  */
  298. data[0x33] = 0x80; /* Background color y */
  299. data[0x34] = 0xe0; /* Background color u */
  300. data[0x35] = 0xe0; /* Background color v */
  302. data[0x36] = 524 >> 8; /* Vtotal for sync master */
  303. data[0x37] = 524 & 0xff;
  304. data[0x38] = 857 >> 8;  /* Htotal for sync master */
  305. data[0x39] = 857 & 0xff;
  306. data[0x3a] = 5;         /* Vsync for sync master */
  307. data[0x3b] = 31; /* Hsync for sync master */
  308. data[0x3c] = 11; /* BVstart for sync master */
  309. data[0x3d] = 99; /* BHstart for sync master */
  310. data[0x3e] = 241 >> 8; /* BVend for sync master */
  311. data[0x3f] = 241;
  312. data[0x40] = 720 >> 8; /* BHend for sync master */
  313. data[0x41] = 720 & 0xff;
  315. data[0x42] = 11 >> 8; /* VSTART for active area  */
  316. data[0x43] = 11;
  317. data[0x44] = 262 >> 8; /* VEND for active area */
  318. data[0x45] = 262 & 0xff;
  319. data[0x46] = 12 >> 8; /* HSTART for active area */
  320. data[0x47] = 12;
  321. data[0x48] = 720 >> 8; /* HEND for active area */
  322. data[0x49] = 720 & 0xff;
  324. data[0x4a] = 12 >> 8;
  325. data[0x4b] = 12;
  326. data[0x4c] = height >> 8;
  327. data[0x4d] = height;
  328. data[0x4e] = 11 >> 8;
  329. data[0x4f] = 11;
  330. data[0x50] = width >> 8;
  331. data[0x51] = width;
  334. /* set video mode */
  335. memcpy(sof, SOF, sizeof(sof));
  336. sof[5] = width >> 8;
  337. sof[6] = width;
  339. sof[7] = height >> 8;
  340. sof[8] = height;
  342. if (codec->codec_write_memory(codec, &data[2], 0x02, 6))
  343. return -1;
  344. if (codec->codec_write_memory(codec, &data[9], 0x09, 4))
  345. return -1;
  346. if (codec->codec_write_memory(codec, &data[0x11], 0x11, 5))
  347. return -1;
  348. if (codec->codec_write_memory(codec, &data[0x24], 0x24, 2))
  349. return -1;
  350. if (codec->codec_write_memory(codec, &data[0x30], 0x30, 34))
  351. return -1;
  352. if (codec->codec_write_memory(codec, sof, 0x60, sizeof(sof)))
  353. return -1;
  354. if (codec->codec_write_memory(codec, SOS, 0x7a, sizeof(SOS)))
  355. return -1;
  356. if (codec->codec_write_memory(codec, DRI, 0xc0, sizeof(DRI)))
  357. return -1;
  358. if (codec->codec_write_memory(codec, DQT, 0xcc, sizeof(DQT)))
  359. return -1;
  360. if (codec->codec_write_memory(codec, DHT, 0x1d4, sizeof(DHT)))
  361. return -1;
  362. if (codec->codec_write_memory(codec, APP, 0x380, sizeof(APP)))
  363. return -1;
  364. if (codec->codec_write_memory(codec, COM, 0x3c0, sizeof(COM)))
  365. return -1;
  367. return zr36060_load_memory(codec);
  368. }
  370. int
  371. zr36060_interrupt(struct codec *codec)
  372. {
  373. printk("zr36060: command compelete interruptn");
  374. #ifdef NEVER
  375. zr->state = ZR_IDLE_STATE;
  377. /* remove pending command complete */
  378. writeb(VI_CMDCMPL, zr->viclear);
  379. #endif
  380. return 0;
  381. }
  383. int
  384. zr36060_compress_image(struct codec *codec)
  385. {
  386. printk("zr36060: compress imagen");
  388. if (codec->state != ZR_IDLE_STATE) {
  389. printk("zr36060: compression image but zr36060 not idlen");
  390. return -1;
  391. }
  393. /* for now compress the whole frame */
  394. if (zr36060_memory(codec, 704, 240, 1, 100))
  395. return -1;
  397. /* Start image compressing */
  398. (*codec->codec_start)(codec);
  400. printk("zr36060: compression startedn");
  401. mdelay(1000);
  402. {
  403. struct mga_dev *mga;
  404. char data;
  405. int i;
  406. int *ptr;
  408. codec->codec_read_memory(codec, &data, 0x08, 1);
  409. printk("zr36060: interrupt status: %xn", data);
  411. printk("zr36060: image_data: ");
  412. mga = codec->private;
  413. ptr = (int *)mga->interface_base;
  414. for(i=0; i < 16; i++) {
  415. printk("%4x ", *ptr++);
  416. }
  417. printk("n");
  418. }
  419. return 0;
  420. }
  422. int
  423. zr36060_decompress_image(struct codec *codec)
  424. {
  425. return 0;
  426. }
  429. int
  430. zr36060_attach(struct codec *codec)
  431. {
  432. char chip_id[2];
  434. if (debug)
  435. printk("zr36060: reseting zr36060n");
  437. codec->codec_reset(codec);
  439. /* read id from zr36060 */
  440. if (debug)
  441. printk("zr36060: reading chip idn");
  442. if (codec->codec_read_memory(codec, chip_id, 0x22, 2)) {
  443. printk("zr36060: Read errorn");
  444. return -1;
  445. }
  447. if (chip_id[0] == 0x33) {
  448. printk("zr36060: zr36060 found revision %xn", chip_id[1]);
  449. } else {
  450. printk("zr36060: zr36060 not found (%x %x)n",
  451.        chip_id[0], chip_id[1]);
  452. return -1;
  453. }
  455. if (debug) 
  456. printk("zr36060: Loading default parmetersn");
  458. zr36060_memory(codec, 704, 240, 1, 100);
  460. #ifdef NEVER
  461. MOD_INC_USE_COUNT;
  462. #endif
  463. return 0;
  464. }
  466. int
  467. zr36060_deattach(struct codec *codec)
  468. {
  469. #ifdef NEVER
  470. /* reset the codec interface */
  471. writeb(0x00, zr->codecctl);
  472. writeb(0x01, zr->codecctl);
  473. writeb(0x00, zr->codecctl);
  475. MOD_DEC_USE_COUNT;
  476. #endif
  477. return 0;
  478. }