tgafb: TURBOchannel support (86c6f7d0) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/video/Kconfig

+15 −5

Original line number	Original line	Diff line number	Diff line
	@@ -525,15 +525,25 @@ config FB_HP300
	default y		default y

	config FB_TGA		config FB_TGA
	tristate "TGA framebuffer support"		tristate "TGA/SFB+ framebuffer support"
	depends on FB && ALPHA		depends on FB && (ALPHA \|\| TC)
	select FB_CFB_FILLRECT		select FB_CFB_FILLRECT
	select FB_CFB_COPYAREA		select FB_CFB_COPYAREA
	select FB_CFB_IMAGEBLIT		select FB_CFB_IMAGEBLIT
	select BITREVERSE		select BITREVERSE
	help		---help---
	This is the frame buffer device driver for generic TGA graphic		This is the frame buffer device driver for generic TGA and SFB+
	cards. Say Y if you have one of those.		graphic cards. These include DEC ZLXp-E1, -E2 and -E3 PCI cards,
			also known as PBXGA-A, -B and -C, and DEC ZLX-E1, -E2 and -E3
			TURBOchannel cards, also known as PMAGD-A, -B and -C.

			Due to hardware limitations ZLX-E2 and E3 cards are not supported
			for DECstation 5000/200 systems. Additionally due to firmware
			limitations these cards may cause troubles with booting DECstation
			5000/240 and /260 systems, but are fully supported under Linux if
			you manage to get it going. ;-)

			Say Y if you have one of those.

	config FB_VESA		config FB_VESA
	bool "VESA VGA graphics support"		bool "VESA VGA graphics support"

drivers/video/tgafb.c

+239 −51

Original line number	Original line	Diff line number	Diff line
	@@ -5,27 +5,45 @@
	* Copyright (C) 1997 Geert Uytterhoeven		* Copyright (C) 1997 Geert Uytterhoeven
	* Copyright (C) 1999,2000 Martin Lucina, Tom Zerucha		* Copyright (C) 1999,2000 Martin Lucina, Tom Zerucha
	* Copyright (C) 2002 Richard Henderson		* Copyright (C) 2002 Richard Henderson
			* Copyright (C) 2006 Maciej W. Rozycki
	*		*
	* This file is subject to the terms and conditions of the GNU General Public		* This file is subject to the terms and conditions of the GNU General Public
	* License. See the file COPYING in the main directory of this archive for		* License. See the file COPYING in the main directory of this archive for
	* more details.		* more details.
	*/		*/

	#include <linux/module.h>		#include <linux/bitrev.h>
	#include <linux/kernel.h>
	#include <linux/errno.h>
	#include <linux/string.h>
	#include <linux/mm.h>
	#include <linux/slab.h>
	#include <linux/delay.h>		#include <linux/delay.h>
	#include <linux/init.h>		#include <linux/device.h>
			#include <linux/errno.h>
	#include <linux/fb.h>		#include <linux/fb.h>
			#include <linux/init.h>
			#include <linux/ioport.h>
			#include <linux/kernel.h>
			#include <linux/mm.h>
			#include <linux/module.h>
	#include <linux/pci.h>		#include <linux/pci.h>
	#include <linux/selection.h>		#include <linux/selection.h>
	#include <linux/bitrev.h>		#include <linux/slab.h>
			#include <linux/string.h>
			#include <linux/tc.h>

	#include <asm/io.h>		#include <asm/io.h>

	#include <video/tgafb.h>		#include <video/tgafb.h>

			#ifdef CONFIG_PCI
			#define TGA_BUS_PCI(dev) (dev->bus == &pci_bus_type)
			#else
			#define TGA_BUS_PCI(dev) 0
			#endif

			#ifdef CONFIG_TC
			#define TGA_BUS_TC(dev) (dev->bus == &tc_bus_type)
			#else
			#define TGA_BUS_TC(dev) 0
			#endif

	/*		/*
	* Local functions.		* Local functions.
	*/		*/
	@@ -42,12 +60,16 @@ static void tgafb_imageblit(struct fb_info , const struct fb_image );
	static void tgafb_fillrect(struct fb_info , const struct fb_fillrect );		static void tgafb_fillrect(struct fb_info , const struct fb_fillrect );
	static void tgafb_copyarea(struct fb_info , const struct fb_copyarea );		static void tgafb_copyarea(struct fb_info , const struct fb_copyarea );

	static int __devinit tgafb_pci_register(struct pci_dev *,		static int __devinit tgafb_register(struct device *dev);
	const struct pci_device_id *);		static void __devexit tgafb_unregister(struct device *dev);
	static void __devexit tgafb_pci_unregister(struct pci_dev *);
			static const char *mode_option;
			static const char *mode_option_pci = "640x480@60";
			static const char *mode_option_tc = "1280x1024@72";

	static const char *mode_option = "640x480@60";

			static struct pci_driver tgafb_pci_driver;
			static struct tc_driver tgafb_tc_driver;

	/*		/*
	* Frame buffer operations		* Frame buffer operations
	@@ -65,9 +87,13 @@ static struct fb_ops tgafb_ops = {
	};		};


			#ifdef CONFIG_PCI
	/*		/*
	* PCI registration operations		* PCI registration operations
	*/		*/
			static int __devinit tgafb_pci_register(struct pci_dev *,
			const struct pci_device_id *);
			static void __devexit tgafb_pci_unregister(struct pci_dev *);

	static struct pci_device_id const tgafb_pci_table[] = {		static struct pci_device_id const tgafb_pci_table[] = {
	{ PCI_DEVICE(PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TGA) },		{ PCI_DEVICE(PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TGA) },
	@@ -75,13 +101,68 @@ static struct pci_device_id const tgafb_pci_table[] = {
	};		};
	MODULE_DEVICE_TABLE(pci, tgafb_pci_table);		MODULE_DEVICE_TABLE(pci, tgafb_pci_table);

	static struct pci_driver tgafb_driver = {		static struct pci_driver tgafb_pci_driver = {
	.name = "tgafb",		.name = "tgafb",
	.id_table = tgafb_pci_table,		.id_table = tgafb_pci_table,
	.probe = tgafb_pci_register,		.probe = tgafb_pci_register,
	.remove = __devexit_p(tgafb_pci_unregister),		.remove = __devexit_p(tgafb_pci_unregister),
	};		};

			static int __devinit
			tgafb_pci_register(struct pci_dev pdev, const struct pci_device_id ent)
			{
			return tgafb_register(&pdev->dev);
			}

			static void __devexit
			tgafb_pci_unregister(struct pci_dev *pdev)
			{
			tgafb_unregister(&pdev->dev);
			}
			#endif /* CONFIG_PCI */

			#ifdef CONFIG_TC
			/*
			* TC registration operations
			*/
			static int __devinit tgafb_tc_register(struct device *);
			static int __devexit tgafb_tc_unregister(struct device *);

			static struct tc_device_id const tgafb_tc_table[] = {
			{ "DEC ", "PMAGD-AA" },
			{ "DEC ", "PMAGD " },
			{ }
			};
			MODULE_DEVICE_TABLE(tc, tgafb_tc_table);

			static struct tc_driver tgafb_tc_driver = {
			.id_table = tgafb_tc_table,
			.driver = {
			.name = "tgafb",
			.bus = &tc_bus_type,
			.probe = tgafb_tc_register,
			.remove = __devexit_p(tgafb_tc_unregister),
			},
			};

			static int __devinit
			tgafb_tc_register(struct device *dev)
			{
			int status = tgafb_register(dev);
			if (!status)
			get_device(dev);
			return status;
			}

			static int __devexit
			tgafb_tc_unregister(struct device *dev)
			{
			put_device(dev);
			tgafb_unregister(dev);
			return 0;
			}
			#endif /* CONFIG_TC */


	/**		/**
	* tgafb_check_var - Optional function. Validates a var passed in.		* tgafb_check_var - Optional function. Validates a var passed in.
	@@ -132,10 +213,10 @@ static int
	tgafb_set_par(struct fb_info *info)		tgafb_set_par(struct fb_info *info)
	{		{
	static unsigned int const deep_presets[4] = {		static unsigned int const deep_presets[4] = {
	0x00014000,		0x00004000,
	0x0001440d,		0x0000440d,
	0xffffffff,		0xffffffff,
	0x0001441d		0x0000441d
	};		};
	static unsigned int const rasterop_presets[4] = {		static unsigned int const rasterop_presets[4] = {
	0x00000003,		0x00000003,
	@@ -157,6 +238,8 @@ tgafb_set_par(struct fb_info *info)
	};		};

	struct tga_par par = (struct tga_par ) info->par;		struct tga_par par = (struct tga_par ) info->par;
			int tga_bus_pci = TGA_BUS_PCI(par->dev);
			int tga_bus_tc = TGA_BUS_TC(par->dev);
	u32 htimings, vtimings, pll_freq;		u32 htimings, vtimings, pll_freq;
	u8 tga_type;		u8 tga_type;
	int i;		int i;
	@@ -221,7 +304,7 @@ tgafb_set_par(struct fb_info *info)
	TGA_WRITE_REG(par, vtimings, TGA_VERT_REG);		TGA_WRITE_REG(par, vtimings, TGA_VERT_REG);

	/* Initalise RAMDAC. */		/* Initalise RAMDAC. */
	if (tga_type == TGA_TYPE_8PLANE) {		if (tga_type == TGA_TYPE_8PLANE && tga_bus_pci) {

	/* Init BT485 RAMDAC registers. */		/* Init BT485 RAMDAC registers. */
	BT485_WRITE(par, 0xa2 \| (par->sync_on_green ? 0x8 : 0x0),		BT485_WRITE(par, 0xa2 \| (par->sync_on_green ? 0x8 : 0x0),
	@@ -261,6 +344,38 @@ tgafb_set_par(struct fb_info *info)
	TGA_RAMDAC_REG);		TGA_RAMDAC_REG);
	}		}

			} else if (tga_type == TGA_TYPE_8PLANE && tga_bus_tc) {

			/* Init BT459 RAMDAC registers. */
			BT459_WRITE(par, BT459_REG_ACC, BT459_CMD_REG_0, 0x40);
			BT459_WRITE(par, BT459_REG_ACC, BT459_CMD_REG_1, 0x00);
			BT459_WRITE(par, BT459_REG_ACC, BT459_CMD_REG_2,
			(par->sync_on_green ? 0xc0 : 0x40));

			BT459_WRITE(par, BT459_REG_ACC, BT459_CUR_CMD_REG, 0x00);

			/* Fill the palette. */
			BT459_LOAD_ADDR(par, 0x0000);
			TGA_WRITE_REG(par, BT459_PALETTE << 2, TGA_RAMDAC_SETUP_REG);

			#ifdef CONFIG_HW_CONSOLE
			for (i = 0; i < 16; i++) {
			int j = color_table[i];

			TGA_WRITE_REG(par, default_red[j], TGA_RAMDAC_REG);
			TGA_WRITE_REG(par, default_grn[j], TGA_RAMDAC_REG);
			TGA_WRITE_REG(par, default_blu[j], TGA_RAMDAC_REG);
			}
			for (i = 0; i < 240 * 3; i += 4) {
			#else
			for (i = 0; i < 256 * 3; i += 4) {
			#endif
			TGA_WRITE_REG(par, 0x55, TGA_RAMDAC_REG);
			TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
			TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
			TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
			}

	} else { /* 24-plane or 24plusZ */		} else { /* 24-plane or 24plusZ */

	/* Init BT463 RAMDAC registers. */		/* Init BT463 RAMDAC registers. */
	@@ -431,6 +546,8 @@ tgafb_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue,
	unsigned transp, struct fb_info *info)		unsigned transp, struct fb_info *info)
	{		{
	struct tga_par par = (struct tga_par ) info->par;		struct tga_par par = (struct tga_par ) info->par;
			int tga_bus_pci = TGA_BUS_PCI(par->dev);
			int tga_bus_tc = TGA_BUS_TC(par->dev);

	if (regno > 255)		if (regno > 255)
	return 1;		return 1;
	@@ -438,12 +555,18 @@ tgafb_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue,
	green >>= 8;		green >>= 8;
	blue >>= 8;		blue >>= 8;

	if (par->tga_type == TGA_TYPE_8PLANE) {		if (par->tga_type == TGA_TYPE_8PLANE && tga_bus_pci) {
	BT485_WRITE(par, regno, BT485_ADDR_PAL_WRITE);		BT485_WRITE(par, regno, BT485_ADDR_PAL_WRITE);
	TGA_WRITE_REG(par, BT485_DATA_PAL, TGA_RAMDAC_SETUP_REG);		TGA_WRITE_REG(par, BT485_DATA_PAL, TGA_RAMDAC_SETUP_REG);
	TGA_WRITE_REG(par, red\|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);		TGA_WRITE_REG(par, red\|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);
	TGA_WRITE_REG(par, green\|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);		TGA_WRITE_REG(par, green\|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);
	TGA_WRITE_REG(par, blue\|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);		TGA_WRITE_REG(par, blue\|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);
			} else if (par->tga_type == TGA_TYPE_8PLANE && tga_bus_tc) {
			BT459_LOAD_ADDR(par, regno);
			TGA_WRITE_REG(par, BT459_PALETTE << 2, TGA_RAMDAC_SETUP_REG);
			TGA_WRITE_REG(par, red, TGA_RAMDAC_REG);
			TGA_WRITE_REG(par, green, TGA_RAMDAC_REG);
			TGA_WRITE_REG(par, blue, TGA_RAMDAC_REG);
	} else {		} else {
	if (regno < 16) {		if (regno < 16) {
	u32 value = (regno << 16) \| (regno << 8) \| regno;		u32 value = (regno << 16) \| (regno << 8) \| regno;
	@@ -1309,18 +1432,29 @@ static void
	tgafb_init_fix(struct fb_info *info)		tgafb_init_fix(struct fb_info *info)
	{		{
	struct tga_par par = (struct tga_par )info->par;		struct tga_par par = (struct tga_par )info->par;
			int tga_bus_pci = TGA_BUS_PCI(par->dev);
			int tga_bus_tc = TGA_BUS_TC(par->dev);
	u8 tga_type = par->tga_type;		u8 tga_type = par->tga_type;
	const char *tga_type_name;		const char *tga_type_name = NULL;

	switch (tga_type) {		switch (tga_type) {
	case TGA_TYPE_8PLANE:		case TGA_TYPE_8PLANE:
			if (tga_bus_pci)
	tga_type_name = "Digital ZLXp-E1";		tga_type_name = "Digital ZLXp-E1";
			if (tga_bus_tc)
			tga_type_name = "Digital ZLX-E1";
	break;		break;
	case TGA_TYPE_24PLANE:		case TGA_TYPE_24PLANE:
			if (tga_bus_pci)
	tga_type_name = "Digital ZLXp-E2";		tga_type_name = "Digital ZLXp-E2";
			if (tga_bus_tc)
			tga_type_name = "Digital ZLX-E2";
	break;		break;
	case TGA_TYPE_24PLUSZ:		case TGA_TYPE_24PLUSZ:
			if (tga_bus_pci)
	tga_type_name = "Digital ZLXp-E3";		tga_type_name = "Digital ZLXp-E3";
			if (tga_bus_tc)
			tga_type_name = "Digital ZLX-E3";
	break;		break;
	default:		default:
	tga_type_name = "Unknown";		tga_type_name = "Unknown";
	@@ -1348,9 +1482,15 @@ tgafb_init_fix(struct fb_info *info)
	info->fix.accel = FB_ACCEL_DEC_TGA;		info->fix.accel = FB_ACCEL_DEC_TGA;
	}		}

	static __devinit int		static int __devinit
	tgafb_pci_register(struct pci_dev pdev, const struct pci_device_id ent)		tgafb_register(struct device *dev)
	{		{
			static const struct fb_videomode modedb_tc = {
			/* 1280x1024 @ 72 Hz, 76.8 kHz hsync */
			"1280x1024@72", 0, 1280, 1024, 7645, 224, 28, 33, 3, 160, 3,
			FB_SYNC_ON_GREEN, FB_VMODE_NONINTERLACED
			};

	static unsigned int const fb_offset_presets[4] = {		static unsigned int const fb_offset_presets[4] = {
	TGA_8PLANE_FB_OFFSET,		TGA_8PLANE_FB_OFFSET,
	TGA_24PLANE_FB_OFFSET,		TGA_24PLANE_FB_OFFSET,
	@@ -1358,40 +1498,51 @@ tgafb_pci_register(struct pci_dev pdev, const struct pci_device_id ent)
	TGA_24PLUSZ_FB_OFFSET		TGA_24PLUSZ_FB_OFFSET
	};		};

			const struct fb_videomode *modedb_tga = NULL;
			resource_size_t bar0_start = 0, bar0_len = 0;
			const char *mode_option_tga = NULL;
			int tga_bus_pci = TGA_BUS_PCI(dev);
			int tga_bus_tc = TGA_BUS_TC(dev);
			unsigned int modedbsize_tga = 0;
	void __iomem *mem_base;		void __iomem *mem_base;
	unsigned long bar0_start, bar0_len;
	struct fb_info *info;		struct fb_info *info;
	struct tga_par *par;		struct tga_par *par;
	u8 tga_type;		u8 tga_type;
	int ret;		int ret = 0;

	/* Enable device in PCI config. */		/* Enable device in PCI config. */
	if (pci_enable_device(pdev)) {		if (tga_bus_pci && pci_enable_device(to_pci_dev(dev))) {
	printk(KERN_ERR "tgafb: Cannot enable PCI device\n");		printk(KERN_ERR "tgafb: Cannot enable PCI device\n");
	return -ENODEV;		return -ENODEV;
	}		}

	/* Allocate the fb and par structures. */		/* Allocate the fb and par structures. */
	info = framebuffer_alloc(sizeof(struct tga_par), &pdev->dev);		info = framebuffer_alloc(sizeof(struct tga_par), dev);
	if (!info) {		if (!info) {
	printk(KERN_ERR "tgafb: Cannot allocate memory\n");		printk(KERN_ERR "tgafb: Cannot allocate memory\n");
	return -ENOMEM;		return -ENOMEM;
	}		}

	par = info->par;		par = info->par;
	pci_set_drvdata(pdev, info);		dev_set_drvdata(dev, info);

	/* Request the mem regions. */		/* Request the mem regions. */
	bar0_start = pci_resource_start(pdev, 0);
	bar0_len = pci_resource_len(pdev, 0);
	ret = -ENODEV;		ret = -ENODEV;
			if (tga_bus_pci) {
			bar0_start = pci_resource_start(to_pci_dev(dev), 0);
			bar0_len = pci_resource_len(to_pci_dev(dev), 0);
			}
			if (tga_bus_tc) {
			bar0_start = to_tc_dev(dev)->resource.start;
			bar0_len = to_tc_dev(dev)->resource.end - bar0_start + 1;
			}
	if (!request_mem_region (bar0_start, bar0_len, "tgafb")) {		if (!request_mem_region (bar0_start, bar0_len, "tgafb")) {
	printk(KERN_ERR "tgafb: cannot reserve FB region\n");		printk(KERN_ERR "tgafb: cannot reserve FB region\n");
	goto err0;		goto err0;
	}		}

	/* Map the framebuffer. */		/* Map the framebuffer. */
	mem_base = ioremap(bar0_start, bar0_len);		mem_base = ioremap_nocache(bar0_start, bar0_len);
	if (!mem_base) {		if (!mem_base) {
	printk(KERN_ERR "tgafb: Cannot map MMIO\n");		printk(KERN_ERR "tgafb: Cannot map MMIO\n");
	goto err1;		goto err1;
	@@ -1399,12 +1550,16 @@ tgafb_pci_register(struct pci_dev pdev, const struct pci_device_id ent)

	/* Grab info about the card. */		/* Grab info about the card. */
	tga_type = (readl(mem_base) >> 12) & 0x0f;		tga_type = (readl(mem_base) >> 12) & 0x0f;
	par->pdev = pdev;		par->dev = dev;
	par->tga_mem_base = mem_base;		par->tga_mem_base = mem_base;
	par->tga_fb_base = mem_base + fb_offset_presets[tga_type];		par->tga_fb_base = mem_base + fb_offset_presets[tga_type];
	par->tga_regs_base = mem_base + TGA_REGS_OFFSET;		par->tga_regs_base = mem_base + TGA_REGS_OFFSET;
	par->tga_type = tga_type;		par->tga_type = tga_type;
	pci_read_config_byte(pdev, PCI_REVISION_ID, &par->tga_chip_rev);		if (tga_bus_pci)
			pci_read_config_byte(to_pci_dev(dev), PCI_REVISION_ID,
			&par->tga_chip_rev);
			if (tga_bus_tc)
			par->tga_chip_rev = TGA_READ_REG(par, TGA_START_REG) & 0xff;

	/* Setup framebuffer. */		/* Setup framebuffer. */
	info->flags = FBINFO_DEFAULT \| FBINFO_HWACCEL_COPYAREA \|		info->flags = FBINFO_DEFAULT \| FBINFO_HWACCEL_COPYAREA \|
	@@ -1414,8 +1569,17 @@ tgafb_pci_register(struct pci_dev pdev, const struct pci_device_id ent)
	info->pseudo_palette = (void *)(par + 1);		info->pseudo_palette = (void *)(par + 1);

	/* This should give a reasonable default video mode. */		/* This should give a reasonable default video mode. */
			if (tga_bus_pci) {
	ret = fb_find_mode(&info->var, info, mode_option, NULL, 0, NULL,		mode_option_tga = mode_option_pci;
			}
			if (tga_bus_tc) {
			mode_option_tga = mode_option_tc;
			modedb_tga = &modedb_tc;
			modedbsize_tga = 1;
			}
			ret = fb_find_mode(&info->var, info,
			mode_option ? mode_option : mode_option_tga,
			modedb_tga, modedbsize_tga, NULL,
	tga_type == TGA_TYPE_8PLANE ? 8 : 32);		tga_type == TGA_TYPE_8PLANE ? 8 : 32);
	if (ret == 0 \|\| ret == 4) {		if (ret == 0 \|\| ret == 4) {
	printk(KERN_ERR "tgafb: Could not find valid video mode\n");		printk(KERN_ERR "tgafb: Could not find valid video mode\n");
	@@ -1438,13 +1602,19 @@ tgafb_pci_register(struct pci_dev pdev, const struct pci_device_id ent)
	goto err1;		goto err1;
	}		}

	printk(KERN_INFO "tgafb: DC21030 [TGA] detected, rev=0x%02x\n",		if (tga_bus_pci) {
			pr_info("tgafb: DC21030 [TGA] detected, rev=0x%02x\n",
	par->tga_chip_rev);		par->tga_chip_rev);
	printk(KERN_INFO "tgafb: at PCI bus %d, device %d, function %d\n",		pr_info("tgafb: at PCI bus %d, device %d, function %d\n",
	pdev->bus->number, PCI_SLOT(pdev->devfn),		to_pci_dev(dev)->bus->number,
	PCI_FUNC(pdev->devfn));		PCI_SLOT(to_pci_dev(dev)->devfn),
	printk(KERN_INFO "fb%d: %s frame buffer device at 0x%lx\n",		PCI_FUNC(to_pci_dev(dev)->devfn));
	info->node, info->fix.id, bar0_start);		}
			if (tga_bus_tc)
			pr_info("tgafb: SFB+ detected, rev=0x%02x\n",
			par->tga_chip_rev);
			pr_info("fb%d: %s frame buffer device at 0x%lx\n",
			info->node, info->fix.id, (long)bar0_start);

	return 0;		return 0;

	@@ -1458,25 +1628,39 @@ tgafb_pci_register(struct pci_dev pdev, const struct pci_device_id ent)
	}		}

	static void __devexit		static void __devexit
	tgafb_pci_unregister(struct pci_dev *pdev)		tgafb_unregister(struct device *dev)
	{		{
	struct fb_info *info = pci_get_drvdata(pdev);		resource_size_t bar0_start = 0, bar0_len = 0;
	struct tga_par *par = info->par;		int tga_bus_pci = TGA_BUS_PCI(dev);
			int tga_bus_tc = TGA_BUS_TC(dev);
			struct fb_info *info = NULL;
			struct tga_par *par;

			info = dev_get_drvdata(dev);
	if (!info)		if (!info)
	return;		return;

			par = info->par;
	unregister_framebuffer(info);		unregister_framebuffer(info);
	fb_dealloc_cmap(&info->cmap);		fb_dealloc_cmap(&info->cmap);
	iounmap(par->tga_mem_base);		iounmap(par->tga_mem_base);
	release_mem_region(pci_resource_start(pdev, 0),		if (tga_bus_pci) {
	pci_resource_len(pdev, 0));		bar0_start = pci_resource_start(to_pci_dev(dev), 0);
			bar0_len = pci_resource_len(to_pci_dev(dev), 0);
			}
			if (tga_bus_tc) {
			bar0_start = to_tc_dev(dev)->resource.start;
			bar0_len = to_tc_dev(dev)->resource.end - bar0_start + 1;
			}
			release_mem_region(bar0_start, bar0_len);
	framebuffer_release(info);		framebuffer_release(info);
	}		}

	static void __devexit		static void __devexit
	tgafb_exit(void)		tgafb_exit(void)
	{		{
	pci_unregister_driver(&tgafb_driver);		tc_unregister_driver(&tgafb_tc_driver);
			pci_unregister_driver(&tgafb_pci_driver);
	}		}

	#ifndef MODULE		#ifndef MODULE
	@@ -1505,6 +1689,7 @@ tgafb_setup(char *arg)
	static int __devinit		static int __devinit
	tgafb_init(void)		tgafb_init(void)
	{		{
			int status;
	#ifndef MODULE		#ifndef MODULE
	char *option = NULL;		char *option = NULL;

	@@ -1512,7 +1697,10 @@ tgafb_init(void)
	return -ENODEV;		return -ENODEV;
	tgafb_setup(option);		tgafb_setup(option);
	#endif		#endif
	return pci_register_driver(&tgafb_driver);		status = pci_register_driver(&tgafb_pci_driver);
			if (!status)
			status = tc_register_driver(&tgafb_tc_driver);
			return status;
	}		}

	/*		/*
	@@ -1522,5 +1710,5 @@ tgafb_init(void)
	module_init(tgafb_init);		module_init(tgafb_init);
	module_exit(tgafb_exit);		module_exit(tgafb_exit);

	MODULE_DESCRIPTION("framebuffer driver for TGA chipset");		MODULE_DESCRIPTION("Framebuffer driver for TGA/SFB+ chipset");
	MODULE_LICENSE("GPL");		MODULE_LICENSE("GPL");

include/video/tgafb.h

+44 −3

Original line number	Original line	Diff line number	Diff line
	@@ -39,6 +39,7 @@
	#define TGA_RASTEROP_REG 0x0034		#define TGA_RASTEROP_REG 0x0034
	#define TGA_PIXELSHIFT_REG 0x0038		#define TGA_PIXELSHIFT_REG 0x0038
	#define TGA_DEEP_REG 0x0050		#define TGA_DEEP_REG 0x0050
			#define TGA_START_REG 0x0054
	#define TGA_PIXELMASK_REG 0x005c		#define TGA_PIXELMASK_REG 0x005c
	#define TGA_CURSOR_BASE_REG 0x0060		#define TGA_CURSOR_BASE_REG 0x0060
	#define TGA_HORIZ_REG 0x0064		#define TGA_HORIZ_REG 0x0064
	@@ -140,7 +141,7 @@


	/*		/*
	* Useful defines for managing the BT463 on the 24-plane TGAs		* Useful defines for managing the BT463 on the 24-plane TGAs/SFB+s
	*/		*/

	#define BT463_ADDR_LO 0x0		#define BT463_ADDR_LO 0x0
	@@ -167,13 +168,36 @@

	#define BT463_WINDOW_TYPE_BASE 0x0300		#define BT463_WINDOW_TYPE_BASE 0x0300

			/*
			* Useful defines for managing the BT459 on the 8-plane SFB+s
			*/

			#define BT459_ADDR_LO 0x0
			#define BT459_ADDR_HI 0x1
			#define BT459_REG_ACC 0x2
			#define BT459_PALETTE 0x3

			#define BT459_CUR_CLR_1 0x0181
			#define BT459_CUR_CLR_2 0x0182
			#define BT459_CUR_CLR_3 0x0183

			#define BT459_CMD_REG_0 0x0201
			#define BT459_CMD_REG_1 0x0202
			#define BT459_CMD_REG_2 0x0203

			#define BT459_READ_MASK 0x0204

			#define BT459_BLINK_MASK 0x0206

			#define BT459_CUR_CMD_REG 0x0300

	/*		/*
	* The framebuffer driver private data.		* The framebuffer driver private data.
	*/		*/

	struct tga_par {		struct tga_par {
	/* PCI device. */		/* PCI/TC device. */
	struct pci_dev *pdev;		struct device *dev;

	/* Device dependent information. */		/* Device dependent information. */
	void __iomem *tga_mem_base;		void __iomem *tga_mem_base;
	@@ -235,4 +259,21 @@ BT463_WRITE(struct tga_par *par, u32 m, u16 a, u8 v)
	TGA_WRITE_REG(par, m << 10 \| v, TGA_RAMDAC_REG);		TGA_WRITE_REG(par, m << 10 \| v, TGA_RAMDAC_REG);
	}		}

			static inline void
			BT459_LOAD_ADDR(struct tga_par *par, u16 a)
			{
			TGA_WRITE_REG(par, BT459_ADDR_LO << 2, TGA_RAMDAC_SETUP_REG);
			TGA_WRITE_REG(par, a & 0xff, TGA_RAMDAC_REG);
			TGA_WRITE_REG(par, BT459_ADDR_HI << 2, TGA_RAMDAC_SETUP_REG);
			TGA_WRITE_REG(par, a >> 8, TGA_RAMDAC_REG);
			}

			static inline void
			BT459_WRITE(struct tga_par *par, u32 m, u16 a, u8 v)
			{
			BT459_LOAD_ADDR(par, a);
			TGA_WRITE_REG(par, m << 2, TGA_RAMDAC_SETUP_REG);
			TGA_WRITE_REG(par, v, TGA_RAMDAC_REG);
			}

	#endif /* TGAFB_H */		#endif /* TGAFB_H */