diff drivers/sis_vid.c @ 1:3b5f5d1c5041

Initial revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/drivers/sis_vid.c	Sat Feb 24 20:28:24 2001 +0000
@@ -0,0 +1,645 @@
+/*
+ *
+ * sis_vid.c
+ *
+ * Copyright (C) 2000 Aaron Holtzman
+ * 
+ * This software has been released under the terms of the GNU Public
+ * license. See http://www.gnu.org/copyleft/gpl.html for details.
+ */
+
+// video4linux interface disabled by A'rpi/ESP-team
+
+
+//It's entirely possible this major conflicts with something else
+/* mknod /dev/mga_vid c 178 0 */
+
+#include <linux/config.h>
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/mm.h>
+#include <linux/string.h>
+#include <linux/errno.h>
+#include <linux/malloc.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+//#include <linux/videodev.h>
+
+#include "sis_vid.h"
+
+#ifdef CONFIG_MTRR 
+#include <asm/mtrr.h>
+#endif
+
+#include <asm/uaccess.h>
+#include <asm/system.h>
+#include <asm/io.h>
+
+#define TRUE 1
+#define FALSE 0
+
+#define MGA_VID_MAJOR 178
+
+
+#ifndef PCI_DEVICE_ID_SI_6323 
+#define PCI_DEVICE_ID_SI_6323 0x6326
+#endif
+
+
+MODULE_AUTHOR("Aaron Holtzman <[e-mail]>");
+
+
+typedef struct bes_registers_s
+{
+	//base address of yuv framebuffer
+	uint32_t yuv_base;
+	uint32_t u_base;
+	uint32_t v_base;
+	uint32_t fb_end;;
+
+	//frame buffer pitch 
+	uint32_t pitch;
+
+	//window boundaries
+	uint32_t left;
+	uint32_t right;
+	uint32_t top;
+	uint32_t bottom;
+
+	//control registers
+	uint32_t misc_0;
+	uint32_t misc_1;
+	uint32_t misc_3;
+	uint32_t misc_4;
+
+	//key overlay mode
+	uint32_t key_mode;
+
+} bes_registers_t;
+
+static bes_registers_t regs;
+static uint32_t mga_vid_in_use = 0;
+static uint32_t vid_src_ready = 0;
+static uint32_t vid_overlay_on = 0;
+
+static uint8_t *mga_mmio_base = 0;
+static uint32_t mga_mem_base = 0; 
+static uint32_t mga_src_base = 0;
+
+static uint32_t mga_ram_size = 0;
+
+static struct pci_dev *pci_dev;
+
+//static struct video_window mga_win;
+static mga_vid_config_t mga_config; 
+
+
+
+// Backend Scaler registers
+
+#define MISC_0 0x98
+#define MISC_1 0x99
+#define MISC_3 0x9d
+#define MISC_4 0xb6
+
+
+
+
+static void mga_vid_frame_sel(int frame)
+{
+	//we don't need the vcount protection as we're only hitting
+	//one register (and it doesn't seem to be double buffered)
+	//regs.besctl = (regs.besctl & ~0x07000000) + (frame << 25);
+	//writel( regs.besctl, mga_mmio_base + BESCTL ); 
+}
+
+
+#define WRITE_REG(x,y,z) {outb((y),(x));outb((z),(x+1));}
+#define READ_REG(x,y) (outb((y),(x)),inb(x+1))
+#define VIDEO_ACCEL 0x3d4
+
+static void mga_vid_write_regs(void)
+{
+	uint32_t foo;
+
+	//unlock the video accel registers
+	WRITE_REG(VIDEO_ACCEL,0x80,0x86);
+	foo = READ_REG(VIDEO_ACCEL,0x80);
+
+	if(foo != 0xa1)
+		return; //something bad happened
+
+	//setup the horizontal window bounds
+	WRITE_REG(VIDEO_ACCEL,0x81,regs.left & 0xff);
+	WRITE_REG(VIDEO_ACCEL,0x82,regs.right & 0xff);
+	WRITE_REG(VIDEO_ACCEL,0x83,(regs.left >> 8) | ((regs.right>>4) & 0x70));
+
+	//setup the vertical window bounds
+	WRITE_REG(VIDEO_ACCEL,0x84,regs.top & 0xff);
+	WRITE_REG(VIDEO_ACCEL,0x85,regs.bottom & 0xff);
+	WRITE_REG(VIDEO_ACCEL,0x86,(regs.top >> 8) | ((regs.bottom>>4) & 0x70));
+
+	//setup the framebuffer base addresses
+	WRITE_REG(VIDEO_ACCEL,0x8a,regs.yuv_base & 0xff);
+	WRITE_REG(VIDEO_ACCEL,0x8b,(regs.yuv_base >> 8) & 0xff);
+	WRITE_REG(VIDEO_ACCEL,0x89,(regs.yuv_base >> 12) & 0xf0);
+
+	WRITE_REG(VIDEO_ACCEL,0xb7,regs.u_base & 0xff);
+	WRITE_REG(VIDEO_ACCEL,0xb8,(regs.u_base >> 8) & 0xff);
+
+	WRITE_REG(VIDEO_ACCEL,0xba,regs.v_base & 0xff);
+	WRITE_REG(VIDEO_ACCEL,0xbb,(regs.v_base >> 8) & 0xff);
+	WRITE_REG(VIDEO_ACCEL,0xb9,((regs.v_base >> 12) & 0xf0) + ((regs.u_base >> 16) & 0xf));
+
+	WRITE_REG(VIDEO_ACCEL,0x8d,regs.fb_end);
+
+	//setup framebuffer pitch
+	WRITE_REG(VIDEO_ACCEL,0x8c,regs.pitch & 0xff);
+	WRITE_REG(VIDEO_ACCEL,0x8e,(regs.pitch >> 8) & 0x0f);
+	WRITE_REG(VIDEO_ACCEL,0xbc,(regs.pitch) & 0xff);
+	WRITE_REG(VIDEO_ACCEL,0xbd,((regs.pitch) >> 8) & 0x0f);
+
+
+	//write key overlay register
+	WRITE_REG(VIDEO_ACCEL,0xa9,regs.key_mode);
+
+	WRITE_REG(VIDEO_ACCEL,0x93,0x40);
+	WRITE_REG(VIDEO_ACCEL,0x94,1);
+	WRITE_REG(VIDEO_ACCEL,0x9e,0);
+	WRITE_REG(VIDEO_ACCEL,0x9f,0);
+
+	//write config registers
+	WRITE_REG(VIDEO_ACCEL,MISC_0,regs.misc_0);
+	WRITE_REG(VIDEO_ACCEL,MISC_1,regs.misc_1);
+	WRITE_REG(VIDEO_ACCEL,MISC_3,regs.misc_3);
+	WRITE_REG(VIDEO_ACCEL,MISC_4,regs.misc_4);
+
+	//setup the video line buffer
+	WRITE_REG(VIDEO_ACCEL,0xa0,(regs.right - regs.left)/ 8);
+
+}
+
+static int mga_vid_set_config(mga_vid_config_t *config)
+{
+	uint32_t x, y, frame_size;
+
+	x = config->x_org;
+	y = config->y_org;
+
+	regs.left =  x;
+	regs.right= config->src_width + x;
+	regs.top =  y;
+	regs.bottom = config->src_height + y;
+
+	printk("mga_vid: Setting up a %dx%d+%d+%d video window (src %dx%d)\n",
+	       config->dest_width, config->dest_height, config->x_org, config->y_org, 
+				 config->src_width, config->src_height);
+
+	
+	regs.pitch = ((config->src_width + 31) & ~31) / 4 ; 
+
+	//frame size in pixels
+	frame_size =  regs.pitch * config->src_height * 4;
+
+	regs.yuv_base = (mga_src_base) >> 2;
+	regs.u_base = (mga_src_base + frame_size) >> 2;
+	regs.v_base = (mga_src_base + frame_size/4) >> 2;
+	regs.fb_end = (mga_src_base + (3*frame_size)/2) >> 14;
+
+	//disable video capture, enable video display, enable graphics display,
+	//select yuv format, odd parity
+	regs.misc_0 = (1 << 1) + (1<<6) + (1<<4);
+
+	//disable dithering, no filtering, no interrupts
+	regs.misc_1 = 0;
+
+	//select 2's complement format YUV for playback
+	regs.misc_3 = (1<<1);
+
+	//select 4:2:0 video format, + yuv4:2:2 cpu writes
+	regs.misc_4 = (1<<2);
+
+	//disable keying
+	regs.key_mode = 0xf;
+
+	mga_vid_write_regs();
+	return 0;
+}
+
+
+static int mga_vid_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+{
+	int frame;
+
+	switch(cmd) 
+	{
+		case MGA_VID_CONFIG:
+			//FIXME remove
+			printk("mga_mmio_base = %p\n",mga_mmio_base);
+			printk("mga_mem_base = %08x\n",mga_mem_base);
+			//FIXME remove
+
+			printk("mga_vid: Received configuration\n");
+
+ 			if(copy_from_user(&mga_config,(mga_vid_config_t*) arg,sizeof(mga_vid_config_t)))
+			{
+				printk("mga_vid: failed copy from userspace\n");
+				return(-EFAULT);
+			}
+
+			mga_config.ram_size = mga_ram_size;
+			//XXX make it look like a g400
+			mga_config.card_type = MGA_G400;;
+
+			if (copy_to_user((mga_vid_config_t *) arg, &mga_config, sizeof(mga_vid_config_t)))
+			{
+				printk("mga_vid: failed copy to userspace\n");
+				return(-EFAULT);
+			}
+			return mga_vid_set_config(&mga_config);	
+		break;
+
+		case MGA_VID_ON:
+			printk("mga_vid: Video ON\n");
+			vid_src_ready = 1;
+			if(vid_overlay_on)
+			{
+				//regs.besctl |= 1;
+				mga_vid_write_regs();
+			}
+		break;
+
+		case MGA_VID_OFF:
+			printk("mga_vid: Video OFF\n");
+			vid_src_ready = 0;   
+			//regs.besctl &= ~1;
+			mga_vid_write_regs();
+		break;
+			
+		case MGA_VID_FSEL:
+			if(copy_from_user(&frame,(int *) arg,sizeof(int)))
+			{
+				printk("mga_vid: FSEL failed copy from userspace\n");
+				return(-EFAULT);
+			}
+
+			mga_vid_frame_sel(frame);
+		break;
+
+	        default:
+			printk("mga_vid: Invalid ioctl\n");
+			return (-EINVAL);
+	}
+       
+	return 0;
+}
+
+
+static int mga_vid_find_card(void)
+{
+	struct pci_dev *dev = NULL;
+
+	if((dev = pci_find_device(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_6323, NULL)))
+	{
+		printk("sis_vid: Found SiS 6326\n");
+	}
+	else
+	{
+		printk("sis_vid: No supported cards found\n");
+		return FALSE;   
+	}
+
+	pci_dev = dev;
+	
+#if LINUX_VERSION_CODE >= 0x020300
+	mga_mmio_base = ioremap_nocache(dev->resource[1].start,0x10000);
+	mga_mem_base =  dev->resource[0].start;
+#else
+	mga_mmio_base = ioremap_nocache(dev->base_address[1] & PCI_BASE_ADDRESS_MEM_MASK,0x10000);
+	mga_mem_base =  dev->base_address[0] & PCI_BASE_ADDRESS_MEM_MASK;
+#endif
+	printk("mga_vid: MMIO at 0x%p\n", mga_mmio_base);
+	printk("mga_vid: Frame Buffer at 0x%08x\n", mga_mem_base);
+
+	//FIXME set ram size properly
+	mga_ram_size = 4;
+	mga_src_base = (mga_ram_size - 1) * 0x100000;
+	
+	//FIXME remove
+	if(1)
+	{
+		mga_vid_config_t config ={0,0,256,256,256,256,10,10,0,0,0,0};
+
+		mga_vid_set_config(&config);
+		mga_vid_write_regs();
+		//regs.misc_0 ^= 2;
+		//mga_vid_write_regs();
+	}
+	//FIXME remove
+
+	return TRUE;
+}
+
+
+static ssize_t mga_vid_read(struct file *file, char *buf, size_t count, loff_t *ppos)
+{
+	return -EINVAL;
+}
+
+static ssize_t mga_vid_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
+{
+	return -EINVAL;
+}
+
+static int mga_vid_mmap(struct file *file, struct vm_area_struct *vma)
+{
+
+	printk("mga_vid: mapping video memory into userspace\n");
+	if(remap_page_range(vma->vm_start, mga_mem_base + mga_src_base,
+		 vma->vm_end - vma->vm_start, vma->vm_page_prot)) 
+	{
+		printk("mga_vid: error mapping video memory\n");
+		return(-EAGAIN);
+	}
+
+	return(0);
+}
+
+static int mga_vid_release(struct inode *inode, struct file *file)
+{
+	//Close the window just in case
+	vid_src_ready = 0;   
+	regs.misc_0 &= 0xed;
+	mga_vid_write_regs();
+	mga_vid_in_use = 0;
+
+	//FIXME put back in!
+	//MOD_DEC_USE_COUNT;
+	return 0;
+}
+
+static long long mga_vid_lseek(struct file *file, long long offset, int origin)
+{
+	return -ESPIPE;
+}					 
+
+static int mga_vid_open(struct inode *inode, struct file *file)
+{
+	int minor = MINOR(inode->i_rdev);
+
+	if(minor != 0)
+	 return(-ENXIO);
+
+	if(mga_vid_in_use == 1) 
+		return(-EBUSY);
+
+	mga_vid_in_use = 1;
+	//FIXME turn me back on!
+	//MOD_INC_USE_COUNT;
+	return(0);
+}
+
+#if LINUX_VERSION_CODE >= 0x020400
+static struct file_operations mga_vid_fops =
+{
+	llseek:		mga_vid_lseek,
+	read:			mga_vid_read,
+	write:		mga_vid_write,
+	ioctl:		mga_vid_ioctl,
+	mmap:			mga_vid_mmap,
+	open:			mga_vid_open,
+	release: 	mga_vid_release
+};
+#else
+static struct file_operations mga_vid_fops =
+{
+	mga_vid_lseek,
+	mga_vid_read,
+	mga_vid_write,
+	NULL,
+	NULL,
+	mga_vid_ioctl,
+	mga_vid_mmap,
+	mga_vid_open,
+	NULL,
+	mga_vid_release
+};
+#endif
+
+#if 0
+static long mga_v4l_read(struct video_device *v, char *buf, unsigned long count, 
+	int noblock)
+{
+	return -EINVAL;
+}
+
+static long mga_v4l_write(struct video_device *v, const char *buf, unsigned long count, int noblock)
+{
+	return -EINVAL;
+}
+
+static int mga_v4l_open(struct video_device *dev, int mode)
+{
+	MOD_INC_USE_COUNT;
+	return 0;
+}
+
+static void mga_v4l_close(struct video_device *dev)
+{
+	//regs.besctl &= ~1;
+	mga_vid_write_regs();
+	vid_overlay_on = 0;
+	MOD_DEC_USE_COUNT;
+	return;
+}
+
+static int mga_v4l_init_done(struct video_device *dev)
+{
+	return 0;
+}
+
+static int mga_v4l_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
+{
+	switch(cmd)
+	{
+		case VIDIOCGCAP:
+		{
+			struct video_capability b;
+			strcpy(b.name, "Matrox G200/400");
+			b.type = VID_TYPE_SCALES|VID_TYPE_OVERLAY|VID_TYPE_CHROMAKEY;
+			b.channels = 0;
+			b.audios = 0;
+			b.maxwidth = 1024;	/* GUESS ?? */
+			b.maxheight = 768;
+			b.minwidth = 32;
+			b.minheight = 16;	/* GUESS ?? */
+			if(copy_to_user(arg,&b,sizeof(b)))
+				return -EFAULT;
+			return 0;
+		}
+		case VIDIOCGPICT:
+		{
+			/*
+			 *	Default values.. if we can change this we
+			 *	can add the feature later
+			 */
+			struct video_picture vp;
+			vp.brightness = 0x8000;
+			vp.hue = 0x8000;
+			vp.colour = 0x8000;
+			vp.whiteness = 0x8000;
+			vp.depth = 8;
+			/* Format is a guess */
+			vp.palette = VIDEO_PALETTE_YUV420P;
+			if(copy_to_user(arg, &vp, sizeof(vp)))
+				return -EFAULT;
+			return 0;
+		}
+		case VIDIOCSPICT:
+		{
+			return -EINVAL;
+		}
+		case VIDIOCSWIN:
+		{
+			struct video_window vw;
+			if(copy_from_user(&vw, arg, sizeof(vw)))
+				return -EFAULT;
+			if(vw.x <0 || vw.y <0 || vw.width < 32 
+				|| vw.height < 16)
+				return -EINVAL;
+			memcpy(&mga_win, &vw, sizeof(mga_win));
+
+			mga_config.x_org = vw.x;
+			mga_config.y_org = vw.y;
+			mga_config.dest_width = vw.width;
+			mga_config.dest_height = vw.height;
+
+			/* 
+			 * May have to add 
+			 *
+			 * #define VIDEO_WINDOW_CHROMAKEY 16 
+			 *
+			 * to <linux/videodev.h> 
+			 */
+
+			//add it here for now
+			#define VIDEO_WINDOW_CHROMAKEY 16 
+
+			if (vw.flags & VIDEO_WINDOW_CHROMAKEY)
+				mga_config.colkey_on = 1;
+			else 
+				mga_config.colkey_on = 0;
+
+			mga_config.colkey_red   = (vw.chromakey >> 24) & 0xFF;
+			mga_config.colkey_green = (vw.chromakey >> 16) & 0xFF;
+			mga_config.colkey_blue  = (vw.chromakey >> 8)  & 0xFF;
+			mga_vid_set_config(&mga_config);
+			return 0;
+				
+		}
+		case VIDIOCGWIN:
+		{
+			if(copy_to_user(arg, &mga_win, sizeof(mga_win)))
+				return -EFAULT;
+			return 0;
+		}
+		case VIDIOCCAPTURE:
+		{
+			int v;
+			if(copy_from_user(&v, arg, sizeof(v)))
+				return -EFAULT;
+			vid_overlay_on = v;
+			if(vid_overlay_on && vid_src_ready)
+			{
+				//regs.besctl |= 1;
+				mga_vid_write_regs();
+			}
+			else
+			{
+				//regs.besctl &= ~1;
+				mga_vid_write_regs();
+			}
+			return 0;
+		}
+		default:
+			return -ENOIOCTLCMD;
+	}
+}
+
+static struct video_device mga_v4l_dev =
+{
+	"Matrox G200/G400",
+	VID_TYPE_CAPTURE,
+	VID_HARDWARE_BT848,		/* This is a lie for now */
+	mga_v4l_open,
+	mga_v4l_close,
+	mga_v4l_read,
+	mga_v4l_write,
+	NULL,
+	mga_v4l_ioctl,
+	NULL,
+	mga_v4l_init_done,
+	NULL,
+	0,
+	0
+};
+
+#endif
+
+/* 
+ * Main Initialization Function 
+ */
+
+
+static int mga_vid_initialize(void)
+{
+	mga_vid_in_use = 0;
+
+	printk( "SiS 6326 YUV Video interface v0.01 (c) Aaron Holtzman \n");
+	if(register_chrdev(MGA_VID_MAJOR, "mga_vid", &mga_vid_fops))
+	{
+		printk("sis_vid: unable to get major: %d\n", MGA_VID_MAJOR);
+		return -EIO;
+	}
+
+	if (!mga_vid_find_card())
+	{
+		printk("sis_vid: no supported devices found\n");
+		unregister_chrdev(MGA_VID_MAJOR, "mga_vid");
+		return -EINVAL;
+	}
+	
+#if 0
+	if (video_register_device(&mga_v4l_dev, VFL_TYPE_GRABBER)<0)
+	{
+		printk("sis_vid: unable to register.\n");
+		unregister_chrdev(MGA_VID_MAJOR, "mga_vid");
+		if(mga_mmio_base)
+			iounmap(mga_mmio_base);
+		mga_mmio_base = 0;
+		return -EINVAL;
+	}
+#endif
+
+	return(0);
+}
+
+int init_module(void)
+{
+	return mga_vid_initialize();
+}
+
+void cleanup_module(void)
+{
+//	video_unregister_device(&mga_v4l_dev);
+	if(mga_mmio_base)
+		iounmap(mga_mmio_base);
+
+	//FIXME turn off BES
+	printk("mga_vid: Cleaning up module\n");
+	unregister_chrdev(MGA_VID_MAJOR, "mga_vid");
+}
+