[mirror_ubuntu-focal-kernel.git] / drivers / media / common / saa7146_i2c.c

#include <media/saa7146_vv.h>

static u32 saa7146_i2c_func(struct i2c_adapter *adapter)
{
//fm	DEB_I2C(("'%s'.\n", adapter->name));

	return	  I2C_FUNC_I2C
		| I2C_FUNC_SMBUS_QUICK
		| I2C_FUNC_SMBUS_READ_BYTE	| I2C_FUNC_SMBUS_WRITE_BYTE
		| I2C_FUNC_SMBUS_READ_BYTE_DATA | I2C_FUNC_SMBUS_WRITE_BYTE_DATA;
}

/* this function returns the status-register of our i2c-device */
static inline u32 saa7146_i2c_status(struct saa7146_dev *dev)
{
	u32 iicsta = saa7146_read(dev, I2C_STATUS);
/*
	DEB_I2C(("status: 0x%08x\n",iicsta));
*/
	return iicsta;
}

/* this function runs through the i2c-messages and prepares the data to be
   sent through the saa7146. have a look at the specifications p. 122 ff
   to understand this. it returns the number of u32s to send, or -1
   in case of an error. */
static int saa7146_i2c_msg_prepare(const struct i2c_msg *m, int num, u32 *op)
{
	int h1, h2;
	int i, j, addr;
	int mem = 0, op_count = 0;

	/* first determine size of needed memory */
	for(i = 0; i < num; i++) {
		mem += m[i].len + 1;
	}

	/* worst case: we need one u32 for three bytes to be send
	   plus one extra byte to address the device */
	mem = 1 + ((mem-1) / 3);

	/* we assume that op points to a memory of at least SAA7146_I2C_MEM bytes
	   size. if we exceed this limit... */
	if ( (4*mem) > SAA7146_I2C_MEM ) {
//fm		DEB_I2C(("cannot prepare i2c-message.\n"));
		return -ENOMEM;
	}

	/* be careful: clear out the i2c-mem first */
	memset(op,0,sizeof(u32)*mem);

	/* loop through all messages */
	for(i = 0; i < num; i++) {

		/* insert the address of the i2c-slave.
		   note: we get 7 bit i2c-addresses,
		   so we have to perform a translation */
		addr = (m[i].addr*2) + ( (0 != (m[i].flags & I2C_M_RD)) ? 1 : 0);
		h1 = op_count/3; h2 = op_count%3;
		op[h1] |= (	    (u8)addr << ((3-h2)*8));
		op[h1] |= (SAA7146_I2C_START << ((3-h2)*2));
		op_count++;

		/* loop through all bytes of message i */
		for(j = 0; j < m[i].len; j++) {
			/* insert the data bytes */
			h1 = op_count/3; h2 = op_count%3;
			op[h1] |= ( (u32)((u8)m[i].buf[j]) << ((3-h2)*8));
			op[h1] |= (       SAA7146_I2C_CONT << ((3-h2)*2));
			op_count++;
		}

	}

	/* have a look at the last byte inserted:
	  if it was: ...CONT change it to ...STOP */
	h1 = (op_count-1)/3; h2 = (op_count-1)%3;
	if ( SAA7146_I2C_CONT == (0x3 & (op[h1] >> ((3-h2)*2))) ) {
		op[h1] &= ~(0x2 << ((3-h2)*2));
		op[h1] |= (SAA7146_I2C_STOP << ((3-h2)*2));
	}

	/* return the number of u32s to send */
	return mem;
}

/* this functions loops through all i2c-messages. normally, it should determine
   which bytes were read through the adapter and write them back to the corresponding
   i2c-message. but instead, we simply write back all bytes.
   fixme: this could be improved. */
static int saa7146_i2c_msg_cleanup(const struct i2c_msg *m, int num, u32 *op)
{
	int i, j;
	int op_count = 0;

	/* loop through all messages */
	for(i = 0; i < num; i++) {

		op_count++;

		/* loop throgh all bytes of message i */
		for(j = 0; j < m[i].len; j++) {
			/* write back all bytes that could have been read */
			m[i].buf[j] = (op[op_count/3] >> ((3-(op_count%3))*8));
			op_count++;
		}
	}

	return 0;
}

/* this functions resets the i2c-device and returns 0 if everything was fine, otherwise -1 */
static int saa7146_i2c_reset(struct saa7146_dev *dev)
{
	/* get current status */
	u32 status = saa7146_i2c_status(dev);

	/* clear registers for sure */
	saa7146_write(dev, I2C_STATUS, dev->i2c_bitrate);
	saa7146_write(dev, I2C_TRANSFER, 0);

	/* check if any operation is still in progress */
	if ( 0 != ( status & SAA7146_I2C_BUSY) ) {

		/* yes, kill ongoing operation */
		DEB_I2C(("busy_state detected.\n"));

		/* set "ABORT-OPERATION"-bit (bit 7)*/
		saa7146_write(dev, I2C_STATUS, (dev->i2c_bitrate | MASK_07));
		saa7146_write(dev, MC2, (MASK_00 | MASK_16));
		msleep(SAA7146_I2C_DELAY);

		/* clear all error-bits pending; this is needed because p.123, note 1 */
		saa7146_write(dev, I2C_STATUS, dev->i2c_bitrate);
		saa7146_write(dev, MC2, (MASK_00 | MASK_16));
		msleep(SAA7146_I2C_DELAY);
	}

	/* check if any error is (still) present. (this can be necessary because p.123, note 1) */
	status = saa7146_i2c_status(dev);

	if ( dev->i2c_bitrate != status ) {

		DEB_I2C(("error_state detected. status:0x%08x\n",status));

		/* Repeat the abort operation. This seems to be necessary
		   after serious protocol errors caused by e.g. the SAA7740 */
		saa7146_write(dev, I2C_STATUS, (dev->i2c_bitrate | MASK_07));
		saa7146_write(dev, MC2, (MASK_00 | MASK_16));
		msleep(SAA7146_I2C_DELAY);

		/* clear all error-bits pending */
		saa7146_write(dev, I2C_STATUS, dev->i2c_bitrate);
		saa7146_write(dev, MC2, (MASK_00 | MASK_16));
		msleep(SAA7146_I2C_DELAY);

		/* the data sheet says it might be necessary to clear the status
		   twice after an abort */
		saa7146_write(dev, I2C_STATUS, dev->i2c_bitrate);
		saa7146_write(dev, MC2, (MASK_00 | MASK_16));
		msleep(SAA7146_I2C_DELAY);
	}

	/* if any error is still present, a fatal error has occured ... */
	status = saa7146_i2c_status(dev);
	if ( dev->i2c_bitrate != status ) {
		DEB_I2C(("fatal error. status:0x%08x\n",status));
		return -1;
	}

	return 0;
}

/* this functions writes out the data-byte 'dword' to the i2c-device.
   it returns 0 if ok, -1 if the transfer failed, -2 if the transfer
   failed badly (e.g. address error) */
static int saa7146_i2c_writeout(struct saa7146_dev *dev, u32* dword, int short_delay)
{
	u32 status = 0, mc2 = 0;
	int trial = 0;
	unsigned long timeout;

	/* write out i2c-command */
	DEB_I2C(("before: 0x%08x (status: 0x%08x), %d\n",*dword,saa7146_read(dev, I2C_STATUS), dev->i2c_op));

	if( 0 != (SAA7146_USE_I2C_IRQ & dev->ext->flags)) {

		saa7146_write(dev, I2C_STATUS,	 dev->i2c_bitrate);
		saa7146_write(dev, I2C_TRANSFER, *dword);

		dev->i2c_op = 1;
		SAA7146_ISR_CLEAR(dev, MASK_16|MASK_17);
		SAA7146_IER_ENABLE(dev, MASK_16|MASK_17);
		saa7146_write(dev, MC2, (MASK_00 | MASK_16));

		timeout = HZ/100 + 1; /* 10ms */
		timeout = wait_event_interruptible_timeout(dev->i2c_wq, dev->i2c_op == 0, timeout);
		if (timeout == -ERESTARTSYS || dev->i2c_op) {
			SAA7146_IER_DISABLE(dev, MASK_16|MASK_17);
			SAA7146_ISR_CLEAR(dev, MASK_16|MASK_17);
			if (timeout == -ERESTARTSYS)
				/* a signal arrived */
				return -ERESTARTSYS;

			printk(KERN_WARNING "%s %s [irq]: timed out waiting for end of xfer\n",
				dev->name, __FUNCTION__);
			return -EIO;
		}
		status = saa7146_read(dev, I2C_STATUS);
	} else {
		saa7146_write(dev, I2C_STATUS,	 dev->i2c_bitrate);
		saa7146_write(dev, I2C_TRANSFER, *dword);
		saa7146_write(dev, MC2, (MASK_00 | MASK_16));

		/* do not poll for i2c-status before upload is complete */
		timeout = jiffies + HZ/100 + 1; /* 10ms */
		while(1) {
			mc2 = (saa7146_read(dev, MC2) & 0x1);
			if( 0 != mc2 ) {
				break;
			}
			if (time_after(jiffies,timeout)) {
				printk(KERN_WARNING "%s %s: timed out waiting for MC2\n",
					dev->name, __FUNCTION__);
				return -EIO;
			}
		}
		/* wait until we get a transfer done or error */
		timeout = jiffies + HZ/100 + 1; /* 10ms */
		/* first read usually delivers bogus results... */
		saa7146_i2c_status(dev);
		while(1) {
			status = saa7146_i2c_status(dev);
			if ((status & 0x3) != 1)
				break;
			if (time_after(jiffies,timeout)) {
				/* this is normal when probing the bus
				 * (no answer from nonexisistant device...)
				 */
				printk(KERN_WARNING "%s %s [poll]: timed out waiting for end of xfer\n",
					dev->name, __FUNCTION__);
				return -EIO;
			}
			if (++trial < 50 && short_delay)
				udelay(10);
			else
				msleep(1);
		}
	}

	/* give a detailed status report */
	if ( 0 != (status & (SAA7146_I2C_SPERR | SAA7146_I2C_APERR |
			     SAA7146_I2C_DTERR | SAA7146_I2C_DRERR |
			     SAA7146_I2C_AL    | SAA7146_I2C_ERR   |
			     SAA7146_I2C_BUSY)) ) {

		if ( 0 == (status & SAA7146_I2C_ERR) ||
		     0 == (status & SAA7146_I2C_BUSY) ) {
			/* it may take some time until ERR goes high - ignore */
			DEB_I2C(("unexpected i2c status %04x\n", status));
		}
		if( 0 != (status & SAA7146_I2C_SPERR) ) {
			DEB_I2C(("error due to invalid start/stop condition.\n"));
		}
		if( 0 != (status & SAA7146_I2C_DTERR) ) {
			DEB_I2C(("error in data transmission.\n"));
		}
		if( 0 != (status & SAA7146_I2C_DRERR) ) {
			DEB_I2C(("error when receiving data.\n"));
		}
		if( 0 != (status & SAA7146_I2C_AL) ) {
			DEB_I2C(("error because arbitration lost.\n"));
		}

		/* we handle address-errors here */
		if( 0 != (status & SAA7146_I2C_APERR) ) {
			DEB_I2C(("error in address phase.\n"));
			return -EREMOTEIO;
		}

		return -EIO;
	}

	/* read back data, just in case we were reading ... */
	*dword = saa7146_read(dev, I2C_TRANSFER);

	DEB_I2C(("after: 0x%08x\n",*dword));
	return 0;
}

static int saa7146_i2c_transfer(struct saa7146_dev *dev, const struct i2c_msg *msgs, int num, int retries)
{
	int i = 0, count = 0;
	u32* buffer = dev->d_i2c.cpu_addr;
	int err = 0;
	int address_err = 0;
	int short_delay = 0;

	if (mutex_lock_interruptible(&dev->i2c_lock))
		return -ERESTARTSYS;

	for(i=0;i<num;i++) {
		DEB_I2C(("msg:%d/%d\n",i+1,num));
	}

	/* prepare the message(s), get number of u32s to transfer */
	count = saa7146_i2c_msg_prepare(msgs, num, buffer);
	if ( 0 > count ) {
		err = -1;
		goto out;
	}

	if ( count > 3 || 0 != (SAA7146_I2C_SHORT_DELAY & dev->ext->flags) )
		short_delay = 1;

	do {
		/* reset the i2c-device if necessary */
		err = saa7146_i2c_reset(dev);
		if ( 0 > err ) {
			DEB_I2C(("could not reset i2c-device.\n"));
			goto out;
		}

		/* write out the u32s one after another */
		for(i = 0; i < count; i++) {
			err = saa7146_i2c_writeout(dev, &buffer[i], short_delay);
			if ( 0 != err) {
				/* this one is unsatisfying: some i2c slaves on some
				   dvb cards don't acknowledge correctly, so the saa7146
				   thinks that an address error occured. in that case, the
				   transaction should be retrying, even if an address error
				   occured. analog saa7146 based cards extensively rely on
				   i2c address probing, however, and address errors indicate that a
				   device is really *not* there. retrying in that case
				   increases the time the device needs to probe greatly, so
				   it should be avoided. because of the fact, that only
				   analog based cards use irq based i2c transactions (for dvb
				   cards, this screwes up other interrupt sources), we bail out
				   completely for analog cards after an address error and trust
				   the saa7146 address error detection. */
				if ( -EREMOTEIO == err ) {
					if( 0 != (SAA7146_USE_I2C_IRQ & dev->ext->flags)) {
						goto out;
					}
					address_err++;
				}
				DEB_I2C(("error while sending message(s). starting again.\n"));
				break;
			}
		}
		if( 0 == err ) {
			err = num;
			break;
		}

		/* delay a bit before retrying */
		msleep(10);

	} while (err != num && retries--);

	/* if every retry had an address error, exit right away */
	if (address_err == retries) {
		goto out;
	}

	/* if any things had to be read, get the results */
	if ( 0 != saa7146_i2c_msg_cleanup(msgs, num, buffer)) {
		DEB_I2C(("could not cleanup i2c-message.\n"));
		err = -1;
		goto out;
	}

	/* return the number of delivered messages */
	DEB_I2C(("transmission successful. (msg:%d).\n",err));
out:
	/* another bug in revision 0: the i2c-registers get uploaded randomly by other
	   uploads, so we better clear them out before continueing */
	if( 0 == dev->revision ) {
		u32 zero = 0;
		saa7146_i2c_reset(dev);
		if( 0 != saa7146_i2c_writeout(dev, &zero, short_delay)) {
			INFO(("revision 0 error. this should never happen.\n"));
		}
	}

	mutex_unlock(&dev->i2c_lock);
	return err;
}

/* utility functions */
static int saa7146_i2c_xfer(struct i2c_adapter* adapter, struct i2c_msg *msg, int num)
{
	struct saa7146_dev* dev = i2c_get_adapdata(adapter);

	/* use helper function to transfer data */
	return saa7146_i2c_transfer(dev, msg, num, adapter->retries);
}


/*****************************************************************************/
/* i2c-adapter helper functions                                              */
#include <linux/i2c-id.h>

/* exported algorithm data */
static struct i2c_algorithm saa7146_algo = {
	.master_xfer	= saa7146_i2c_xfer,
	.functionality	= saa7146_i2c_func,
};

int saa7146_i2c_adapter_prepare(struct saa7146_dev *dev, struct i2c_adapter *i2c_adapter, u32 bitrate)
{
	DEB_EE(("bitrate: 0x%08x\n",bitrate));

	/* enable i2c-port pins */
	saa7146_write(dev, MC1, (MASK_08 | MASK_24));

	dev->i2c_bitrate = bitrate;
	saa7146_i2c_reset(dev);

	if( NULL != i2c_adapter ) {
		BUG_ON(!i2c_adapter->class);
		i2c_set_adapdata(i2c_adapter,dev);
		i2c_adapter->dev.parent    = &dev->pci->dev;
		i2c_adapter->algo	   = &saa7146_algo;
		i2c_adapter->algo_data     = NULL;
		i2c_adapter->id		   = I2C_HW_SAA7146;
		i2c_adapter->timeout = SAA7146_I2C_TIMEOUT;
		i2c_adapter->retries = SAA7146_I2C_RETRIES;
	}

	return 0;
}
Commit	Line	Data
1da177e4 LT	1	#include <media/saa7146_vv.h>
	2
	3	static u32 saa7146_i2c_func(struct i2c_adapter *adapter)
	4	{
	5	//fm DEB_I2C(("'%s'.\n", adapter->name));
	6
	7	return I2C_FUNC_I2C
	8	\| I2C_FUNC_SMBUS_QUICK
	9	\| I2C_FUNC_SMBUS_READ_BYTE \| I2C_FUNC_SMBUS_WRITE_BYTE
	10	\| I2C_FUNC_SMBUS_READ_BYTE_DATA \| I2C_FUNC_SMBUS_WRITE_BYTE_DATA;
	11	}
	12
	13	/* this function returns the status-register of our i2c-device */
	14	static inline u32 saa7146_i2c_status(struct saa7146_dev *dev)
	15	{
	16	u32 iicsta = saa7146_read(dev, I2C_STATUS);
	17	/*
	18	DEB_I2C(("status: 0x%08x\n",iicsta));
	19	*/
	20	return iicsta;
	21	}
	22
	23	/* this function runs through the i2c-messages and prepares the data to be
	24	sent through the saa7146. have a look at the specifications p. 122 ff
	25	to understand this. it returns the number of u32s to send, or -1
	26	in case of an error. */
	27	static int saa7146_i2c_msg_prepare(const struct i2c_msg m, int num, u32 op)
	28	{
	29	int h1, h2;
	30	int i, j, addr;
	31	int mem = 0, op_count = 0;
	32
	33	/* first determine size of needed memory */
	34	for(i = 0; i < num; i++) {
	35	mem += m[i].len + 1;
	36	}
	37
	38	/* worst case: we need one u32 for three bytes to be send
	39	plus one extra byte to address the device */
	40	mem = 1 + ((mem-1) / 3);
	41
	42	/* we assume that op points to a memory of at least SAA7146_I2C_MEM bytes
	43	size. if we exceed this limit... */
	44	if ( (4*mem) > SAA7146_I2C_MEM ) {
	45	//fm DEB_I2C(("cannot prepare i2c-message.\n"));
	46	return -ENOMEM;
	47	}
	48
	49	/* be careful: clear out the i2c-mem first */
	50	memset(op,0,sizeof(u32)*mem);
	51
	52	/* loop through all messages */
	53	for(i = 0; i < num; i++) {
	54
	55	/* insert the address of the i2c-slave.
	56	note: we get 7 bit i2c-addresses,
	57	so we have to perform a translation */
	58	addr = (m[i].addr*2) + ( (0 != (m[i].flags & I2C_M_RD)) ? 1 : 0);
	59	h1 = op_count/3; h2 = op_count%3;
	60	op[h1] \|= ( (u8)addr << ((3-h2)*8));
	61	op[h1] \|= (SAA7146_I2C_START << ((3-h2)*2));
	62	op_count++;
	63
	64	/* loop through all bytes of message i */
65	for(j = 0; j < m[i].len; j++) {
66	/* insert the data bytes */
67	h1 = op_count/3; h2 = op_count%3;
68	op[h1] \|= ( (u32)((u8)m[i].buf[j]) << ((3-h2)*8));
69	op[h1] \|= ( SAA7146_I2C_CONT << ((3-h2)*2));
70	op_count++;
71	}
72
73	}
74
75	/* have a look at the last byte inserted:
76	if it was: ...CONT change it to ...STOP */
77	h1 = (op_count-1)/3; h2 = (op_count-1)%3;
78	if ( SAA7146_I2C_CONT == (0x3 & (op[h1] >> ((3-h2)*2))) ) {
79	op[h1] &= ~(0x2 << ((3-h2)*2));
80	op[h1] \|= (SAA7146_I2C_STOP << ((3-h2)*2));
81	}
82
83	/* return the number of u32s to send */
84	return mem;
85	}
86
87	/* this functions loops through all i2c-messages. normally, it should determine
88	which bytes were read through the adapter and write them back to the corresponding
89	i2c-message. but instead, we simply write back all bytes.
90	fixme: this could be improved. */
91	static int saa7146_i2c_msg_cleanup(const struct i2c_msg m, int num, u32 op)
92	{
93	int i, j;
94	int op_count = 0;
95
96	/* loop through all messages */
97	for(i = 0; i < num; i++) {
98
99	op_count++;
100
101	/* loop throgh all bytes of message i */
102	for(j = 0; j < m[i].len; j++) {
103	/* write back all bytes that could have been read */
104	m[i].buf[j] = (op[op_count/3] >> ((3-(op_count%3))*8));
105	op_count++;
106	}
107	}
108
109	return 0;
110	}
111
112	/* this functions resets the i2c-device and returns 0 if everything was fine, otherwise -1 */
113	static int saa7146_i2c_reset(struct saa7146_dev *dev)
114	{
115	/* get current status */
116	u32 status = saa7146_i2c_status(dev);
117
118	/* clear registers for sure */
119	saa7146_write(dev, I2C_STATUS, dev->i2c_bitrate);
120	saa7146_write(dev, I2C_TRANSFER, 0);
121
122	/* check if any operation is still in progress */
123	if ( 0 != ( status & SAA7146_I2C_BUSY) ) {
124
125	/* yes, kill ongoing operation */
126	DEB_I2C(("busy_state detected.\n"));
127
128	/* set "ABORT-OPERATION"-bit (bit 7)*/
129	saa7146_write(dev, I2C_STATUS, (dev->i2c_bitrate \| MASK_07));
130	saa7146_write(dev, MC2, (MASK_00 \| MASK_16));
131	msleep(SAA7146_I2C_DELAY);
132
133	/* clear all error-bits pending; this is needed because p.123, note 1 */
134	saa7146_write(dev, I2C_STATUS, dev->i2c_bitrate);
135	saa7146_write(dev, MC2, (MASK_00 \| MASK_16));
136	msleep(SAA7146_I2C_DELAY);
137	}
138
139	/* check if any error is (still) present. (this can be necessary because p.123, note 1) */
140	status = saa7146_i2c_status(dev);
141
142	if ( dev->i2c_bitrate != status ) {
143
144	DEB_I2C(("error_state detected. status:0x%08x\n",status));
145
146	/* Repeat the abort operation. This seems to be necessary
147	after serious protocol errors caused by e.g. the SAA7740 */
148	saa7146_write(dev, I2C_STATUS, (dev->i2c_bitrate \| MASK_07));
149	saa7146_write(dev, MC2, (MASK_00 \| MASK_16));
150	msleep(SAA7146_I2C_DELAY);
151
152	/* clear all error-bits pending */
153	saa7146_write(dev, I2C_STATUS, dev->i2c_bitrate);
154	saa7146_write(dev, MC2, (MASK_00 \| MASK_16));
155	msleep(SAA7146_I2C_DELAY);
156
157	/* the data sheet says it might be necessary to clear the status
158	twice after an abort */
159	saa7146_write(dev, I2C_STATUS, dev->i2c_bitrate);
160	saa7146_write(dev, MC2, (MASK_00 \| MASK_16));
161	msleep(SAA7146_I2C_DELAY);
162	}
163
164	/* if any error is still present, a fatal error has occured ... */
165	status = saa7146_i2c_status(dev);
166	if ( dev->i2c_bitrate != status ) {
167	DEB_I2C(("fatal error. status:0x%08x\n",status));
168	return -1;
169	}
170
171	return 0;
172	}
173
174	/* this functions writes out the data-byte 'dword' to the i2c-device.
175	it returns 0 if ok, -1 if the transfer failed, -2 if the transfer
176	failed badly (e.g. address error) */
177	static int saa7146_i2c_writeout(struct saa7146_dev dev, u32 dword, int short_delay)
178	{
179	u32 status = 0, mc2 = 0;
180	int trial = 0;
181	unsigned long timeout;
182
183	/* write out i2c-command */
184	DEB_I2C(("before: 0x%08x (status: 0x%08x), %d\n",*dword,saa7146_read(dev, I2C_STATUS), dev->i2c_op));
185
186	if( 0 != (SAA7146_USE_I2C_IRQ & dev->ext->flags)) {
187
188	saa7146_write(dev, I2C_STATUS, dev->i2c_bitrate);
189	saa7146_write(dev, I2C_TRANSFER, *dword);
190
191	dev->i2c_op = 1;
35e55255	192	SAA7146_ISR_CLEAR(dev, MASK_16\|MASK_17);
1da177e4 LT	193	SAA7146_IER_ENABLE(dev, MASK_16\|MASK_17);
	194	saa7146_write(dev, MC2, (MASK_00 \| MASK_16));
	195
35e55255 HB	196	timeout = HZ/100 + 1; /* 10ms */
	197	timeout = wait_event_interruptible_timeout(dev->i2c_wq, dev->i2c_op == 0, timeout);
	198	if (timeout == -ERESTARTSYS \|\| dev->i2c_op) {
	199	SAA7146_IER_DISABLE(dev, MASK_16\|MASK_17);
	200	SAA7146_ISR_CLEAR(dev, MASK_16\|MASK_17);
	201	if (timeout == -ERESTARTSYS)
	202	/* a signal arrived */
	203	return -ERESTARTSYS;
	204
276e49a0 OE	205	printk(KERN_WARNING "%s %s [irq]: timed out waiting for end of xfer\n",
276e49a0 OE	206	dev->name, __FUNCTION__);
35e55255	207	return -EIO;
1da177e4 LT	208	}
	209	status = saa7146_read(dev, I2C_STATUS);
	210	} else {
	211	saa7146_write(dev, I2C_STATUS, dev->i2c_bitrate);
	212	saa7146_write(dev, I2C_TRANSFER, *dword);
	213	saa7146_write(dev, MC2, (MASK_00 \| MASK_16));
	214
	215	/* do not poll for i2c-status before upload is complete */
	216	timeout = jiffies + HZ/100 + 1; /* 10ms */
	217	while(1) {
	218	mc2 = (saa7146_read(dev, MC2) & 0x1);
	219	if( 0 != mc2 ) {
	220	break;
	221	}
	222	if (time_after(jiffies,timeout)) {
276e49a0 OE	223	printk(KERN_WARNING "%s %s: timed out waiting for MC2\n",
276e49a0 OE	224	dev->name, __FUNCTION__);
1da177e4 LT	225	return -EIO;
	226	}
	227	}
	228	/* wait until we get a transfer done or error */
	229	timeout = jiffies + HZ/100 + 1; /* 10ms */
9bb6e259 OE	230	/* first read usually delivers bogus results... */
9bb6e259 OE	231	saa7146_i2c_status(dev);
1da177e4	232	while(1) {
1da177e4 LT	233	status = saa7146_i2c_status(dev);
	234	if ((status & 0x3) != 1)
	235	break;
	236	if (time_after(jiffies,timeout)) {
	237	/* this is normal when probing the bus
	238	* (no answer from nonexisistant device...)
	239	*/
276e49a0 OE	240	printk(KERN_WARNING "%s %s [poll]: timed out waiting for end of xfer\n",
276e49a0 OE	241	dev->name, __FUNCTION__);
1da177e4 LT	242	return -EIO;
1da177e4 LT	243	}
9bb6e259	244	if (++trial < 50 && short_delay)
1da177e4 LT	245	udelay(10);
1da177e4 LT	246	else
9bb6e259	247	msleep(1);
1da177e4 LT	248	}
	249	}
	250
	251	/* give a detailed status report */
276e49a0 OE	252	if ( 0 != (status & (SAA7146_I2C_SPERR \| SAA7146_I2C_APERR \|
	253	SAA7146_I2C_DTERR \| SAA7146_I2C_DRERR \|
	254	SAA7146_I2C_AL \| SAA7146_I2C_ERR \|
	255	SAA7146_I2C_BUSY)) ) {
	256
	257	if ( 0 == (status & SAA7146_I2C_ERR) \|\|
	258	0 == (status & SAA7146_I2C_BUSY) ) {
	259	/* it may take some time until ERR goes high - ignore */
	260	DEB_I2C(("unexpected i2c status %04x\n", status));
	261	}
1da177e4 LT	262	if( 0 != (status & SAA7146_I2C_SPERR) ) {
	263	DEB_I2C(("error due to invalid start/stop condition.\n"));
	264	}
	265	if( 0 != (status & SAA7146_I2C_DTERR) ) {
	266	DEB_I2C(("error in data transmission.\n"));
	267	}
	268	if( 0 != (status & SAA7146_I2C_DRERR) ) {
	269	DEB_I2C(("error when receiving data.\n"));
	270	}
	271	if( 0 != (status & SAA7146_I2C_AL) ) {
	272	DEB_I2C(("error because arbitration lost.\n"));
	273	}
	274
	275	/* we handle address-errors here */
	276	if( 0 != (status & SAA7146_I2C_APERR) ) {
	277	DEB_I2C(("error in address phase.\n"));
	278	return -EREMOTEIO;
	279	}
	280
	281	return -EIO;
	282	}
	283
	284	/* read back data, just in case we were reading ... */
	285	*dword = saa7146_read(dev, I2C_TRANSFER);
	286
	287	DEB_I2C(("after: 0x%08x\n",*dword));
	288	return 0;
	289	}
	290
36c15f8e	291	static int saa7146_i2c_transfer(struct saa7146_dev dev, const struct i2c_msg msgs, int num, int retries)
1da177e4 LT	292	{
	293	int i = 0, count = 0;
	294	u32* buffer = dev->d_i2c.cpu_addr;
	295	int err = 0;
afd1a0c9 MCC	296	int address_err = 0;
afd1a0c9 MCC	297	int short_delay = 0;
1da177e4	298
3593cab5	299	if (mutex_lock_interruptible(&dev->i2c_lock))
1da177e4 LT	300	return -ERESTARTSYS;
	301
	302	for(i=0;i<num;i++) {
	303	DEB_I2C(("msg:%d/%d\n",i+1,num));
	304	}
	305
	306	/* prepare the message(s), get number of u32s to transfer */
	307	count = saa7146_i2c_msg_prepare(msgs, num, buffer);
	308	if ( 0 > count ) {
	309	err = -1;
	310	goto out;
	311	}
	312
	313	if ( count > 3 \|\| 0 != (SAA7146_I2C_SHORT_DELAY & dev->ext->flags) )
	314	short_delay = 1;
	315
	316	do {
	317	/* reset the i2c-device if necessary */
	318	err = saa7146_i2c_reset(dev);
	319	if ( 0 > err ) {
	320	DEB_I2C(("could not reset i2c-device.\n"));
	321	goto out;
	322	}
	323
	324	/* write out the u32s one after another */
	325	for(i = 0; i < count; i++) {
	326	err = saa7146_i2c_writeout(dev, &buffer[i], short_delay);
	327	if ( 0 != err) {
	328	/* this one is unsatisfying: some i2c slaves on some
	329	dvb cards don't acknowledge correctly, so the saa7146
	330	thinks that an address error occured. in that case, the
	331	transaction should be retrying, even if an address error
	332	occured. analog saa7146 based cards extensively rely on
	333	i2c address probing, however, and address errors indicate that a
	334	device is really not there. retrying in that case
	335	increases the time the device needs to probe greatly, so
	336	it should be avoided. because of the fact, that only
	337	analog based cards use irq based i2c transactions (for dvb
	338	cards, this screwes up other interrupt sources), we bail out
	339	completely for analog cards after an address error and trust
	340	the saa7146 address error detection. */
	341	if ( -EREMOTEIO == err ) {
	342	if( 0 != (SAA7146_USE_I2C_IRQ & dev->ext->flags)) {
	343	goto out;
	344	}
afd1a0c9	345	address_err++;
1da177e4 LT	346	}
	347	DEB_I2C(("error while sending message(s). starting again.\n"));
	348	break;
	349	}
	350	}
	351	if( 0 == err ) {
	352	err = num;
	353	break;
	354	}
	355
afd1a0c9 MCC	356	/* delay a bit before retrying */
afd1a0c9 MCC	357	msleep(10);
1da177e4 LT	358
	359	} while (err != num && retries--);
	360
afd1a0c9 MCC	361	/* if every retry had an address error, exit right away */
	362	if (address_err == retries) {
	363	goto out;
1da177e4 LT	364	}
	365
	366	/* if any things had to be read, get the results */
	367	if ( 0 != saa7146_i2c_msg_cleanup(msgs, num, buffer)) {
	368	DEB_I2C(("could not cleanup i2c-message.\n"));
	369	err = -1;
	370	goto out;
	371	}
	372
	373	/* return the number of delivered messages */
	374	DEB_I2C(("transmission successful. (msg:%d).\n",err));
	375	out:
	376	/* another bug in revision 0: the i2c-registers get uploaded randomly by other
	377	uploads, so we better clear them out before continueing */
	378	if( 0 == dev->revision ) {
	379	u32 zero = 0;
	380	saa7146_i2c_reset(dev);
	381	if( 0 != saa7146_i2c_writeout(dev, &zero, short_delay)) {
	382	INFO(("revision 0 error. this should never happen.\n"));
	383	}
	384	}
	385
3593cab5	386	mutex_unlock(&dev->i2c_lock);
1da177e4 LT	387	return err;
	388	}
	389
	390	/* utility functions */
	391	static int saa7146_i2c_xfer(struct i2c_adapter* adapter, struct i2c_msg *msg, int num)
	392	{
	393	struct saa7146_dev* dev = i2c_get_adapdata(adapter);
	394
	395	/* use helper function to transfer data */
	396	return saa7146_i2c_transfer(dev, msg, num, adapter->retries);
	397	}
	398
	399
	400	/*****************************************************************************/
	401	/* i2c-adapter helper functions */
	402	#include <linux/i2c-id.h>
	403
	404	/* exported algorithm data */
	405	static struct i2c_algorithm saa7146_algo = {
1da177e4 LT	406	.master_xfer = saa7146_i2c_xfer,
	407	.functionality = saa7146_i2c_func,
	408	};
	409
	410	int saa7146_i2c_adapter_prepare(struct saa7146_dev dev, struct i2c_adapter i2c_adapter, u32 bitrate)
	411	{
	412	DEB_EE(("bitrate: 0x%08x\n",bitrate));
	413
	414	/* enable i2c-port pins */
	415	saa7146_write(dev, MC1, (MASK_08 \| MASK_24));
	416
	417	dev->i2c_bitrate = bitrate;
	418	saa7146_i2c_reset(dev);
	419
	420	if( NULL != i2c_adapter ) {
1da177e4 LT	421	BUG_ON(!i2c_adapter->class);
1da177e4 LT	422	i2c_set_adapdata(i2c_adapter,dev);
1ac2854c	423	i2c_adapter->dev.parent = &dev->pci->dev;
1da177e4 LT	424	i2c_adapter->algo = &saa7146_algo;
1da177e4 LT	425	i2c_adapter->algo_data = NULL;
1684a984	426	i2c_adapter->id = I2C_HW_SAA7146;
1da177e4 LT	427	i2c_adapter->timeout = SAA7146_I2C_TIMEOUT;
	428	i2c_adapter->retries = SAA7146_I2C_RETRIES;
	429	}
	430
	431	return 0;
	432	}