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 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 /* With some changes from Frodo Looijaard <frodol@dds.nl>, Ky�sti M�lkki 22 <kmalkki@cc.hut.fi> and Jean Delvare <khali@linux-fr.org> */ 23 24 #include <linux/kernel.h> 25 #include <linux/module.h> 26 #include <linux/delay.h> 27 #include <linux/slab.h> 28 #include <linux/init.h> 29 #include <linux/errno.h> 30 #include <linux/sched.h> 31 #include <linux/i2c.h> 32 #include <linux/i2c-algo-bit.h> 33 34 35 /* ----- global defines ----------------------------------------------- */ 36 #define DEB(x) if (i2c_debug>=1) x; 37 #define DEB2(x) if (i2c_debug>=2) x; 38 #define DEBSTAT(x) if (i2c_debug>=3) x; /* print several statistical values*/ 39 #define DEBPROTO(x) if (i2c_debug>=9) { x; } 40 /* debug the protocol by showing transferred bits */ 41 42 43 /* ----- global variables --------------------------------------------- */ 44 45 /* module parameters: 46 */ 47 static int i2c_debug; 48 static int bit_test; /* see if the line-setting functions work */ 49 50 /* --- setting states on the bus with the right timing: --------------- */ 51 52 #define setsda(adap,val) adap->setsda(adap->data, val) 53 #define setscl(adap,val) adap->setscl(adap->data, val) 54 #define getsda(adap) adap->getsda(adap->data) 55 #define getscl(adap) adap->getscl(adap->data) 56 57 static inline void sdalo(struct i2c_algo_bit_data *adap) 58 { 59 setsda(adap,0); 60 udelay(adap->udelay); 61 } 62 63 static inline void sdahi(struct i2c_algo_bit_data *adap) 64 { 65 setsda(adap,1); 66 udelay(adap->udelay); 67 } 68 69 static inline void scllo(struct i2c_algo_bit_data *adap) 70 { 71 setscl(adap,0); 72 udelay(adap->udelay); 73 } 74 75 /* 76 * Raise scl line, and do checking for delays. This is necessary for slower 77 * devices. 78 */ 79 static inline int sclhi(struct i2c_algo_bit_data *adap) 80 { 81 unsigned long start; 82 83 setscl(adap,1); 84 85 /* Not all adapters have scl sense line... */ 86 if (adap->getscl == NULL ) { 87 udelay(adap->udelay); 88 return 0; 89 } 90 91 start=jiffies; 92 while (! getscl(adap) ) { 93 /* the hw knows how to read the clock line, 94 * so we wait until it actually gets high. 95 * This is safer as some chips may hold it low 96 * while they are processing data internally. 97 */ 98 if (time_after_eq(jiffies, start+adap->timeout)) { 99 return -ETIMEDOUT; 100 } 101 cond_resched(); 102 } 103 DEBSTAT(printk(KERN_DEBUG "needed %ld jiffies\n", jiffies-start)); 104 udelay(adap->udelay); 105 return 0; 106 } 107 108 109 /* --- other auxiliary functions -------------------------------------- */ 110 static void i2c_start(struct i2c_algo_bit_data *adap) 111 { 112 /* assert: scl, sda are high */ 113 DEBPROTO(printk("S ")); 114 sdalo(adap); 115 scllo(adap); 116 } 117 118 static void i2c_repstart(struct i2c_algo_bit_data *adap) 119 { 120 /* scl, sda may not be high */ 121 DEBPROTO(printk(" Sr ")); 122 setsda(adap,1); 123 sclhi(adap); 124 udelay(adap->udelay); 125 126 sdalo(adap); 127 scllo(adap); 128 } 129 130 131 static void i2c_stop(struct i2c_algo_bit_data *adap) 132 { 133 DEBPROTO(printk("P\n")); 134 /* assert: scl is low */ 135 sdalo(adap); 136 sclhi(adap); 137 sdahi(adap); 138 } 139 140 141 142 /* send a byte without start cond., look for arbitration, 143 check ackn. from slave */ 144 /* returns: 145 * 1 if the device acknowledged 146 * 0 if the device did not ack 147 * -ETIMEDOUT if an error occurred (while raising the scl line) 148 */ 149 static int i2c_outb(struct i2c_adapter *i2c_adap, char c) 150 { 151 int i; 152 int sb; 153 int ack; 154 struct i2c_algo_bit_data *adap = i2c_adap->algo_data; 155 156 /* assert: scl is low */ 157 for ( i=7 ; i>=0 ; i-- ) { 158 sb = c & ( 1 << i ); 159 setsda(adap,sb); 160 udelay(adap->udelay); 161 DEBPROTO(printk(KERN_DEBUG "%d",sb!=0)); 162 if (sclhi(adap)<0) { /* timed out */ 163 sdahi(adap); /* we don't want to block the net */ 164 DEB2(printk(KERN_DEBUG " i2c_outb: 0x%02x, timeout at bit #%d\n", c&0xff, i)); 165 return -ETIMEDOUT; 166 }; 167 /* do arbitration here: 168 * if ( sb && ! getsda(adap) ) -> ouch! Get out of here. 169 */ 170 setscl(adap, 0 ); 171 udelay(adap->udelay); 172 } 173 sdahi(adap); 174 if (sclhi(adap)<0){ /* timeout */ 175 DEB2(printk(KERN_DEBUG " i2c_outb: 0x%02x, timeout at ack\n", c&0xff)); 176 return -ETIMEDOUT; 177 }; 178 /* read ack: SDA should be pulled down by slave */ 179 ack=getsda(adap); /* ack: sda is pulled low ->success. */ 180 DEB2(printk(KERN_DEBUG " i2c_outb: 0x%02x , getsda() = %d\n", c & 0xff, ack)); 181 182 DEBPROTO( printk(KERN_DEBUG "[%2.2x]",c&0xff) ); 183 DEBPROTO(if (0==ack){ printk(KERN_DEBUG " A ");} else printk(KERN_DEBUG " NA ") ); 184 scllo(adap); 185 return 0==ack; /* return 1 if device acked */ 186 /* assert: scl is low (sda undef) */ 187 } 188 189 190 static int i2c_inb(struct i2c_adapter *i2c_adap) 191 { 192 /* read byte via i2c port, without start/stop sequence */ 193 /* acknowledge is sent in i2c_read. */ 194 int i; 195 unsigned char indata=0; 196 struct i2c_algo_bit_data *adap = i2c_adap->algo_data; 197 198 /* assert: scl is low */ 199 sdahi(adap); 200 for (i=0;i<8;i++) { 201 if (sclhi(adap)<0) { /* timeout */ 202 DEB2(printk(KERN_DEBUG " i2c_inb: timeout at bit #%d\n", 7-i)); 203 return -ETIMEDOUT; 204 }; 205 indata *= 2; 206 if ( getsda(adap) ) 207 indata |= 0x01; 208 scllo(adap); 209 } 210 /* assert: scl is low */ 211 DEB2(printk(KERN_DEBUG "i2c_inb: 0x%02x\n", indata & 0xff)); 212 213 DEBPROTO(printk(KERN_DEBUG " 0x%02x", indata & 0xff)); 214 return (int) (indata & 0xff); 215 } 216 217 /* 218 * Sanity check for the adapter hardware - check the reaction of 219 * the bus lines only if it seems to be idle. 220 */ 221 static int test_bus(struct i2c_algo_bit_data *adap, char* name) { 222 int scl,sda; 223 224 if (adap->getscl==NULL) 225 printk(KERN_INFO "i2c-algo-bit.o: Testing SDA only, " 226 "SCL is not readable.\n"); 227 228 sda=getsda(adap); 229 scl=(adap->getscl==NULL?1:getscl(adap)); 230 printk(KERN_DEBUG "i2c-algo-bit.o: (0) scl=%d, sda=%d\n",scl,sda); 231 if (!scl || !sda ) { 232 printk(KERN_WARNING "i2c-algo-bit.o: %s seems to be busy.\n", name); 233 goto bailout; 234 } 235 236 sdalo(adap); 237 sda=getsda(adap); 238 scl=(adap->getscl==NULL?1:getscl(adap)); 239 printk(KERN_DEBUG "i2c-algo-bit.o: (1) scl=%d, sda=%d\n",scl,sda); 240 if ( 0 != sda ) { 241 printk(KERN_WARNING "i2c-algo-bit.o: SDA stuck high!\n"); 242 goto bailout; 243 } 244 if ( 0 == scl ) { 245 printk(KERN_WARNING "i2c-algo-bit.o: SCL unexpected low " 246 "while pulling SDA low!\n"); 247 goto bailout; 248 } 249 250 sdahi(adap); 251 sda=getsda(adap); 252 scl=(adap->getscl==NULL?1:getscl(adap)); 253 printk(KERN_DEBUG "i2c-algo-bit.o: (2) scl=%d, sda=%d\n",scl,sda); 254 if ( 0 == sda ) { 255 printk(KERN_WARNING "i2c-algo-bit.o: SDA stuck low!\n"); 256 goto bailout; 257 } 258 if ( 0 == scl ) { 259 printk(KERN_WARNING "i2c-algo-bit.o: SCL unexpected low " 260 "while pulling SDA high!\n"); 261 goto bailout; 262 } 263 264 scllo(adap); 265 sda=getsda(adap); 266 scl=(adap->getscl==NULL?0:getscl(adap)); 267 printk(KERN_DEBUG "i2c-algo-bit.o: (3) scl=%d, sda=%d\n",scl,sda); 268 if ( 0 != scl ) { 269 printk(KERN_WARNING "i2c-algo-bit.o: SCL stuck high!\n"); 270 goto bailout; 271 } 272 if ( 0 == sda ) { 273 printk(KERN_WARNING "i2c-algo-bit.o: SDA unexpected low " 274 "while pulling SCL low!\n"); 275 goto bailout; 276 } 277 278 sclhi(adap); 279 sda=getsda(adap); 280 scl=(adap->getscl==NULL?1:getscl(adap)); 281 printk(KERN_DEBUG "i2c-algo-bit.o: (4) scl=%d, sda=%d\n",scl,sda); 282 if ( 0 == scl ) { 283 printk(KERN_WARNING "i2c-algo-bit.o: SCL stuck low!\n"); 284 goto bailout; 285 } 286 if ( 0 == sda ) { 287 printk(KERN_WARNING "i2c-algo-bit.o: SDA unexpected low " 288 "while pulling SCL high!\n"); 289 goto bailout; 290 } 291 printk(KERN_INFO "i2c-algo-bit.o: %s passed test.\n",name); 292 return 0; 293 bailout: 294 sdahi(adap); 295 sclhi(adap); 296 return -ENODEV; 297 } 298 299 /* ----- Utility functions 300 */ 301 302 /* try_address tries to contact a chip for a number of 303 * times before it gives up. 304 * return values: 305 * 1 chip answered 306 * 0 chip did not answer 307 * -x transmission error 308 */ 309 static inline int try_address(struct i2c_adapter *i2c_adap, 310 unsigned char addr, int retries) 311 { 312 struct i2c_algo_bit_data *adap = i2c_adap->algo_data; 313 int i,ret = -1; 314 for (i=0;i<=retries;i++) { 315 ret = i2c_outb(i2c_adap,addr); 316 if (ret==1) 317 break; /* success! */ 318 i2c_stop(adap); 319 udelay(5/*adap->udelay*/); 320 if (i==retries) /* no success */ 321 break; 322 i2c_start(adap); 323 udelay(adap->udelay); 324 } 325 DEB2(if (i) 326 printk(KERN_DEBUG "i2c-algo-bit.o: Used %d tries to %s client at 0x%02x : %s\n", 327 i+1, addr & 1 ? "read" : "write", addr>>1, 328 ret==1 ? "success" : ret==0 ? "no ack" : "failed, timeout?" ) 329 ); 330 return ret; 331 } 332 333 static int sendbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg) 334 { 335 struct i2c_algo_bit_data *adap = i2c_adap->algo_data; 336 char c; 337 const char *temp = msg->buf; 338 int count = msg->len; 339 unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK; 340 int retval; 341 int wrcount=0; 342 343 while (count > 0) { 344 c = *temp; 345 DEB2(dev_dbg(&i2c_adap->dev, "sendbytes: writing %2.2X\n", c&0xff)); 346 retval = i2c_outb(i2c_adap,c); 347 if ((retval>0) || (nak_ok && (retval==0))) { /* ok or ignored NAK */ 348 count--; 349 temp++; 350 wrcount++; 351 } else { /* arbitration or no acknowledge */ 352 dev_err(&i2c_adap->dev, "sendbytes: error - bailout.\n"); 353 i2c_stop(adap); 354 return (retval<0)? retval : -EFAULT; 355 /* got a better one ?? */ 356 } 357 #if 0 358 /* from asm/delay.h */ 359 __delay(adap->mdelay * (loops_per_sec / 1000) ); 360 #endif 361 } 362 return wrcount; 363 } 364 365 static inline int readbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg) 366 { 367 int inval; 368 int rdcount=0; /* counts bytes read */ 369 struct i2c_algo_bit_data *adap = i2c_adap->algo_data; 370 char *temp = msg->buf; 371 int count = msg->len; 372 373 while (count > 0) { 374 inval = i2c_inb(i2c_adap); 375 /*printk("%#02x ",inval); if ( ! (count % 16) ) printk("\n"); */ 376 if (inval>=0) { 377 *temp = inval; 378 rdcount++; 379 } else { /* read timed out */ 380 printk(KERN_ERR "i2c-algo-bit.o: readbytes: i2c_inb timed out.\n"); 381 break; 382 } 383 384 temp++; 385 count--; 386 387 if (msg->flags & I2C_M_NO_RD_ACK) 388 continue; 389 390 if ( count > 0 ) { /* send ack */ 391 sdalo(adap); 392 DEBPROTO(printk(" Am ")); 393 } else { 394 sdahi(adap); /* neg. ack on last byte */ 395 DEBPROTO(printk(" NAm ")); 396 } 397 if (sclhi(adap)<0) { /* timeout */ 398 sdahi(adap); 399 printk(KERN_ERR "i2c-algo-bit.o: readbytes: Timeout at ack\n"); 400 return -ETIMEDOUT; 401 }; 402 scllo(adap); 403 sdahi(adap); 404 } 405 return rdcount; 406 } 407 408 /* doAddress initiates the transfer by generating the start condition (in 409 * try_address) and transmits the address in the necessary format to handle 410 * reads, writes as well as 10bit-addresses. 411 * returns: 412 * 0 everything went okay, the chip ack'ed, or IGNORE_NAK flag was set 413 * -x an error occurred (like: -EREMOTEIO if the device did not answer, or 414 * -ETIMEDOUT, for example if the lines are stuck...) 415 */ 416 static inline int bit_doAddress(struct i2c_adapter *i2c_adap, struct i2c_msg *msg) 417 { 418 unsigned short flags = msg->flags; 419 unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK; 420 struct i2c_algo_bit_data *adap = i2c_adap->algo_data; 421 422 unsigned char addr; 423 int ret, retries; 424 425 retries = nak_ok ? 0 : i2c_adap->retries; 426 427 if ( (flags & I2C_M_TEN) ) { 428 /* a ten bit address */ 429 addr = 0xf0 | (( msg->addr >> 7) & 0x03); 430 DEB2(printk(KERN_DEBUG "addr0: %d\n",addr)); 431 /* try extended address code...*/ 432 ret = try_address(i2c_adap, addr, retries); 433 if ((ret != 1) && !nak_ok) { 434 printk(KERN_ERR "died at extended address code.\n"); 435 return -EREMOTEIO; 436 } 437 /* the remaining 8 bit address */ 438 ret = i2c_outb(i2c_adap,msg->addr & 0x7f); 439 if ((ret != 1) && !nak_ok) { 440 /* the chip did not ack / xmission error occurred */ 441 printk(KERN_ERR "died at 2nd address code.\n"); 442 return -EREMOTEIO; 443 } 444 if ( flags & I2C_M_RD ) { 445 i2c_repstart(adap); 446 /* okay, now switch into reading mode */ 447 addr |= 0x01; 448 ret = try_address(i2c_adap, addr, retries); 449 if ((ret!=1) && !nak_ok) { 450 printk(KERN_ERR "died at extended address code.\n"); 451 return -EREMOTEIO; 452 } 453 } 454 } else { /* normal 7bit address */ 455 addr = ( msg->addr << 1 ); 456 if (flags & I2C_M_RD ) 457 addr |= 1; 458 if (flags & I2C_M_REV_DIR_ADDR ) 459 addr ^= 1; 460 ret = try_address(i2c_adap, addr, retries); 461 if ((ret!=1) && !nak_ok) 462 return -EREMOTEIO; 463 } 464 465 return 0; 466 } 467 468 static int bit_xfer(struct i2c_adapter *i2c_adap, 469 struct i2c_msg msgs[], int num) 470 { 471 struct i2c_msg *pmsg; 472 struct i2c_algo_bit_data *adap = i2c_adap->algo_data; 473 474 int i,ret; 475 unsigned short nak_ok; 476 477 i2c_start(adap); 478 for (i=0;i<num;i++) { 479 pmsg = &msgs[i]; 480 nak_ok = pmsg->flags & I2C_M_IGNORE_NAK; 481 if (!(pmsg->flags & I2C_M_NOSTART)) { 482 if (i) { 483 i2c_repstart(adap); 484 } 485 ret = bit_doAddress(i2c_adap, pmsg); 486 if ((ret != 0) && !nak_ok) { 487 DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: NAK from device addr %2.2x msg #%d\n" 488 ,msgs[i].addr,i)); 489 return (ret<0) ? ret : -EREMOTEIO; 490 } 491 } 492 if (pmsg->flags & I2C_M_RD ) { 493 /* read bytes into buffer*/ 494 ret = readbytes(i2c_adap, pmsg); 495 DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: read %d bytes.\n",ret)); 496 if (ret < pmsg->len ) { 497 return (ret<0)? ret : -EREMOTEIO; 498 } 499 } else { 500 /* write bytes from buffer */ 501 ret = sendbytes(i2c_adap, pmsg); 502 DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: wrote %d bytes.\n",ret)); 503 if (ret < pmsg->len ) { 504 return (ret<0) ? ret : -EREMOTEIO; 505 } 506 } 507 } 508 i2c_stop(adap); 509 return num; 510 } 511 512 static u32 bit_func(struct i2c_adapter *adap) 513 { 514 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | 515 I2C_FUNC_10BIT_ADDR | I2C_FUNC_PROTOCOL_MANGLING; 516 } 517 518 519 /* -----exported algorithm data: ------------------------------------- */ 520 521 static struct i2c_algorithm i2c_bit_algo = { 522 .name = "Bit-shift algorithm", 523 .id = I2C_ALGO_BIT, 524 .master_xfer = bit_xfer, 525 .functionality = bit_func, 526 }; 527 528 /* 529 * registering functions to load algorithms at runtime 530 */ 531 int i2c_bit_add_bus(struct i2c_adapter *adap) 532 { 533 struct i2c_algo_bit_data *bit_adap = adap->algo_data; 534 535 if (bit_test) { 536 int ret = test_bus(bit_adap, adap->name); 537 if (ret<0) 538 return -ENODEV; 539 } 540 541 DEB2(dev_dbg(&adap->dev, "hw routines registered.\n")); 542 543 /* register new adapter to i2c module... */ 544 545 adap->id |= i2c_bit_algo.id; 546 adap->algo = &i2c_bit_algo; 547 548 adap->timeout = 100; /* default values, should */ 549 adap->retries = 3; /* be replaced by defines */ 550 551 i2c_add_adapter(adap); 552 return 0; 553 } 554 555 556 int i2c_bit_del_bus(struct i2c_adapter *adap) 557 { 558 return i2c_del_adapter(adap); 559 } 560 561 EXPORT_SYMBOL(i2c_bit_add_bus); 562 EXPORT_SYMBOL(i2c_bit_del_bus); 563 564 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>"); 565 MODULE_DESCRIPTION("I2C-Bus bit-banging algorithm"); 566 MODULE_LICENSE("GPL"); 567 568 module_param(bit_test, bool, 0); 569 module_param(i2c_debug, int, S_IRUGO | S_IWUSR); 570 571 MODULE_PARM_DESC(bit_test, "Test the lines of the bus to see if it is stuck"); 572 MODULE_PARM_DESC(i2c_debug, 573 "debug level - 0 off; 1 normal; 2,3 more verbose; 9 bit-protocol"); 574