1/* -------------------------------------------------------------------------
2 * i2c-algo-bit.c i2c driver algorithms for bit-shift adapters
3 * -------------------------------------------------------------------------
4 *   Copyright (C) 1995-2000 Simon G. Vogl
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    GNU General Public License for more details.
15 * ------------------------------------------------------------------------- */
16
17/* With some changes from Frodo Looijaard <frodol@dds.nl>, Ky��sti M��lkki
18   <kmalkki@cc.hut.fi> and Jean Delvare <jdelvare@suse.de> */
19
20#include <linux/kernel.h>
21#include <linux/module.h>
22#include <linux/delay.h>
23#include <linux/errno.h>
24#include <linux/sched.h>
25#include <linux/i2c.h>
26#include <linux/i2c-algo-bit.h>
27
28
29/* ----- global defines ----------------------------------------------- */
30
31#ifdef DEBUG
32#define bit_dbg(level, dev, format, args...) \
33	do { \
34		if (i2c_debug >= level) \
35			dev_dbg(dev, format, ##args); \
36	} while (0)
37#else
38#define bit_dbg(level, dev, format, args...) \
39	do {} while (0)
40#endif /* DEBUG */
41
42/* ----- global variables ---------------------------------------------	*/
43
44static int bit_test;	/* see if the line-setting functions work	*/
45module_param(bit_test, int, S_IRUGO);
46MODULE_PARM_DESC(bit_test, "lines testing - 0 off; 1 report; 2 fail if stuck");
47
48#ifdef DEBUG
49static int i2c_debug = 1;
50module_param(i2c_debug, int, S_IRUGO | S_IWUSR);
51MODULE_PARM_DESC(i2c_debug,
52		 "debug level - 0 off; 1 normal; 2 verbose; 3 very verbose");
53#endif
54
55/* --- setting states on the bus with the right timing: ---------------	*/
56
57#define setsda(adap, val)	adap->setsda(adap->data, val)
58#define setscl(adap, val)	adap->setscl(adap->data, val)
59#define getsda(adap)		adap->getsda(adap->data)
60#define getscl(adap)		adap->getscl(adap->data)
61
62static inline void sdalo(struct i2c_algo_bit_data *adap)
63{
64	setsda(adap, 0);
65	udelay((adap->udelay + 1) / 2);
66}
67
68static inline void sdahi(struct i2c_algo_bit_data *adap)
69{
70	setsda(adap, 1);
71	udelay((adap->udelay + 1) / 2);
72}
73
74static inline void scllo(struct i2c_algo_bit_data *adap)
75{
76	setscl(adap, 0);
77	udelay(adap->udelay / 2);
78}
79
80/*
81 * Raise scl line, and do checking for delays. This is necessary for slower
82 * devices.
83 */
84static int sclhi(struct i2c_algo_bit_data *adap)
85{
86	unsigned long start;
87
88	setscl(adap, 1);
89
90	/* Not all adapters have scl sense line... */
91	if (!adap->getscl)
92		goto done;
93
94	start = jiffies;
95	while (!getscl(adap)) {
96		/* This hw knows how to read the clock line, so we wait
97		 * until it actually gets high.  This is safer as some
98		 * chips may hold it low ("clock stretching") while they
99		 * are processing data internally.
100		 */
101		if (time_after(jiffies, start + adap->timeout)) {
102			/* Test one last time, as we may have been preempted
103			 * between last check and timeout test.
104			 */
105			if (getscl(adap))
106				break;
107			return -ETIMEDOUT;
108		}
109		cpu_relax();
110	}
111#ifdef DEBUG
112	if (jiffies != start && i2c_debug >= 3)
113		pr_debug("i2c-algo-bit: needed %ld jiffies for SCL to go "
114			 "high\n", jiffies - start);
115#endif
116
117done:
118	udelay(adap->udelay);
119	return 0;
120}
121
122
123/* --- other auxiliary functions --------------------------------------	*/
124static void i2c_start(struct i2c_algo_bit_data *adap)
125{
126	/* assert: scl, sda are high */
127	setsda(adap, 0);
128	udelay(adap->udelay);
129	scllo(adap);
130}
131
132static void i2c_repstart(struct i2c_algo_bit_data *adap)
133{
134	/* assert: scl is low */
135	sdahi(adap);
136	sclhi(adap);
137	setsda(adap, 0);
138	udelay(adap->udelay);
139	scllo(adap);
140}
141
142
143static void i2c_stop(struct i2c_algo_bit_data *adap)
144{
145	/* assert: scl is low */
146	sdalo(adap);
147	sclhi(adap);
148	setsda(adap, 1);
149	udelay(adap->udelay);
150}
151
152
153
154/* send a byte without start cond., look for arbitration,
155   check ackn. from slave */
156/* returns:
157 * 1 if the device acknowledged
158 * 0 if the device did not ack
159 * -ETIMEDOUT if an error occurred (while raising the scl line)
160 */
161static int i2c_outb(struct i2c_adapter *i2c_adap, unsigned char c)
162{
163	int i;
164	int sb;
165	int ack;
166	struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
167
168	/* assert: scl is low */
169	for (i = 7; i >= 0; i--) {
170		sb = (c >> i) & 1;
171		setsda(adap, sb);
172		udelay((adap->udelay + 1) / 2);
173		if (sclhi(adap) < 0) { /* timed out */
174			bit_dbg(1, &i2c_adap->dev, "i2c_outb: 0x%02x, "
175				"timeout at bit #%d\n", (int)c, i);
176			return -ETIMEDOUT;
177		}
178		/* FIXME do arbitration here:
179		 * if (sb && !getsda(adap)) -> ouch! Get out of here.
180		 *
181		 * Report a unique code, so higher level code can retry
182		 * the whole (combined) message and *NOT* issue STOP.
183		 */
184		scllo(adap);
185	}
186	sdahi(adap);
187	if (sclhi(adap) < 0) { /* timeout */
188		bit_dbg(1, &i2c_adap->dev, "i2c_outb: 0x%02x, "
189			"timeout at ack\n", (int)c);
190		return -ETIMEDOUT;
191	}
192
193	/* read ack: SDA should be pulled down by slave, or it may
194	 * NAK (usually to report problems with the data we wrote).
195	 */
196	ack = !getsda(adap);    /* ack: sda is pulled low -> success */
197	bit_dbg(2, &i2c_adap->dev, "i2c_outb: 0x%02x %s\n", (int)c,
198		ack ? "A" : "NA");
199
200	scllo(adap);
201	return ack;
202	/* assert: scl is low (sda undef) */
203}
204
205
206static int i2c_inb(struct i2c_adapter *i2c_adap)
207{
208	/* read byte via i2c port, without start/stop sequence	*/
209	/* acknowledge is sent in i2c_read.			*/
210	int i;
211	unsigned char indata = 0;
212	struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
213
214	/* assert: scl is low */
215	sdahi(adap);
216	for (i = 0; i < 8; i++) {
217		if (sclhi(adap) < 0) { /* timeout */
218			bit_dbg(1, &i2c_adap->dev, "i2c_inb: timeout at bit "
219				"#%d\n", 7 - i);
220			return -ETIMEDOUT;
221		}
222		indata *= 2;
223		if (getsda(adap))
224			indata |= 0x01;
225		setscl(adap, 0);
226		udelay(i == 7 ? adap->udelay / 2 : adap->udelay);
227	}
228	/* assert: scl is low */
229	return indata;
230}
231
232/*
233 * Sanity check for the adapter hardware - check the reaction of
234 * the bus lines only if it seems to be idle.
235 */
236static int test_bus(struct i2c_adapter *i2c_adap)
237{
238	struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
239	const char *name = i2c_adap->name;
240	int scl, sda, ret;
241
242	if (adap->pre_xfer) {
243		ret = adap->pre_xfer(i2c_adap);
244		if (ret < 0)
245			return -ENODEV;
246	}
247
248	if (adap->getscl == NULL)
249		pr_info("%s: Testing SDA only, SCL is not readable\n", name);
250
251	sda = getsda(adap);
252	scl = (adap->getscl == NULL) ? 1 : getscl(adap);
253	if (!scl || !sda) {
254		printk(KERN_WARNING
255		       "%s: bus seems to be busy (scl=%d, sda=%d)\n",
256		       name, scl, sda);
257		goto bailout;
258	}
259
260	sdalo(adap);
261	sda = getsda(adap);
262	scl = (adap->getscl == NULL) ? 1 : getscl(adap);
263	if (sda) {
264		printk(KERN_WARNING "%s: SDA stuck high!\n", name);
265		goto bailout;
266	}
267	if (!scl) {
268		printk(KERN_WARNING "%s: SCL unexpected low "
269		       "while pulling SDA low!\n", name);
270		goto bailout;
271	}
272
273	sdahi(adap);
274	sda = getsda(adap);
275	scl = (adap->getscl == NULL) ? 1 : getscl(adap);
276	if (!sda) {
277		printk(KERN_WARNING "%s: SDA stuck low!\n", name);
278		goto bailout;
279	}
280	if (!scl) {
281		printk(KERN_WARNING "%s: SCL unexpected low "
282		       "while pulling SDA high!\n", name);
283		goto bailout;
284	}
285
286	scllo(adap);
287	sda = getsda(adap);
288	scl = (adap->getscl == NULL) ? 0 : getscl(adap);
289	if (scl) {
290		printk(KERN_WARNING "%s: SCL stuck high!\n", name);
291		goto bailout;
292	}
293	if (!sda) {
294		printk(KERN_WARNING "%s: SDA unexpected low "
295		       "while pulling SCL low!\n", name);
296		goto bailout;
297	}
298
299	sclhi(adap);
300	sda = getsda(adap);
301	scl = (adap->getscl == NULL) ? 1 : getscl(adap);
302	if (!scl) {
303		printk(KERN_WARNING "%s: SCL stuck low!\n", name);
304		goto bailout;
305	}
306	if (!sda) {
307		printk(KERN_WARNING "%s: SDA unexpected low "
308		       "while pulling SCL high!\n", name);
309		goto bailout;
310	}
311
312	if (adap->post_xfer)
313		adap->post_xfer(i2c_adap);
314
315	pr_info("%s: Test OK\n", name);
316	return 0;
317bailout:
318	sdahi(adap);
319	sclhi(adap);
320
321	if (adap->post_xfer)
322		adap->post_xfer(i2c_adap);
323
324	return -ENODEV;
325}
326
327/* ----- Utility functions
328 */
329
330/* try_address tries to contact a chip for a number of
331 * times before it gives up.
332 * return values:
333 * 1 chip answered
334 * 0 chip did not answer
335 * -x transmission error
336 */
337static int try_address(struct i2c_adapter *i2c_adap,
338		       unsigned char addr, int retries)
339{
340	struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
341	int i, ret = 0;
342
343	for (i = 0; i <= retries; i++) {
344		ret = i2c_outb(i2c_adap, addr);
345		if (ret == 1 || i == retries)
346			break;
347		bit_dbg(3, &i2c_adap->dev, "emitting stop condition\n");
348		i2c_stop(adap);
349		udelay(adap->udelay);
350		yield();
351		bit_dbg(3, &i2c_adap->dev, "emitting start condition\n");
352		i2c_start(adap);
353	}
354	if (i && ret)
355		bit_dbg(1, &i2c_adap->dev, "Used %d tries to %s client at "
356			"0x%02x: %s\n", i + 1,
357			addr & 1 ? "read from" : "write to", addr >> 1,
358			ret == 1 ? "success" : "failed, timeout?");
359	return ret;
360}
361
362static int sendbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
363{
364	const unsigned char *temp = msg->buf;
365	int count = msg->len;
366	unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK;
367	int retval;
368	int wrcount = 0;
369
370	while (count > 0) {
371		retval = i2c_outb(i2c_adap, *temp);
372
373		/* OK/ACK; or ignored NAK */
374		if ((retval > 0) || (nak_ok && (retval == 0))) {
375			count--;
376			temp++;
377			wrcount++;
378
379		/* A slave NAKing the master means the slave didn't like
380		 * something about the data it saw.  For example, maybe
381		 * the SMBus PEC was wrong.
382		 */
383		} else if (retval == 0) {
384			dev_err(&i2c_adap->dev, "sendbytes: NAK bailout.\n");
385			return -EIO;
386
387		/* Timeout; or (someday) lost arbitration
388		 *
389		 * FIXME Lost ARB implies retrying the transaction from
390		 * the first message, after the "winning" master issues
391		 * its STOP.  As a rule, upper layer code has no reason
392		 * to know or care about this ... it is *NOT* an error.
393		 */
394		} else {
395			dev_err(&i2c_adap->dev, "sendbytes: error %d\n",
396					retval);
397			return retval;
398		}
399	}
400	return wrcount;
401}
402
403static int acknak(struct i2c_adapter *i2c_adap, int is_ack)
404{
405	struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
406
407	/* assert: sda is high */
408	if (is_ack)		/* send ack */
409		setsda(adap, 0);
410	udelay((adap->udelay + 1) / 2);
411	if (sclhi(adap) < 0) {	/* timeout */
412		dev_err(&i2c_adap->dev, "readbytes: ack/nak timeout\n");
413		return -ETIMEDOUT;
414	}
415	scllo(adap);
416	return 0;
417}
418
419static int readbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
420{
421	int inval;
422	int rdcount = 0;	/* counts bytes read */
423	unsigned char *temp = msg->buf;
424	int count = msg->len;
425	const unsigned flags = msg->flags;
426
427	while (count > 0) {
428		inval = i2c_inb(i2c_adap);
429		if (inval >= 0) {
430			*temp = inval;
431			rdcount++;
432		} else {   /* read timed out */
433			break;
434		}
435
436		temp++;
437		count--;
438
439		/* Some SMBus transactions require that we receive the
440		   transaction length as the first read byte. */
441		if (rdcount == 1 && (flags & I2C_M_RECV_LEN)) {
442			if (inval <= 0 || inval > I2C_SMBUS_BLOCK_MAX) {
443				if (!(flags & I2C_M_NO_RD_ACK))
444					acknak(i2c_adap, 0);
445				dev_err(&i2c_adap->dev, "readbytes: invalid "
446					"block length (%d)\n", inval);
447				return -EPROTO;
448			}
449			/* The original count value accounts for the extra
450			   bytes, that is, either 1 for a regular transaction,
451			   or 2 for a PEC transaction. */
452			count += inval;
453			msg->len += inval;
454		}
455
456		bit_dbg(2, &i2c_adap->dev, "readbytes: 0x%02x %s\n",
457			inval,
458			(flags & I2C_M_NO_RD_ACK)
459				? "(no ack/nak)"
460				: (count ? "A" : "NA"));
461
462		if (!(flags & I2C_M_NO_RD_ACK)) {
463			inval = acknak(i2c_adap, count);
464			if (inval < 0)
465				return inval;
466		}
467	}
468	return rdcount;
469}
470
471/* doAddress initiates the transfer by generating the start condition (in
472 * try_address) and transmits the address in the necessary format to handle
473 * reads, writes as well as 10bit-addresses.
474 * returns:
475 *  0 everything went okay, the chip ack'ed, or IGNORE_NAK flag was set
476 * -x an error occurred (like: -ENXIO if the device did not answer, or
477 *	-ETIMEDOUT, for example if the lines are stuck...)
478 */
479static int bit_doAddress(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
480{
481	unsigned short flags = msg->flags;
482	unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK;
483	struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
484
485	unsigned char addr;
486	int ret, retries;
487
488	retries = nak_ok ? 0 : i2c_adap->retries;
489
490	if (flags & I2C_M_TEN) {
491		/* a ten bit address */
492		addr = 0xf0 | ((msg->addr >> 7) & 0x06);
493		bit_dbg(2, &i2c_adap->dev, "addr0: %d\n", addr);
494		/* try extended address code...*/
495		ret = try_address(i2c_adap, addr, retries);
496		if ((ret != 1) && !nak_ok)  {
497			dev_err(&i2c_adap->dev,
498				"died at extended address code\n");
499			return -ENXIO;
500		}
501		/* the remaining 8 bit address */
502		ret = i2c_outb(i2c_adap, msg->addr & 0xff);
503		if ((ret != 1) && !nak_ok) {
504			/* the chip did not ack / xmission error occurred */
505			dev_err(&i2c_adap->dev, "died at 2nd address code\n");
506			return -ENXIO;
507		}
508		if (flags & I2C_M_RD) {
509			bit_dbg(3, &i2c_adap->dev, "emitting repeated "
510				"start condition\n");
511			i2c_repstart(adap);
512			/* okay, now switch into reading mode */
513			addr |= 0x01;
514			ret = try_address(i2c_adap, addr, retries);
515			if ((ret != 1) && !nak_ok) {
516				dev_err(&i2c_adap->dev,
517					"died at repeated address code\n");
518				return -EIO;
519			}
520		}
521	} else {		/* normal 7bit address	*/
522		addr = msg->addr << 1;
523		if (flags & I2C_M_RD)
524			addr |= 1;
525		if (flags & I2C_M_REV_DIR_ADDR)
526			addr ^= 1;
527		ret = try_address(i2c_adap, addr, retries);
528		if ((ret != 1) && !nak_ok)
529			return -ENXIO;
530	}
531
532	return 0;
533}
534
535static int bit_xfer(struct i2c_adapter *i2c_adap,
536		    struct i2c_msg msgs[], int num)
537{
538	struct i2c_msg *pmsg;
539	struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
540	int i, ret;
541	unsigned short nak_ok;
542
543	if (adap->pre_xfer) {
544		ret = adap->pre_xfer(i2c_adap);
545		if (ret < 0)
546			return ret;
547	}
548
549	bit_dbg(3, &i2c_adap->dev, "emitting start condition\n");
550	i2c_start(adap);
551	for (i = 0; i < num; i++) {
552		pmsg = &msgs[i];
553		nak_ok = pmsg->flags & I2C_M_IGNORE_NAK;
554		if (!(pmsg->flags & I2C_M_NOSTART)) {
555			if (i) {
556				bit_dbg(3, &i2c_adap->dev, "emitting "
557					"repeated start condition\n");
558				i2c_repstart(adap);
559			}
560			ret = bit_doAddress(i2c_adap, pmsg);
561			if ((ret != 0) && !nak_ok) {
562				bit_dbg(1, &i2c_adap->dev, "NAK from "
563					"device addr 0x%02x msg #%d\n",
564					msgs[i].addr, i);
565				goto bailout;
566			}
567		}
568		if (pmsg->flags & I2C_M_RD) {
569			/* read bytes into buffer*/
570			ret = readbytes(i2c_adap, pmsg);
571			if (ret >= 1)
572				bit_dbg(2, &i2c_adap->dev, "read %d byte%s\n",
573					ret, ret == 1 ? "" : "s");
574			if (ret < pmsg->len) {
575				if (ret >= 0)
576					ret = -EIO;
577				goto bailout;
578			}
579		} else {
580			/* write bytes from buffer */
581			ret = sendbytes(i2c_adap, pmsg);
582			if (ret >= 1)
583				bit_dbg(2, &i2c_adap->dev, "wrote %d byte%s\n",
584					ret, ret == 1 ? "" : "s");
585			if (ret < pmsg->len) {
586				if (ret >= 0)
587					ret = -EIO;
588				goto bailout;
589			}
590		}
591	}
592	ret = i;
593
594bailout:
595	bit_dbg(3, &i2c_adap->dev, "emitting stop condition\n");
596	i2c_stop(adap);
597
598	if (adap->post_xfer)
599		adap->post_xfer(i2c_adap);
600	return ret;
601}
602
603static u32 bit_func(struct i2c_adapter *adap)
604{
605	return I2C_FUNC_I2C | I2C_FUNC_NOSTART | I2C_FUNC_SMBUS_EMUL |
606	       I2C_FUNC_SMBUS_READ_BLOCK_DATA |
607	       I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
608	       I2C_FUNC_10BIT_ADDR | I2C_FUNC_PROTOCOL_MANGLING;
609}
610
611
612/* -----exported algorithm data: -------------------------------------	*/
613
614const struct i2c_algorithm i2c_bit_algo = {
615	.master_xfer	= bit_xfer,
616	.functionality	= bit_func,
617};
618EXPORT_SYMBOL(i2c_bit_algo);
619
620/*
621 * registering functions to load algorithms at runtime
622 */
623static int __i2c_bit_add_bus(struct i2c_adapter *adap,
624			     int (*add_adapter)(struct i2c_adapter *))
625{
626	struct i2c_algo_bit_data *bit_adap = adap->algo_data;
627	int ret;
628
629	if (bit_test) {
630		ret = test_bus(adap);
631		if (bit_test >= 2 && ret < 0)
632			return -ENODEV;
633	}
634
635	/* register new adapter to i2c module... */
636	adap->algo = &i2c_bit_algo;
637	adap->retries = 3;
638
639	ret = add_adapter(adap);
640	if (ret < 0)
641		return ret;
642
643	/* Complain if SCL can't be read */
644	if (bit_adap->getscl == NULL) {
645		dev_warn(&adap->dev, "Not I2C compliant: can't read SCL\n");
646		dev_warn(&adap->dev, "Bus may be unreliable\n");
647	}
648	return 0;
649}
650
651int i2c_bit_add_bus(struct i2c_adapter *adap)
652{
653	return __i2c_bit_add_bus(adap, i2c_add_adapter);
654}
655EXPORT_SYMBOL(i2c_bit_add_bus);
656
657int i2c_bit_add_numbered_bus(struct i2c_adapter *adap)
658{
659	return __i2c_bit_add_bus(adap, i2c_add_numbered_adapter);
660}
661EXPORT_SYMBOL(i2c_bit_add_numbered_bus);
662
663MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
664MODULE_DESCRIPTION("I2C-Bus bit-banging algorithm");
665MODULE_LICENSE("GPL");
666