[net-next-2.6.git] / drivers / video / savage / savagefb-i2c.c

/*
 * linux/drivers/video/savage/savagefb-i2c.c - S3 Savage DDC2
 *
 * Copyright 2004 Antonino A. Daplas <adaplas @pol.net>
 *
 * Based partly on rivafb-i2c.c
 *
 * 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 more details.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/gfp.h>
#include <linux/pci.h>
#include <linux/fb.h>

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

#define SAVAGE_DDC 	0x50

#define VGA_CR_IX	0x3d4
#define VGA_CR_DATA	0x3d5

#define CR_SERIAL1	0xa0	/* I2C serial communications interface */
#define MM_SERIAL1	0xff20
#define CR_SERIAL2	0xb1	/* DDC2 monitor communications interface */

/* based on vt8365 documentation */
#define PROSAVAGE_I2C_ENAB	0x10
#define PROSAVAGE_I2C_SCL_OUT	0x01
#define PROSAVAGE_I2C_SDA_OUT	0x02
#define PROSAVAGE_I2C_SCL_IN	0x04
#define PROSAVAGE_I2C_SDA_IN	0x08

#define SAVAGE4_I2C_ENAB	0x00000020
#define SAVAGE4_I2C_SCL_OUT	0x00000001
#define SAVAGE4_I2C_SDA_OUT	0x00000002
#define SAVAGE4_I2C_SCL_IN	0x00000008
#define SAVAGE4_I2C_SDA_IN	0x00000010

static void savage4_gpio_setscl(void *data, int val)
{
	struct savagefb_i2c_chan *chan = data;
	unsigned int r;

	r = readl(chan->ioaddr + chan->reg);
	if(val)
		r |= SAVAGE4_I2C_SCL_OUT;
	else
		r &= ~SAVAGE4_I2C_SCL_OUT;
	writel(r, chan->ioaddr + chan->reg);
	readl(chan->ioaddr + chan->reg);	/* flush posted write */
}

static void savage4_gpio_setsda(void *data, int val)
{
	struct savagefb_i2c_chan *chan = data;

	unsigned int r;
	r = readl(chan->ioaddr + chan->reg);
	if(val)
		r |= SAVAGE4_I2C_SDA_OUT;
	else
		r &= ~SAVAGE4_I2C_SDA_OUT;
	writel(r, chan->ioaddr + chan->reg);
	readl(chan->ioaddr + chan->reg);	/* flush posted write */
}

static int savage4_gpio_getscl(void *data)
{
	struct savagefb_i2c_chan *chan = data;

	return (0 != (readl(chan->ioaddr + chan->reg) & SAVAGE4_I2C_SCL_IN));
}

static int savage4_gpio_getsda(void *data)
{
	struct savagefb_i2c_chan *chan = data;

	return (0 != (readl(chan->ioaddr + chan->reg) & SAVAGE4_I2C_SDA_IN));
}

static void prosavage_gpio_setscl(void* data, int val)
{
	struct savagefb_i2c_chan *chan = data;
	u32			  r;

	r = VGArCR(chan->reg, chan->par);
	r |= PROSAVAGE_I2C_ENAB;
	if (val) {
		r |= PROSAVAGE_I2C_SCL_OUT;
	} else {
		r &= ~PROSAVAGE_I2C_SCL_OUT;
	}

	VGAwCR(chan->reg, r, chan->par);
}

static void prosavage_gpio_setsda(void* data, int val)
{
	struct savagefb_i2c_chan *chan = data;
	unsigned int r;

	r = VGArCR(chan->reg, chan->par);
	r |= PROSAVAGE_I2C_ENAB;
	if (val) {
		r |= PROSAVAGE_I2C_SDA_OUT;
	} else {
		r &= ~PROSAVAGE_I2C_SDA_OUT;
	}

	VGAwCR(chan->reg, r, chan->par);
}

static int prosavage_gpio_getscl(void* data)
{
	struct savagefb_i2c_chan *chan = data;

	return (VGArCR(chan->reg, chan->par) & PROSAVAGE_I2C_SCL_IN) ? 1 : 0;
}

static int prosavage_gpio_getsda(void* data)
{
	struct savagefb_i2c_chan *chan = data;

	return (VGArCR(chan->reg, chan->par) & PROSAVAGE_I2C_SDA_IN) ? 1 : 0;
}

static int savage_setup_i2c_bus(struct savagefb_i2c_chan *chan,
				const char *name)
{
	int rc = 0;

	if (chan->par) {
		strcpy(chan->adapter.name, name);
		chan->adapter.owner		= THIS_MODULE;
		chan->adapter.algo_data		= &chan->algo;
		chan->adapter.dev.parent	= &chan->par->pcidev->dev;
		chan->algo.udelay		= 10;
		chan->algo.timeout		= 20;
		chan->algo.data 		= chan;

		i2c_set_adapdata(&chan->adapter, chan);

		/* Raise SCL and SDA */
		chan->algo.setsda(chan, 1);
		chan->algo.setscl(chan, 1);
		udelay(20);

		rc = i2c_bit_add_bus(&chan->adapter);

		if (rc == 0)
			dev_dbg(&chan->par->pcidev->dev,
				"I2C bus %s registered.\n", name);
		else
			dev_warn(&chan->par->pcidev->dev,
				 "Failed to register I2C bus %s.\n", name);
	} else
		chan->par = NULL;

	return rc;
}

void savagefb_create_i2c_busses(struct fb_info *info)
{
	struct savagefb_par *par = info->par;
	par->chan.par	= par;

	switch(info->fix.accel) {
	case FB_ACCEL_PROSAVAGE_DDRK:
	case FB_ACCEL_PROSAVAGE_PM:
		par->chan.reg         = CR_SERIAL2;
		par->chan.ioaddr      = par->mmio.vbase;
		par->chan.algo.setsda = prosavage_gpio_setsda;
		par->chan.algo.setscl = prosavage_gpio_setscl;
		par->chan.algo.getsda = prosavage_gpio_getsda;
		par->chan.algo.getscl = prosavage_gpio_getscl;
		break;
	case FB_ACCEL_SAVAGE4:
		par->chan.reg = CR_SERIAL1;
		if (par->pcidev->revision > 1 && !(VGArCR(0xa6, par) & 0x40))
			par->chan.reg = CR_SERIAL2;
		par->chan.ioaddr      = par->mmio.vbase;
		par->chan.algo.setsda = prosavage_gpio_setsda;
		par->chan.algo.setscl = prosavage_gpio_setscl;
		par->chan.algo.getsda = prosavage_gpio_getsda;
		par->chan.algo.getscl = prosavage_gpio_getscl;
		break;
	case FB_ACCEL_SAVAGE2000:
		par->chan.reg         = 0xff20;
		par->chan.ioaddr      = par->mmio.vbase;
		par->chan.algo.setsda = savage4_gpio_setsda;
		par->chan.algo.setscl = savage4_gpio_setscl;
		par->chan.algo.getsda = savage4_gpio_getsda;
		par->chan.algo.getscl = savage4_gpio_getscl;
		break;
	default:
		par->chan.par = NULL;
	}

	savage_setup_i2c_bus(&par->chan, "SAVAGE DDC2");
}

void savagefb_delete_i2c_busses(struct fb_info *info)
{
	struct savagefb_par *par = info->par;

	if (par->chan.par)
		i2c_del_adapter(&par->chan.adapter);

	par->chan.par = NULL;
}

int savagefb_probe_i2c_connector(struct fb_info *info, u8 **out_edid)
{
	struct savagefb_par *par = info->par;
	u8 *edid;

	if (par->chan.par)
		edid = fb_ddc_read(&par->chan.adapter);
	else
		edid = NULL;

	if (!edid) {
		/* try to get from firmware */
		const u8 *e = fb_firmware_edid(info->device);

		if (e)
			edid = kmemdup(e, EDID_LENGTH, GFP_KERNEL);
	}

	*out_edid = edid;

	return (edid) ? 0 : 1;
}

MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/drivers/video/savage/savagefb-i2c.c - S3 Savage DDC2
	3	*
	4	* Copyright 2004 Antonino A. Daplas <adaplas @pol.net>
	5	*
	6	* Based partly on rivafb-i2c.c
	7	*
	8	* This file is subject to the terms and conditions of the GNU General Public
	9	* License. See the file COPYING in the main directory of this archive
	10	* for more details.
	11	*/
	12
1da177e4 LT	13	#include <linux/module.h>
1da177e4 LT	14	#include <linux/kernel.h>
1da177e4	15	#include <linux/delay.h>
5a0e3ad6	16	#include <linux/gfp.h>
1da177e4 LT	17	#include <linux/pci.h>
	18	#include <linux/fb.h>
	19
	20	#include <asm/io.h>
	21	#include "savagefb.h"
	22
	23	#define SAVAGE_DDC 0x50
	24
	25	#define VGA_CR_IX 0x3d4
	26	#define VGA_CR_DATA 0x3d5
	27
	28	#define CR_SERIAL1 0xa0 /* I2C serial communications interface */
	29	#define MM_SERIAL1 0xff20
	30	#define CR_SERIAL2 0xb1 /* DDC2 monitor communications interface */
	31
	32	/* based on vt8365 documentation */
	33	#define PROSAVAGE_I2C_ENAB 0x10
	34	#define PROSAVAGE_I2C_SCL_OUT 0x01
	35	#define PROSAVAGE_I2C_SDA_OUT 0x02
	36	#define PROSAVAGE_I2C_SCL_IN 0x04
	37	#define PROSAVAGE_I2C_SDA_IN 0x08
	38
	39	#define SAVAGE4_I2C_ENAB 0x00000020
	40	#define SAVAGE4_I2C_SCL_OUT 0x00000001
	41	#define SAVAGE4_I2C_SDA_OUT 0x00000002
	42	#define SAVAGE4_I2C_SCL_IN 0x00000008
	43	#define SAVAGE4_I2C_SDA_IN 0x00000010
	44
1da177e4 LT	45	static void savage4_gpio_setscl(void *data, int val)
1da177e4 LT	46	{
b8901b09	47	struct savagefb_i2c_chan *chan = data;
1da177e4 LT	48	unsigned int r;
	49
	50	r = readl(chan->ioaddr + chan->reg);
	51	if(val)
	52	r \|= SAVAGE4_I2C_SCL_OUT;
	53	else
	54	r &= ~SAVAGE4_I2C_SCL_OUT;
	55	writel(r, chan->ioaddr + chan->reg);
	56	readl(chan->ioaddr + chan->reg); /* flush posted write */
	57	}
	58
	59	static void savage4_gpio_setsda(void *data, int val)
	60	{
b8901b09	61	struct savagefb_i2c_chan *chan = data;
1da177e4 LT	62
	63	unsigned int r;
	64	r = readl(chan->ioaddr + chan->reg);
	65	if(val)
	66	r \|= SAVAGE4_I2C_SDA_OUT;
	67	else
	68	r &= ~SAVAGE4_I2C_SDA_OUT;
	69	writel(r, chan->ioaddr + chan->reg);
	70	readl(chan->ioaddr + chan->reg); /* flush posted write */
	71	}
	72
	73	static int savage4_gpio_getscl(void *data)
	74	{
b8901b09	75	struct savagefb_i2c_chan *chan = data;
1da177e4 LT	76
	77	return (0 != (readl(chan->ioaddr + chan->reg) & SAVAGE4_I2C_SCL_IN));
	78	}
	79
	80	static int savage4_gpio_getsda(void *data)
	81	{
b8901b09	82	struct savagefb_i2c_chan *chan = data;
1da177e4 LT	83
	84	return (0 != (readl(chan->ioaddr + chan->reg) & SAVAGE4_I2C_SDA_IN));
	85	}
	86
	87	static void prosavage_gpio_setscl(void* data, int val)
	88	{
b8901b09	89	struct savagefb_i2c_chan *chan = data;
1da177e4 LT	90	u32 r;
1da177e4 LT	91
f7829158	92	r = VGArCR(chan->reg, chan->par);
1da177e4 LT	93	r \|= PROSAVAGE_I2C_ENAB;
	94	if (val) {
	95	r \|= PROSAVAGE_I2C_SCL_OUT;
	96	} else {
	97	r &= ~PROSAVAGE_I2C_SCL_OUT;
	98	}
f7829158 AD	99
f7829158 AD	100	VGAwCR(chan->reg, r, chan->par);
1da177e4 LT	101	}
	102
	103	static void prosavage_gpio_setsda(void* data, int val)
	104	{
b8901b09	105	struct savagefb_i2c_chan *chan = data;
1da177e4 LT	106	unsigned int r;
1da177e4 LT	107
f7829158	108	r = VGArCR(chan->reg, chan->par);
1da177e4 LT	109	r \|= PROSAVAGE_I2C_ENAB;
	110	if (val) {
	111	r \|= PROSAVAGE_I2C_SDA_OUT;
	112	} else {
	113	r &= ~PROSAVAGE_I2C_SDA_OUT;
	114	}
f7829158 AD	115
f7829158 AD	116	VGAwCR(chan->reg, r, chan->par);
1da177e4 LT	117	}
	118
	119	static int prosavage_gpio_getscl(void* data)
	120	{
b8901b09	121	struct savagefb_i2c_chan *chan = data;
1da177e4	122
f7829158	123	return (VGArCR(chan->reg, chan->par) & PROSAVAGE_I2C_SCL_IN) ? 1 : 0;
1da177e4 LT	124	}
	125
	126	static int prosavage_gpio_getsda(void* data)
	127	{
b8901b09	128	struct savagefb_i2c_chan *chan = data;
1da177e4	129
f7829158	130	return (VGArCR(chan->reg, chan->par) & PROSAVAGE_I2C_SDA_IN) ? 1 : 0;
1da177e4 LT	131	}
1da177e4 LT	132
1da177e4 LT	133	static int savage_setup_i2c_bus(struct savagefb_i2c_chan *chan,
	134	const char *name)
	135	{
1da177e4 LT	136	int rc = 0;
1da177e4 LT	137
b8901b09	138	if (chan->par) {
1da177e4 LT	139	strcpy(chan->adapter.name, name);
1da177e4 LT	140	chan->adapter.owner = THIS_MODULE;
1da177e4 LT	141	chan->adapter.algo_data = &chan->algo;
1da177e4 LT	142	chan->adapter.dev.parent = &chan->par->pcidev->dev;
9201a858	143	chan->algo.udelay = 10;
1da177e4 LT	144	chan->algo.timeout = 20;
	145	chan->algo.data = chan;
	146
	147	i2c_set_adapdata(&chan->adapter, chan);
	148
	149	/* Raise SCL and SDA */
	150	chan->algo.setsda(chan, 1);
	151	chan->algo.setscl(chan, 1);
	152	udelay(20);
	153
b8901b09	154	rc = i2c_bit_add_bus(&chan->adapter);
1da177e4 LT	155
	156	if (rc == 0)
	157	dev_dbg(&chan->par->pcidev->dev,
	158	"I2C bus %s registered.\n", name);
	159	else
	160	dev_warn(&chan->par->pcidev->dev,
	161	"Failed to register I2C bus %s.\n", name);
1da177e4 LT	162	} else
	163	chan->par = NULL;
	164
	165	return rc;
	166	}
	167
	168	void savagefb_create_i2c_busses(struct fb_info *info)
	169	{
b8901b09	170	struct savagefb_par *par = info->par;
1da177e4 LT	171	par->chan.par = par;
	172
	173	switch(info->fix.accel) {
	174	case FB_ACCEL_PROSAVAGE_DDRK:
	175	case FB_ACCEL_PROSAVAGE_PM:
	176	par->chan.reg = CR_SERIAL2;
	177	par->chan.ioaddr = par->mmio.vbase;
	178	par->chan.algo.setsda = prosavage_gpio_setsda;
	179	par->chan.algo.setscl = prosavage_gpio_setscl;
	180	par->chan.algo.getsda = prosavage_gpio_getsda;
	181	par->chan.algo.getscl = prosavage_gpio_getscl;
	182	break;
	183	case FB_ACCEL_SAVAGE4:
f0a2f357 OZ	184	par->chan.reg = CR_SERIAL1;
	185	if (par->pcidev->revision > 1 && !(VGArCR(0xa6, par) & 0x40))
	186	par->chan.reg = CR_SERIAL2;
	187	par->chan.ioaddr = par->mmio.vbase;
	188	par->chan.algo.setsda = prosavage_gpio_setsda;
	189	par->chan.algo.setscl = prosavage_gpio_setscl;
	190	par->chan.algo.getsda = prosavage_gpio_getsda;
	191	par->chan.algo.getscl = prosavage_gpio_getscl;
	192	break;
c35dba60	193	case FB_ACCEL_SAVAGE2000:
1da177e4 LT	194	par->chan.reg = 0xff20;
	195	par->chan.ioaddr = par->mmio.vbase;
	196	par->chan.algo.setsda = savage4_gpio_setsda;
	197	par->chan.algo.setscl = savage4_gpio_setscl;
	198	par->chan.algo.getsda = savage4_gpio_getsda;
	199	par->chan.algo.getscl = savage4_gpio_getscl;
	200	break;
	201	default:
	202	par->chan.par = NULL;
	203	}
	204
	205	savage_setup_i2c_bus(&par->chan, "SAVAGE DDC2");
	206	}
	207
	208	void savagefb_delete_i2c_busses(struct fb_info *info)
	209	{
b8901b09	210	struct savagefb_par *par = info->par;
1da177e4	211
b8901b09	212	if (par->chan.par)
3269711b	213	i2c_del_adapter(&par->chan.adapter);
1da177e4 LT	214
	215	par->chan.par = NULL;
	216	}
	217
13776711	218	int savagefb_probe_i2c_connector(struct fb_info info, u8 *out_edid)
1da177e4	219	{
13776711	220	struct savagefb_par *par = info->par;
946c4eab AD	221	u8 *edid;
	222
	223	if (par->chan.par)
	224	edid = fb_ddc_read(&par->chan.adapter);
	225	else
	226	edid = NULL;
13776711 AD	227
	228	if (!edid) {
	229	/* try to get from firmware */
7b6a186d AD	230	const u8 *e = fb_firmware_edid(info->device);
7b6a186d AD	231
bfba7b37 AD	232	if (e)
bfba7b37 AD	233	edid = kmemdup(e, EDID_LENGTH, GFP_KERNEL);
13776711 AD	234	}
13776711 AD	235
0e4be280	236	*out_edid = edid;
1da177e4	237
13776711	238	return (edid) ? 0 : 1;
1da177e4 LT	239	}
	240
	241	MODULE_LICENSE("GPL");