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