/drivers/media/video/bt8xx/bttv-i2c.c

  1/*
  2
  3    bttv-i2c.c  --  all the i2c code is here
  4
  5    bttv - Bt848 frame grabber driver
  6
  7    Copyright (C) 1996,97,98 Ralph  Metzler (rjkm@thp.uni-koeln.de)
  8			   & Marcus Metzler (mocm@thp.uni-koeln.de)
  9    (c) 1999-2003 Gerd Knorr <kraxel@bytesex.org>
 10
 11    (c) 2005 Mauro Carvalho Chehab <mchehab@infradead.org>
 12	- Multituner support and i2c address binding
 13
 14    This program is free software; you can redistribute it and/or modify
 15    it under the terms of the GNU General Public License as published by
 16    the Free Software Foundation; either version 2 of the License, or
 17    (at your option) any later version.
 18
 19    This program is distributed in the hope that it will be useful,
 20    but WITHOUT ANY WARRANTY; without even the implied warranty of
 21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 22    GNU General Public License for more details.
 23
 24    You should have received a copy of the GNU General Public License
 25    along with this program; if not, write to the Free Software
 26    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 27
 28*/
 29
 30#include <linux/module.h>
 31#include <linux/init.h>
 32#include <linux/delay.h>
 33
 34#include "bttvp.h"
 35#include <media/v4l2-common.h>
 36#include <linux/jiffies.h>
 37#include <asm/io.h>
 38
 39static int i2c_debug;
 40static int i2c_hw;
 41static int i2c_scan;
 42module_param(i2c_debug, int, 0644);
 43MODULE_PARM_DESC(i2c_debug, "configure i2c debug level");
 44module_param(i2c_hw,    int, 0444);
 45MODULE_PARM_DESC(i2c_hw,"force use of hardware i2c support, "
 46			"instead of software bitbang");
 47module_param(i2c_scan,  int, 0444);
 48MODULE_PARM_DESC(i2c_scan,"scan i2c bus at insmod time");
 49
 50static unsigned int i2c_udelay = 5;
 51module_param(i2c_udelay, int, 0444);
 52MODULE_PARM_DESC(i2c_udelay,"soft i2c delay at insmod time, in usecs "
 53		"(should be 5 or higher). Lower value means higher bus speed.");
 54
 55/* ----------------------------------------------------------------------- */
 56/* I2C functions - bitbanging adapter (software i2c)                       */
 57
 58static void bttv_bit_setscl(void *data, int state)
 59{
 60	struct bttv *btv = (struct bttv*)data;
 61
 62	if (state)
 63		btv->i2c_state |= 0x02;
 64	else
 65		btv->i2c_state &= ~0x02;
 66	btwrite(btv->i2c_state, BT848_I2C);
 67	btread(BT848_I2C);
 68}
 69
 70static void bttv_bit_setsda(void *data, int state)
 71{
 72	struct bttv *btv = (struct bttv*)data;
 73
 74	if (state)
 75		btv->i2c_state |= 0x01;
 76	else
 77		btv->i2c_state &= ~0x01;
 78	btwrite(btv->i2c_state, BT848_I2C);
 79	btread(BT848_I2C);
 80}
 81
 82static int bttv_bit_getscl(void *data)
 83{
 84	struct bttv *btv = (struct bttv*)data;
 85	int state;
 86
 87	state = btread(BT848_I2C) & 0x02 ? 1 : 0;
 88	return state;
 89}
 90
 91static int bttv_bit_getsda(void *data)
 92{
 93	struct bttv *btv = (struct bttv*)data;
 94	int state;
 95
 96	state = btread(BT848_I2C) & 0x01;
 97	return state;
 98}
 99
100static struct i2c_algo_bit_data __devinitdata bttv_i2c_algo_bit_template = {
101	.setsda  = bttv_bit_setsda,
102	.setscl  = bttv_bit_setscl,
103	.getsda  = bttv_bit_getsda,
104	.getscl  = bttv_bit_getscl,
105	.udelay  = 16,
106	.timeout = 200,
107};
108
109/* ----------------------------------------------------------------------- */
110/* I2C functions - hardware i2c                                            */
111
112static u32 functionality(struct i2c_adapter *adap)
113{
114	return I2C_FUNC_SMBUS_EMUL;
115}
116
117static int
118bttv_i2c_wait_done(struct bttv *btv)
119{
120	int rc = 0;
121
122	/* timeout */
123	if (wait_event_interruptible_timeout(btv->i2c_queue,
124		btv->i2c_done, msecs_to_jiffies(85)) == -ERESTARTSYS)
125
126	rc = -EIO;
127
128	if (btv->i2c_done & BT848_INT_RACK)
129		rc = 1;
130	btv->i2c_done = 0;
131	return rc;
132}
133
134#define I2C_HW (BT878_I2C_MODE  | BT848_I2C_SYNC |\
135		BT848_I2C_SCL | BT848_I2C_SDA)
136
137static int
138bttv_i2c_sendbytes(struct bttv *btv, const struct i2c_msg *msg, int last)
139{
140	u32 xmit;
141	int retval,cnt;
142
143	/* sanity checks */
144	if (0 == msg->len)
145		return -EINVAL;
146
147	/* start, address + first byte */
148	xmit = (msg->addr << 25) | (msg->buf[0] << 16) | I2C_HW;
149	if (msg->len > 1 || !last)
150		xmit |= BT878_I2C_NOSTOP;
151	btwrite(xmit, BT848_I2C);
152	retval = bttv_i2c_wait_done(btv);
153	if (retval < 0)
154		goto err;
155	if (retval == 0)
156		goto eio;
157	if (i2c_debug) {
158		printk(" <W %02x %02x", msg->addr << 1, msg->buf[0]);
159		if (!(xmit & BT878_I2C_NOSTOP))
160			printk(" >\n");
161	}
162
163	for (cnt = 1; cnt < msg->len; cnt++ ) {
164		/* following bytes */
165		xmit = (msg->buf[cnt] << 24) | I2C_HW | BT878_I2C_NOSTART;
166		if (cnt < msg->len-1 || !last)
167			xmit |= BT878_I2C_NOSTOP;
168		btwrite(xmit, BT848_I2C);
169		retval = bttv_i2c_wait_done(btv);
170		if (retval < 0)
171			goto err;
172		if (retval == 0)
173			goto eio;
174		if (i2c_debug) {
175			printk(" %02x", msg->buf[cnt]);
176			if (!(xmit & BT878_I2C_NOSTOP))
177				printk(" >\n");
178		}
179	}
180	return msg->len;
181
182 eio:
183	retval = -EIO;
184 err:
185	if (i2c_debug)
186		printk(" ERR: %d\n",retval);
187	return retval;
188}
189
190static int
191bttv_i2c_readbytes(struct bttv *btv, const struct i2c_msg *msg, int last)
192{
193	u32 xmit;
194	u32 cnt;
195	int retval;
196
197	for(cnt = 0; cnt < msg->len; cnt++) {
198		xmit = (msg->addr << 25) | (1 << 24) | I2C_HW;
199		if (cnt < msg->len-1)
200			xmit |= BT848_I2C_W3B;
201		if (cnt < msg->len-1 || !last)
202			xmit |= BT878_I2C_NOSTOP;
203		if (cnt)
204			xmit |= BT878_I2C_NOSTART;
205		btwrite(xmit, BT848_I2C);
206		retval = bttv_i2c_wait_done(btv);
207		if (retval < 0)
208			goto err;
209		if (retval == 0)
210			goto eio;
211		msg->buf[cnt] = ((u32)btread(BT848_I2C) >> 8) & 0xff;
212		if (i2c_debug) {
213			if (!(xmit & BT878_I2C_NOSTART))
214				printk(" <R %02x", (msg->addr << 1) +1);
215			printk(" =%02x", msg->buf[cnt]);
216			if (!(xmit & BT878_I2C_NOSTOP))
217				printk(" >\n");
218		}
219	}
220	return msg->len;
221
222 eio:
223	retval = -EIO;
224 err:
225	if (i2c_debug)
226		printk(" ERR: %d\n",retval);
227	return retval;
228}
229
230static int bttv_i2c_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
231{
232	struct v4l2_device *v4l2_dev = i2c_get_adapdata(i2c_adap);
233	struct bttv *btv = to_bttv(v4l2_dev);
234	int retval = 0;
235	int i;
236
237	if (i2c_debug)
238		printk("bt-i2c:");
239	btwrite(BT848_INT_I2CDONE|BT848_INT_RACK, BT848_INT_STAT);
240	for (i = 0 ; i < num; i++) {
241		if (msgs[i].flags & I2C_M_RD) {
242			/* read */
243			retval = bttv_i2c_readbytes(btv, &msgs[i], i+1 == num);
244			if (retval < 0)
245				goto err;
246		} else {
247			/* write */
248			retval = bttv_i2c_sendbytes(btv, &msgs[i], i+1 == num);
249			if (retval < 0)
250				goto err;
251		}
252	}
253	return num;
254
255 err:
256	return retval;
257}
258
259static const struct i2c_algorithm bttv_algo = {
260	.master_xfer   = bttv_i2c_xfer,
261	.functionality = functionality,
262};
263
264/* ----------------------------------------------------------------------- */
265/* I2C functions - common stuff                                            */
266
267/* read I2C */
268int bttv_I2CRead(struct bttv *btv, unsigned char addr, char *probe_for)
269{
270	unsigned char buffer = 0;
271
272	if (0 != btv->i2c_rc)
273		return -1;
274	if (bttv_verbose && NULL != probe_for)
275		printk(KERN_INFO "bttv%d: i2c: checking for %s @ 0x%02x... ",
276		       btv->c.nr,probe_for,addr);
277	btv->i2c_client.addr = addr >> 1;
278	if (1 != i2c_master_recv(&btv->i2c_client, &buffer, 1)) {
279		if (NULL != probe_for) {
280			if (bttv_verbose)
281				printk("not found\n");
282		} else
283			printk(KERN_WARNING "bttv%d: i2c read 0x%x: error\n",
284			       btv->c.nr,addr);
285		return -1;
286	}
287	if (bttv_verbose && NULL != probe_for)
288		printk("found\n");
289	return buffer;
290}
291
292/* write I2C */
293int bttv_I2CWrite(struct bttv *btv, unsigned char addr, unsigned char b1,
294		    unsigned char b2, int both)
295{
296	unsigned char buffer[2];
297	int bytes = both ? 2 : 1;
298
299	if (0 != btv->i2c_rc)
300		return -1;
301	btv->i2c_client.addr = addr >> 1;
302	buffer[0] = b1;
303	buffer[1] = b2;
304	if (bytes != i2c_master_send(&btv->i2c_client, buffer, bytes))
305		return -1;
306	return 0;
307}
308
309/* read EEPROM content */
310void __devinit bttv_readee(struct bttv *btv, unsigned char *eedata, int addr)
311{
312	memset(eedata, 0, 256);
313	if (0 != btv->i2c_rc)
314		return;
315	btv->i2c_client.addr = addr >> 1;
316	tveeprom_read(&btv->i2c_client, eedata, 256);
317}
318
319static char *i2c_devs[128] = {
320	[ 0x1c >> 1 ] = "lgdt330x",
321	[ 0x30 >> 1 ] = "IR (hauppauge)",
322	[ 0x80 >> 1 ] = "msp34xx",
323	[ 0x86 >> 1 ] = "tda9887",
324	[ 0xa0 >> 1 ] = "eeprom",
325	[ 0xc0 >> 1 ] = "tuner (analog)",
326	[ 0xc2 >> 1 ] = "tuner (analog)",
327};
328
329static void do_i2c_scan(char *name, struct i2c_client *c)
330{
331	unsigned char buf;
332	int i,rc;
333
334	for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
335		c->addr = i;
336		rc = i2c_master_recv(c,&buf,0);
337		if (rc < 0)
338			continue;
339		printk("%s: i2c scan: found device @ 0x%x  [%s]\n",
340		       name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
341	}
342}
343
344/* init + register i2c algo-bit adapter */
345int __devinit init_bttv_i2c(struct bttv *btv)
346{
347	strlcpy(btv->i2c_client.name, "bttv internal", I2C_NAME_SIZE);
348
349	if (i2c_hw)
350		btv->use_i2c_hw = 1;
351	if (btv->use_i2c_hw) {
352		/* bt878 */
353		strlcpy(btv->c.i2c_adap.name, "bt878",
354			sizeof(btv->c.i2c_adap.name));
355		btv->c.i2c_adap.algo = &bttv_algo;
356	} else {
357		/* bt848 */
358	/* Prevents usage of invalid delay values */
359		if (i2c_udelay<5)
360			i2c_udelay=5;
361
362		strlcpy(btv->c.i2c_adap.name, "bttv",
363			sizeof(btv->c.i2c_adap.name));
364		memcpy(&btv->i2c_algo, &bttv_i2c_algo_bit_template,
365		       sizeof(bttv_i2c_algo_bit_template));
366		btv->i2c_algo.udelay = i2c_udelay;
367		btv->i2c_algo.data = btv;
368		btv->c.i2c_adap.algo_data = &btv->i2c_algo;
369	}
370	btv->c.i2c_adap.owner = THIS_MODULE;
371
372	btv->c.i2c_adap.dev.parent = &btv->c.pci->dev;
373	snprintf(btv->c.i2c_adap.name, sizeof(btv->c.i2c_adap.name),
374		 "bt%d #%d [%s]", btv->id, btv->c.nr,
375		 btv->use_i2c_hw ? "hw" : "sw");
376
377	i2c_set_adapdata(&btv->c.i2c_adap, &btv->c.v4l2_dev);
378	btv->i2c_client.adapter = &btv->c.i2c_adap;
379
380
381	if (btv->use_i2c_hw) {
382		btv->i2c_rc = i2c_add_adapter(&btv->c.i2c_adap);
383	} else {
384		bttv_bit_setscl(btv,1);
385		bttv_bit_setsda(btv,1);
386		btv->i2c_rc = i2c_bit_add_bus(&btv->c.i2c_adap);
387	}
388	if (0 == btv->i2c_rc && i2c_scan)
389		do_i2c_scan(btv->c.v4l2_dev.name, &btv->i2c_client);
390
391	return btv->i2c_rc;
392}
393
394/* Instantiate the I2C IR receiver device, if present */
395void __devinit init_bttv_i2c_ir(struct bttv *btv)
396{
397	if (0 == btv->i2c_rc) {
398		struct i2c_board_info info;
399		/* The external IR receiver is at i2c address 0x34 (0x35 for
400		   reads).  Future Hauppauge cards will have an internal
401		   receiver at 0x30 (0x31 for reads).  In theory, both can be
402		   fitted, and Hauppauge suggest an external overrides an
403		   internal.
404
405		   That's why we probe 0x1a (~0x34) first. CB
406		*/
407		const unsigned short addr_list[] = {
408			0x1a, 0x18, 0x4b, 0x64, 0x30, 0x71,
409			I2C_CLIENT_END
410		};
411
412		memset(&info, 0, sizeof(struct i2c_board_info));
413		strlcpy(info.type, "ir_video", I2C_NAME_SIZE);
414		i2c_new_probed_device(&btv->c.i2c_adap, &info, addr_list);
415	}
416}
417
418int __devexit fini_bttv_i2c(struct bttv *btv)
419{
420	if (0 != btv->i2c_rc)
421		return 0;
422
423	return i2c_del_adapter(&btv->c.i2c_adap);
424}
425
426/*
427 * Local variables:
428 * c-basic-offset: 8
429 * End:
430 */