[deliverable/linux.git] / drivers / video / via / via_i2c.c

/*
 * Copyright 1998-2009 VIA Technologies, Inc. All Rights Reserved.
 * Copyright 2001-2008 S3 Graphics, Inc. All Rights Reserved.

 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation;
 * either version 2, or (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTIES OR REPRESENTATIONS; without even
 * the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE.See the GNU General Public License
 * for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc.,
 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/spinlock.h>
#include <linux/module.h>
#include <linux/via-core.h>
#include <linux/via_i2c.h>

/*
 * There can only be one set of these, so there's no point in having
 * them be dynamically allocated...
 */
#define VIAFB_NUM_I2C		5
static struct via_i2c_stuff via_i2c_par[VIAFB_NUM_I2C];
struct viafb_dev *i2c_vdev;  /* Passed in from core */

static void via_i2c_setscl(void *data, int state)
{
	u8 val;
	struct via_port_cfg *adap_data = data;
	unsigned long flags;

	spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
	val = via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0xF0;
	if (state)
		val |= 0x20;
	else
		val &= ~0x20;
	switch (adap_data->type) {
	case VIA_PORT_I2C:
		val |= 0x01;
		break;
	case VIA_PORT_GPIO:
		val |= 0x80;
		break;
	default:
		printk(KERN_ERR "viafb_i2c: specify wrong i2c type.\n");
	}
	via_write_reg(adap_data->io_port, adap_data->ioport_index, val);
	spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
}

static int via_i2c_getscl(void *data)
{
	struct via_port_cfg *adap_data = data;
	unsigned long flags;
	int ret = 0;

	spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
	if (via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0x08)
		ret = 1;
	spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
	return ret;
}

static int via_i2c_getsda(void *data)
{
	struct via_port_cfg *adap_data = data;
	unsigned long flags;
	int ret = 0;

	spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
	if (via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0x04)
		ret = 1;
	spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
	return ret;
}

static void via_i2c_setsda(void *data, int state)
{
	u8 val;
	struct via_port_cfg *adap_data = data;
	unsigned long flags;

	spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
	val = via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0xF0;
	if (state)
		val |= 0x10;
	else
		val &= ~0x10;
	switch (adap_data->type) {
	case VIA_PORT_I2C:
		val |= 0x01;
		break;
	case VIA_PORT_GPIO:
		val |= 0x40;
		break;
	default:
		printk(KERN_ERR "viafb_i2c: specify wrong i2c type.\n");
	}
	via_write_reg(adap_data->io_port, adap_data->ioport_index, val);
	spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
}

int viafb_i2c_readbyte(u8 adap, u8 slave_addr, u8 index, u8 *pdata)
{
	int ret;
	u8 mm1[] = {0x00};
	struct i2c_msg msgs[2];

	if (!via_i2c_par[adap].is_active)
		return -ENODEV;
	*pdata = 0;
	msgs[0].flags = 0;
	msgs[1].flags = I2C_M_RD;
	msgs[0].addr = msgs[1].addr = slave_addr / 2;
	mm1[0] = index;
	msgs[0].len = 1; msgs[1].len = 1;
	msgs[0].buf = mm1; msgs[1].buf = pdata;
	ret = i2c_transfer(&via_i2c_par[adap].adapter, msgs, 2);
	if (ret == 2)
		ret = 0;
	else if (ret >= 0)
		ret = -EIO;

	return ret;
}

int viafb_i2c_writebyte(u8 adap, u8 slave_addr, u8 index, u8 data)
{
	int ret;
	u8 msg[2] = { index, data };
	struct i2c_msg msgs;

	if (!via_i2c_par[adap].is_active)
		return -ENODEV;
	msgs.flags = 0;
	msgs.addr = slave_addr / 2;
	msgs.len = 2;
	msgs.buf = msg;
	ret = i2c_transfer(&via_i2c_par[adap].adapter, &msgs, 1);
	if (ret == 1)
		ret = 0;
	else if (ret >= 0)
		ret = -EIO;

	return ret;
}

int viafb_i2c_readbytes(u8 adap, u8 slave_addr, u8 index, u8 *buff, int buff_len)
{
	int ret;
	u8 mm1[] = {0x00};
	struct i2c_msg msgs[2];

	if (!via_i2c_par[adap].is_active)
		return -ENODEV;
	msgs[0].flags = 0;
	msgs[1].flags = I2C_M_RD;
	msgs[0].addr = msgs[1].addr = slave_addr / 2;
	mm1[0] = index;
	msgs[0].len = 1; msgs[1].len = buff_len;
	msgs[0].buf = mm1; msgs[1].buf = buff;
	ret = i2c_transfer(&via_i2c_par[adap].adapter, msgs, 2);
	if (ret == 2)
		ret = 0;
	else if (ret >= 0)
		ret = -EIO;

	return ret;
}

/*
 * Allow other viafb subdevices to look up a specific adapter
 * by port name.
 */
struct i2c_adapter *viafb_find_i2c_adapter(enum viafb_i2c_adap which)
{
	struct via_i2c_stuff *stuff = &via_i2c_par[which];

	return &stuff->adapter;
}
EXPORT_SYMBOL_GPL(viafb_find_i2c_adapter);


static int create_i2c_bus(struct i2c_adapter *adapter,
			  struct i2c_algo_bit_data *algo,
			  struct via_port_cfg *adap_cfg,
			  struct pci_dev *pdev)
{
	algo->setsda = via_i2c_setsda;
	algo->setscl = via_i2c_setscl;
	algo->getsda = via_i2c_getsda;
	algo->getscl = via_i2c_getscl;
	algo->udelay = 10;
	algo->timeout = 2;
	algo->data = adap_cfg;

	sprintf(adapter->name, "viafb i2c io_port idx 0x%02x",
		adap_cfg->ioport_index);
	adapter->owner = THIS_MODULE;
	adapter->id = 0x01FFFF;
	adapter->class = I2C_CLASS_DDC;
	adapter->algo_data = algo;
	if (pdev)
		adapter->dev.parent = &pdev->dev;
	else
		adapter->dev.parent = NULL;
	/* i2c_set_adapdata(adapter, adap_cfg); */

	/* Raise SCL and SDA */
	via_i2c_setsda(adap_cfg, 1);
	via_i2c_setscl(adap_cfg, 1);
	udelay(20);

	return i2c_bit_add_bus(adapter);
}

static int viafb_i2c_probe(struct platform_device *platdev)
{
	int i, ret;
	struct via_port_cfg *configs;

	i2c_vdev = platdev->dev.platform_data;
	configs = i2c_vdev->port_cfg;

	for (i = 0; i < VIAFB_NUM_PORTS; i++) {
		struct via_port_cfg *adap_cfg = configs++;
		struct via_i2c_stuff *i2c_stuff = &via_i2c_par[i];

		i2c_stuff->is_active = 0;
		if (adap_cfg->type == 0 || adap_cfg->mode != VIA_MODE_I2C)
			continue;
		ret = create_i2c_bus(&i2c_stuff->adapter,
				     &i2c_stuff->algo, adap_cfg,
				NULL); /* FIXME: PCIDEV */
		if (ret < 0) {
			printk(KERN_ERR "viafb: cannot create i2c bus %u:%d\n",
				i, ret);
			continue;  /* Still try to make the rest */
		}
		i2c_stuff->is_active = 1;
	}

	return 0;
}

static int viafb_i2c_remove(struct platform_device *platdev)
{
	int i;

	for (i = 0; i < VIAFB_NUM_PORTS; i++) {
		struct via_i2c_stuff *i2c_stuff = &via_i2c_par[i];
		/*
		 * Only remove those entries in the array that we've
		 * actually used (and thus initialized algo_data)
		 */
		if (i2c_stuff->is_active)
			i2c_del_adapter(&i2c_stuff->adapter);
	}
	return 0;
}

static struct platform_driver via_i2c_driver = {
	.driver = {
		.name = "viafb-i2c",
	},
	.probe = viafb_i2c_probe,
	.remove = viafb_i2c_remove,
};

int viafb_i2c_init(void)
{
	return platform_driver_register(&via_i2c_driver);
}

void viafb_i2c_exit(void)
{
	platform_driver_unregister(&via_i2c_driver);
}
Commit	Line	Data
9f291634	1	/*
277d32a3	2	* Copyright 1998-2009 VIA Technologies, Inc. All Rights Reserved.
9f291634 JC	3	* Copyright 2001-2008 S3 Graphics, Inc. All Rights Reserved.
	4
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU General Public
	7	* License as published by the Free Software Foundation;
	8	* either version 2, or (at your option) any later version.
	9
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTIES OR REPRESENTATIONS; without even
	12	* the implied warranty of MERCHANTABILITY or FITNESS FOR
	13	* A PARTICULAR PURPOSE.See the GNU General Public License
	14	* for more details.
	15
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc.,
	19	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	20	*/
	21
7582eb9b	22	#include <linux/platform_device.h>
9221fc65 JC	23	#include <linux/delay.h>
	24	#include <linux/spinlock.h>
	25	#include <linux/module.h>
ec66841e JC	26	#include <linux/via-core.h>
ec66841e JC	27	#include <linux/via_i2c.h>
9f291634	28
f045f77b JC	29	/*
	30	* There can only be one set of these, so there's no point in having
	31	* them be dynamically allocated...
	32	*/
	33	#define VIAFB_NUM_I2C 5
	34	static struct via_i2c_stuff via_i2c_par[VIAFB_NUM_I2C];
75b035ac	35	struct viafb_dev i2c_vdev; / Passed in from core */
f045f77b	36
9f291634 JC	37	static void via_i2c_setscl(void *data, int state)
	38	{
	39	u8 val;
f045f77b	40	struct via_port_cfg *adap_data = data;
75b035ac	41	unsigned long flags;
9f291634	42
75b035ac JC	43	spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
75b035ac JC	44	val = via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0xF0;
9f291634 JC	45	if (state)
	46	val \|= 0x20;
	47	else
	48	val &= ~0x20;
277d32a3	49	switch (adap_data->type) {
f045f77b	50	case VIA_PORT_I2C:
9f291634 JC	51	val \|= 0x01;
9f291634 JC	52	break;
f045f77b	53	case VIA_PORT_GPIO:
9f291634 JC	54	val \|= 0x80;
	55	break;
	56	default:
4a28ea9c	57	printk(KERN_ERR "viafb_i2c: specify wrong i2c type.\n");
9f291634	58	}
75b035ac JC	59	via_write_reg(adap_data->io_port, adap_data->ioport_index, val);
75b035ac JC	60	spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
9f291634 JC	61	}
	62
	63	static int via_i2c_getscl(void *data)
	64	{
f045f77b	65	struct via_port_cfg *adap_data = data;
75b035ac JC	66	unsigned long flags;
	67	int ret = 0;
	68
	69	spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
	70	if (via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0x08)
	71	ret = 1;
	72	spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
	73	return ret;
9f291634 JC	74	}
	75
	76	static int via_i2c_getsda(void *data)
	77	{
f045f77b	78	struct via_port_cfg *adap_data = data;
75b035ac JC	79	unsigned long flags;
	80	int ret = 0;
	81
	82	spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
	83	if (via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0x04)
	84	ret = 1;
	85	spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
	86	return ret;
9f291634 JC	87	}
	88
	89	static void via_i2c_setsda(void *data, int state)
	90	{
	91	u8 val;
f045f77b	92	struct via_port_cfg *adap_data = data;
75b035ac	93	unsigned long flags;
9f291634	94
75b035ac JC	95	spin_lock_irqsave(&i2c_vdev->reg_lock, flags);
75b035ac JC	96	val = via_read_reg(adap_data->io_port, adap_data->ioport_index) & 0xF0;
9f291634 JC	97	if (state)
	98	val \|= 0x10;
	99	else
	100	val &= ~0x10;
277d32a3	101	switch (adap_data->type) {
f045f77b	102	case VIA_PORT_I2C:
9f291634 JC	103	val \|= 0x01;
9f291634 JC	104	break;
f045f77b	105	case VIA_PORT_GPIO:
9f291634 JC	106	val \|= 0x40;
	107	break;
	108	default:
4a28ea9c	109	printk(KERN_ERR "viafb_i2c: specify wrong i2c type.\n");
9f291634	110	}
75b035ac JC	111	via_write_reg(adap_data->io_port, adap_data->ioport_index, val);
75b035ac JC	112	spin_unlock_irqrestore(&i2c_vdev->reg_lock, flags);
9f291634 JC	113	}
9f291634 JC	114
277d32a3	115	int viafb_i2c_readbyte(u8 adap, u8 slave_addr, u8 index, u8 *pdata)
9f291634	116	{
85c5702a	117	int ret;
9f291634 JC	118	u8 mm1[] = {0x00};
	119	struct i2c_msg msgs[2];
	120
b052d7f8 JC	121	if (!via_i2c_par[adap].is_active)
b052d7f8 JC	122	return -ENODEV;
9f291634 JC	123	*pdata = 0;
	124	msgs[0].flags = 0;
	125	msgs[1].flags = I2C_M_RD;
	126	msgs[0].addr = msgs[1].addr = slave_addr / 2;
	127	mm1[0] = index;
	128	msgs[0].len = 1; msgs[1].len = 1;
	129	msgs[0].buf = mm1; msgs[1].buf = pdata;
85c5702a FTS	130	ret = i2c_transfer(&via_i2c_par[adap].adapter, msgs, 2);
	131	if (ret == 2)
	132	ret = 0;
	133	else if (ret >= 0)
	134	ret = -EIO;
	135
	136	return ret;
9f291634 JC	137	}
9f291634 JC	138
277d32a3	139	int viafb_i2c_writebyte(u8 adap, u8 slave_addr, u8 index, u8 data)
9f291634	140	{
85c5702a	141	int ret;
9f291634 JC	142	u8 msg[2] = { index, data };
	143	struct i2c_msg msgs;
	144
b052d7f8 JC	145	if (!via_i2c_par[adap].is_active)
b052d7f8 JC	146	return -ENODEV;
9f291634 JC	147	msgs.flags = 0;
	148	msgs.addr = slave_addr / 2;
	149	msgs.len = 2;
	150	msgs.buf = msg;
85c5702a FTS	151	ret = i2c_transfer(&via_i2c_par[adap].adapter, &msgs, 1);
	152	if (ret == 1)
	153	ret = 0;
	154	else if (ret >= 0)
	155	ret = -EIO;
	156
	157	return ret;
9f291634 JC	158	}
9f291634 JC	159
277d32a3	160	int viafb_i2c_readbytes(u8 adap, u8 slave_addr, u8 index, u8 *buff, int buff_len)
9f291634	161	{
85c5702a	162	int ret;
9f291634 JC	163	u8 mm1[] = {0x00};
	164	struct i2c_msg msgs[2];
	165
b052d7f8 JC	166	if (!via_i2c_par[adap].is_active)
b052d7f8 JC	167	return -ENODEV;
9f291634 JC	168	msgs[0].flags = 0;
	169	msgs[1].flags = I2C_M_RD;
	170	msgs[0].addr = msgs[1].addr = slave_addr / 2;
	171	mm1[0] = index;
	172	msgs[0].len = 1; msgs[1].len = buff_len;
	173	msgs[0].buf = mm1; msgs[1].buf = buff;
85c5702a FTS	174	ret = i2c_transfer(&via_i2c_par[adap].adapter, msgs, 2);
	175	if (ret == 2)
	176	ret = 0;
	177	else if (ret >= 0)
	178	ret = -EIO;
	179
	180	return ret;
9f291634 JC	181	}
9f291634 JC	182
b8f7e5d8 JC	183	/*
	184	* Allow other viafb subdevices to look up a specific adapter
	185	* by port name.
	186	*/
	187	struct i2c_adapter *viafb_find_i2c_adapter(enum viafb_i2c_adap which)
	188	{
	189	struct via_i2c_stuff *stuff = &via_i2c_par[which];
	190
	191	return &stuff->adapter;
	192	}
	193	EXPORT_SYMBOL_GPL(viafb_find_i2c_adapter);
	194
	195
277d32a3 HW	196	static int create_i2c_bus(struct i2c_adapter *adapter,
277d32a3 HW	197	struct i2c_algo_bit_data *algo,
f045f77b	198	struct via_port_cfg *adap_cfg,
277d32a3	199	struct pci_dev *pdev)
9f291634	200	{
277d32a3 HW	201	algo->setsda = via_i2c_setsda;
	202	algo->setscl = via_i2c_setscl;
	203	algo->getsda = via_i2c_getsda;
	204	algo->getscl = via_i2c_getscl;
e029ab0d FTS	205	algo->udelay = 10;
e029ab0d FTS	206	algo->timeout = 2;
277d32a3 HW	207	algo->data = adap_cfg;
	208
	209	sprintf(adapter->name, "viafb i2c io_port idx 0x%02x",
	210	adap_cfg->ioport_index);
	211	adapter->owner = THIS_MODULE;
	212	adapter->id = 0x01FFFF;
	213	adapter->class = I2C_CLASS_DDC;
	214	adapter->algo_data = algo;
	215	if (pdev)
	216	adapter->dev.parent = &pdev->dev;
	217	else
	218	adapter->dev.parent = NULL;
	219	/* i2c_set_adapdata(adapter, adap_cfg); */
9f291634 JC	220
9f291634 JC	221	/* Raise SCL and SDA */
277d32a3 HW	222	via_i2c_setsda(adap_cfg, 1);
277d32a3 HW	223	via_i2c_setscl(adap_cfg, 1);
9f291634 JC	224	udelay(20);
9f291634 JC	225
277d32a3 HW	226	return i2c_bit_add_bus(adapter);
	227	}
	228
7582eb9b	229	static int viafb_i2c_probe(struct platform_device *platdev)
277d32a3 HW	230	{
277d32a3 HW	231	int i, ret;
7582eb9b JC	232	struct via_port_cfg *configs;
	233
	234	i2c_vdev = platdev->dev.platform_data;
	235	configs = i2c_vdev->port_cfg;
277d32a3	236
f045f77b JC	237	for (i = 0; i < VIAFB_NUM_PORTS; i++) {
	238	struct via_port_cfg *adap_cfg = configs++;
	239	struct via_i2c_stuff *i2c_stuff = &via_i2c_par[i];
277d32a3	240
b052d7f8	241	i2c_stuff->is_active = 0;
f045f77b	242	if (adap_cfg->type == 0 \|\| adap_cfg->mode != VIA_MODE_I2C)
4da62e6c	243	continue;
277d32a3 HW	244	ret = create_i2c_bus(&i2c_stuff->adapter,
	245	&i2c_stuff->algo, adap_cfg,
	246	NULL); /* FIXME: PCIDEV */
	247	if (ret < 0) {
	248	printk(KERN_ERR "viafb: cannot create i2c bus %u:%d\n",
	249	i, ret);
b052d7f8	250	continue; /* Still try to make the rest */
277d32a3	251	}
b052d7f8	252	i2c_stuff->is_active = 1;
277d32a3 HW	253	}
	254
	255	return 0;
9f291634 JC	256	}
9f291634 JC	257
7582eb9b	258	static int viafb_i2c_remove(struct platform_device *platdev)
9f291634	259	{
277d32a3 HW	260	int i;
277d32a3 HW	261
f045f77b JC	262	for (i = 0; i < VIAFB_NUM_PORTS; i++) {
	263	struct via_i2c_stuff *i2c_stuff = &via_i2c_par[i];
	264	/*
	265	* Only remove those entries in the array that we've
	266	* actually used (and thus initialized algo_data)
	267	*/
b052d7f8	268	if (i2c_stuff->is_active)
277d32a3 HW	269	i2c_del_adapter(&i2c_stuff->adapter);
277d32a3 HW	270	}
7582eb9b JC	271	return 0;
	272	}
	273
	274	static struct platform_driver via_i2c_driver = {
	275	.driver = {
	276	.name = "viafb-i2c",
	277	},
	278	.probe = viafb_i2c_probe,
	279	.remove = viafb_i2c_remove,
	280	};
	281
	282	int viafb_i2c_init(void)
	283	{
	284	return platform_driver_register(&via_i2c_driver);
	285	}
	286
	287	void viafb_i2c_exit(void)
	288	{
	289	platform_driver_unregister(&via_i2c_driver);
9f291634	290	}