[mirror_ubuntu-hirsute-kernel.git] / drivers / media / video / cx18 / cx18-i2c.c

/*
 *  cx18 I2C functions
 *
 *  Derived from ivtv-i2c.c
 *
 *  Copyright (C) 2007  Hans Verkuil <hverkuil@xs4all.nl>
 *
 *  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 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; 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 "cx18-driver.h"
#include "cx18-cards.h"
#include "cx18-gpio.h"
#include "cx18-av-core.h"
#include "cx18-i2c.h"

#include <media/ir-kbd-i2c.h>

#define CX18_REG_I2C_1_WR   0xf15000
#define CX18_REG_I2C_1_RD   0xf15008
#define CX18_REG_I2C_2_WR   0xf25100
#define CX18_REG_I2C_2_RD   0xf25108

#define SETSCL_BIT      0x0001
#define SETSDL_BIT      0x0002
#define GETSCL_BIT      0x0004
#define GETSDL_BIT      0x0008

#ifndef I2C_ADAP_CLASS_TV_ANALOG
#define I2C_ADAP_CLASS_TV_ANALOG I2C_CLASS_TV_ANALOG
#endif

#define CX18_CS5345_I2C_ADDR		0x4c

/* This array should match the CX18_HW_ defines */
static const u8 hw_driverids[] = {
	I2C_DRIVERID_TUNER,
	I2C_DRIVERID_TVEEPROM,
	I2C_DRIVERID_CS5345,
	0, 		/* CX18_HW_GPIO dummy driver ID */
	0 		/* CX18_HW_CX23418 dummy driver ID */
};

/* This array should match the CX18_HW_ defines */
static const u8 hw_addrs[] = {
	0,
	0,
	CX18_CS5345_I2C_ADDR,
	0, 		/* CX18_HW_GPIO dummy driver ID */
	0,		/* CX18_HW_CX23418 dummy driver ID */
};

/* This array should match the CX18_HW_ defines */
/* This might well become a card-specific array */
static const u8 hw_bus[] = {
	0,
	0,
	0,
	0, 		/* CX18_HW_GPIO dummy driver ID */
	0,		/* CX18_HW_CX23418 dummy driver ID */
};

/* This array should match the CX18_HW_ defines */
static const char * const hw_devicenames[] = {
	"tuner",
	"tveeprom",
	"cs5345",
	"gpio",
	"cx23418",
};

int cx18_i2c_register(struct cx18 *cx, unsigned idx)
{
	struct i2c_board_info info;
	struct i2c_client *c;
	u8 id, bus;
	int i;

	CX18_DEBUG_I2C("i2c client register\n");
	if (idx >= ARRAY_SIZE(hw_driverids) || hw_driverids[idx] == 0)
		return -1;
	id = hw_driverids[idx];
	bus = hw_bus[idx];
	memset(&info, 0, sizeof(info));
	strlcpy(info.type, hw_devicenames[idx], sizeof(info.type));
	info.addr = hw_addrs[idx];
	for (i = 0; i < I2C_CLIENTS_MAX; i++)
		if (cx->i2c_clients[i] == NULL)
			break;

	if (i == I2C_CLIENTS_MAX) {
		CX18_ERR("insufficient room for new I2C client!\n");
		return -ENOMEM;
	}

	if (id != I2C_DRIVERID_TUNER) {
		c = i2c_new_device(&cx->i2c_adap[bus], &info);
		if (c->driver == NULL)
			i2c_unregister_device(c);
		else
			cx->i2c_clients[i] = c;
		return cx->i2c_clients[i] ? 0 : -ENODEV;
	}

	/* special tuner handling */
	c = i2c_new_probed_device(&cx->i2c_adap[1], &info, cx->card_i2c->radio);
	if (c && c->driver == NULL)
		i2c_unregister_device(c);
	else if (c)
		cx->i2c_clients[i++] = c;
	c = i2c_new_probed_device(&cx->i2c_adap[1], &info, cx->card_i2c->demod);
	if (c && c->driver == NULL)
		i2c_unregister_device(c);
	else if (c)
		cx->i2c_clients[i++] = c;
	c = i2c_new_probed_device(&cx->i2c_adap[1], &info, cx->card_i2c->tv);
	if (c && c->driver == NULL)
		i2c_unregister_device(c);
	else if (c)
		cx->i2c_clients[i++] = c;
	return 0;
}

static int attach_inform(struct i2c_client *client)
{
	return 0;
}

static int detach_inform(struct i2c_client *client)
{
	int i;
	struct cx18 *cx = (struct cx18 *)i2c_get_adapdata(client->adapter);

	CX18_DEBUG_I2C("i2c client detach\n");
	for (i = 0; i < I2C_CLIENTS_MAX; i++) {
		if (cx->i2c_clients[i] == client) {
			cx->i2c_clients[i] = NULL;
			break;
		}
	}
	CX18_DEBUG_I2C("i2c detach [client=%s,%s]\n",
		   client->name, (i < I2C_CLIENTS_MAX) ? "ok" : "failed");

	return 0;
}

static void cx18_setscl(void *data, int state)
{
	struct cx18 *cx = ((struct cx18_i2c_algo_callback_data *)data)->cx;
	int bus_index = ((struct cx18_i2c_algo_callback_data *)data)->bus_index;
	u32 addr = bus_index ? CX18_REG_I2C_2_WR : CX18_REG_I2C_1_WR;
	u32 r = read_reg(addr);

	if (state)
		write_reg_sync(r | SETSCL_BIT, addr);
	else
		write_reg_sync(r & ~SETSCL_BIT, addr);
}

static void cx18_setsda(void *data, int state)
{
	struct cx18 *cx = ((struct cx18_i2c_algo_callback_data *)data)->cx;
	int bus_index = ((struct cx18_i2c_algo_callback_data *)data)->bus_index;
	u32 addr = bus_index ? CX18_REG_I2C_2_WR : CX18_REG_I2C_1_WR;
	u32 r = read_reg(addr);

	if (state)
		write_reg_sync(r | SETSDL_BIT, addr);
	else
		write_reg_sync(r & ~SETSDL_BIT, addr);
}

static int cx18_getscl(void *data)
{
	struct cx18 *cx = ((struct cx18_i2c_algo_callback_data *)data)->cx;
	int bus_index = ((struct cx18_i2c_algo_callback_data *)data)->bus_index;
	u32 addr = bus_index ? CX18_REG_I2C_2_RD : CX18_REG_I2C_1_RD;

	return read_reg(addr) & GETSCL_BIT;
}

static int cx18_getsda(void *data)
{
	struct cx18 *cx = ((struct cx18_i2c_algo_callback_data *)data)->cx;
	int bus_index = ((struct cx18_i2c_algo_callback_data *)data)->bus_index;
	u32 addr = bus_index ? CX18_REG_I2C_2_RD : CX18_REG_I2C_1_RD;

	return read_reg(addr) & GETSDL_BIT;
}

/* template for i2c-bit-algo */
static struct i2c_adapter cx18_i2c_adap_template = {
	.name = "cx18 i2c driver",
	.id = I2C_HW_B_CX2341X,
	.algo = NULL,                   /* set by i2c-algo-bit */
	.algo_data = NULL,              /* filled from template */
	.client_register = attach_inform,
	.client_unregister = detach_inform,
	.owner = THIS_MODULE,
};

#define CX18_SCL_PERIOD (10) /* usecs. 10 usec is period for a 100 KHz clock */
#define CX18_ALGO_BIT_TIMEOUT (2) /* seconds */

static struct i2c_algo_bit_data cx18_i2c_algo_template = {
	.setsda		= cx18_setsda,
	.setscl		= cx18_setscl,
	.getsda		= cx18_getsda,
	.getscl		= cx18_getscl,
	.udelay		= CX18_SCL_PERIOD/2,       /* 1/2 clock period in usec*/
	.timeout	= CX18_ALGO_BIT_TIMEOUT*HZ /* jiffies */
};

static struct i2c_client cx18_i2c_client_template = {
	.name = "cx18 internal",
};

int cx18_call_i2c_client(struct cx18 *cx, int addr, unsigned cmd, void *arg)
{
	struct i2c_client *client;
	int retval;
	int i;

	CX18_DEBUG_I2C("call_i2c_client addr=%02x\n", addr);
	for (i = 0; i < I2C_CLIENTS_MAX; i++) {
		client = cx->i2c_clients[i];
		if (client == NULL || client->driver == NULL ||
				client->driver->command == NULL)
			continue;
		if (addr == client->addr) {
			retval = client->driver->command(client, cmd, arg);
			return retval;
		}
	}
	if (cmd != VIDIOC_G_CHIP_IDENT)
		CX18_ERR("i2c addr 0x%02x not found for cmd 0x%x!\n",
			       addr, cmd);
	return -ENODEV;
}

/* Find the i2c device based on the driver ID and return
   its i2c address or -ENODEV if no matching device was found. */
static int cx18_i2c_id_addr(struct cx18 *cx, u32 id)
{
	struct i2c_client *client;
	int retval = -ENODEV;
	int i;

	for (i = 0; i < I2C_CLIENTS_MAX; i++) {
		client = cx->i2c_clients[i];
		if (client == NULL || client->driver == NULL)
			continue;
		if (id == client->driver->id) {
			retval = client->addr;
			break;
		}
	}
	return retval;
}

/* Find the i2c device name matching the DRIVERID */
static const char *cx18_i2c_id_name(u32 id)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
		if (hw_driverids[i] == id)
			return hw_devicenames[i];
	return "unknown device";
}

/* Find the i2c device name matching the CX18_HW_ flag */
static const char *cx18_i2c_hw_name(u32 hw)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
		if (1 << i == hw)
			return hw_devicenames[i];
	return "unknown device";
}

/* Find the i2c device matching the CX18_HW_ flag and return
   its i2c address or -ENODEV if no matching device was found. */
int cx18_i2c_hw_addr(struct cx18 *cx, u32 hw)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
		if (1 << i == hw)
			return cx18_i2c_id_addr(cx, hw_driverids[i]);
	return -ENODEV;
}

/* Calls i2c device based on CX18_HW_ flag. If hw == 0, then do nothing.
   If hw == CX18_HW_GPIO then call the gpio handler. */
int cx18_i2c_hw(struct cx18 *cx, u32 hw, unsigned int cmd, void *arg)
{
	int addr;

	if (hw == CX18_HW_GPIO || hw == 0)
		return 0;
	if (hw == CX18_HW_CX23418)
		return cx18_av_cmd(cx, cmd, arg);

	addr = cx18_i2c_hw_addr(cx, hw);
	if (addr < 0) {
		CX18_ERR("i2c hardware 0x%08x (%s) not found for cmd 0x%x!\n",
			       hw, cx18_i2c_hw_name(hw), cmd);
		return addr;
	}
	return cx18_call_i2c_client(cx, addr, cmd, arg);
}

/* Calls i2c device based on I2C driver ID. */
int cx18_i2c_id(struct cx18 *cx, u32 id, unsigned int cmd, void *arg)
{
	int addr;

	addr = cx18_i2c_id_addr(cx, id);
	if (addr < 0) {
		if (cmd != VIDIOC_G_CHIP_IDENT)
			CX18_ERR("i2c ID 0x%08x (%s) not found for cmd 0x%x!\n",
				id, cx18_i2c_id_name(id), cmd);
		return addr;
	}
	return cx18_call_i2c_client(cx, addr, cmd, arg);
}

/* broadcast cmd for all I2C clients and for the gpio subsystem */
void cx18_call_i2c_clients(struct cx18 *cx, unsigned int cmd, void *arg)
{
	if (cx->i2c_adap[0].algo == NULL || cx->i2c_adap[1].algo == NULL) {
		CX18_ERR("adapter is not set\n");
		return;
	}
	cx18_av_cmd(cx, cmd, arg);
	i2c_clients_command(&cx->i2c_adap[0], cmd, arg);
	i2c_clients_command(&cx->i2c_adap[1], cmd, arg);
}

/* init + register i2c algo-bit adapter */
int init_cx18_i2c(struct cx18 *cx)
{
	int i;
	CX18_DEBUG_I2C("i2c init\n");

	for (i = 0; i < 2; i++) {
		memcpy(&cx->i2c_adap[i], &cx18_i2c_adap_template,
			sizeof(struct i2c_adapter));
		memcpy(&cx->i2c_algo[i], &cx18_i2c_algo_template,
			sizeof(struct i2c_algo_bit_data));
		cx->i2c_algo_cb_data[i].cx = cx;
		cx->i2c_algo_cb_data[i].bus_index = i;
		cx->i2c_algo[i].data = &cx->i2c_algo_cb_data[i];
		cx->i2c_adap[i].algo_data = &cx->i2c_algo[i];

		sprintf(cx->i2c_adap[i].name + strlen(cx->i2c_adap[i].name),
				" #%d-%d", cx->num, i);
		i2c_set_adapdata(&cx->i2c_adap[i], cx);

		memcpy(&cx->i2c_client[i], &cx18_i2c_client_template,
			sizeof(struct i2c_client));
		sprintf(cx->i2c_client[i].name +
				strlen(cx->i2c_client[i].name), "%d", i);
		cx->i2c_client[i].adapter = &cx->i2c_adap[i];
		cx->i2c_adap[i].dev.parent = &cx->dev->dev;
	}

	if (read_reg(CX18_REG_I2C_2_WR) != 0x0003c02f) {
		/* Reset/Unreset I2C hardware block */
		write_reg(0x10000000, 0xc71004); /* Clock select 220MHz */
		write_reg_sync(0x10001000, 0xc71024); /* Clock Enable */
	}
	/* courtesy of Steven Toth <stoth@hauppauge.com> */
	write_reg_sync(0x00c00000, 0xc7001c);
	mdelay(10);
	write_reg_sync(0x00c000c0, 0xc7001c);
	mdelay(10);
	write_reg_sync(0x00c00000, 0xc7001c);

	write_reg_sync(0x00c00000, 0xc730c8); /* Set to edge-triggered intrs. */
	write_reg_sync(0x00c00000, 0xc730c4); /* Clear any stale intrs */

	/* Hw I2C1 Clock Freq ~100kHz */
	write_reg_sync(0x00021c0f & ~4, CX18_REG_I2C_1_WR);
	cx18_setscl(&cx->i2c_algo_cb_data[0], 1);
	cx18_setsda(&cx->i2c_algo_cb_data[0], 1);

	/* Hw I2C2 Clock Freq ~100kHz */
	write_reg_sync(0x00021c0f & ~4, CX18_REG_I2C_2_WR);
	cx18_setscl(&cx->i2c_algo_cb_data[1], 1);
	cx18_setsda(&cx->i2c_algo_cb_data[1], 1);

	cx18_reset_i2c_slaves_gpio(cx);

	return i2c_bit_add_bus(&cx->i2c_adap[0]) ||
		i2c_bit_add_bus(&cx->i2c_adap[1]);
}

void exit_cx18_i2c(struct cx18 *cx)
{
	int i;
	CX18_DEBUG_I2C("i2c exit\n");
	write_reg(read_reg(CX18_REG_I2C_1_WR) | 4, CX18_REG_I2C_1_WR);
	write_reg(read_reg(CX18_REG_I2C_2_WR) | 4, CX18_REG_I2C_2_WR);

	for (i = 0; i < 2; i++) {
		i2c_del_adapter(&cx->i2c_adap[i]);
	}
}

/*
   Hauppauge HVR1600 should have:
   32 cx24227
   98 unknown
   a0 eeprom
   c2 tuner
   e? zilog ir
   */
Commit	Line	Data
1c1e45d1 HV	1	/*
	2	* cx18 I2C functions
	3	*
	4	* Derived from ivtv-i2c.c
	5	*
	6	* Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
	21	* 02111-1307 USA
	22	*/
	23
	24	#include "cx18-driver.h"
	25	#include "cx18-cards.h"
	26	#include "cx18-gpio.h"
	27	#include "cx18-av-core.h"
50510993	28	#include "cx18-i2c.h"
1c1e45d1 HV	29
	30	#include <media/ir-kbd-i2c.h>
	31
	32	#define CX18_REG_I2C_1_WR 0xf15000
	33	#define CX18_REG_I2C_1_RD 0xf15008
	34	#define CX18_REG_I2C_2_WR 0xf25100
	35	#define CX18_REG_I2C_2_RD 0xf25108
	36
	37	#define SETSCL_BIT 0x0001
	38	#define SETSDL_BIT 0x0002
	39	#define GETSCL_BIT 0x0004
	40	#define GETSDL_BIT 0x0008
	41
	42	#ifndef I2C_ADAP_CLASS_TV_ANALOG
	43	#define I2C_ADAP_CLASS_TV_ANALOG I2C_CLASS_TV_ANALOG
	44	#endif
	45
	46	#define CX18_CS5345_I2C_ADDR 0x4c
	47
	48	/* This array should match the CX18_HW_ defines */
	49	static const u8 hw_driverids[] = {
	50	I2C_DRIVERID_TUNER,
	51	I2C_DRIVERID_TVEEPROM,
	52	I2C_DRIVERID_CS5345,
	53	0, /* CX18_HW_GPIO dummy driver ID */
	54	0 /* CX18_HW_CX23418 dummy driver ID */
	55	};
	56
	57	/* This array should match the CX18_HW_ defines */
	58	static const u8 hw_addrs[] = {
	59	0,
	60	0,
	61	CX18_CS5345_I2C_ADDR,
	62	0, /* CX18_HW_GPIO dummy driver ID */
	63	0, /* CX18_HW_CX23418 dummy driver ID */
	64	};
	65
	66	/* This array should match the CX18_HW_ defines */
	67	/* This might well become a card-specific array */
	68	static const u8 hw_bus[] = {
	69	0,
	70	0,
	71	0,
	72	0, /* CX18_HW_GPIO dummy driver ID */
	73	0, /* CX18_HW_CX23418 dummy driver ID */
	74	};
	75
	76	/* This array should match the CX18_HW_ defines */
af294867	77	static const char * const hw_devicenames[] = {
1c1e45d1 HV	78	"tuner",
	79	"tveeprom",
	80	"cs5345",
	81	"gpio",
	82	"cx23418",
	83	};
	84
	85	int cx18_i2c_register(struct cx18 *cx, unsigned idx)
	86	{
	87	struct i2c_board_info info;
	88	struct i2c_client *c;
	89	u8 id, bus;
	90	int i;
	91
	92	CX18_DEBUG_I2C("i2c client register\n");
	93	if (idx >= ARRAY_SIZE(hw_driverids) \|\| hw_driverids[idx] == 0)
	94	return -1;
	95	id = hw_driverids[idx];
	96	bus = hw_bus[idx];
	97	memset(&info, 0, sizeof(info));
af294867	98	strlcpy(info.type, hw_devicenames[idx], sizeof(info.type));
1c1e45d1 HV	99	info.addr = hw_addrs[idx];
	100	for (i = 0; i < I2C_CLIENTS_MAX; i++)
	101	if (cx->i2c_clients[i] == NULL)
	102	break;
	103
	104	if (i == I2C_CLIENTS_MAX) {
	105	CX18_ERR("insufficient room for new I2C client!\n");
	106	return -ENOMEM;
	107	}
	108
	109	if (id != I2C_DRIVERID_TUNER) {
	110	c = i2c_new_device(&cx->i2c_adap[bus], &info);
	111	if (c->driver == NULL)
	112	i2c_unregister_device(c);
	113	else
	114	cx->i2c_clients[i] = c;
	115	return cx->i2c_clients[i] ? 0 : -ENODEV;
	116	}
	117
	118	/* special tuner handling */
	119	c = i2c_new_probed_device(&cx->i2c_adap[1], &info, cx->card_i2c->radio);
	120	if (c && c->driver == NULL)
	121	i2c_unregister_device(c);
	122	else if (c)
	123	cx->i2c_clients[i++] = c;
	124	c = i2c_new_probed_device(&cx->i2c_adap[1], &info, cx->card_i2c->demod);
	125	if (c && c->driver == NULL)
	126	i2c_unregister_device(c);
	127	else if (c)
	128	cx->i2c_clients[i++] = c;
	129	c = i2c_new_probed_device(&cx->i2c_adap[1], &info, cx->card_i2c->tv);
	130	if (c && c->driver == NULL)
	131	i2c_unregister_device(c);
	132	else if (c)
	133	cx->i2c_clients[i++] = c;
	134	return 0;
	135	}
	136
	137	static int attach_inform(struct i2c_client *client)
	138	{
	139	return 0;
	140	}
	141
	142	static int detach_inform(struct i2c_client *client)
	143	{
	144	int i;
	145	struct cx18 cx = (struct cx18 )i2c_get_adapdata(client->adapter);
	146
	147	CX18_DEBUG_I2C("i2c client detach\n");
	148	for (i = 0; i < I2C_CLIENTS_MAX; i++) {
	149	if (cx->i2c_clients[i] == client) {
	150	cx->i2c_clients[i] = NULL;
	151	break;
	152	}
	153	}
	154	CX18_DEBUG_I2C("i2c detach [client=%s,%s]\n",
	155	client->name, (i < I2C_CLIENTS_MAX) ? "ok" : "failed");
	156
	157	return 0;
	158	}
	159
	160	static void cx18_setscl(void *data, int state)
	161	{
	162	struct cx18 cx = ((struct cx18_i2c_algo_callback_data )data)->cx;
163	int bus_index = ((struct cx18_i2c_algo_callback_data *)data)->bus_index;
164	u32 addr = bus_index ? CX18_REG_I2C_2_WR : CX18_REG_I2C_1_WR;
165	u32 r = read_reg(addr);
166
167	if (state)
168	write_reg_sync(r \| SETSCL_BIT, addr);
169	else
170	write_reg_sync(r & ~SETSCL_BIT, addr);
171	}
172
173	static void cx18_setsda(void *data, int state)
174	{
175	struct cx18 cx = ((struct cx18_i2c_algo_callback_data )data)->cx;
176	int bus_index = ((struct cx18_i2c_algo_callback_data *)data)->bus_index;
177	u32 addr = bus_index ? CX18_REG_I2C_2_WR : CX18_REG_I2C_1_WR;
178	u32 r = read_reg(addr);
179
180	if (state)
181	write_reg_sync(r \| SETSDL_BIT, addr);
182	else
183	write_reg_sync(r & ~SETSDL_BIT, addr);
184	}
185
186	static int cx18_getscl(void *data)
187	{
188	struct cx18 cx = ((struct cx18_i2c_algo_callback_data )data)->cx;
189	int bus_index = ((struct cx18_i2c_algo_callback_data *)data)->bus_index;
190	u32 addr = bus_index ? CX18_REG_I2C_2_RD : CX18_REG_I2C_1_RD;
191
192	return read_reg(addr) & GETSCL_BIT;
193	}
194
195	static int cx18_getsda(void *data)
196	{
197	struct cx18 cx = ((struct cx18_i2c_algo_callback_data )data)->cx;
198	int bus_index = ((struct cx18_i2c_algo_callback_data *)data)->bus_index;
199	u32 addr = bus_index ? CX18_REG_I2C_2_RD : CX18_REG_I2C_1_RD;
200
201	return read_reg(addr) & GETSDL_BIT;
202	}
203
204	/* template for i2c-bit-algo */
205	static struct i2c_adapter cx18_i2c_adap_template = {
206	.name = "cx18 i2c driver",
207	.id = I2C_HW_B_CX2341X,
208	.algo = NULL, /* set by i2c-algo-bit */
209	.algo_data = NULL, /* filled from template */
210	.client_register = attach_inform,
211	.client_unregister = detach_inform,
212	.owner = THIS_MODULE,
213	};
214
215	#define CX18_SCL_PERIOD (10) /* usecs. 10 usec is period for a 100 KHz clock */
216	#define CX18_ALGO_BIT_TIMEOUT (2) /* seconds */
217
218	static struct i2c_algo_bit_data cx18_i2c_algo_template = {
219	.setsda = cx18_setsda,
220	.setscl = cx18_setscl,
221	.getsda = cx18_getsda,
222	.getscl = cx18_getscl,
223	.udelay = CX18_SCL_PERIOD/2, /* 1/2 clock period in usec*/
224	.timeout = CX18_ALGO_BIT_TIMEOUTHZ / jiffies */
225	};
226
227	static struct i2c_client cx18_i2c_client_template = {
228	.name = "cx18 internal",
229	};
230
231	int cx18_call_i2c_client(struct cx18 cx, int addr, unsigned cmd, void arg)
232	{
233	struct i2c_client *client;
234	int retval;
235	int i;
236
237	CX18_DEBUG_I2C("call_i2c_client addr=%02x\n", addr);
238	for (i = 0; i < I2C_CLIENTS_MAX; i++) {
239	client = cx->i2c_clients[i];
240	if (client == NULL \|\| client->driver == NULL \|\|
241	client->driver->command == NULL)
242	continue;
243	if (addr == client->addr) {
244	retval = client->driver->command(client, cmd, arg);
245	return retval;
246	}
247	}
248	if (cmd != VIDIOC_G_CHIP_IDENT)
249	CX18_ERR("i2c addr 0x%02x not found for cmd 0x%x!\n",
250	addr, cmd);
251	return -ENODEV;
252	}
253
254	/* Find the i2c device based on the driver ID and return
255	its i2c address or -ENODEV if no matching device was found. */
256	static int cx18_i2c_id_addr(struct cx18 *cx, u32 id)
257	{
258	struct i2c_client *client;
259	int retval = -ENODEV;
260	int i;
261
262	for (i = 0; i < I2C_CLIENTS_MAX; i++) {
263	client = cx->i2c_clients[i];
264	if (client == NULL \|\| client->driver == NULL)
265	continue;
266	if (id == client->driver->id) {
267	retval = client->addr;
268	break;
269	}
270	}
271	return retval;
272	}
273
274	/* Find the i2c device name matching the DRIVERID */
275	static const char *cx18_i2c_id_name(u32 id)
276	{
277	int i;
278
279	for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
280	if (hw_driverids[i] == id)
af294867	281	return hw_devicenames[i];
1c1e45d1 HV	282	return "unknown device";
	283	}
	284
	285	/* Find the i2c device name matching the CX18_HW_ flag */
	286	static const char *cx18_i2c_hw_name(u32 hw)
	287	{
	288	int i;
	289
	290	for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
	291	if (1 << i == hw)
af294867	292	return hw_devicenames[i];
1c1e45d1 HV	293	return "unknown device";
	294	}
	295
	296	/* Find the i2c device matching the CX18_HW_ flag and return
	297	its i2c address or -ENODEV if no matching device was found. */
	298	int cx18_i2c_hw_addr(struct cx18 *cx, u32 hw)
	299	{
	300	int i;
	301
	302	for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
	303	if (1 << i == hw)
	304	return cx18_i2c_id_addr(cx, hw_driverids[i]);
	305	return -ENODEV;
	306	}
	307
	308	/* Calls i2c device based on CX18_HW_ flag. If hw == 0, then do nothing.
	309	If hw == CX18_HW_GPIO then call the gpio handler. */
	310	int cx18_i2c_hw(struct cx18 cx, u32 hw, unsigned int cmd, void arg)
	311	{
	312	int addr;
	313
	314	if (hw == CX18_HW_GPIO \|\| hw == 0)
	315	return 0;
	316	if (hw == CX18_HW_CX23418)
	317	return cx18_av_cmd(cx, cmd, arg);
	318
	319	addr = cx18_i2c_hw_addr(cx, hw);
	320	if (addr < 0) {
	321	CX18_ERR("i2c hardware 0x%08x (%s) not found for cmd 0x%x!\n",
	322	hw, cx18_i2c_hw_name(hw), cmd);
	323	return addr;
	324	}
	325	return cx18_call_i2c_client(cx, addr, cmd, arg);
	326	}
	327
	328	/* Calls i2c device based on I2C driver ID. */
	329	int cx18_i2c_id(struct cx18 cx, u32 id, unsigned int cmd, void arg)
	330	{
	331	int addr;
	332
	333	addr = cx18_i2c_id_addr(cx, id);
	334	if (addr < 0) {
	335	if (cmd != VIDIOC_G_CHIP_IDENT)
	336	CX18_ERR("i2c ID 0x%08x (%s) not found for cmd 0x%x!\n",
	337	id, cx18_i2c_id_name(id), cmd);
	338	return addr;
	339	}
	340	return cx18_call_i2c_client(cx, addr, cmd, arg);
	341	}
	342
	343	/* broadcast cmd for all I2C clients and for the gpio subsystem */
	344	void cx18_call_i2c_clients(struct cx18 cx, unsigned int cmd, void arg)
	345	{
	346	if (cx->i2c_adap[0].algo == NULL \|\| cx->i2c_adap[1].algo == NULL) {
	347	CX18_ERR("adapter is not set\n");
	348	return;
	349	}
	350	cx18_av_cmd(cx, cmd, arg);
	351	i2c_clients_command(&cx->i2c_adap[0], cmd, arg);
	352	i2c_clients_command(&cx->i2c_adap[1], cmd, arg);
	353	}
	354
	355	/* init + register i2c algo-bit adapter */
	356	int init_cx18_i2c(struct cx18 *cx)
357	{
358	int i;
359	CX18_DEBUG_I2C("i2c init\n");
360
361	for (i = 0; i < 2; i++) {
362	memcpy(&cx->i2c_adap[i], &cx18_i2c_adap_template,
363	sizeof(struct i2c_adapter));
364	memcpy(&cx->i2c_algo[i], &cx18_i2c_algo_template,
365	sizeof(struct i2c_algo_bit_data));
366	cx->i2c_algo_cb_data[i].cx = cx;
367	cx->i2c_algo_cb_data[i].bus_index = i;
368	cx->i2c_algo[i].data = &cx->i2c_algo_cb_data[i];
369	cx->i2c_adap[i].algo_data = &cx->i2c_algo[i];
370
371	sprintf(cx->i2c_adap[i].name + strlen(cx->i2c_adap[i].name),
372	" #%d-%d", cx->num, i);
373	i2c_set_adapdata(&cx->i2c_adap[i], cx);
374
375	memcpy(&cx->i2c_client[i], &cx18_i2c_client_template,
376	sizeof(struct i2c_client));
377	sprintf(cx->i2c_client[i].name +
378	strlen(cx->i2c_client[i].name), "%d", i);
379	cx->i2c_client[i].adapter = &cx->i2c_adap[i];
380	cx->i2c_adap[i].dev.parent = &cx->dev->dev;
381	}
382
383	if (read_reg(CX18_REG_I2C_2_WR) != 0x0003c02f) {
384	/* Reset/Unreset I2C hardware block */
385	write_reg(0x10000000, 0xc71004); /* Clock select 220MHz */
386	write_reg_sync(0x10001000, 0xc71024); /* Clock Enable */
387	}
388	/* courtesy of Steven Toth <stoth@hauppauge.com> */
389	write_reg_sync(0x00c00000, 0xc7001c);
390	mdelay(10);
391	write_reg_sync(0x00c000c0, 0xc7001c);
392	mdelay(10);
393	write_reg_sync(0x00c00000, 0xc7001c);
394
395	write_reg_sync(0x00c00000, 0xc730c8); /* Set to edge-triggered intrs. */
396	write_reg_sync(0x00c00000, 0xc730c4); /* Clear any stale intrs */
397
398	/* Hw I2C1 Clock Freq ~100kHz */
399	write_reg_sync(0x00021c0f & ~4, CX18_REG_I2C_1_WR);
400	cx18_setscl(&cx->i2c_algo_cb_data[0], 1);
401	cx18_setsda(&cx->i2c_algo_cb_data[0], 1);
402
403	/* Hw I2C2 Clock Freq ~100kHz */
404	write_reg_sync(0x00021c0f & ~4, CX18_REG_I2C_2_WR);
405	cx18_setscl(&cx->i2c_algo_cb_data[1], 1);
406	cx18_setsda(&cx->i2c_algo_cb_data[1], 1);
407
1f09e8a2 AW	408	cx18_reset_i2c_slaves_gpio(cx);
1f09e8a2 AW	409
1c1e45d1 HV	410	return i2c_bit_add_bus(&cx->i2c_adap[0]) \|\|
	411	i2c_bit_add_bus(&cx->i2c_adap[1]);
	412	}
	413
	414	void exit_cx18_i2c(struct cx18 *cx)
	415	{
	416	int i;
	417	CX18_DEBUG_I2C("i2c exit\n");
	418	write_reg(read_reg(CX18_REG_I2C_1_WR) \| 4, CX18_REG_I2C_1_WR);
	419	write_reg(read_reg(CX18_REG_I2C_2_WR) \| 4, CX18_REG_I2C_2_WR);
	420
	421	for (i = 0; i < 2; i++) {
	422	i2c_del_adapter(&cx->i2c_adap[i]);
	423	}
	424	}
	425
	426	/*
	427	Hauppauge HVR1600 should have:
	428	32 cx24227
	429	98 unknown
	430	a0 eeprom
	431	c2 tuner
	432	e? zilog ir
	433	*/