xref: /openbmc/linux/drivers/i2c/algos/i2c-algo-pca.c (revision b6dcefde)
1 /*
2  *  i2c-algo-pca.c i2c driver algorithms for PCA9564 adapters
3  *    Copyright (C) 2004 Arcom Control Systems
4  *    Copyright (C) 2008 Pengutronix
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  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, write to the Free Software
18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */
20 
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/moduleparam.h>
24 #include <linux/delay.h>
25 #include <linux/jiffies.h>
26 #include <linux/init.h>
27 #include <linux/errno.h>
28 #include <linux/i2c.h>
29 #include <linux/i2c-algo-pca.h>
30 
31 #define DEB1(fmt, args...) do { if (i2c_debug >= 1)			\
32 				 printk(KERN_DEBUG fmt, ## args); } while (0)
33 #define DEB2(fmt, args...) do { if (i2c_debug >= 2)			\
34 				 printk(KERN_DEBUG fmt, ## args); } while (0)
35 #define DEB3(fmt, args...) do { if (i2c_debug >= 3)			\
36 				 printk(KERN_DEBUG fmt, ## args); } while (0)
37 
38 static int i2c_debug;
39 
40 #define pca_outw(adap, reg, val) adap->write_byte(adap->data, reg, val)
41 #define pca_inw(adap, reg) adap->read_byte(adap->data, reg)
42 
43 #define pca_status(adap) pca_inw(adap, I2C_PCA_STA)
44 #define pca_clock(adap) adap->i2c_clock
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_completion(adap->data)
48 #define pca_reset(adap) adap->reset_chip(adap->data)
49 
50 static void pca9665_reset(void *pd)
51 {
52 	struct i2c_algo_pca_data *adap = pd;
53 	pca_outw(adap, I2C_PCA_INDPTR, I2C_PCA_IPRESET);
54 	pca_outw(adap, I2C_PCA_IND, 0xA5);
55 	pca_outw(adap, I2C_PCA_IND, 0x5A);
56 }
57 
58 /*
59  * Generate a start condition on the i2c bus.
60  *
61  * returns after the start condition has occurred
62  */
63 static int pca_start(struct i2c_algo_pca_data *adap)
64 {
65 	int sta = pca_get_con(adap);
66 	DEB2("=== START\n");
67 	sta |= I2C_PCA_CON_STA;
68 	sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_SI);
69 	pca_set_con(adap, sta);
70 	return pca_wait(adap);
71 }
72 
73 /*
74  * Generate a repeated start condition on the i2c bus
75  *
76  * return after the repeated start condition has occurred
77  */
78 static int pca_repeated_start(struct i2c_algo_pca_data *adap)
79 {
80 	int sta = pca_get_con(adap);
81 	DEB2("=== REPEATED START\n");
82 	sta |= I2C_PCA_CON_STA;
83 	sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_SI);
84 	pca_set_con(adap, sta);
85 	return pca_wait(adap);
86 }
87 
88 /*
89  * Generate a stop condition on the i2c bus
90  *
91  * returns after the stop condition has been generated
92  *
93  * STOPs do not generate an interrupt or set the SI flag, since the
94  * part returns the idle state (0xf8). Hence we don't need to
95  * pca_wait here.
96  */
97 static void pca_stop(struct i2c_algo_pca_data *adap)
98 {
99 	int sta = pca_get_con(adap);
100 	DEB2("=== STOP\n");
101 	sta |= I2C_PCA_CON_STO;
102 	sta &= ~(I2C_PCA_CON_STA|I2C_PCA_CON_SI);
103 	pca_set_con(adap, sta);
104 }
105 
106 /*
107  * Send the slave address and R/W bit
108  *
109  * returns after the address has been sent
110  */
111 static int pca_address(struct i2c_algo_pca_data *adap,
112 			struct i2c_msg *msg)
113 {
114 	int sta = pca_get_con(adap);
115 	int addr;
116 
117 	addr = ( (0x7f & msg->addr) << 1 );
118 	if (msg->flags & I2C_M_RD )
119 		addr |= 1;
120 	DEB2("=== SLAVE ADDRESS %#04x+%c=%#04x\n",
121 	     msg->addr, msg->flags & I2C_M_RD ? 'R' : 'W', addr);
122 
123 	pca_outw(adap, I2C_PCA_DAT, addr);
124 
125 	sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI);
126 	pca_set_con(adap, sta);
127 
128 	return pca_wait(adap);
129 }
130 
131 /*
132  * Transmit a byte.
133  *
134  * Returns after the byte has been transmitted
135  */
136 static int pca_tx_byte(struct i2c_algo_pca_data *adap,
137 			__u8 b)
138 {
139 	int sta = pca_get_con(adap);
140 	DEB2("=== WRITE %#04x\n", b);
141 	pca_outw(adap, I2C_PCA_DAT, b);
142 
143 	sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI);
144 	pca_set_con(adap, sta);
145 
146 	return pca_wait(adap);
147 }
148 
149 /*
150  * Receive a byte
151  *
152  * returns immediately.
153  */
154 static void pca_rx_byte(struct i2c_algo_pca_data *adap,
155 			__u8 *b, int ack)
156 {
157 	*b = pca_inw(adap, I2C_PCA_DAT);
158 	DEB2("=== READ %#04x %s\n", *b, ack ? "ACK" : "NACK");
159 }
160 
161 /*
162  * Setup ACK or NACK for next received byte and wait for it to arrive.
163  *
164  * Returns after next byte has arrived.
165  */
166 static int pca_rx_ack(struct i2c_algo_pca_data *adap,
167 		       int ack)
168 {
169 	int sta = pca_get_con(adap);
170 
171 	sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI|I2C_PCA_CON_AA);
172 
173 	if ( ack )
174 		sta |= I2C_PCA_CON_AA;
175 
176 	pca_set_con(adap, sta);
177 	return pca_wait(adap);
178 }
179 
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 completed = 1;
191 	unsigned long timeout = jiffies + i2c_adap->timeout;
192 
193 	while ((state = pca_status(adap)) != 0xf8) {
194 		if (time_before(jiffies, timeout)) {
195 			msleep(10);
196 		} else {
197 			dev_dbg(&i2c_adap->dev, "bus is not idle. status is "
198 				"%#04x\n", state);
199 			return -EAGAIN;
200 		}
201 	}
202 
203 	DEB1("{{{ XFER %d messages\n", num);
204 
205 	if (i2c_debug>=2) {
206 		for (curmsg = 0; curmsg < num; curmsg++) {
207 			int addr, i;
208 			msg = &msgs[curmsg];
209 
210 			addr = (0x7f & msg->addr) ;
211 
212 			if (msg->flags & I2C_M_RD )
213 				printk(KERN_INFO "    [%02d] RD %d bytes from %#02x [%#02x, ...]\n",
214 				       curmsg, msg->len, addr, (addr<<1) | 1);
215 			else {
216 				printk(KERN_INFO "    [%02d] WR %d bytes to %#02x [%#02x%s",
217 				       curmsg, msg->len, addr, addr<<1,
218 				       msg->len == 0 ? "" : ", ");
219 				for(i=0; i < msg->len; i++)
220 					printk("%#04x%s", msg->buf[i], i == msg->len - 1 ? "" : ", ");
221 				printk("]\n");
222 			}
223 		}
224 	}
225 
226 	curmsg = 0;
227 	ret = -EREMOTEIO;
228 	while (curmsg < num) {
229 		state = pca_status(adap);
230 
231 		DEB3("STATE is 0x%02x\n", state);
232 		msg = &msgs[curmsg];
233 
234 		switch (state) {
235 		case 0xf8: /* On reset or stop the bus is idle */
236 			completed = pca_start(adap);
237 			break;
238 
239 		case 0x08: /* A START condition has been transmitted */
240 		case 0x10: /* A repeated start condition has been transmitted */
241 			completed = pca_address(adap, msg);
242 			break;
243 
244 		case 0x18: /* SLA+W has been transmitted; ACK has been received */
245 		case 0x28: /* Data byte in I2CDAT has been transmitted; ACK has been received */
246 			if (numbytes < msg->len) {
247 				completed = pca_tx_byte(adap,
248 							msg->buf[numbytes]);
249 				numbytes++;
250 				break;
251 			}
252 			curmsg++; numbytes = 0;
253 			if (curmsg == num)
254 				pca_stop(adap);
255 			else
256 				completed = pca_repeated_start(adap);
257 			break;
258 
259 		case 0x20: /* SLA+W has been transmitted; NOT ACK has been received */
260 			DEB2("NOT ACK received after SLA+W\n");
261 			pca_stop(adap);
262 			goto out;
263 
264 		case 0x40: /* SLA+R has been transmitted; ACK has been received */
265 			completed = pca_rx_ack(adap, msg->len > 1);
266 			break;
267 
268 		case 0x50: /* Data bytes has been received; ACK has been returned */
269 			if (numbytes < msg->len) {
270 				pca_rx_byte(adap, &msg->buf[numbytes], 1);
271 				numbytes++;
272 				completed = pca_rx_ack(adap,
273 						       numbytes < msg->len - 1);
274 				break;
275 			}
276 			curmsg++; numbytes = 0;
277 			if (curmsg == num)
278 				pca_stop(adap);
279 			else
280 				completed = pca_repeated_start(adap);
281 			break;
282 
283 		case 0x48: /* SLA+R has been transmitted; NOT ACK has been received */
284 			DEB2("NOT ACK received after SLA+R\n");
285 			pca_stop(adap);
286 			goto out;
287 
288 		case 0x30: /* Data byte in I2CDAT has been transmitted; NOT ACK has been received */
289 			DEB2("NOT ACK received after data byte\n");
290 			pca_stop(adap);
291 			goto out;
292 
293 		case 0x38: /* Arbitration lost during SLA+W, SLA+R or data bytes */
294 			DEB2("Arbitration lost\n");
295 			/*
296 			 * The PCA9564 data sheet (2006-09-01) says "A
297 			 * START condition will be transmitted when the
298 			 * bus becomes free (STOP or SCL and SDA high)"
299 			 * when the STA bit is set (p. 11).
300 			 *
301 			 * In case this won't work, try pca_reset()
302 			 * instead.
303 			 */
304 			pca_start(adap);
305 			goto out;
306 
307 		case 0x58: /* Data byte has been received; NOT ACK has been returned */
308 			if ( numbytes == msg->len - 1 ) {
309 				pca_rx_byte(adap, &msg->buf[numbytes], 0);
310 				curmsg++; numbytes = 0;
311 				if (curmsg == num)
312 					pca_stop(adap);
313 				else
314 					completed = pca_repeated_start(adap);
315 			} else {
316 				DEB2("NOT ACK sent after data byte received. "
317 				     "Not final byte. numbytes %d. len %d\n",
318 				     numbytes, msg->len);
319 				pca_stop(adap);
320 				goto out;
321 			}
322 			break;
323 		case 0x70: /* Bus error - SDA stuck low */
324 			DEB2("BUS ERROR - SDA Stuck low\n");
325 			pca_reset(adap);
326 			goto out;
327 		case 0x90: /* Bus error - SCL stuck low */
328 			DEB2("BUS ERROR - SCL Stuck low\n");
329 			pca_reset(adap);
330 			goto out;
331 		case 0x00: /* Bus error during master or slave mode due to illegal START or STOP condition */
332 			DEB2("BUS ERROR - Illegal START or STOP\n");
333 			pca_reset(adap);
334 			goto out;
335 		default:
336 			dev_err(&i2c_adap->dev, "unhandled SIO state 0x%02x\n", state);
337 			break;
338 		}
339 
340 		if (!completed)
341 			goto out;
342 	}
343 
344 	ret = curmsg;
345  out:
346 	DEB1("}}} transfered %d/%d messages. "
347 	     "status is %#04x. control is %#04x\n",
348 	     curmsg, num, pca_status(adap),
349 	     pca_get_con(adap));
350 	return ret;
351 }
352 
353 static u32 pca_func(struct i2c_adapter *adap)
354 {
355         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
356 }
357 
358 static const struct i2c_algorithm pca_algo = {
359 	.master_xfer	= pca_xfer,
360 	.functionality	= pca_func,
361 };
362 
363 static unsigned int pca_probe_chip(struct i2c_adapter *adap)
364 {
365 	struct i2c_algo_pca_data *pca_data = adap->algo_data;
366 	/* The trick here is to check if there is an indirect register
367 	 * available. If there is one, we will read the value we first
368 	 * wrote on I2C_PCA_IADR. Otherwise, we will read the last value
369 	 * we wrote on I2C_PCA_ADR
370 	 */
371 	pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_IADR);
372 	pca_outw(pca_data, I2C_PCA_IND, 0xAA);
373 	pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_ITO);
374 	pca_outw(pca_data, I2C_PCA_IND, 0x00);
375 	pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_IADR);
376 	if (pca_inw(pca_data, I2C_PCA_IND) == 0xAA) {
377 		printk(KERN_INFO "%s: PCA9665 detected.\n", adap->name);
378 		return I2C_PCA_CHIP_9665;
379 	} else {
380 		printk(KERN_INFO "%s: PCA9564 detected.\n", adap->name);
381 		return I2C_PCA_CHIP_9564;
382 	}
383 }
384 
385 static int pca_init(struct i2c_adapter *adap)
386 {
387 	struct i2c_algo_pca_data *pca_data = adap->algo_data;
388 
389 	adap->algo = &pca_algo;
390 
391 	if (pca_probe_chip(adap) == I2C_PCA_CHIP_9564) {
392 		static int freqs[] = {330, 288, 217, 146, 88, 59, 44, 36};
393 		int clock;
394 
395 		if (pca_data->i2c_clock > 7) {
396 			switch (pca_data->i2c_clock) {
397 			case 330000:
398 				pca_data->i2c_clock = I2C_PCA_CON_330kHz;
399 				break;
400 			case 288000:
401 				pca_data->i2c_clock = I2C_PCA_CON_288kHz;
402 				break;
403 			case 217000:
404 				pca_data->i2c_clock = I2C_PCA_CON_217kHz;
405 				break;
406 			case 146000:
407 				pca_data->i2c_clock = I2C_PCA_CON_146kHz;
408 				break;
409 			case 88000:
410 				pca_data->i2c_clock = I2C_PCA_CON_88kHz;
411 				break;
412 			case 59000:
413 				pca_data->i2c_clock = I2C_PCA_CON_59kHz;
414 				break;
415 			case 44000:
416 				pca_data->i2c_clock = I2C_PCA_CON_44kHz;
417 				break;
418 			case 36000:
419 				pca_data->i2c_clock = I2C_PCA_CON_36kHz;
420 				break;
421 			default:
422 				printk(KERN_WARNING
423 					"%s: Invalid I2C clock speed selected."
424 					" Using default 59kHz.\n", adap->name);
425 			pca_data->i2c_clock = I2C_PCA_CON_59kHz;
426 			}
427 		} else {
428 			printk(KERN_WARNING "%s: "
429 				"Choosing the clock frequency based on "
430 				"index is deprecated."
431 				" Use the nominal frequency.\n", adap->name);
432 		}
433 
434 		pca_reset(pca_data);
435 
436 		clock = pca_clock(pca_data);
437 		printk(KERN_INFO "%s: Clock frequency is %dkHz\n",
438 		     adap->name, freqs[clock]);
439 
440 		pca_set_con(pca_data, I2C_PCA_CON_ENSIO | clock);
441 	} else {
442 		int clock;
443 		int mode;
444 		int tlow, thi;
445 		/* Values can be found on PCA9665 datasheet section 7.3.2.6 */
446 		int min_tlow, min_thi;
447 		/* These values are the maximum raise and fall values allowed
448 		 * by the I2C operation mode (Standard, Fast or Fast+)
449 		 * They are used (added) below to calculate the clock dividers
450 		 * of PCA9665. Note that they are slightly different of the
451 		 * real maximum, to allow the change on mode exactly on the
452 		 * maximum clock rate for each mode
453 		 */
454 		int raise_fall_time;
455 
456 		struct i2c_algo_pca_data *pca_data = adap->algo_data;
457 
458 		/* Ignore the reset function from the module,
459 		 * we can use the parallel bus reset
460 		 */
461 		pca_data->reset_chip = pca9665_reset;
462 
463 		if (pca_data->i2c_clock > 1265800) {
464 			printk(KERN_WARNING "%s: I2C clock speed too high."
465 				" Using 1265.8kHz.\n", adap->name);
466 			pca_data->i2c_clock = 1265800;
467 		}
468 
469 		if (pca_data->i2c_clock < 60300) {
470 			printk(KERN_WARNING "%s: I2C clock speed too low."
471 				" Using 60.3kHz.\n", adap->name);
472 			pca_data->i2c_clock = 60300;
473 		}
474 
475 		/* To avoid integer overflow, use clock/100 for calculations */
476 		clock = pca_clock(pca_data) / 100;
477 
478 		if (pca_data->i2c_clock > 10000) {
479 			mode = I2C_PCA_MODE_TURBO;
480 			min_tlow = 14;
481 			min_thi  = 5;
482 			raise_fall_time = 22; /* Raise 11e-8s, Fall 11e-8s */
483 		} else if (pca_data->i2c_clock > 4000) {
484 			mode = I2C_PCA_MODE_FASTP;
485 			min_tlow = 17;
486 			min_thi  = 9;
487 			raise_fall_time = 22; /* Raise 11e-8s, Fall 11e-8s */
488 		} else if (pca_data->i2c_clock > 1000) {
489 			mode = I2C_PCA_MODE_FAST;
490 			min_tlow = 44;
491 			min_thi  = 20;
492 			raise_fall_time = 58; /* Raise 29e-8s, Fall 29e-8s */
493 		} else {
494 			mode = I2C_PCA_MODE_STD;
495 			min_tlow = 157;
496 			min_thi  = 134;
497 			raise_fall_time = 127; /* Raise 29e-8s, Fall 98e-8s */
498 		}
499 
500 		/* The minimum clock that respects the thi/tlow = 134/157 is
501 		 * 64800 Hz. Below that, we have to fix the tlow to 255 and
502 		 * calculate the thi factor.
503 		 */
504 		if (clock < 648) {
505 			tlow = 255;
506 			thi = 1000000 - clock * raise_fall_time;
507 			thi /= (I2C_PCA_OSC_PER * clock) - tlow;
508 		} else {
509 			tlow = (1000000 - clock * raise_fall_time) * min_tlow;
510 			tlow /= I2C_PCA_OSC_PER * clock * (min_thi + min_tlow);
511 			thi = tlow * min_thi / min_tlow;
512 		}
513 
514 		pca_reset(pca_data);
515 
516 		printk(KERN_INFO
517 		     "%s: Clock frequency is %dHz\n", adap->name, clock * 100);
518 
519 		pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_IMODE);
520 		pca_outw(pca_data, I2C_PCA_IND, mode);
521 		pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_ISCLL);
522 		pca_outw(pca_data, I2C_PCA_IND, tlow);
523 		pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_ISCLH);
524 		pca_outw(pca_data, I2C_PCA_IND, thi);
525 
526 		pca_set_con(pca_data, I2C_PCA_CON_ENSIO);
527 	}
528 	udelay(500); /* 500 us for oscilator to stabilise */
529 
530 	return 0;
531 }
532 
533 /*
534  * registering functions to load algorithms at runtime
535  */
536 int i2c_pca_add_bus(struct i2c_adapter *adap)
537 {
538 	int rval;
539 
540 	rval = pca_init(adap);
541 	if (rval)
542 		return rval;
543 
544 	return i2c_add_adapter(adap);
545 }
546 EXPORT_SYMBOL(i2c_pca_add_bus);
547 
548 int i2c_pca_add_numbered_bus(struct i2c_adapter *adap)
549 {
550 	int rval;
551 
552 	rval = pca_init(adap);
553 	if (rval)
554 		return rval;
555 
556 	return i2c_add_numbered_adapter(adap);
557 }
558 EXPORT_SYMBOL(i2c_pca_add_numbered_bus);
559 
560 MODULE_AUTHOR("Ian Campbell <icampbell@arcom.com>, "
561 	"Wolfram Sang <w.sang@pengutronix.de>");
562 MODULE_DESCRIPTION("I2C-Bus PCA9564/PCA9665 algorithm");
563 MODULE_LICENSE("GPL");
564 
565 module_param(i2c_debug, int, 0);
566