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

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

DVD

开发平台：

Unix_Linux

mgavideo.c：源码内容
  1. /*
  2.  * Video Capture Driver ( Video for Linux 1/2 )
  3.  * for the Matrox Marvel G200 and Rainbow Runner-G series
  4.  *
  5.  * This module is an interface to the G100 and G200 video extension
  6.  * registers.  
  7.  *
  8.  * Copyright (C) 1999  Ryan Drake <stiletto@mediaone.net>
  9.  *
  10.  * This program is free software; you can redistribute it and/or
  11.  * modify it under the terms of the GNU General Public License
  12.  * as published by the Free Software Foundation; either version 2
  13.  * of the License, or (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23.  *
  24.  *
  25.  *****************************************************************************
  26.  * Version History:
  27.  * V1.0 Ryan Drake         Initial version by Ryan Drake
  28.  * V1.1 Gerard v.d. Horst  Activated the backend scaler
  29.  */
  31. #ifndef __KERNEL__
  32. #define __KERNEL__
  33. #endif
  34. #ifndef MODULE
  35. #define MODULE
  36. #endif
  38. #include <linux/module.h>
  39. #include <linux/delay.h>
  40. #include <linux/errno.h>
  41. #include <linux/kernel.h>
  42. #include <linux/malloc.h>
  43. #include <linux/poll.h>
  44. #include <asm/io.h>
  45. #include <linux/pci.h>
  46. #include <linux/interrupt.h>
  47. #include "mgavideo.h"
  48. #include "tuner.h"
  49. #include "msp3400.h"
  50. #include "ks0127.h"
  51. #include "zr36060.h"
  53. #define dprintk     if (debug) printk
  55. static int debug = 0; /* insmod parameter */
  56. static int memsize = 8192 * 1024;
  58. #if LINUX_VERSION_CODE >= 0x020100
  59. MODULE_PARM(debug,"i");
  60. MODULE_PARM(memsize,"i");
  61. #endif
  64. /* i2c registers */
  65. #define PALWTADD        0x3c00
  66. #define X_DATAREG       0x3c0a
  67. #define XMISCCTRL       0x1e
  68. #define XGENIOCTRL      0x2a
  69. #define XGENIODATA      0x2b
  70. #define XKEYOPMODE      0x51
  71. #define XCOLMSK0RED     0x52
  72. #define XCOLMSK0GREEN   0x53
  73. #define XCOLMSK0BLUE    0x54
  74. #define XCOLKEY0RED     0x55
  75. #define XCOLKEY0GREEN   0x56
  76. #define XCOLKEY0BLUE    0x57
  77. #define SDA             0x10
  78. #define SCL             0x20
  81. #define I2C_DELAY       10
  83. /****************************************************************************
  84. * raw register access : these routines directly interact with the mga's
  85. *                       control aperature.  must not be called until after
  86. *                       the board's pci memory has been mapped.
  87. ****************************************************************************/
  88. static u32 _mgaread( struct mga_dev* mga, u32 reg )
  89. {
  90.         return readl( mga->ctrl + reg );
  91. }
  93. static u8 _mgareadb(struct mga_dev* mga, u32 reg )
  94. {
  95.         return readb(mga->ctrl + reg );
  96. }
  98. #ifdef NEVER
  99. static u16 _mgareadw(struct mga_dev* mga, u32 reg )
  100. {
  101.         return readw(mga->ctrl + reg );
  102. }
  103. #endif
  105. static void _mgawrite( struct mga_dev* mga, u32 reg, u32 data )
  106. {
  107.         writel( data, mga->ctrl + reg );
  108. }
  110. static void _mgawriteb( struct mga_dev* mga, u32 reg, u32 data )
  111. {
  112.         writeb( data, mga->ctrl + reg );
  113. }
  115. static void _mgawritew( struct mga_dev* mga, u32 reg, u32 data )
  116. {
  117.         writeb( data, mga->ctrl + reg );
  118. }
  121. /****************************************************************************
  122.  * Codec Interface      *
  123.  ****************************************************************************/
  125. /* Notes: 
  126.    This interface is made to work with the Zoran DVD Codec. More specifically it
  127.    implements 8 bit VMI protocol A, with a big endian target chip.
  128.    Tell me if it works with the ZR36060, or what needs to be configurable (byte order, bus size ?)
  129.    It also uses a fixed 128Kb buffer size.
  130.    There is room for improvements: 
  131.     1. if the previous command is a write we can concatenate the datas instead of wasting 8 bytes
  132.        for each write command
  133.     2. the command buffer is only 512 bytes wide. We can have on in kernel memory and only
  134.        write the content on the MGA framebuffer at execute time. This could speed up memory access,
  135.        and provide a solution that doesn't change the content of the framebuffer, as we don't have
  136.        a reserved buffer yet (X fb memory management stuff to the rescue...)
  137.  */
  139. /*
  140.  * CODECCTL fields and commands
  141.  */
  142. #define codecen 0x0001          /* CODEC enable, invert to disable */
  143. #define codecmode 0x0002        /* CODEC l33 mode, invert for VMI mode */
  144. #define cmdexectrig 0x0004      /* command execution trigger, invert to prevent execution */
  145. #define codecdatain 0x0008      /* compression, invert for decompression */
  146. #define vmimode 0x0010          /* VMI mode B, invert for mode A */
  147. #define stopcodec 0x0020        /* stop after current field, invert to not stop */
  148. #define codectransen 0x0040     /* enable transfer, invert to disable */
  150. #define CODEC_CMD(count, pause, stop, addr, read) ( (count) | ((pause) << 8) | ((stop) << 9) | ((addr) << 10) | ((read) << 15) )
  151. #define CODEC_WRITE(addr, byte) ( ((addr) << 8) | (byte) )
  152. #define RESET_CODEC_CMD_PTR  mga->codeccmd   = mga->codecaddr + 0x0020000
  153. #define RESET_CODEC_DATA_PTR mga->codecdata  = mga->codecaddr + 0x0020200
  155. /* Resets the codec interface to the IDLE state */
  156. void codec_reset(struct mga_dev *mga) { 
  157. writel(VI_CMDCMPL, mga->ctrl + VICLEAR);
  158. writeb(0, mga->ctrl + CODECCTL);
  159. /* I repeat it twice per p. 4-110 of the G_4_00 HB */
  160. writeb(codecen, mga->ctrl + CODECCTL);
  161. writeb(codecen, mga->ctrl + CODECCTL);
  162. /* pulse recovery width (only usefull during bistream transfer
  163.    if I understand correctly p.46 of the Handbook
  164.    but we program the register anyway, as it belongs to 
  165.    the IDLE procedure referenced in the G400 manual */
  166. writeb((0<<4), mga->ctrl + CODECCTL + 1);
  167. RESET_CODEC_CMD_PTR;
  168. }
  170. /* Plays with the MISCCTL part of the codec interface
  171.    Used to reset the actual CODEC chip connected to the MISC lines
  172.    of the interface.
  173.  */
  174. void codec_miscctl(struct mga_dev *mga, u8 and, u8 or) {
  175.   /* we must be in IDLE (or COMP/DECOMP) for this to work p. 4-89)
  176.      p. 4-92 states that MISC[2] is connected to EOI (?) when the CODEC Interface
  177.      is enabled. So it seems that we can bang on these 2 bits too... */
  178.   codec_reset(mga);
  179.   writeb((readb(mga->ctrl + CODECMISCCTL) & and) | or, mga->ctrl + CODECMISCCTL);
  180. }
  182. void mga_extrst(struct mga_dev *mga, u8 activate) {
  183.   u8 prev = readb(mga->ctrl + RST);
  184.   if (activate)
  185.     writeb(prev | 2, mga->ctrl + RST);
  186.   else
  187.     writeb(prev & ~2, mga->ctrl + RST);
  188. }
  190. int codec_miscctl_func1(struct mga_dev *mga, u8 param) {
  191.   writeb(readb(mga->ctrl + CODECCTL) | codecen, mga->ctrl + CODECCTL);
  192.   writeb(readb(mga->ctrl + CODECMISCCTL) & ~param, mga->ctrl + CODECMISCCTL);
  193.   writeb(readb(mga->ctrl + CODECCTL) & ~codecen, mga->ctrl + CODECCTL);
  194.   writeb(XGENIOCTRL, mga->ctrl + PALWTADD);
  195.   writeb(readb(mga->ctrl + X_DATAREG) & ~0x40, mga->ctrl + X_DATAREG);
  196.   writeb(XGENIODATA, mga->ctrl + PALWTADD);
  197.   if (readb(mga->ctrl + X_DATAREG) & 0x40)
  198.     return 0;
  199.   else
  200.     return 1;
  201. }
  203. int codec_miscctl_func2(struct mga_dev *mga) {
  204.    writeb(readb(mga->ctrl + CODECCTL) | codecen, mga->ctrl + CODECCTL);
  205.    writeb(readb(mga->ctrl + CODECMISCCTL) |  0x40, mga->ctrl + CODECMISCCTL);
  206.    writeb(readb(mga->ctrl + CODECMISCCTL) & ~0x40, mga->ctrl + CODECMISCCTL);
  207.    writeb(readb(mga->ctrl + CODECCTL) & ~codecen, mga->ctrl + CODECCTL);
  208.    return 1;
  209. }
  211. int codec_I34_reset(struct mga_dev *mga) {
  212.   codec_miscctl(mga, 0x00, 0x00);
  213.   codec_miscctl(mga, 0x00, 0x03);
  214.   codec_miscctl(mga, 0x00, 0x03);
  216.   codec_miscctl(mga, ~0x0f, 0x07);
  217.   mdelay(10);
  218.   codec_miscctl(mga, ~0x0f, 0x03);
  219.   mdelay(1);
  220.   codec_miscctl(mga, ~0x0f, 0x07);
  222.   codec_miscctl(mga, ~0x0f, 0x07);
  223.   mdelay(100);
  224.   codec_miscctl(mga, ~0x0f, 0x0f);
  225.   mdelay(1);
  226.   codec_miscctl(mga, ~0x0f, 0x07);
  227.   mdelay(200);
  229.   return 0;
  230. } 
  232. /* Adds a READ command to the command buffer */
  233. void codec_read(struct mga_dev *mga, u8 reg) {
  234. /* duplicate reads because we're talking on an 8 bit bus */
  235.         writel(CODEC_CMD(2, 0, 0, reg, 1), mga->codeccmd);
  236. writel(0, mga->codeccmd+4);
  237. mga->codeccmd += 8;
  238. }
  240. /* Adds a WRITE command to the command buffer */
  241. void codec_write(struct mga_dev *mga, u8 reg, u16 data) {
  242. u8 b;
  243. /* per p. 44 of the Zoran HB : */
  244. /* 2 consecutive byte accesses to the same address */
  245. writel(CODEC_CMD(2, 0, 0, 0, 0), mga->codeccmd);
  246. writel(0, mga->codeccmd+4);
  247. mga->codeccmd += 8;
  248. /*#ifdef __LITTLE_ENDIAN
  249. b = (data>>8) & 0xFF;
  250.         writew(CODEC_WRITE(reg, b), mga->codeccmd);
  251.         b = data & 0xFF;
  252.         writew(CODEC_WRITE(reg, b), mga->codeccmd+2);
  253. #else
  254. */
  255. /* m.s. byte first */
  256. b = data & 0xFF;
  257. writew(CODEC_WRITE(reg, b), mga->codeccmd);
  258. b = (data>>8) & 0xFF;
  259. writew(CODEC_WRITE(reg, b), mga->codeccmd+2);
  260. writel(0, mga->codeccmd+4);
  261. mga->codeccmd += 8;
  262. // watch out the command buffer : we only have 512 bytes to play with !
  263. if ((mga->codeccmd - mga->codecaddr - 0x0020000) > 500) {
  264. dprintk("mgavideo: flushing codec command buffer...n");
  265. codec_exec(mga);
  266. }
  267. }
  269. /* Triggers execution of the command buffer
  270.    We automatically add a dummy read command with the STOP bit enabled
  271.    to terminate the instruction chain
  272. */
  273. void codec_exec(struct mga_dev *mga) {
  274. /* push a dummy command with the STOP bit enabled */
  275. writel(CODEC_CMD(2, 0, 1, 0x7, 1), mga->codeccmd);
  276. writel(0, mga->codeccmd+4);
  277. mga->codeccmd += 8;
  279. /* p. 3-68 of the MGA HandBook : it's not mentionned but we need not shift the addr
  280.    by 3 bits. Instead it's placed directly from bit 0 onward, but bits 0-7 are nulls
  281.    because we are Kb aligned */
  282. writel(((mga->codecaddr - (u32)mga->fb) & ~0x03), mga->ctrl + CODECADDR);
  283. RESET_CODEC_DATA_PTR;
  284. writel(0, mga->codecdata); writel(0, mga->codecdata+4);
  285. writel(0, mga->codecdata+8); writel(0, mga->codecdata+12);
  286. writel(0, mga->codecdata+16); writel(0, mga->codecdata+20);
  287. /* WARNING: it's the right combination : I've been blocked by those 2 bits for too long ! */
  288. codec_reset(mga);
  289. writeb(codecen | cmdexectrig, mga->ctrl + CODECCTL);
  290. /* give time to the Codec Interface do actually do its job */
  291. udelay(6);
  292. // if (!(_mgaread(mga, VSTATUS) & 0x02)) {
  293. // dprintk("mgavideo: warning no cmdcmpl after codec command...n");
  294. // }
  295. //    else {
  296. // _mgawrite(mga, VICLEAR, 0x02);
  297. // }
  298. }
  300. /* Retrieves a word from the data buffer */
  301. u16 codec_getw(struct mga_dev *mga) {
  302. u16 data;
  303. data = readw(mga->codecdata);
  304. /*#ifdef __LITTLE_ENDIAN
  305.   data = __swab16(data);
  306.   #endif
  307. */
  308. #ifdef BYTEORDERHACK
  309. if (mga->little_endian_codec)
  310. data = __swab16(data);
  311. #endif
  312. mga->codecdata += 8;
  313. return data;
  314. }
  316. /* dumps the content of the codec interface buffers */
  317. void dump_codec_cmdbuffer(struct mga_dev *mga) {
  318. RESET_CODEC_CMD_PTR;
  319. dprintk("mgavideo: Command buffer:n");
  320. dprintk("mgavideo: 0x%8.8x%8.8xn", readl(mga->codeccmd+4), readl(mga->codeccmd));
  321. dprintk("mgavideo: 0x%8.8x%8.8xn", readl(mga->codeccmd+12), readl(mga->codeccmd+8));
  322. dprintk("mgavideo: 0x%8.8x%8.8xn", readl(mga->codeccmd+20), readl(mga->codeccmd+16));
  323. dprintk("mgavideo: 0x%8.8x%8.8xn", readl(mga->codeccmd+28), readl(mga->codeccmd+24));
  324. dprintk("mgavideo: 0x%8.8x%8.8xn", readl(mga->codeccmd+36), readl(mga->codeccmd+32));
  325. dprintk("mgavideo: Data buffer:n");
  326. dprintk("mgavideo: 0x%8.8x%8.8xn", readl(mga->codecdata+4), readl(mga->codecdata));
  327. dprintk("mgavideo: 0x%8.8x%8.8xn", readl(mga->codecdata+12), readl(mga->codecdata+8));
  328. dprintk("mgavideo: 0x%8.8x%8.8xn", readl(mga->codecdata+20), readl(mga->codecdata+16));
  329. dprintk("mgavideo: 0x%8.8x%8.8xn", readl(mga->codecdata+28), readl(mga->codecdata+24));
  330. dprintk("mgavideo: 0x%8.8x%8.8xn", readl(mga->codecdata+36), readl(mga->codecdata+32));
  331. }
  333. static void 
  334. mgacodec_and_or_codecctl(struct codec *codec, u16 and, u16 or)
  335. {
  336. int codecctl;
  337. struct mga_dev *mga;
  339. mga = codec->private;
  340. codecctl = (mga->codecctl_shadow & and) | or;
  341. mga->codecctl_shadow = codecctl;
  343. _mgawritew(mga, CODECCTL, codecctl);
  344. }
  347. static void 
  348. mgacodec_and_or_codecmisc(struct codec *codec, u16 and, u16 or)
  349. {
  350. int codecmisc;
  351. struct mga_dev *mga;
  353. mga = codec->private;
  356. codecmisc = (mga->codecmisc_shadow & and) | or;
  357. mga->codecmisc_shadow = codecmisc;
  359. _mgawriteb(mga, CODECCTL+3, codecmisc);
  360. }
  364. static int
  365. mgacodec_execute_command(struct codec *codec)
  366. {
  367. int i;
  368. int status;
  370. struct mga_dev *mga;
  372. mga = codec->private;
  374. /* tell the system where memory buffer for zr36060 exists */
  375. _mgawrite(mga, CODECADDR, (mga->host_interface_base & ~0x03) | 0x01);
  378. if (mga->codecctl_shadow & VC_TRANSEN) {
  379. printk("wait for transfor to stopn");
  380. mgacodec_and_or_codecctl(codec, ~(VC_TRIG | VC_TRANSEN), 0);
  382. for(i = 1024 * 1024, status = _mgaread(mga, VSTATUS);
  383.     (status & VS_STALLED) == 0 && i--; 
  384.     status = _mgaread(mga, VSTATUS)) ;
  385. printk("transfer stoped status %x VS_STALLED %xn", status, VS_STALLED);
  386. }
  388. /* remove any pending command complete */
  389. _mgawriteb(mga, VICLEAR, VI_CMDCMPL);
  391. codec->state = ZR_WRITE_STATE;
  393. /* start codec command */
  394. mgacodec_and_or_codecctl(codec, ~0x00, VC_TRIG);
  396. /* wait for codec command to complete */
  397. for(i = 4096, status = _mgareadb(mga, VSTATUS);
  398. (status & VS_STALLED) == 0 && i--; 
  399. status = _mgareadb(mga, VSTATUS)) ;
  401. /* Ack the command complete interrupt */
  402. _mgawriteb(mga, VICLEAR, VI_CMDCMPL);
  404. codec->state = ZR_IDLE_STATE;
  405. mga->codec_offset = 0;
  407. if (status & VI_CMDCMPL)
  408. return 0;
  410. printk("mgavideo: no command complete on command 0x%x status 0x%xn", 
  411.        readw(mga->command_base), status);
  413. return 1;
  414. }
  416. static int
  417. mgacodec_read_memory(struct codec *codec, void *ptr, int mem, int size)
  418. {
  419. int last_high;
  420. int last_read;
  421. int last_exec;
  422. int i;
  423. int j;
  424. char *buffer;
  425. struct mga_dev *mga;
  427. mga = codec->private;
  428. buffer = ptr;
  430. last_high = -1;
  431. last_read = 0;
  432. last_exec = 0;
  434. dprintk("mgavideo: read %d bytes to memory %xn", size, mem);
  436. for(i=0; i < size; i++, mem++) {
  437. if (mga->codec_offset > (512 - 32)) {
  438. if (i > 0) {
  439. writew(0x8201 | (3 << 10), 
  440.        mga->command_base + last_read);
  441. }
  443. if (mgacodec_execute_command(codec)) {
  444. printk("mgavideo: Codec read buffer errorn");
  445. return -1;
  446. }
  448. for(j = last_exec; j < i; j++) {
  449. *buffer++ = readb(mga->read_base + 
  450.  (j - last_exec) * 8);
  452. }
  454. last_exec = i;
  456. }
  457. writew(0x0002, mga->command_base + mga->codec_offset);
  458. mga->codec_offset += 8;
  460. if (last_high != (mem >> 8)) {
  461. writew((mem >> 8) | 0x0100, 
  462. mga->command_base + mga->codec_offset);
  463. mga->codec_offset += 2;
  464. }
  466. writew((mem & 0xff) | 0x0200, 
  467. mga->command_base + mga->codec_offset);
  468. mga->codec_offset += 2;
  470. mga->codec_offset = (mga->codec_offset & ~7) + 8;
  472. writew(0x8001 | (3 << 10), 
  473. mga->command_base + mga->codec_offset);
  474. last_read = mga->codec_offset;
  476. mga->codec_offset += 8;
  477. }
  479. if (last_read > 0) {
  480. writew(0x8201 | (3 << 10), mga->command_base + last_read);
  481. }
  483. if (mgacodec_execute_command(codec)) {
  484. printk("mgavideo: Codec read buffer errorn");
  485. return -1;
  486. }
  488. for(i=last_exec; i < size; i++) {
  489. *buffer++ = readb(mga->read_base + (i - last_exec) * 8);
  490. }
  492. return 0;
  493. }
  495. static int
  496. mgacodec_write_memory(struct codec *codec, void *mem, int start_reg, int length)
  497. {
  498. int offset;
  499. int count;
  500. int last_high;
  501. char *buffer;
  502. struct mga_dev *mga;
  504. mga = codec->private;
  505. buffer = mem;
  507. offset = (int)mga->command_base + 8;
  508. count = 0;
  509. last_high = -1;
  511. dprintk("mgavideo writing %d bytes to memory %xn", 
  512. length, start_reg);
  514. while(length--) {
  515. if (last_high != (start_reg >> 8)) {
  516. last_high = start_reg >> 8;
  517. writew((start_reg >> 8) | 0x0100, offset);
  518. offset += 2;
  519. count++;
  520. }
  521.     
  522. writew((start_reg++ & 0xff) | 0x0200, offset);
  523. writew((*buffer++ & 0xff) | 0x0300, offset+2);
  524. offset+= 4;
  525. count += 2;
  527. if (count > 250) {
  528. writew(count | 0x200, mga->command_base);
  529. if (mgacodec_execute_command(codec)) {
  530. printk("mgavideo: Codec write buffer errorn");
  531. return -1;
  532. }
  533. offset = (int)mga->command_base + 8;
  534. count = 0;
  535. }
  536. }
  538. if (count) {
  539. writew(count | 0x200, mga->command_base);
  540. if (mgacodec_execute_command(codec)) {
  541. printk("mgavideo: Codec write buffer errorn");
  542. return -1;
  543. }
  544. }
  546. return 0;
  547. }
  549. static int
  550. mgacodec_zr6060_start(struct codec *codec)
  551. {
  552. struct mga_dev *mga;
  554. mga = codec->private;
  556. _mgawrite(mga, CODECHOSTPTR, 64 * 1024);
  558. mgacodec_and_or_codecctl(codec, 0x4f, 0x4b);
  560. return 0;
  561. }
  564. static int
  565. mgacodec_zr36060_reset(struct codec *codec) 
  566. {
  567. struct mga_dev *mga;
  569. mga = codec->private;
  571. /* reset the codec interface engine */
  572. mgacodec_and_or_codecctl(codec, 0x00, 0x00);
  573. mgacodec_and_or_codecctl(codec, 0x00, 0x03);
  574. mgacodec_and_or_codecctl(codec, 0x00, 0x03);
  577. /* pulse the reset line */
  578. mgacodec_and_or_codecmisc(codec, ~0x0f, 0x07);
  579. mdelay(10);
  580. mgacodec_and_or_codecmisc(codec, ~0x0f, 0x03);
  581. mdelay(1);
  582. mgacodec_and_or_codecmisc(codec, ~0x0f, 0x07);
  584. /* pulse the sleep line */
  585. mgacodec_and_or_codecmisc(codec, ~0x0f, 0x07);
  586. mdelay(100);
  587. mgacodec_and_or_codecmisc(codec, ~0x0f, 0x0f);
  588. mdelay(1);
  589. mgacodec_and_or_codecmisc(codec, ~0x0f, 0x07);
  590. mdelay(200);
  592. /* tell the system where memory buffer for zr36060 exists */
  593. _mgawrite(mga, CODECADDR, (mga->host_interface_base & ~0x03) | 0x01);
  595. return 0;
  596. }
  599. /****************************************************************************
  600. * mga i2c bus interface
  601. ****************************************************************************/
  602. static void _mgai2c_attach( struct i2c_bus* bus, int id )
  603. {
  604.         struct mga_dev* mga = (struct mga_dev*)bus->data;
  606.         dprintk( "mgavideo: i2c device attach: %dn", id );
  608.         switch( id )
  609.         {
  610.         case I2C_DRIVERID_MSP3400:
  611.                 mga->hasaudio = 1;
  612.                 break;
  614.         case I2C_DRIVERID_TUNER:
  615.                 mga->hastuner = 1;
  616.                 break;
  618.         case I2C_DRIVERID_KS0127:
  619.                 mga->hasdecoder = 1;
  620.                 break;
  621.         }
  622. }
  624. static void _mgai2c_detach( struct i2c_bus* bus, int id )
  625. {
  626.         struct mga_dev* mga = (struct mga_dev*)bus->data;
  628.         dprintk( "mgavideo: i2c device detach: %dn", id );
  630.         switch( id )
  631.         {
  632.         case I2C_DRIVERID_MSP3400:
  633.                 mga->hasaudio = 0;
  634.                 break;
  636.         case I2C_DRIVERID_TUNER:
  637.                 mga->hastuner = 0;
  638.                 break;
  640.         case I2C_DRIVERID_KS0127:
  641.                 mga->hasdecoder = 0;
  642.                 break;
  643.         }
  644. }
  646. static void _mgai2c_setlines( struct i2c_bus* bus, int ctrl, int data )
  647. {
  648.         struct mga_dev* mga = (struct mga_dev*)bus->data;
  650.         if( ctrl )
  651.         {
  652.         writeb( XGENIOCTRL, mga->ctrl + PALWTADD );
  653.         writeb( readb( mga->ctrl + X_DATAREG ) & ~SCL, mga->ctrl + X_DATAREG );
  654.         }
  655.         else
  656.         {
  657.         writeb( XGENIODATA, mga->ctrl + PALWTADD );
  658.         writeb( readb( mga->ctrl + X_DATAREG ) & ~SCL, mga->ctrl + X_DATAREG );
  659.         writeb( XGENIOCTRL, mga->ctrl + PALWTADD );
  660.         writeb( readb( mga->ctrl + X_DATAREG ) | SCL, mga->ctrl + X_DATAREG );
  661.         }
  663.         if( data )
  664.         {
  665.         writeb( XGENIOCTRL, mga->ctrl + PALWTADD );
  666.         writeb( readb( mga->ctrl + X_DATAREG ) & ~SDA, mga->ctrl + X_DATAREG );
  667.         }
  668.         else
  669.         {
  670.         writeb( XGENIODATA, mga->ctrl + PALWTADD );
  671.         writeb( readb( mga->ctrl + X_DATAREG ) & ~SDA, mga->ctrl + X_DATAREG );
  672.         writeb( XGENIOCTRL, mga->ctrl + PALWTADD );
  673.         writeb( readb( mga->ctrl + X_DATAREG ) | SDA, mga->ctrl + X_DATAREG );
  674.         }
  676.         udelay( I2C_DELAY );
  677. }
  679. static int _mgai2c_getdataline( struct i2c_bus* bus )
  680. {
  681.         struct mga_dev* mga = (struct mga_dev*)bus->data;
  683.         writeb( XGENIOCTRL, mga->ctrl + PALWTADD );
  684.         writeb( readb( mga->ctrl + X_DATAREG ) & ~SDA, mga->ctrl + X_DATAREG );
  685.         writeb( XGENIODATA, mga->ctrl + PALWTADD );
  686.         return ( readb( mga->ctrl + X_DATAREG ) & SDA )?1:0;
  687. }
  690. /****************************************************************************
  691. * private api : internal interface to the mga's video subsystem
  692. ****************************************************************************/
  695. /****************************************************************************
  696. * mgavideo api : public interface to the mga's video subsystem
  697. ****************************************************************************/
  698. /* component device control */
  699. void mgavideo_tuner( struct mga_dev* mga, unsigned int cmd, void* arg )
  700. {
  701.         if( mga == NULL )
  702.                 return;
  704.         if( mga->hastuner )
  705.                 i2c_control_device( &(mga->i2c), I2C_DRIVERID_TUNER, cmd, arg );
  706. }
  708. void mgavideo_audio( struct mga_dev* mga, unsigned int cmd, void* arg )
  709. {
  710.         if( mga == NULL )
  711.                 return;
  713.         if( mga->hasaudio )
  714.                 i2c_control_device( &(mga->i2c), I2C_DRIVERID_MSP3400, cmd, arg );
  715. }
  717. void mgavideo_decoder( struct mga_dev* mga, unsigned int cmd, void* arg )
  718. {
  719.         if( mga == NULL )
  720.                 return;
  722.         if( mga->hasdecoder )
  723.                 i2c_control_device( &(mga->i2c), I2C_DRIVERID_KS0127, cmd, arg );
  724. }
  726. void mgavideo_zr36060_reset(struct mga_dev* mga)
  727. {
  728.   // dbarth:
  729.   // is it still usefull to have that here. It creates a dependency with mgavideo
  730.   // and complicates module loading/unloading
  731.   // Please tell me
  732. #ifdef NEVER
  733. zr36060_attach(&mga->zr36060);
  734. #endif
  735. }
  737. int mgavideo_querycaps( struct mga_dev* mga )
  738. {
  739.         int caps = 0;
  741.         if( mga == NULL )
  742.                 return 0;
  744.         if( mga->hastuner )
  745.                 caps |= MGAVIDEO_HAS_TUNER;
  747.         if( mga->hasaudio )
  748.                 caps |= MGAVIDEO_HAS_AUDIO;
  750.         if( mga->hasdecoder )
  751.                 caps |= MGAVIDEO_HAS_DECODER;
  753.         return caps;
  754. }
  756. u8* mgavideo_lock_video( struct mga_dev* mga )
  757. {
  758.         mga->locked = mga->status;
  760.         if( mga->status & VS_FIELD ) {
  761.                 return mga->fb + mga->vin_addr1;
  762.         } else {
  763.                 return mga->fb + mga->vin_addr0;
  764.         }
  765. }
  768. void mgavideo_unlock_video( struct mga_dev* mga )
  769. {
  770.         mga->locked = 0;
  771. }
  774. static void _detect_tvt( struct mga_dev* mga )
  775. {
  776.         int msp, tuner_addr, tuner;
  778.         if( mga->hastuner && mga->hasaudio ) {
  779.                 mgavideo_tuner( mga, TUNER_GET_ADDRESS, &tuner_addr );
  780.                 mgavideo_audio( mga, MSP_GET_UNIT, &msp );
  781.                 tuner = TUNER_ABSENT;
  783.                 switch( tuner_addr ) {
  784.                 case 0xc0:
  785.                         /* Samsung MULTI PAL - unsupported by tuner.c? */
  786.                         break;
  788.                 case 0xc2:
  789.                         if( (msp&0xff) == 0x07 ) { /* Usa audio */
  790.                                 tuner = TUNER_PHILIPS_NTSC;
  791.                         } else {
  792.                         /* Samsung SECAM - unsupported by tuner.c? */
  793.                         }
  794.                         break;
  795.                 
  796.                 case 0xc4:
  797.                         tuner = TUNER_PHILIPS_PAL_I;
  798.                         break;
  800.                 case 0xc6:
  801.                         if( (msp&0xff) == 0x07 ) { /* Usa audio */
  802.                         /* Samsung NTSC - unsupported by tuner.c? */
  803.                         } else {
  804.                                 tuner = TUNER_PHILIPS_SECAM;
  805.                         }
  806.                 }
  807.                 
  808.                 mgavideo_tuner( mga, TUNER_SET_TYPE, &tuner );
  809.         }
  810. }
  812. /****************************************************************************
  813. * interrupt processing
  814. ****************************************************************************/
  816. static void mgavideo_vsync(struct mga_dev *mga)
  817. {
  818.         /* increment frame counter */
  819.         mga->grabbed++;
  821. /* We may have change the pitch or base address */
  822. if (mga->status & VS_FIELD) {
  823. /* program even field data */
  824. _mgawrite( mga, VINCTL0, ( VIN_ON | VBI_RAW | (mga->vinpitch >> 2) << 3) );
  825. } else {
  826. /* program odd field data */
  827. _mgawrite( mga, VINCTL1, ( VIN_ON | VBI_RAW | (mga->vinpitch >> 2) << 3) );
  828. }
  829. #ifdef NEVER
  830. zr36060_compress_image(&mga->zr36060);
  831. {
  832. struct timeval curr;
  833. do_gettimeofday(&curr);
  834. dprintk("mgavideo: interrupt status=%x  frames e=%d o=%d time: %d:%dn", mga->status, 
  835. mga->req_even, mga->req_odd, curr.tv_sec, curr.tv_usec);
  836. }
  837. #endif
  838.         
  839.         if( !(mga->locked & ( VS_VIDEO | VS_RAWVBI | VS_SLICEDVBI ) ) ) {
  840. /* if no video fields are locked, program the next window
  841.  * based on what window was just grabbed */
  842. #ifdef NEVER
  843. _mgawrite( mga, VINNEXTWIN, (mga->status&VS_FIELD)?0:1 );
  844. #else
  845. _mgawrite( mga, VINNEXTWIN, (mga->status&VS_FIELD)?1:0 );
  846. #endif
  848.                 /* queue bottom half if present, and requested */
  849.                 if( mga->tqnode_dpc.routine ) {
  850.                         if (( mga->req_even && !( mga->status & VS_FIELD ))
  851.                         ||  ( mga->req_odd  &&  ( mga->status & VS_FIELD ))) {
  853.                                 queue_task(&mga->tqnode_dpc, &tq_immediate);
  854.                                 mark_bh(IMMEDIATE_BH);
  855.                         } else {
  856. #ifdef NEVER
  857. printk("frame not wanted odd %d even %d status= %xn",
  858. mga->req_even, mga->req_odd, mga->status);
  859. #endif
  860. }
  861.                 }
  862.         } else {
  863.                 /* otherwise, program the next window based on what field
  864.                  * is locked */
  865. #ifdef NEVER
  866. _mgawrite( mga, VINNEXTWIN, (mga->status&VS_FIELD)?0:1 );
  867. #else
  868. _mgawrite( mga, VINNEXTWIN, (mga->status&VS_FIELD)?1:0 );
  869. #endif
  870. #ifdef NEVER
  871. printk("frame buffer lockedn");
  872. #endif
  873.         }
  874. }
  877. static void interrupt_hw(int irq, void *v, struct pt_regs *regs)
  878. {
  879.         struct mga_dev* mga = (struct mga_dev*)v;
  881.         if (mga == NULL)
  882.                 return;
  884.         /* read status register */
  885.         mga->status = _mgaread( mga, VSTATUS );
  887. if (mga->status & VI_IVSYNC)  {
  888. mgavideo_vsync(mga);
  889. _mgawrite( mga, VICLEAR, VI_IVSYNC );
  890. }
  891. if (mga->status & VI_CMDCMPL) {
  892. printk("mgavideo: command complete pendingn");
  893. #ifdef NEVER
  894. zr36060_interrupt(&mga->zr);
  895. _mgawrite( mga, VICLEAR, VI_CMDCMPL);
  896. #endif
  897. }
  898. if (mga->status & VI_BLVL) {
  899. printk("mgavideo: buffer level pendingn");
  900. _mgawrite( mga, VICLEAR, VI_BLVL);
  901. }
  902. if (mga->status & VI_EOI)  {
  903. printk("mgavideo: codec decompression end of image pendingn");
  904. _mgawrite( mga, VICLEAR, VI_EOI);
  905. }
  906. }
  909. /* enable interrupts */
  910. void mgavideo_ivsync_enable( struct mga_dev* mga, int en )
  911. {
  912.         u32 istat;
  914.         if( mga == NULL )
  915.                 return;
  917.         dprintk( "mgavideo: %sable IVSYNC interruptn", en?"en":"dis" );
  919.         _mgawrite( mga, VICLEAR, VI_IVSYNC );
  921.         istat = _mgaread( mga, VIEN );
  922.         _mgawrite( mga, VIEN, en?(istat|VI_IVSYNC):(istat&~VI_IVSYNC) );
  923. }
  925. /* register a routine to be called for each frame */
  926. void mgavideo_register_bh( struct mga_dev* mga, int req_even, int req_odd,
  927.                            void(*routine)(void*), void* data )
  928. {
  929.         mga->req_even = req_even;
  930.         mga->req_odd = req_odd;
  931.         mga->tqnode_dpc.next = NULL;
  932.         mga->tqnode_dpc.sync = 0;
  933.         mga->tqnode_dpc.routine = routine;
  934.         mga->tqnode_dpc.data = data;
  935. }
  937. /*
  938.  * reset the the hardware for dma cap for new size. Also need to
  939.  * update the ks0127 to scale for new size.
  940.  */
  941. void  mgavideo_set_dims(struct mga_dev *mga, int width, int height)
  942. {
  943. mgavideo_decoder( mga, KS0127_SET_WIDTH, &width);
  944. mga->vinpitch = width;
  946. #ifdef NEVER
  947. mgavideo_decoder( mga, KS0127_SET_HEIGHT, &height);
  948. #endif
  949. }
  951. /****************************************************************************
  952. * back-end scaler
  953. ****************************************************************************/
  954. void* mgavideo_get_base( struct mga_dev* mga )
  955. {
  956.         return mga->fb;
  957. }
  959. void mgavideo_set_window( struct mga_dev* mga, int x, int y, int w, int h )
  960. {
  961.         _mgawrite( mga, BESHCOORD, (x<<16) | (x+w-1) );
  962.         _mgawrite( mga, BESVCOORD, (y<<16) | (y+h-1) );
  963.         _mgawrite( mga, BESHISCAL, (_VINWID<<16) / w);
  964.         _mgawrite( mga, BESVISCAL, (_VINHGT<<16) / h);
  965. }
  967. void mgavideo_set_colorkey( struct mga_dev* mga, int r, int g, int b )
  968. {
  969.         /* Activate the colorkey mode */
  970.         writeb( XKEYOPMODE, mga->ctrl + PALWTADD );
  971.         writeb( 1, mga->ctrl + X_DATAREG );
  973.         writeb( XCOLMSK0RED, mga->ctrl + PALWTADD );
  974.         writeb( 0xff, mga->ctrl + X_DATAREG );
  976.         writeb( XCOLMSK0GREEN, mga->ctrl + PALWTADD );
  977.         writeb( 0xff, mga->ctrl + X_DATAREG );
  979.         writeb( XCOLMSK0BLUE, mga->ctrl + PALWTADD );
  980.         writeb( 0xff, mga->ctrl + X_DATAREG );
  982.         writeb( XCOLKEY0RED, mga->ctrl + PALWTADD );
  983.         writeb( r, mga->ctrl + X_DATAREG );
  985.         writeb( XCOLKEY0GREEN, mga->ctrl + PALWTADD );
  986.         writeb( g, mga->ctrl + X_DATAREG );
  988.         writeb( XCOLKEY0BLUE, mga->ctrl + PALWTADD );
  989.         writeb( b, mga->ctrl + X_DATAREG );
  990. }
  992. void mgavideo_set_overlay( struct mga_dev* mga )
  993. {
  994.         /* Activate the overlay mode */
  995.         writeb( XKEYOPMODE, mga->ctrl + PALWTADD );
  996.         writeb( 0, mga->ctrl + X_DATAREG );
  997. }
  999. void mgavideo_preview_enable( struct mga_dev* mga, int en )
  1000. {
  1001.         /* Activate scaler */
  1002.         _mgawrite( mga, BESCTL, en?0x00000007:0x00000000 ); 
  1004.         /* Activate automatic switching of windows
  1005.          * This is for testing only
  1006.         */
  1007.         _mgawrite( mga, VINNEXTWIN, en?2:0 );
  1008. }
  1011. /****************************************************************************
  1012. * initialization
  1013. ****************************************************************************/
  1014. static void _mgavideo_init( struct mga_dev* mga )
  1015. {
  1016.         writeb( XMISCCTRL, mga->ctrl + PALWTADD );
  1017.         writeb( readb( mga->ctrl + X_DATAREG ) | 0x06, mga->ctrl + X_DATAREG );
  1019.         /* detect tv-tuner */
  1020.         _detect_tvt( mga );
  1022.         /* enable video-in */
  1023.         _mgawrite( mga, VINCTL, 0x0101ab01 );
  1025.         /* just in case, clear video interrupt */
  1026.         _mgawrite( mga, VICLEAR, VI_IVSYNC );
  1028.         /* setup video window 0 */
  1029.         _mgawrite( mga, VINCTL0, ( VIN_ON | VBI_RAW | (mga->vinpitch >> 2) << 3) );
  1030.         _mgawrite( mga, VBIADDR0, mga->vbi_addr0);
  1031.         _mgawrite( mga, VINADDR0, mga->vin_addr0);
  1033.         /* setup video window 1 */
  1034.         _mgawrite( mga, VINCTL1, ( VIN_ON | VBI_RAW | (mga->vinpitch >> 2) << 3) );
  1035.         _mgawrite( mga, VBIADDR1, mga->vbi_addr1);
  1036.         _mgawrite( mga, VINADDR1, mga->vin_addr1);
  1038.         /* setup backend scaler */
  1039.         _mgawrite( mga, BESPITCH, mga->vinpitch & (~3));
  1040.         _mgawrite( mga, BESHSRCLST, (_VINWID-1)<<16 );
  1041.         _mgawrite( mga, BESHSRCST, 0<<14 );
  1042.         _mgawrite( mga, BESHSRCEND, (_VINWID * 4 -1)<<14 );
  1043.         _mgawrite( mga, BESV1SRCLST, 255 );
  1044.         _mgawrite( mga, BESV2SRCLST, 255 );
  1045.         _mgawrite( mga, BESA1ORG, mga->vin_addr0 );
  1046.         _mgawrite( mga, BESA2ORG, mga->vin_addr1 );
  1047.         _mgawrite( mga, BESB1ORG, mga->vin_addr0 );
  1048.         _mgawrite( mga, BESB2ORG, mga->vin_addr1 );
  1050.         /* register interrupt routine */
  1051.         if( mga->irq ) {
  1052.                 if( request_irq( mga->irq, interrupt_hw, SA_SHIRQ,
  1053.                                  mga->name, mga ) < 0 ) {
  1054.                         dprintk( "mgavideo: Denied IRQ %dn", mga->irq );
  1055.                         mga->irq_status = 0;
  1056.                 } else {
  1057.                         mga->irq_status = mga->irq;
  1058.                 }
  1059.         }
  1060. }
  1063. #define NBOARDS 4
  1064. struct mga_dev mgavideo_dev[NBOARDS];
  1066. /* HACK to get the MGA struct.
  1067.    the 'mgavideo_get' routine cannot handle multiple use
  1068.    of the same board anyway...
  1069. */
  1070. struct mga_dev* mgavideo_get_codec() {
  1071.   if (&mgavideo_dev[0] != NULL)
  1072.     return &mgavideo_dev[0];
  1073.   else
  1074.     return NULL;
  1075. }
  1077. /* find all mga adapters */
  1078. struct mga_dev* mgavideo_get( void )
  1079. {
  1080.         int i;
  1081.         struct mga_dev* mga;
  1083.         for( i=0; i<NBOARDS; i++ )
  1084.         {
  1085.                 mga = &mgavideo_dev[i];
  1086.                 if( !mga->inuse && (mga->ctrl != NULL) )
  1087.                 {
  1088.                         dprintk( "mgavideo: acquire video device %xn", i );
  1089.                         mga->inuse++;
  1090.                         MOD_INC_USE_COUNT;
  1092.                         _mgavideo_init( mga );
  1093.                        return mga;
  1094.                 }
  1095.         }
  1097.         return NULL;
  1098. }
  1100. /* release a mga adapter that is not needed anymore */
  1101. void mgavideo_release( struct mga_dev* mga )
  1102. {
  1103.         if( mga == NULL )
  1104.                 return;
  1106.         if( mga->ctrl )
  1107.         {
  1108.                 /* clear any pending interrupt */
  1109.                 _mgawrite( mga, VICLEAR, VI_IVSYNC );
  1111.                 /* disable video interrupt */
  1112.                 _mgawrite( mga, VIEN, _mgaread( mga, VIEN ) & ~VI_IVSYNC );
  1114.                 /* disable video-in */
  1115.                 _mgawrite( mga, VINCTL, 0x0101ab00 );
  1117.                 /* disable (temp) backend scaler */
  1118.                 mgavideo_preview_enable( mga, 0 );
  1120. /* Turn off the zr36060 */
  1121. #ifdef NEVER
  1122. zr36060_deattach(&mga->zr);
  1123. #endif
  1125.                 /* un-register isr */
  1126.                 if( mga->irq_status ) {
  1127.                         free_irq( mga->irq_status, mga );
  1128.                         mga->irq_status = 0;
  1129.                 }
  1131.                 MOD_DEC_USE_COUNT;
  1132.                 mga->inuse--;
  1133.                 dprintk( "mgavideo: release video devicen" );
  1134.                 printk( "mgavideo: grabbed %d total framesn", mga->grabbed );
  1135.         }
  1136. }
  1139. /****************************************************************************
  1140. * linux kernel module api
  1141. ****************************************************************************/
  1142. #ifdef MODULE
  1143. int init_module( void )
  1144. #else
  1145. int mgavideo_init( void )
  1146. #endif
  1147. {
  1148.         int found = 0;
  1149.         struct pci_dev* dev;
  1150.         struct mga_dev* mga;
  1151.         u32 mem;
  1152.         u32 addr = 0;
  1154.         dprintk( "mgavideo: Looking for boards...n" );
  1156.         /* find the next MGA G100 or G200 */
  1157.         for( dev = pci_devices; dev != NULL; dev = dev->next )
  1158.         {
  1159.                 if (dev->class != PCI_CLASS_NOT_DEFINED_VGA &&
  1160.                   ((dev->class) >> 16 != PCI_BASE_CLASS_DISPLAY))
  1161.                         continue;
  1163.                 if (PCI_FUNC(dev->devfn) != 0)
  1164.                         continue;
  1166.                 /* ignore non-mga adapters */
  1167.                 if (dev->vendor != PCI_VENDOR_ID_MATROX)
  1168.                         continue;
  1170.                 /* ignore non-gseries adapters */
  1171.                 if (dev->device != PCI_DEVICE_ID_MATROX_G200_PCI &&
  1172.                     dev->device != PCI_DEVICE_ID_MATROX_G200_AGP &&
  1173.                     dev->device != PCI_DEVICE_ID_MATROX_G100_MM &&
  1174.                     dev->device != PCI_DEVICE_ID_MATROX_G100_AGP)
  1175.                         continue;
  1178.                 /* the device is cool. set up a context for it */
  1179.                 mga = &mgavideo_dev[found];
  1180.                 memset( mga, 0, sizeof( *mga ) );
  1182.                 mga->device = dev->device;
  1183.                 mga->inuse = 0;
  1184.                 mga->irq = dev->irq;
  1186.          dprintk( "mgavideo: mapping fb memory...n" );
  1187.                 /* read and map the frame buffer and control aperture */
  1188.                 addr = dev->base_address[0] & PCI_BASE_ADDRESS_MEM_MASK;
  1189.                 mga->fb = ioremap( addr, 0x800000 );
  1190.          dprintk( "mgavideo: mapping ctrl memory...n" );
  1191.                 addr = dev->base_address[1] & PCI_BASE_ADDRESS_MEM_MASK;
  1192.                 mga->ctrl = ioremap( addr, 0x4000 );
  1193.          dprintk( "mgavideo: Okn" );
  1195.                 /* setup address for video in memory */
  1196.                 mem = memsize - 1l;
  1197.                 mem  = (mem - _VIN_WINDOW) & VINADDRx_MASK;
  1198.                 mga->vin_addr0 = mem;
  1199.                 mem  = (mem - _VIN_WINDOW) & VINADDRx_MASK;
  1200.                 mga->vin_addr1 = mem;
  1201.                 mem  = (mem - _VBI_WINDOW) & VBIADDRx_MASK;
  1202.                 mga->vbi_addr0 =  mem;
  1203.                 mem  = (mem - _VBI_WINDOW) & VBIADDRx_MASK;
  1204.                 mga->vbi_addr1 = mem;
  1206. /* init memory for zr36060 */
  1208. mem = (mem - (257 * 1024)) & ~0x3ff;
  1209. mga->host_interface_base = mem;
  1210. mga->interface_base = (u8 *)(mga->fb) + mem;
  1211. mga->command_base = (u8 *)(mga->fb) + (mem + 256 * 1024);
  1212. mga->read_base = mga->command_base + 512;
  1213. mga->codec_offset = 0;
  1215. /* Default pitch for mga */
  1216. mga->vinpitch = 704;
  1218. mga->vin_field = _VIN_FIELD_EVEN;
  1221. /* fill in zr36060 register address */
  1222. mga->zr36060.codec_id = ZR36060_ID;
  1223. mga->zr36060.private = mga;
  1224. mga->zr36060.memory_size = 8;
  1226. mga->zr36060.codec_read_memory = mgacodec_read_memory;
  1227. mga->zr36060.codec_write_memory = mgacodec_write_memory;
  1228. mga->zr36060.codec_reset = mgacodec_zr36060_reset;
  1229. mga->zr36060.codec_start = mgacodec_zr6060_start;
  1231. /*******************************************/
  1232. /* Setup addresses for the Codec Interface */
  1233. /*******************************************/
  1235. /* p. 3-68 of the MGA HandBook : the Codec Addr must be aligned
  1236.    on a 1Kb boundary */
  1237. mga->codecaddr = ((u32)mga->fb + 0x0004000) & ~0xFF;
  1239.                 /* reset the device */
  1240.                 _mgawrite( mga, VINCTL, 0x0101ab00 );
  1242.                 /* setup the i2c */
  1243.                 sprintf( mga->i2c.name, "mga%d", found );
  1244.                 mga->i2c.id = I2C_BUSID_MGA;
  1245.                 mga->i2c.data = mga;
  1246.             #if LINUX_VERSION_CODE >= 0x020100
  1247.                 mga->i2c.bus_lock = SPIN_LOCK_UNLOCKED;
  1248.             #endif
  1249.                 mga->i2c.attach_inform = _mgai2c_attach;
  1250.                 mga->i2c.detach_inform = _mgai2c_detach;
  1251.                 mga->i2c.i2c_setlines = _mgai2c_setlines;
  1252.                 mga->i2c.i2c_getdataline = _mgai2c_getdataline;
  1253.                 mga->i2c.i2c_read = NULL;
  1254.                 mga->i2c.i2c_write = NULL;
  1255.                 i2c_register_bus( &mga->i2c );
  1257.                 sprintf( mga->name, "mgavideo%d", found );
  1259.                 /* okay everything looks good */
  1260.                 dprintk( "mgavideo: Found %s: device 0x%x irq %in", mga->name, mga->device, mga->irq );
  1261.                 
  1262.                 if( ++found >= NBOARDS )
  1263.                         break;
  1264.         }
  1266.         if( !found )
  1267.                 return -ENODEV;
  1269.         return 0;
  1270. }
  1272. #ifdef MODULE
  1273. void cleanup_module( void )
  1274. {
  1275.         int i;
  1276.         struct mga_dev* mga;
  1278.         for( i=0; i<NBOARDS; i++ )
  1279.         {
  1280.                 mga = &mgavideo_dev[i];
  1281.                 if( mga->ctrl )
  1282.                 {
  1283.                         i2c_unregister_bus( &mga->i2c );
  1284.                         iounmap( (void*)mga->ctrl );
  1285.                         iounmap((void*)mga->fb);
  1286.                 }
  1287.         }
  1288. }
  1289. #endif