WebSVN - shark - Blame - Rev 774 - /shark/trunk/drivers/cm7326/saa7146

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

Subversion Repositories shark

(root)/shark/trunk/drivers/cm7326/saa7146_i2c.c - Rev 774