CTC++ Coverage Report - Execution Profile    #399/1532

Files Summary | Functions Summary | Execution Profile | Index | No Index
First | Previous | Next | Last

File: drivers/i2c/algos/i2c-algo-pca.c
Instrumentation mode: function-decision-multicondition
TER: 0 % ( 0/179)

Start/	End/
True	False	-	Line	Source
			1	/*
			2	*  i2c-algo-pca.c i2c driver algorithms for PCA9564 adapters
			3	*    Copyright (C) 2004 Arcom Control Systems
			4	*
			5	*  This program is free software; you can redistribute it and/or modify
			6	*  it under the terms of the GNU General Public License as published by
			7	*  the Free Software Foundation; either version 2 of the License, or
			8	*  (at your option) any later version.
			9	*
			10	*  This program is distributed in the hope that it will be useful,
			11	*  but WITHOUT ANY WARRANTY; without even the implied warranty of
			12	*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
			13	*  GNU General Public License for more details.
			14	*
			15	*  You should have received a copy of the GNU General Public License
			16	*  along with this program; if not, write to the Free Software
			17	*  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
			18	*/
			19
			20	#include <linux/kernel.h>
			21	#include <linux/module.h>
			22	#include <linux/moduleparam.h>
			23	#include <linux/delay.h>
			24	#include <linux/slab.h>
			25	#include <linux/init.h>
			26	#include <linux/errno.h>
			27	#include <linux/i2c.h>
			28	#include <linux/i2c-algo-pca.h>
			29	#include "i2c-algo-pca.h"
			30
			31	#define DRIVER "i2c-algo-pca"
			32
			33	#define DEB1(fmt, args...) do { if (i2c_debug>=1) printk(fmt, ## args); } while(0)
			34	#define DEB2(fmt, args...) do { if (i2c_debug>=2) printk(fmt, ## args); } while(0)
			35	#define DEB3(fmt, args...) do { if (i2c_debug>=3) printk(fmt, ## args); } while(0)
			36
			37	static int i2c_debug;
			38
			39	#define pca_outw(adap, reg, val) adap->write_byte(adap, reg, val)
			40	#define pca_inw(adap, reg) adap->read_byte(adap, reg)
			41
			42	#define pca_status(adap) pca_inw(adap, I2C_PCA_STA)
			43	#define pca_clock(adap) adap->get_clock(adap)
			44	#define pca_own(adap) adap->get_own(adap)
			45	#define pca_set_con(adap, val) pca_outw(adap, I2C_PCA_CON, val)
			46	#define pca_get_con(adap) pca_inw(adap, I2C_PCA_CON)
			47	#define pca_wait(adap) adap->wait_for_interrupt(adap)
			48
			49	/*
			50	* Generate a start condition on the i2c bus.
			51	*
			52	* returns after the start condition has occurred
			53	*/
0	0	-	54	static void pca_start(struct i2c_algo_pca_data *adap)
			55	{
			56	int sta = pca_get_con(adap);
			57	DEB2("=== START\n");
0	0	-	57	if (i2c_debug >= 2)
0	0	-	57	do-while (0)
			58	sta |= I2C_PCA_CON_STA;
			59	sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_SI);
			60	pca_set_con(adap, sta);
			61	pca_wait(adap);
			62	}
			63
			64	/*
			65	* Generate a repeated start condition on the i2c bus
			66	*
			67	* return after the repeated start condition has occurred
			68	*/
0	0	-	69	static void pca_repeated_start(struct i2c_algo_pca_data *adap)
			70	{
			71	int sta = pca_get_con(adap);
			72	DEB2("=== REPEATED START\n");
0	0	-	72	if (i2c_debug >= 2)
0	0	-	72	do-while (0)
			73	sta |= I2C_PCA_CON_STA;
			74	sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_SI);
			75	pca_set_con(adap, sta);
			76	pca_wait(adap);
			77	}
			78
			79	/*
			80	* Generate a stop condition on the i2c bus
			81	*
			82	* returns after the stop condition has been generated
			83	*
			84	* STOPs do not generate an interrupt or set the SI flag, since the
			85	* part returns the idle state (0xf8). Hence we don't need to
			86	* pca_wait here.
			87	*/
0	0	-	88	static void pca_stop(struct i2c_algo_pca_data *adap)
			89	{
			90	int sta = pca_get_con(adap);
			91	DEB2("=== STOP\n");
0	0	-	91	if (i2c_debug >= 2)
0	0	-	91	do-while (0)
			92	sta |= I2C_PCA_CON_STO;
			93	sta &= ~(I2C_PCA_CON_STA|I2C_PCA_CON_SI);
			94	pca_set_con(adap, sta);
			95	}
			96
			97	/*
			98	* Send the slave address and R/W bit
			99	*
			100	* returns after the address has been sent
			101	*/
0	0	-	102	static void pca_address(struct i2c_algo_pca_data *adap,
			103	struct i2c_msg *msg)
			104	{
			105	int sta = pca_get_con(adap);
			106	int addr;
			107
			108	addr = ( (0x7f & msg->addr) << 1 );
0	0	-	109	if (msg->flags & I2C_M_RD )
			110	addr |= 1;
			111	DEB2("=== SLAVE ADDRESS %#04x+%c=%#04x\n",
0	0	-	111	if (i2c_debug >= 2)
0	0	-	111	ternary-?: msg -> flags & 0x01
0	0	-	111	do-while (0)
			112	msg->addr, msg->flags & I2C_M_RD ? 'R' : 'W', addr);
			113
			114	pca_outw(adap, I2C_PCA_DAT, addr);
			115
			116	sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI);
			117	pca_set_con(adap, sta);
			118
			119	pca_wait(adap);
			120	}
			121
			122	/*
			123	* Transmit a byte.
			124	*
			125	* Returns after the byte has been transmitted
			126	*/
0	0	-	127	static void pca_tx_byte(struct i2c_algo_pca_data *adap,
			128	__u8 b)
			129	{
			130	int sta = pca_get_con(adap);
			131	DEB2("=== WRITE %#04x\n", b);
0	0	-	131	if (i2c_debug >= 2)
0	0	-	131	do-while (0)
			132	pca_outw(adap, I2C_PCA_DAT, b);
			133
			134	sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI);
			135	pca_set_con(adap, sta);
			136
			137	pca_wait(adap);
			138	}
			139
			140	/*
			141	* Receive a byte
			142	*
			143	* returns immediately.
			144	*/
0	0	-	145	static void pca_rx_byte(struct i2c_algo_pca_data *adap,
			146	__u8 *b, int ack)
			147	{
			148	*b = pca_inw(adap, I2C_PCA_DAT);
			149	DEB2("=== READ %#04x %s\n", *b, ack ? "ACK" : "NACK");
0	0	-	149	if (i2c_debug >= 2)
0	0	-	149	ternary-?: ack
0	0	-	149	do-while (0)
			150	}
			151
			152	/*
			153	* Setup ACK or NACK for next received byte and wait for it to arrive.
			154	*
			155	* Returns after next byte has arrived.
			156	*/
0	0	-	157	static void pca_rx_ack(struct i2c_algo_pca_data *adap,
			158	int ack)
			159	{
			160	int sta = pca_get_con(adap);
			161
			162	sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI|I2C_PCA_CON_AA);
			163
0	0	-	164	if ( ack )
			165	sta |= I2C_PCA_CON_AA;
			166
			167	pca_set_con(adap, sta);
			168	pca_wait(adap);
			169	}
			170
			171	/*
			172	* Reset the i2c bus / SIO
			173	*/
0	0	-	174	static void pca_reset(struct i2c_algo_pca_data *adap)
			175	{
			176	/* apparently only an external reset will do it. not a lot can be done */
			177	printk(KERN_ERR DRIVER ": Haven't figured out how to do a reset yet\n");
			178	}
			179
0	0	-	180	static int pca_xfer(struct i2c_adapter *i2c_adap,
			181	struct i2c_msg *msgs,
			182	int num)
			183	{
			184	struct i2c_algo_pca_data *adap = i2c_adap->algo_data;
			185	struct i2c_msg *msg = NULL;
			186	int curmsg;
			187	int numbytes = 0;
			188	int state;
			189	int ret;
			190	int timeout = 100;
			191
0	0	-	192	while ((state = pca_status(adap)) != 0xf8 && timeout--) {
0		-	192	T && T
	0	-	192	T && F
	0	-	192	F && _
			193	msleep(10);
			194	}
0	0	-	195	if (state != 0xf8) {
			196	dev_dbg(&i2c_adap->dev, "bus is not idle. status is %#04x\n", state);
0	0	-	196	do-while (0)
0		-	197	return -EIO;
			198	}
			199
			200	DEB1("{{{ XFER %d messages\n", num);
0	0	-	200	if (i2c_debug >= 1)
0	0	-	200	do-while (0)
			201
0	0	-	202	if (i2c_debug>=2) {
0	0	-	203	for (curmsg = 0; curmsg < num; curmsg++) {
			204	int addr, i;
			205	msg = &msgs[curmsg];
			206
			207	addr = (0x7f & msg->addr) ;
			208
0	0	-	209	if (msg->flags & I2C_M_RD )
			210	printk(KERN_INFO "    [%02d] RD %d bytes from %#02x [%#02x, ...]\n",
			211	curmsg, msg->len, addr, (addr<<1) | 1);
			212	else {
			213	printk(KERN_INFO "    [%02d] WR %d bytes to %#02x [%#02x%s",
			214	curmsg, msg->len, addr, addr<<1,
			215	msg->len == 0 ? "" : ", ");
0	0	-	215	ternary-?: msg -> len == 0
0	0	-	216	for(i=0; i < msg->len; i++)
			217	printk("%#04x%s", msg->buf[i], i == msg->len - 1 ? "" : ", ");
0	0	-	217	ternary-?: i == msg -> len - 1
			218	printk("]\n");
			219	}
			220	}
			221	}
			222
			223	curmsg = 0;
			224	ret = -EREMOTEIO;
0	0	-	225	while (curmsg < num) {
			226	state = pca_status(adap);
			227
			228	DEB3("STATE is 0x%02x\n", state);
0	0	-	228	if (i2c_debug >= 3)
0	0	-	228	do-while (0)
			229	msg = &msgs[curmsg];
			230
			231	switch (state) {
0		-	232	case 0xf8: /* On reset or stop the bus is idle */
			233	pca_start(adap);
0		-	234	break;
			235
0		-	236	case 0x08: /* A START condition has been transmitted */
0		-	237	case 0x10: /* A repeated start condition has been transmitted */
			238	pca_address(adap, msg);
0		-	239	break;
			240
0		-	241	case 0x18: /* SLA+W has been transmitted; ACK has been received */
0		-	242	case 0x28: /* Data byte in I2CDAT has been transmitted; ACK has been received */
0	0	-	243	if (numbytes < msg->len) {
			244	pca_tx_byte(adap, msg->buf[numbytes]);
			245	numbytes++;
0		-	246	break;
			247	}
			248	curmsg++; numbytes = 0;
0	0	-	249	if (curmsg == num)
			250	pca_stop(adap);
			251	else
			252	pca_repeated_start(adap);
0		-	253	break;
			254
0		-	255	case 0x20: /* SLA+W has been transmitted; NOT ACK has been received */
			256	DEB2("NOT ACK received after SLA+W\n");
0	0	-	256	if (i2c_debug >= 2)
0	0	-	256	do-while (0)
			257	pca_stop(adap);
0		-	258	goto out;
			259
0		-	260	case 0x40: /* SLA+R has been transmitted; ACK has been received */
			261	pca_rx_ack(adap, msg->len > 1);
0		-	262	break;
			263
0		-	264	case 0x50: /* Data bytes has been received; ACK has been returned */
0	0	-	265	if (numbytes < msg->len) {
			266	pca_rx_byte(adap, &msg->buf[numbytes], 1);
			267	numbytes++;
			268	pca_rx_ack(adap, numbytes < msg->len - 1);
0		-	269	break;
			270	}
			271	curmsg++; numbytes = 0;
0	0	-	272	if (curmsg == num)
			273	pca_stop(adap);
			274	else
			275	pca_repeated_start(adap);
0		-	276	break;
			277
0		-	278	case 0x48: /* SLA+R has been transmitted; NOT ACK has been received */
			279	DEB2("NOT ACK received after SLA+R\n");
0	0	-	279	if (i2c_debug >= 2)
0	0	-	279	do-while (0)
			280	pca_stop(adap);
0		-	281	goto out;
			282
0		-	283	case 0x30: /* Data byte in I2CDAT has been transmitted; NOT ACK has been received */
			284	DEB2("NOT ACK received after data byte\n");
0	0	-	284	if (i2c_debug >= 2)
0	0	-	284	do-while (0)
0		-	285	goto out;
			286
0		-	287	case 0x38: /* Arbitration lost during SLA+W, SLA+R or data bytes */
			288	DEB2("Arbitration lost\n");
0	0	-	288	if (i2c_debug >= 2)
0	0	-	288	do-while (0)
0		-	289	goto out;
			290
0		-	291	case 0x58: /* Data byte has been received; NOT ACK has been returned */
0	0	-	292	if ( numbytes == msg->len - 1 ) {
			293	pca_rx_byte(adap, &msg->buf[numbytes], 0);
			294	curmsg++; numbytes = 0;
0	0	-	295	if (curmsg == num)
			296	pca_stop(adap);
			297	else
			298	pca_repeated_start(adap);
			299	} else {
			300	DEB2("NOT ACK sent after data byte received. "
0	0	-	300	if (i2c_debug >= 2)
0	0	-	300	do-while (0)
			301	"Not final byte. numbytes %d. len %d\n",
			302	numbytes, msg->len);
			303	pca_stop(adap);
0		-	304	goto out;
			305	}
0		-	306	break;
0		-	307	case 0x70: /* Bus error - SDA stuck low */
			308	DEB2("BUS ERROR - SDA Stuck low\n");
0	0	-	308	if (i2c_debug >= 2)
0	0	-	308	do-while (0)
			309	pca_reset(adap);
0		-	310	goto out;
0		-	311	case 0x90: /* Bus error - SCL stuck low */
			312	DEB2("BUS ERROR - SCL Stuck low\n");
0	0	-	312	if (i2c_debug >= 2)
0	0	-	312	do-while (0)
			313	pca_reset(adap);
0		-	314	goto out;
0		-	315	case 0x00: /* Bus error during master or slave mode due to illegal START or STOP condition */
			316	DEB2("BUS ERROR - Illegal START or STOP\n");
0	0	-	316	if (i2c_debug >= 2)
0	0	-	316	do-while (0)
			317	pca_reset(adap);
0		-	318	goto out;
0		-	319	default:
			320	printk(KERN_ERR DRIVER ": unhandled SIO state 0x%02x\n", state);
0		-	321	break;
			322	}
			323
			324	}
			325
			326	ret = curmsg;
			327	out:
			328	DEB1(KERN_CRIT "}}} transfered %d/%d messages. "
0	0	-	328	if (i2c_debug >= 1)
0	0	-	328	do-while (0)
			329	"status is %#04x. control is %#04x\n",
			330	curmsg, num, pca_status(adap),
			331	pca_get_con(adap));
0		-	332	return ret;
			333	}
			334
0	0	-	335	static u32 pca_func(struct i2c_adapter *adap)
			336	{
0		-	337	return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
			338	}
			339
0	0	-	340	static int pca_init(struct i2c_algo_pca_data *adap)
			341	{
			342	static int freqs[] = {330,288,217,146,88,59,44,36};
			343	int own, clock;
			344
			345	own = pca_own(adap);
			346	clock = pca_clock(adap);
			347	DEB1(KERN_INFO DRIVER ": own address is %#04x\n", own);
0	0	-	347	if (i2c_debug >= 1)
0	0	-	347	do-while (0)
			348	DEB1(KERN_INFO DRIVER ": clock freqeuncy is %dkHz\n", freqs[clock]);
0	0	-	348	if (i2c_debug >= 1)
0	0	-	348	do-while (0)
			349
			350	pca_outw(adap, I2C_PCA_ADR, own << 1);
			351
			352	pca_set_con(adap, I2C_PCA_CON_ENSIO | clock);
			353	udelay(500); /* 500 µs for oscilator to stabilise */
0	0	-	353	ternary-?: __builtin_constant_p ( 500 )
0	0	-	353	ternary-?: ( 500 ) > 20000
			354
0		-	355	return 0;
			356	}
			357
			358	static struct i2c_algorithm pca_algo = {
			359	.master_xfer   = pca_xfer,
			360	.functionality   = pca_func,
			361	};
			362
			363	/*
			364	* registering functions to load algorithms at runtime
			365	*/
0	0	-	366	int i2c_pca_add_bus(struct i2c_adapter *adap)
			367	{
			368	struct i2c_algo_pca_data *pca_adap = adap->algo_data;
			369	int rval;
			370
			371	/* register new adapter to i2c module... */
			372	adap->algo = &pca_algo;
			373
			374	adap->timeout = 100;      /* default values, should   */
			375	adap->retries = 3;      /* be replaced by defines   */
			376
			377	rval = pca_init(pca_adap);
			378
0	0	-	379	if (!rval)
			380	i2c_add_adapter(adap);
			381
0		-	382	return rval;
			383	}
			384
0	0	-	385	int i2c_pca_del_bus(struct i2c_adapter *adap)
			386	{
0		-	387	return i2c_del_adapter(adap);
			388	}
			389
			390	EXPORT_SYMBOL(i2c_pca_add_bus);
			391	EXPORT_SYMBOL(i2c_pca_del_bus);
			392
			393	MODULE_AUTHOR("Ian Campbell <icampbell@arcom.com>");
			394	MODULE_DESCRIPTION("I2C-Bus PCA9564 algorithm");
			395	MODULE_LICENSE("GPL");
			396
0	0	-	397	module_param(i2c_debug, int, 0);
0		-	397	return ( & ( i2c_debug ) )
***TER 0% (0/179) of SOURCE FILE i2c-algo-pca.c

Files Summary | Functions Summary | Execution Profile | Index | No Index
First | Previous | Next | Last | Top