[mirror_ubuntu-jammy-kernel.git] / drivers / video / fbdev / via / via_i2c.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright 1998-2009 VIA Technologies, Inc. All Rights Reserved.
 * Copyright 2001-2008 S3 Graphics, Inc. All Rights Reserved.

 */

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