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

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

DVD

开发平台：

Unix_Linux

mga_vid.c：源码内容
  1. /*
  2.  *
  3.  * mga_vid.c
  4.  *
  5.  * Copyright (C) 1999 Aaron Holtzman
  6.  * 
  7.  * Module skeleton based on gutted agpgart module by Jeff Hartmann 
  8.  * <slicer@ionet.net>
  9.  *
  10.  * Matrox MGA G200/G400 YUV Video Interface module Version 0.1.0
  11.  * 
  12.  * BES == Back End Scaler
  13.  * 
  14.  * This software has been released under the terms of the GNU Public
  15.  * license. See http://www.gnu.org/copyleft/gpl.html for details.
  16.  */
  18. //It's entirely possible this major conflicts with something else
  19. /* mknod /dev/mga_vid c 178 0 */
  21. #include <linux/config.h>
  22. #include <linux/version.h>
  23. #include <linux/module.h>
  24. #include <linux/types.h>
  25. #include <linux/kernel.h>
  26. #include <linux/sched.h>
  27. #include <linux/mm.h>
  28. #include <linux/string.h>
  29. #include <linux/errno.h>
  30. #include <linux/malloc.h>
  31. #include <linux/pci.h>
  32. #include <linux/init.h>
  33. #include <linux/videodev.h>
  35. #include "mga_vid.h"
  37. #ifdef CONFIG_MTRR 
  38. #include <asm/mtrr.h>
  39. #endif
  41. #include <asm/uaccess.h>
  42. #include <asm/system.h>
  43. #include <asm/io.h>
  45. #define TRUE 1
  46. #define FALSE 0
  48. #define MGA_VID_MAJOR 178
  50. #define MGA_VIDMEM_SIZE 16
  52. #ifndef PCI_DEVICE_ID_MATROX_G200_PCI 
  53. #define PCI_DEVICE_ID_MATROX_G200_PCI 0x0520
  54. #endif
  56. #ifndef PCI_DEVICE_ID_MATROX_G200_AGP 
  57. #define PCI_DEVICE_ID_MATROX_G200_AGP 0x0521
  58. #endif
  60. #ifndef PCI_DEVICE_ID_MATROX_G400 
  61. #define PCI_DEVICE_ID_MATROX_G400 0x0525
  62. #endif
  64. MODULE_AUTHOR("Aaron Holtzman <aholtzma@engr.uvic.ca>");
  67. typedef struct bes_registers_s
  68. {
  69. //BES Control
  70. uint_32 besctl;
  71. //BES Global control
  72. uint_32 besglobctl;
  73. //Luma control (brightness and contrast)
  74. uint_32 beslumactl;
  75. //Line pitch
  76. uint_32 bespitch;
  78. //Buffer A-1 Chroma 3 plane org
  79. uint_32 besa1c3org;
  80. //Buffer A-1 Chroma org
  81. uint_32 besa1corg;
  82. //Buffer A-1 Luma org
  83. uint_32 besa1org;
  85. //Buffer A-2 Chroma 3 plane org
  86. uint_32 besa2c3org;
  87. //Buffer A-2 Chroma org
  88. uint_32 besa2corg;
  89. //Buffer A-2 Luma org
  90. uint_32 besa2org;
  92. //Buffer B-1 Chroma 3 plane org
  93. uint_32 besb1c3org;
  94. //Buffer B-1 Chroma org
  95. uint_32 besb1corg;
  96. //Buffer B-1 Luma org
  97. uint_32 besb1org;
  99. //Buffer B-2 Chroma 3 plane org
  100. uint_32 besb2c3org;
  101. //Buffer B-2 Chroma org
  102. uint_32 besb2corg;
  103. //Buffer B-2 Luma org
  104. uint_32 besb2org;
  106. //BES Horizontal coord
  107. uint_32 beshcoord;
  108. //BES Horizontal inverse scaling [5.14]
  109. uint_32 beshiscal;
  110. //BES Horizontal source start [10.14] (for scaling)
  111. uint_32 beshsrcst;
  112. //BES Horizontal source ending [10.14] (for scaling) 
  113. uint_32 beshsrcend;
  114. //BES Horizontal source last 
  115. uint_32 beshsrclst;
  118. //BES Vertical coord
  119. uint_32 besvcoord;
  120. //BES Vertical inverse scaling [5.14]
  121. uint_32 besviscal;
  122. //BES Field 1 vertical source last position
  123. uint_32 besv1srclst;
  124. //BES Field 1 weight start
  125. uint_32 besv1wght;
  126. //BES Field 2 vertical source last position
  127. uint_32 besv2srclst;
  128. //BES Field 2 weight start
  129. uint_32 besv2wght;
  131. } bes_registers_t;
  133. static bes_registers_t regs;
  134. static uint_32 mga_vid_in_use = 0;
  135. static uint_32 is_g400 = 0;
  136. static uint_32 vid_src_ready = 0;
  137. static uint_32 vid_overlay_on = 0;
  139. static uint_8 *mga_mmio_base = 0;
  140. static uint_32 mga_mem_base = 0; 
  141. static uint_32 mga_src_base = 0;
  143. static struct pci_dev *pci_dev;
  145. static struct video_window mga_win;
  146. static mga_vid_config_t mga_config; 
  148. //All register offsets are converted to word aligned offsets (32 bit)
  149. //because we want all our register accesses to be 32 bits
  150. #define VCOUNT      0x1e20
  152. #define PALWTADD      0x3c00 // Index register for X_DATAREG port
  153. #define X_DATAREG     0x3c0a
  155. #define XMULCTRL      0x19
  156. #define BPP_8         0x00
  157. #define BPP_15        0x01
  158. #define BPP_16        0x02
  159. #define BPP_24        0x03
  160. #define BPP_32_DIR    0x04
  161. #define BPP_32_PAL    0x07
  163. #define XCOLMSK       0x40
  164. #define X_COLKEY      0x42
  165. #define XKEYOPMODE    0x51
  166. #define XCOLMSK0RED   0x52
  167. #define XCOLMSK0GREEN 0x53
  168. #define XCOLMSK0BLUE  0x54
  169. #define XCOLKEY0RED   0x55
  170. #define XCOLKEY0GREEN 0x56
  171. #define XCOLKEY0BLUE  0x57
  173. // Backend Scaler registers
  174. #define BESCTL      0x3d20
  175. #define BESGLOBCTL  0x3dc0
  176. #define BESLUMACTL  0x3d40
  177. #define BESPITCH    0x3d24
  178. #define BESA1C3ORG  0x3d60
  179. #define BESA1CORG   0x3d10
  180. #define BESA1ORG    0x3d00
  181. #define BESHCOORD   0x3d28
  182. #define BESHISCAL   0x3d30
  183. #define BESHSRCEND  0x3d3C
  184. #define BESHSRCLST  0x3d50
  185. #define BESHSRCST   0x3d38
  186. #define BESV1WGHT   0x3d48
  187. #define BESV2WGHT   0x3d4c
  188. #define BESV1SRCLST 0x3d54
  189. #define BESV2SRCLST 0x3d58
  190. #define BESVISCAL   0x3d34
  191. #define BESVCOORD   0x3d2c
  192. #define BESSTATUS   0x3dc4
  194. static void mga_vid_write_regs(void)
  195. {
  196. //Make sure internal registers don't get updated until we're done
  197. writel( (readl(mga_mmio_base + VCOUNT)-1)<<16,
  198. mga_mmio_base + BESGLOBCTL);
  200. // color or coordinate keying
  201. writeb( XKEYOPMODE, mga_mmio_base + PALWTADD);
  202. writeb( mga_config.colkey_on, mga_mmio_base + X_DATAREG);
  203. if ( mga_config.colkey_on ) 
  204. {
  205. uint_32 r=0, g=0, b=0;
  207. writeb( XMULCTRL, mga_mmio_base + PALWTADD);
  208. switch (readb (mga_mmio_base + X_DATAREG)) 
  209. {
  210. case BPP_8:
  211. /* Need to look up the color index, just using
  212.  color 0 for now. */
  213. break;
  215. case BPP_15:
  216. r = mga_config.colkey_red   >> 3;
  217. g = mga_config.colkey_green >> 3;
  218. b = mga_config.colkey_blue  >> 3;
  219. break;
  221. case BPP_16:
  222. r = mga_config.colkey_red   >> 3;
  223. g = mga_config.colkey_green >> 2;
  224. b = mga_config.colkey_blue  >> 3;
  225. break;
  227. case BPP_24:
  228. case BPP_32_DIR:
  229. case BPP_32_PAL:
  230. r = mga_config.colkey_red;
  231. g = mga_config.colkey_green;
  232. b = mga_config.colkey_blue;
  233. break;
  234. }
  236. // Disable color keying on alpha channel 
  237. writeb( XCOLMSK, mga_mmio_base + PALWTADD);
  238. writeb( 0x00, mga_mmio_base + X_DATAREG);
  239. writeb( X_COLKEY, mga_mmio_base + PALWTADD);
  240. writeb( 0x00, mga_mmio_base + X_DATAREG);
  242. // Set up color key registers
  243. writeb( XCOLKEY0RED, mga_mmio_base + PALWTADD);
  244. writeb( r, mga_mmio_base + X_DATAREG);
  245. writeb( XCOLKEY0GREEN, mga_mmio_base + PALWTADD);
  246. writeb( g, mga_mmio_base + X_DATAREG);
  247. writeb( XCOLKEY0BLUE, mga_mmio_base + PALWTADD);
  248. writeb( b, mga_mmio_base + X_DATAREG);
  250. // Set up color key mask registers
  251. writeb( XCOLMSK0RED, mga_mmio_base + PALWTADD);
  252. writeb( 0xff, mga_mmio_base + X_DATAREG);
  253. writeb( XCOLMSK0GREEN, mga_mmio_base + PALWTADD);
  254. writeb( 0xff, mga_mmio_base + X_DATAREG);
  255. writeb( XCOLMSK0BLUE, mga_mmio_base + PALWTADD);
  256. writeb( 0xff, mga_mmio_base + X_DATAREG);
  257. }
  259. // Backend Scaler
  260. writel( regs.besctl,      mga_mmio_base + BESCTL); 
  261. if(is_g400)
  262. writel( regs.beslumactl,  mga_mmio_base + BESLUMACTL); 
  263. writel( regs.bespitch,    mga_mmio_base + BESPITCH); 
  265. writel( regs.besa1org,    mga_mmio_base + BESA1ORG);
  266. writel( regs.besa1corg,   mga_mmio_base + BESA1CORG);
  267. if(is_g400)
  268. writel( regs.besa1c3org,  mga_mmio_base + BESA1C3ORG);
  270. writel( regs.beshcoord,   mga_mmio_base + BESHCOORD);
  271. writel( regs.beshiscal,   mga_mmio_base + BESHISCAL);
  272. writel( regs.beshsrcst,   mga_mmio_base + BESHSRCST);
  273. writel( regs.beshsrcend,  mga_mmio_base + BESHSRCEND);
  274. writel( regs.beshsrclst,  mga_mmio_base + BESHSRCLST);
  276. writel( regs.besvcoord,   mga_mmio_base + BESVCOORD);
  277. writel( regs.besviscal,   mga_mmio_base + BESVISCAL);
  278. writel( regs.besv1srclst, mga_mmio_base + BESV1SRCLST);
  279. writel( regs.besv1wght,   mga_mmio_base + BESV1WGHT);
  281. //update the registers somewhere between 1 and 2 frames from now.
  282. writel( regs.besglobctl + ((readl(mga_mmio_base + VCOUNT)+2)<<16),
  283. mga_mmio_base + BESGLOBCTL);
  285. printk("mga_vid: wrote BES registersn");
  286. printk("mga_vid: BESCTL = 0x%08xn",
  287. readl(mga_mmio_base + BESCTL));
  288. printk("mga_vid: BESGLOBCTL = 0x%08xn",
  289. readl(mga_mmio_base + BESGLOBCTL));
  290. printk("mga_vid: BESSTATUS= 0x%08xn",
  291. readl(mga_mmio_base + BESSTATUS));
  293. //FIXME remove
  294. printk("besa1org = %08lxn",regs.besa1org);
  295. printk("besa1corg= %08lxn",regs.besa1corg);
  296. printk("besa1c3org= %08lxn",regs.besa1c3org);
  297. //FIXME remove
  298. }
  300. static int mga_vid_set_config(mga_vid_config_t *config)
  301. {
  302. int x, y, sw, sh, dw, dh;
  303. int besleft, bestop, ifactor, ofsleft, ofstop, baseadrofs, weight, weights;
  304. x = config->x_org;
  305. y = config->y_org;
  306. sw = config->src_width;
  307. sh = config->src_height;
  308. dw = config->dest_width;
  309. dh = config->dest_height;
  311. printk("mga_vid: Setting up a %dx%d+%d+%d video window (src %dx%d)n",
  312.        dw, dh, x, y, sw, sh);
  314. //FIXME check that window is valid and inside desktop
  316. //FIXME figure out a better way to allocate memory on card
  317. //allocate 2 megs
  318. //mga_src_base = mga_mem_base + (MGA_VIDMEM_SIZE-2) * 0x100000;
  319. mga_src_base = (MGA_VIDMEM_SIZE-2) * 0x100000;
  321. //Setup the BES registers for a three plane 4:2:0 video source 
  323. //BES enabled, even start polarity, filtering enabled, chroma upsampling
  324. //enabled, 420 mode enabled, dither enabled, mirror disabled, b/w
  325. //disabled, blanking enabled, software field select, buffer a1 displayed
  326. regs.besctl = 1 + (1<<10) + (1<<11) + (1<<16) + (1<<17) + (1<<18); 
  328. if(is_g400)
  329. {
  330. //zoom disabled, zoom filter disabled, 420 3 plane format, proc amp
  331. //disabled, rgb mode disabled 
  332. regs.besglobctl = (1<<5);
  333. }
  334. else
  335. {
  336. //zoom disabled, zoom filter disabled, Cb samples in 0246, Cr
  337. //in 1357, BES register update on besvcnt
  338. regs.besglobctl = 0;
  339. }
  342. //Disable contrast and brightness control
  343. regs.beslumactl = 0x80<<0;
  345. //Setup destination window boundaries
  346. besleft = x > 0 ? x : 0;
  347. bestop = y > 0 ? y : 0;
  348. regs.beshcoord = (besleft<<16) + (x + dw-1);
  349. regs.besvcoord = (bestop<<16) + (y + dh-1);
  351. //Setup source dimensions
  352. regs.beshsrclst  = (sw - 1) << 16;
  353. regs.bespitch = (sw + 31) & ~31 ; 
  355. //Setup horizontal scaling
  356. ifactor = ((sw-1)<<14)/(dw-1);
  357. ofsleft = besleft - x;
  359. regs.beshiscal = ifactor<<2;
  360. regs.beshsrcst = (ofsleft*ifactor)<<2;
  361. regs.beshsrcend = regs.beshsrcst + (((dw - ofsleft - 1) * ifactor) << 2);
  363. //Setup vertical scaling
  364. ifactor = ((sh-1)<<14)/(dh-1);
  365. ofstop = bestop - y;
  367. regs.besviscal = ifactor<<2;
  369. baseadrofs = ((ofstop*regs.besviscal)>>16)*regs.bespitch;
  370. regs.besa1org = (uint_32) mga_src_base + baseadrofs;
  372. if (is_g400) 
  373. baseadrofs = (((ofstop*regs.besviscal)/4)>>16)*regs.bespitch;
  374. else 
  375. baseadrofs = (((ofstop*regs.besviscal)/2)>>16)*regs.bespitch;
  377. regs.besa1corg = (uint_32) mga_src_base + regs.bespitch * sh + baseadrofs;
  378. regs.besa1c3org = regs.besa1corg + ((regs.bespitch * sh) / 4);
  380. weight = ofstop * (regs.besviscal >> 2);
  381. weights = weight < 0 ? 1 : 0;
  382. regs.besv1wght = (weights << 16) + ((weight & 0x3FFF) << 2);
  383. regs.besv1srclst = sh - 1 - (((ofstop * regs.besviscal) >> 16) & 0x03FF);
  385. mga_vid_write_regs();
  386. return 0;
  387. }
  390. static int mga_vid_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  391. {
  393. switch(cmd) 
  394. {
  395. case MGA_VID_CONFIG:
  396. //FIXME remove
  397. printk("vcount = %dn",readl(mga_mmio_base + VCOUNT));
  398. printk("mga_mmio_base = %pn",mga_mmio_base);
  399. printk("mga_mem_base = %08lxn",mga_mem_base);
  400. //FIXME remove
  402. printk("mga_vid: Received configurationn");
  403. if(copy_from_user(&mga_config,(mga_vid_config_t*) arg,sizeof(mga_vid_config_t)))
  404. {
  405. printk("mga_vid: failed copy from userspacen");
  406. return(-EFAULT);
  407. }
  408. return mga_vid_set_config(&mga_config);
  409. break;
  411. case MGA_VID_ON:
  412. printk("mga_vid: Video ONn");
  413. vid_src_ready = 1;
  414. if(vid_overlay_on)
  415. {
  416. regs.besctl |= 1;
  417. mga_vid_write_regs();
  418. }
  419. break;
  421. case MGA_VID_OFF:
  422. printk("mga_vid: Video OFFn");
  423. vid_src_ready = 0;   
  424. regs.besctl &= ~1;
  425. mga_vid_write_regs();
  426. break;
  428.         default:
  429. printk("mga_vid: Invalid ioctln");
  430. return (-EINVAL);
  431. }
  432.        
  433. return 0;
  434. }
  437. static int mga_vid_find_card(void)
  438. {
  439. struct pci_dev *dev = NULL;
  441. if((dev = pci_find_device(PCI_VENDOR_ID_MATROX, PCI_DEVICE_ID_MATROX_G400, NULL)))
  442. {
  443. is_g400 = 1;
  444. printk("mga_vid: Found MGA G400n");
  445. }
  446. else if((dev = pci_find_device(PCI_VENDOR_ID_MATROX, PCI_DEVICE_ID_MATROX_G200_AGP, NULL)))
  447. {
  448. is_g400 = 0;
  449. printk("mga_vid: Found MGA G200 AGPn");
  450. }
  451. else if((dev = pci_find_device(PCI_VENDOR_ID_MATROX, PCI_DEVICE_ID_MATROX_G200_PCI, NULL)))
  452. {
  453. is_g400 = 0;
  454. printk("mga_vid: Found MGA G200 PCIn");
  455. }
  456. else
  457. {
  458. printk("mga_vid: No supported cards foundn");
  459. return FALSE;   
  460. }
  462. pci_dev = dev;
  464. #if LINUX_VERSION_CODE >= 0x020300
  465. mga_mmio_base = ioremap_nocache(dev->resource[1].start,0x4000);
  466. mga_mem_base =  dev->resource[0].start;
  467. #else
  468. mga_mmio_base = ioremap_nocache(dev->base_address[1] & PCI_BASE_ADDRESS_MEM_MASK,0x4000);
  469. mga_mem_base =  dev->base_address[0] & PCI_BASE_ADDRESS_MEM_MASK;
  470. #endif
  471. printk("MMIO at 0x%pn", mga_mmio_base);
  472. printk("Frame at 0x%08lXn", mga_mem_base);
  474. return TRUE;
  475. }
  478. static ssize_t mga_vid_read(struct file *file, char *buf, size_t count, loff_t *ppos)
  479. {
  480. return -EINVAL;
  481. }
  483. static ssize_t mga_vid_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
  484. {
  485. return -EINVAL;
  486. }
  488. static int mga_vid_mmap(struct file *file, struct vm_area_struct *vma)
  489. {
  491. printk("mga_vid: mapping video memory into userspacen");
  492. if(remap_page_range(vma->vm_start, mga_mem_base + (MGA_VIDMEM_SIZE-2) * 0x100000,
  493.  vma->vm_end - vma->vm_start, vma->vm_page_prot)) 
  494. {
  495. printk("mga_vid: error mapping video memoryn");
  496. return(-EAGAIN);
  497. }
  499. return(0);
  500. }
  502. static int mga_vid_release(struct inode *inode, struct file *file)
  503. {
  504. //Close the window just in case
  505. vid_src_ready = 0;   
  506. regs.besctl &= ~1;
  507. mga_vid_write_regs();
  508. mga_vid_in_use = 0;
  510. //FIXME put back in!
  511. //MOD_DEC_USE_COUNT;
  512. return 0;
  513. }
  515. static long long mga_vid_lseek(struct file *file, long long offset, int origin)
  516. {
  517. return -ESPIPE;
  518. }  
  520. static int mga_vid_open(struct inode *inode, struct file *file)
  521. {
  522. int minor = MINOR(inode->i_rdev);
  524. if(minor != 0)
  525.  return(-ENXIO);
  527. if(mga_vid_in_use == 1) 
  528. return(-EBUSY);
  530. mga_vid_in_use = 1;
  531. //FIXME turn me back on!
  532. //MOD_INC_USE_COUNT;
  533. return(0);
  534. }
  536. static struct file_operations mga_vid_fops =
  537. {
  538. mga_vid_lseek,
  539. mga_vid_read,
  540. mga_vid_write,
  541. NULL,
  542. NULL,
  543. mga_vid_ioctl,
  544. mga_vid_mmap,
  545. mga_vid_open,
  546. NULL,
  547. mga_vid_release
  548. };
  551. static long mga_v4l_read(struct video_device *v, char *buf, unsigned long count, 
  552. int noblock)
  553. {
  554. return -EINVAL;
  555. }
  557. static long mga_v4l_write(struct video_device *v, const char *buf, unsigned long count, int noblock)
  558. {
  559. return -EINVAL;
  560. }
  562. static int mga_v4l_open(struct video_device *dev, int mode)
  563. {
  564. MOD_INC_USE_COUNT;
  565. return 0;
  566. }
  568. static void mga_v4l_close(struct video_device *dev)
  569. {
  570. regs.besctl &= ~1;
  571. mga_vid_write_regs();
  572. vid_overlay_on = 0;
  573. MOD_DEC_USE_COUNT;
  574. return;
  575. }
  577. static int mga_v4l_init_done(struct video_device *dev)
  578. {
  579. return 0;
  580. }
  582. static int mga_v4l_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
  583. {
  584. switch(cmd)
  585. {
  586. case VIDIOCGCAP:
  587. {
  588. struct video_capability b;
  589. strcpy(b.name, "Matrox G200/400");
  590. b.type = VID_TYPE_SCALES|VID_TYPE_OVERLAY|VID_TYPE_CHROMAKEY;
  591. b.channels = 0;
  592. b.audios = 0;
  593. b.maxwidth = 1024; /* GUESS ?? */
  594. b.maxheight = 768;
  595. b.minwidth = 32;
  596. b.minheight = 16; /* GUESS ?? */
  597. if(copy_to_user(arg,&b,sizeof(b)))
  598. return -EFAULT;
  599. return 0;
  600. }
  601. case VIDIOCGPICT:
  602. {
  603. /*
  604.  * Default values.. if we can change this we
  605.  * can add the feature later
  606.  */
  607. struct video_picture vp;
  608. vp.brightness = 0x8000;
  609. vp.hue = 0x8000;
  610. vp.colour = 0x8000;
  611. vp.whiteness = 0x8000;
  612. vp.depth = 8;
  613. /* Format is a guess */
  614. vp.palette = VIDEO_PALETTE_YUV420P;
  615. if(copy_to_user(arg, &vp, sizeof(vp)))
  616. return -EFAULT;
  617. return 0;
  618. }
  619. case VIDIOCSPICT:
  620. {
  621. return -EINVAL;
  622. }
  623. case VIDIOCSWIN:
  624. {
  625. struct video_window vw;
  626. if(copy_from_user(&vw, arg, sizeof(vw)))
  627. return -EFAULT;
  628. if(vw.x <0 || vw.y <0 || vw.width < 32 
  629. || vw.height < 16)
  630. return -EINVAL;
  631. memcpy(&mga_win, &vw, sizeof(mga_win));
  633. mga_config.x_org = vw.x;
  634. mga_config.y_org = vw.y;
  635. mga_config.dest_width = vw.width;
  636. mga_config.dest_height = vw.height;
  638. /* 
  639.  * May have to add 
  640.  *
  641.  * #define VIDEO_WINDOW_CHROMAKEY 16 
  642.  *
  643.  * to <linux/videodev.h> 
  644.  */
  646. //add it here for now
  647. #define VIDEO_WINDOW_CHROMAKEY 16 
  649. if (vw.flags & VIDEO_WINDOW_CHROMAKEY)
  650. mga_config.colkey_on = 1;
  651. else 
  652. mga_config.colkey_on = 0;
  654. mga_config.colkey_red   = (vw.chromakey >> 24) & 0xFF;
  655. mga_config.colkey_green = (vw.chromakey >> 16) & 0xFF;
  656. mga_config.colkey_blue  = (vw.chromakey >> 8)  & 0xFF;
  657. mga_vid_set_config(&mga_config);
  658. return 0;
  660. }
  661. case VIDIOCGWIN:
  662. {
  663. if(copy_to_user(arg, &mga_win, sizeof(mga_win)))
  664. return -EFAULT;
  665. return 0;
  666. }
  667. case VIDIOCCAPTURE:
  668. {
  669. int v;
  670. if(copy_from_user(&v, arg, sizeof(v)))
  671. return -EFAULT;
  672. vid_overlay_on = v;
  673. if(vid_overlay_on && vid_src_ready)
  674. {
  675. regs.besctl |= 1;
  676. mga_vid_write_regs();
  677. }
  678. else
  679. {
  680. regs.besctl &= ~1;
  681. mga_vid_write_regs();
  682. }
  683. return 0;
  684. }
  685. default:
  686. return -ENOIOCTLCMD;
  687. }
  688. }
  690. static struct video_device mga_v4l_dev =
  691. {
  692. "Matrox G200/G400",
  693. VID_TYPE_CAPTURE,
  694. VID_HARDWARE_BT848, /* This is a lie for now */
  695. mga_v4l_open,
  696. mga_v4l_close,
  697. mga_v4l_read,
  698. mga_v4l_write,
  699. NULL,
  700. mga_v4l_ioctl,
  701. NULL,
  702. mga_v4l_init_done,
  703. NULL,
  704. 0,
  705. 0
  706. };
  710. /* 
  711.  * Main Initialization Function 
  712.  */
  715. static int mga_vid_initialize(void)
  716. {
  717. mga_vid_in_use = 0;
  719. printk( "Matrox MGA G200/G400 YUV Video interface v0.01 (c) Aaron Holtzman n");
  720. if(register_chrdev(MGA_VID_MAJOR, "mga_vid", &mga_vid_fops))
  721. {
  722. printk("mga_vid: unable to get major: %dn", MGA_VID_MAJOR);
  723. return -EIO;
  724. }
  726. if (!mga_vid_find_card())
  727. {
  728. printk("mga_vid: no supported devices foundn");
  729. unregister_chrdev(MGA_VID_MAJOR, "mga_vid");
  730. return -EINVAL;
  731. }
  733. if (video_register_device(&mga_v4l_dev, VFL_TYPE_GRABBER)<0)
  734. {
  735. printk("mga_vid: unable to register.n");
  736. unregister_chrdev(MGA_VID_MAJOR, "mga_vid");
  737. if(mga_mmio_base)
  738. iounmap(mga_mmio_base);
  739. mga_mmio_base = 0;
  740. return -EINVAL;
  741. }
  743. return(0);
  744. }
  746. int init_module(void)
  747. {
  748.    return mga_vid_initialize();
  749. }
  751. void cleanup_module(void)
  752. {
  753. video_unregister_device(&mga_v4l_dev);
  754. if(mga_mmio_base)
  755. iounmap(mga_mmio_base);
  757. //FIXME turn off BES
  758. printk("mga_vid: Cleaning up modulen");
  759. unregister_chrdev(MGA_VID_MAJOR, "mga_vid");
  760. }