/drivers/media/video/au0828/au0828-i2c.c

  1/*
  2 *  Driver for the Auvitek AU0828 USB bridge
  3 *
  4 *  Copyright (c) 2008 Steven Toth <stoth@linuxtv.org>
  5 *
  6 *  This program is free software; you can redistribute it and/or modify
  7 *  it under the terms of the GNU General Public License as published by
  8 *  the Free Software Foundation; either version 2 of the License, or
  9 *  (at your option) any later version.
 10 *
 11 *  This program is distributed in the hope that it will be useful,
 12 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 13 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 14 *
 15 *  GNU General Public License for more details.
 16 *
 17 *  You should have received a copy of the GNU General Public License
 18 *  along with this program; if not, write to the Free Software
 19 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 20 */
 21
 22#include <linux/module.h>
 23#include <linux/moduleparam.h>
 24#include <linux/init.h>
 25#include <linux/delay.h>
 26#include <linux/io.h>
 27
 28#include "au0828.h"
 29
 30#include <media/v4l2-common.h>
 31
 32static int i2c_scan;
 33module_param(i2c_scan, int, 0444);
 34MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
 35
 36#define I2C_WAIT_DELAY 512
 37#define I2C_WAIT_RETRY 64
 38
 39static inline int i2c_slave_did_write_ack(struct i2c_adapter *i2c_adap)
 40{
 41	struct au0828_dev *dev = i2c_adap->algo_data;
 42	return au0828_read(dev, AU0828_I2C_STATUS_201) &
 43		AU0828_I2C_STATUS_NO_WRITE_ACK ? 0 : 1;
 44}
 45
 46static inline int i2c_slave_did_read_ack(struct i2c_adapter *i2c_adap)
 47{
 48	struct au0828_dev *dev = i2c_adap->algo_data;
 49	return au0828_read(dev, AU0828_I2C_STATUS_201) &
 50		AU0828_I2C_STATUS_NO_READ_ACK ? 0 : 1;
 51}
 52
 53static int i2c_wait_read_ack(struct i2c_adapter *i2c_adap)
 54{
 55	int count;
 56
 57	for (count = 0; count < I2C_WAIT_RETRY; count++) {
 58		if (!i2c_slave_did_read_ack(i2c_adap))
 59			break;
 60		udelay(I2C_WAIT_DELAY);
 61	}
 62
 63	if (I2C_WAIT_RETRY == count)
 64		return 0;
 65
 66	return 1;
 67}
 68
 69static inline int i2c_is_read_busy(struct i2c_adapter *i2c_adap)
 70{
 71	struct au0828_dev *dev = i2c_adap->algo_data;
 72	return au0828_read(dev, AU0828_I2C_STATUS_201) &
 73		AU0828_I2C_STATUS_READ_DONE ? 0 : 1;
 74}
 75
 76static int i2c_wait_read_done(struct i2c_adapter *i2c_adap)
 77{
 78	int count;
 79
 80	for (count = 0; count < I2C_WAIT_RETRY; count++) {
 81		if (!i2c_is_read_busy(i2c_adap))
 82			break;
 83		udelay(I2C_WAIT_DELAY);
 84	}
 85
 86	if (I2C_WAIT_RETRY == count)
 87		return 0;
 88
 89	return 1;
 90}
 91
 92static inline int i2c_is_write_done(struct i2c_adapter *i2c_adap)
 93{
 94	struct au0828_dev *dev = i2c_adap->algo_data;
 95	return au0828_read(dev, AU0828_I2C_STATUS_201) &
 96		AU0828_I2C_STATUS_WRITE_DONE ? 1 : 0;
 97}
 98
 99static int i2c_wait_write_done(struct i2c_adapter *i2c_adap)
100{
101	int count;
102
103	for (count = 0; count < I2C_WAIT_RETRY; count++) {
104		if (i2c_is_write_done(i2c_adap))
105			break;
106		udelay(I2C_WAIT_DELAY);
107	}
108
109	if (I2C_WAIT_RETRY == count)
110		return 0;
111
112	return 1;
113}
114
115static inline int i2c_is_busy(struct i2c_adapter *i2c_adap)
116{
117	struct au0828_dev *dev = i2c_adap->algo_data;
118	return au0828_read(dev, AU0828_I2C_STATUS_201) &
119		AU0828_I2C_STATUS_BUSY ? 1 : 0;
120}
121
122static int i2c_wait_done(struct i2c_adapter *i2c_adap)
123{
124	int count;
125
126	for (count = 0; count < I2C_WAIT_RETRY; count++) {
127		if (!i2c_is_busy(i2c_adap))
128			break;
129		udelay(I2C_WAIT_DELAY);
130	}
131
132	if (I2C_WAIT_RETRY == count)
133		return 0;
134
135	return 1;
136}
137
138/* FIXME: Implement join handling correctly */
139static int i2c_sendbytes(struct i2c_adapter *i2c_adap,
140	const struct i2c_msg *msg, int joined_rlen)
141{
142	int i, strobe = 0;
143	struct au0828_dev *dev = i2c_adap->algo_data;
144
145	dprintk(4, "%s()\n", __func__);
146
147	au0828_write(dev, AU0828_I2C_MULTIBYTE_MODE_2FF, 0x01);
148
149	/* Set the I2C clock */
150	au0828_write(dev, AU0828_I2C_CLK_DIVIDER_202,
151		     dev->board.i2c_clk_divider);
152
153	/* Hardware needs 8 bit addresses */
154	au0828_write(dev, AU0828_I2C_DEST_ADDR_203, msg->addr << 1);
155
156	dprintk(4, "SEND: %02x\n", msg->addr);
157
158	/* Deal with i2c_scan */
159	if (msg->len == 0) {
160		/* The analog tuner detection code makes use of the SMBUS_QUICK
161		   message (which involves a zero length i2c write).  To avoid
162		   checking the status register when we didn't strobe out any
163		   actual bytes to the bus, just do a read check.  This is
164		   consistent with how I saw i2c device checking done in the
165		   USB trace of the Windows driver */
166		au0828_write(dev, AU0828_I2C_TRIGGER_200,
167			     AU0828_I2C_TRIGGER_READ);
168
169		if (!i2c_wait_done(i2c_adap))
170			return -EIO;
171
172		if (i2c_wait_read_ack(i2c_adap))
173			return -EIO;
174
175		return 0;
176	}
177
178	for (i = 0; i < msg->len;) {
179
180		dprintk(4, " %02x\n", msg->buf[i]);
181
182		au0828_write(dev, AU0828_I2C_WRITE_FIFO_205, msg->buf[i]);
183
184		strobe++;
185		i++;
186
187		if ((strobe >= 4) || (i >= msg->len)) {
188
189			/* Strobe the byte into the bus */
190			if (i < msg->len)
191				au0828_write(dev, AU0828_I2C_TRIGGER_200,
192					     AU0828_I2C_TRIGGER_WRITE |
193					     AU0828_I2C_TRIGGER_HOLD);
194			else
195				au0828_write(dev, AU0828_I2C_TRIGGER_200,
196					     AU0828_I2C_TRIGGER_WRITE);
197
198			/* Reset strobe trigger */
199			strobe = 0;
200
201			if (!i2c_wait_write_done(i2c_adap))
202				return -EIO;
203
204		}
205
206	}
207	if (!i2c_wait_done(i2c_adap))
208		return -EIO;
209
210	dprintk(4, "\n");
211
212	return msg->len;
213}
214
215/* FIXME: Implement join handling correctly */
216static int i2c_readbytes(struct i2c_adapter *i2c_adap,
217	const struct i2c_msg *msg, int joined)
218{
219	struct au0828_dev *dev = i2c_adap->algo_data;
220	int i;
221
222	dprintk(4, "%s()\n", __func__);
223
224	au0828_write(dev, AU0828_I2C_MULTIBYTE_MODE_2FF, 0x01);
225
226	/* Set the I2C clock */
227	au0828_write(dev, AU0828_I2C_CLK_DIVIDER_202,
228		     dev->board.i2c_clk_divider);
229
230	/* Hardware needs 8 bit addresses */
231	au0828_write(dev, AU0828_I2C_DEST_ADDR_203, msg->addr << 1);
232
233	dprintk(4, " RECV:\n");
234
235	/* Deal with i2c_scan */
236	if (msg->len == 0) {
237		au0828_write(dev, AU0828_I2C_TRIGGER_200,
238			     AU0828_I2C_TRIGGER_READ);
239
240		if (i2c_wait_read_ack(i2c_adap))
241			return -EIO;
242		return 0;
243	}
244
245	for (i = 0; i < msg->len;) {
246
247		i++;
248
249		if (i < msg->len)
250			au0828_write(dev, AU0828_I2C_TRIGGER_200,
251				     AU0828_I2C_TRIGGER_READ |
252				     AU0828_I2C_TRIGGER_HOLD);
253		else
254			au0828_write(dev, AU0828_I2C_TRIGGER_200,
255				     AU0828_I2C_TRIGGER_READ);
256
257		if (!i2c_wait_read_done(i2c_adap))
258			return -EIO;
259
260		msg->buf[i-1] = au0828_read(dev, AU0828_I2C_READ_FIFO_209) &
261			0xff;
262
263		dprintk(4, " %02x\n", msg->buf[i-1]);
264	}
265	if (!i2c_wait_done(i2c_adap))
266		return -EIO;
267
268	dprintk(4, "\n");
269
270	return msg->len;
271}
272
273static int i2c_xfer(struct i2c_adapter *i2c_adap,
274		    struct i2c_msg *msgs, int num)
275{
276	int i, retval = 0;
277
278	dprintk(4, "%s(num = %d)\n", __func__, num);
279
280	for (i = 0; i < num; i++) {
281		dprintk(4, "%s(num = %d) addr = 0x%02x  len = 0x%x\n",
282			__func__, num, msgs[i].addr, msgs[i].len);
283		if (msgs[i].flags & I2C_M_RD) {
284			/* read */
285			retval = i2c_readbytes(i2c_adap, &msgs[i], 0);
286		} else if (i + 1 < num && (msgs[i + 1].flags & I2C_M_RD) &&
287			   msgs[i].addr == msgs[i + 1].addr) {
288			/* write then read from same address */
289			retval = i2c_sendbytes(i2c_adap, &msgs[i],
290					       msgs[i + 1].len);
291			if (retval < 0)
292				goto err;
293			i++;
294			retval = i2c_readbytes(i2c_adap, &msgs[i], 1);
295		} else {
296			/* write */
297			retval = i2c_sendbytes(i2c_adap, &msgs[i], 0);
298		}
299		if (retval < 0)
300			goto err;
301	}
302	return num;
303
304err:
305	return retval;
306}
307
308static u32 au0828_functionality(struct i2c_adapter *adap)
309{
310	return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_I2C;
311}
312
313static struct i2c_algorithm au0828_i2c_algo_template = {
314	.master_xfer	= i2c_xfer,
315	.functionality	= au0828_functionality,
316};
317
318/* ----------------------------------------------------------------------- */
319
320static struct i2c_adapter au0828_i2c_adap_template = {
321	.name              = DRIVER_NAME,
322	.owner             = THIS_MODULE,
323	.algo              = &au0828_i2c_algo_template,
324};
325
326static struct i2c_client au0828_i2c_client_template = {
327	.name	= "au0828 internal",
328};
329
330static char *i2c_devs[128] = {
331	[0x8e >> 1] = "au8522",
332	[0xa0 >> 1] = "eeprom",
333	[0xc2 >> 1] = "tuner/xc5000",
334};
335
336static void do_i2c_scan(char *name, struct i2c_client *c)
337{
338	unsigned char buf;
339	int i, rc;
340
341	for (i = 0; i < 128; i++) {
342		c->addr = i;
343		rc = i2c_master_recv(c, &buf, 0);
344		if (rc < 0)
345			continue;
346		printk(KERN_INFO "%s: i2c scan: found device @ 0x%x  [%s]\n",
347		       name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
348	}
349}
350
351/* init + register i2c algo-bit adapter */
352int au0828_i2c_register(struct au0828_dev *dev)
353{
354	dprintk(1, "%s()\n", __func__);
355
356	memcpy(&dev->i2c_adap, &au0828_i2c_adap_template,
357	       sizeof(dev->i2c_adap));
358	memcpy(&dev->i2c_algo, &au0828_i2c_algo_template,
359	       sizeof(dev->i2c_algo));
360	memcpy(&dev->i2c_client, &au0828_i2c_client_template,
361	       sizeof(dev->i2c_client));
362
363	dev->i2c_adap.dev.parent = &dev->usbdev->dev;
364
365	strlcpy(dev->i2c_adap.name, DRIVER_NAME,
366		sizeof(dev->i2c_adap.name));
367
368	dev->i2c_adap.algo = &dev->i2c_algo;
369	dev->i2c_adap.algo_data = dev;
370	i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);
371	i2c_add_adapter(&dev->i2c_adap);
372
373	dev->i2c_client.adapter = &dev->i2c_adap;
374
375	if (0 == dev->i2c_rc) {
376		printk(KERN_INFO "%s: i2c bus registered\n", DRIVER_NAME);
377		if (i2c_scan)
378			do_i2c_scan(DRIVER_NAME, &dev->i2c_client);
379	} else
380		printk(KERN_INFO "%s: i2c bus register FAILED\n", DRIVER_NAME);
381
382	return dev->i2c_rc;
383}
384
385int au0828_i2c_unregister(struct au0828_dev *dev)
386{
387	i2c_del_adapter(&dev->i2c_adap);
388	return 0;
389}
390