1/*!*************************************************************************** 2*! 3*! FILE NAME : i2c.c 4*! 5*! DESCRIPTION: implements an interface for IIC/I2C, both directly from other 6*! kernel modules (i2c_writereg/readreg) and from userspace using 7*! ioctl()'s 8*! 9*! Nov 30 1998 Torbjorn Eliasson Initial version. 10*! Bjorn Wesen Elinux kernel version. 11*! Jan 14 2000 Johan Adolfsson Fixed PB shadow register stuff - 12*! don't use PB_I2C if DS1302 uses same bits, 13*! use PB. 14*| June 23 2003 Pieter Grimmerink Added 'i2c_sendnack'. i2c_readreg now 15*| generates nack on last received byte, 16*| instead of ack. 17*| i2c_getack changed data level while clock 18*| was high, causing DS75 to see a stop condition 19*! 20*! --------------------------------------------------------------------------- 21*! 22*! (C) Copyright 1999-2002 Axis Communications AB, LUND, SWEDEN 23*! 24*!***************************************************************************/ 25/* $Id: i2c.c,v 1.1.1.1 2007-08-03 18:51:41 $ */ 26/****************** INCLUDE FILES SECTION ***********************************/ 27 28#include <linux/module.h> 29#include <linux/sched.h> 30#include <linux/slab.h> 31#include <linux/errno.h> 32#include <linux/kernel.h> 33#include <linux/fs.h> 34#include <linux/string.h> 35#include <linux/init.h> 36 37#include <asm/etraxi2c.h> 38 39#include <asm/system.h> 40#include <asm/io.h> 41#include <asm/delay.h> 42 43#include "i2c.h" 44 45/****************** I2C DEFINITION SECTION *************************/ 46 47#define D(x) 48 49#define I2C_MAJOR 123 /* LOCAL/EXPERIMENTAL */ 50static const char i2c_name[] = "i2c"; 51 52#define CLOCK_LOW_TIME 8 53#define CLOCK_HIGH_TIME 8 54#define START_CONDITION_HOLD_TIME 8 55#define STOP_CONDITION_HOLD_TIME 8 56#define ENABLE_OUTPUT 0x01 57#define ENABLE_INPUT 0x00 58#define I2C_CLOCK_HIGH 1 59#define I2C_CLOCK_LOW 0 60#define I2C_DATA_HIGH 1 61#define I2C_DATA_LOW 0 62 63#define i2c_enable() 64#define i2c_disable() 65 66/* enable or disable output-enable, to select output or input on the i2c bus */ 67 68#define i2c_dir_out() crisv32_io_set_dir(&cris_i2c_data, crisv32_io_dir_out) 69#define i2c_dir_in() crisv32_io_set_dir(&cris_i2c_data, crisv32_io_dir_in) 70 71/* control the i2c clock and data signals */ 72 73#define i2c_clk(x) crisv32_io_set(&cris_i2c_clk, x) 74#define i2c_data(x) crisv32_io_set(&cris_i2c_data, x) 75 76/* read a bit from the i2c interface */ 77 78#define i2c_getbit() crisv32_io_rd(&cris_i2c_data) 79 80#define i2c_delay(usecs) udelay(usecs) 81 82/****************** VARIABLE SECTION ************************************/ 83 84static struct crisv32_iopin cris_i2c_clk; 85static struct crisv32_iopin cris_i2c_data; 86 87/****************** FUNCTION DEFINITION SECTION *************************/ 88 89 90/* generate i2c start condition */ 91 92void 93i2c_start(void) 94{ 95 /* 96 * SCL=1 SDA=1 97 */ 98 i2c_dir_out(); 99 i2c_delay(CLOCK_HIGH_TIME/6); 100 i2c_data(I2C_DATA_HIGH); 101 i2c_clk(I2C_CLOCK_HIGH); 102 i2c_delay(CLOCK_HIGH_TIME); 103 /* 104 * SCL=1 SDA=0 105 */ 106 i2c_data(I2C_DATA_LOW); 107 i2c_delay(START_CONDITION_HOLD_TIME); 108 /* 109 * SCL=0 SDA=0 110 */ 111 i2c_clk(I2C_CLOCK_LOW); 112 i2c_delay(CLOCK_LOW_TIME); 113} 114 115/* generate i2c stop condition */ 116 117void 118i2c_stop(void) 119{ 120 i2c_dir_out(); 121 122 /* 123 * SCL=0 SDA=0 124 */ 125 i2c_clk(I2C_CLOCK_LOW); 126 i2c_data(I2C_DATA_LOW); 127 i2c_delay(CLOCK_LOW_TIME*2); 128 /* 129 * SCL=1 SDA=0 130 */ 131 i2c_clk(I2C_CLOCK_HIGH); 132 i2c_delay(CLOCK_HIGH_TIME*2); 133 /* 134 * SCL=1 SDA=1 135 */ 136 i2c_data(I2C_DATA_HIGH); 137 i2c_delay(STOP_CONDITION_HOLD_TIME); 138 139 i2c_dir_in(); 140} 141 142/* write a byte to the i2c interface */ 143 144void 145i2c_outbyte(unsigned char x) 146{ 147 int i; 148 149 i2c_dir_out(); 150 151 for (i = 0; i < 8; i++) { 152 if (x & 0x80) { 153 i2c_data(I2C_DATA_HIGH); 154 } else { 155 i2c_data(I2C_DATA_LOW); 156 } 157 158 i2c_delay(CLOCK_LOW_TIME/2); 159 i2c_clk(I2C_CLOCK_HIGH); 160 i2c_delay(CLOCK_HIGH_TIME); 161 i2c_clk(I2C_CLOCK_LOW); 162 i2c_delay(CLOCK_LOW_TIME/2); 163 x <<= 1; 164 } 165 i2c_data(I2C_DATA_LOW); 166 i2c_delay(CLOCK_LOW_TIME/2); 167 168 /* 169 * enable input 170 */ 171 i2c_dir_in(); 172} 173 174/* read a byte from the i2c interface */ 175 176unsigned char 177i2c_inbyte(void) 178{ 179 unsigned char aBitByte = 0; 180 int i; 181 182 /* Switch off I2C to get bit */ 183 i2c_disable(); 184 i2c_dir_in(); 185 i2c_delay(CLOCK_HIGH_TIME/2); 186 187 /* Get bit */ 188 aBitByte |= i2c_getbit(); 189 190 /* Enable I2C */ 191 i2c_enable(); 192 i2c_delay(CLOCK_LOW_TIME/2); 193 194 for (i = 1; i < 8; i++) { 195 aBitByte <<= 1; 196 /* Clock pulse */ 197 i2c_clk(I2C_CLOCK_HIGH); 198 i2c_delay(CLOCK_HIGH_TIME); 199 i2c_clk(I2C_CLOCK_LOW); 200 i2c_delay(CLOCK_LOW_TIME); 201 202 /* Switch off I2C to get bit */ 203 i2c_disable(); 204 i2c_dir_in(); 205 i2c_delay(CLOCK_HIGH_TIME/2); 206 207 /* Get bit */ 208 aBitByte |= i2c_getbit(); 209 210 /* Enable I2C */ 211 i2c_enable(); 212 i2c_delay(CLOCK_LOW_TIME/2); 213 } 214 i2c_clk(I2C_CLOCK_HIGH); 215 i2c_delay(CLOCK_HIGH_TIME); 216 217 /* 218 * we leave the clock low, getbyte is usually followed 219 * by sendack/nack, they assume the clock to be low 220 */ 221 i2c_clk(I2C_CLOCK_LOW); 222 return aBitByte; 223} 224 225/*#--------------------------------------------------------------------------- 226*# 227*# FUNCTION NAME: i2c_getack 228*# 229*# DESCRIPTION : checks if ack was received from ic2 230*# 231*#--------------------------------------------------------------------------*/ 232 233int 234i2c_getack(void) 235{ 236 int ack = 1; 237 /* 238 * enable output 239 */ 240 i2c_dir_out(); 241 /* 242 * Release data bus by setting 243 * data high 244 */ 245 i2c_data(I2C_DATA_HIGH); 246 /* 247 * enable input 248 */ 249 i2c_dir_in(); 250 i2c_delay(CLOCK_HIGH_TIME/4); 251 /* 252 * generate ACK clock pulse 253 */ 254 i2c_clk(I2C_CLOCK_HIGH); 255 /* 256 * Use PORT PB instead of I2C 257 * for input. (I2C not working) 258 */ 259 i2c_clk(1); 260 i2c_data(1); 261 /* 262 * switch off I2C 263 */ 264 i2c_data(1); 265 i2c_disable(); 266 i2c_dir_in(); 267 /* 268 * now wait for ack 269 */ 270 i2c_delay(CLOCK_HIGH_TIME/2); 271 /* 272 * check for ack 273 */ 274 if(i2c_getbit()) 275 ack = 0; 276 i2c_delay(CLOCK_HIGH_TIME/2); 277 if(!ack){ 278 if(!i2c_getbit()) /* receiver pulld SDA low */ 279 ack = 1; 280 i2c_delay(CLOCK_HIGH_TIME/2); 281 } 282 283 /* 284 * our clock is high now, make sure data is low 285 * before we enable our output. If we keep data high 286 * and enable output, we would generate a stop condition. 287 */ 288 i2c_data(I2C_DATA_LOW); 289 290 /* 291 * end clock pulse 292 */ 293 i2c_enable(); 294 i2c_dir_out(); 295 i2c_clk(I2C_CLOCK_LOW); 296 i2c_delay(CLOCK_HIGH_TIME/4); 297 /* 298 * enable output 299 */ 300 i2c_dir_out(); 301 /* 302 * remove ACK clock pulse 303 */ 304 i2c_data(I2C_DATA_HIGH); 305 i2c_delay(CLOCK_LOW_TIME/2); 306 return ack; 307} 308 309/*#--------------------------------------------------------------------------- 310*# 311*# FUNCTION NAME: I2C::sendAck 312*# 313*# DESCRIPTION : Send ACK on received data 314*# 315*#--------------------------------------------------------------------------*/ 316void 317i2c_sendack(void) 318{ 319 /* 320 * enable output 321 */ 322 i2c_delay(CLOCK_LOW_TIME); 323 i2c_dir_out(); 324 /* 325 * set ack pulse high 326 */ 327 i2c_data(I2C_DATA_LOW); 328 /* 329 * generate clock pulse 330 */ 331 i2c_delay(CLOCK_HIGH_TIME/6); 332 i2c_clk(I2C_CLOCK_HIGH); 333 i2c_delay(CLOCK_HIGH_TIME); 334 i2c_clk(I2C_CLOCK_LOW); 335 i2c_delay(CLOCK_LOW_TIME/6); 336 /* 337 * reset data out 338 */ 339 i2c_data(I2C_DATA_HIGH); 340 i2c_delay(CLOCK_LOW_TIME); 341 342 i2c_dir_in(); 343} 344 345/*#--------------------------------------------------------------------------- 346*# 347*# FUNCTION NAME: i2c_sendnack 348*# 349*# DESCRIPTION : Sends NACK on received data 350*# 351*#--------------------------------------------------------------------------*/ 352void 353i2c_sendnack(void) 354{ 355 /* 356 * enable output 357 */ 358 i2c_delay(CLOCK_LOW_TIME); 359 i2c_dir_out(); 360 /* 361 * set data high 362 */ 363 i2c_data(I2C_DATA_HIGH); 364 /* 365 * generate clock pulse 366 */ 367 i2c_delay(CLOCK_HIGH_TIME/6); 368 i2c_clk(I2C_CLOCK_HIGH); 369 i2c_delay(CLOCK_HIGH_TIME); 370 i2c_clk(I2C_CLOCK_LOW); 371 i2c_delay(CLOCK_LOW_TIME); 372 373 i2c_dir_in(); 374} 375 376/*#--------------------------------------------------------------------------- 377*# 378*# FUNCTION NAME: i2c_writereg 379*# 380*# DESCRIPTION : Writes a value to an I2C device 381*# 382*#--------------------------------------------------------------------------*/ 383int 384i2c_writereg(unsigned char theSlave, unsigned char theReg, 385 unsigned char theValue) 386{ 387 int error, cntr = 3; 388 unsigned long flags; 389 390 do { 391 error = 0; 392 /* 393 * we don't like to be interrupted 394 */ 395 local_irq_save(flags); 396 397 i2c_start(); 398 /* 399 * send slave address 400 */ 401 i2c_outbyte((theSlave & 0xfe)); 402 /* 403 * wait for ack 404 */ 405 if(!i2c_getack()) 406 error = 1; 407 /* 408 * now select register 409 */ 410 i2c_dir_out(); 411 i2c_outbyte(theReg); 412 /* 413 * now it's time to wait for ack 414 */ 415 if(!i2c_getack()) 416 error |= 2; 417 /* 418 * send register register data 419 */ 420 i2c_outbyte(theValue); 421 /* 422 * now it's time to wait for ack 423 */ 424 if(!i2c_getack()) 425 error |= 4; 426 /* 427 * end byte stream 428 */ 429 i2c_stop(); 430 /* 431 * enable interrupt again 432 */ 433 local_irq_restore(flags); 434 435 } while(error && cntr--); 436 437 i2c_delay(CLOCK_LOW_TIME); 438 439 return -error; 440} 441 442/*#--------------------------------------------------------------------------- 443*# 444*# FUNCTION NAME: i2c_readreg 445*# 446*# DESCRIPTION : Reads a value from the decoder registers. 447*# 448*#--------------------------------------------------------------------------*/ 449unsigned char 450i2c_readreg(unsigned char theSlave, unsigned char theReg) 451{ 452 unsigned char b = 0; 453 int error, cntr = 3; 454 unsigned long flags; 455 456 do { 457 error = 0; 458 /* 459 * we don't like to be interrupted 460 */ 461 local_irq_save(flags); 462 /* 463 * generate start condition 464 */ 465 i2c_start(); 466 467 /* 468 * send slave address 469 */ 470 i2c_outbyte((theSlave & 0xfe)); 471 /* 472 * wait for ack 473 */ 474 if(!i2c_getack()) 475 error = 1; 476 /* 477 * now select register 478 */ 479 i2c_dir_out(); 480 i2c_outbyte(theReg); 481 /* 482 * now it's time to wait for ack 483 */ 484 if(!i2c_getack()) 485 error = 1; 486 /* 487 * repeat start condition 488 */ 489 i2c_delay(CLOCK_LOW_TIME); 490 i2c_start(); 491 /* 492 * send slave address 493 */ 494 i2c_outbyte(theSlave | 0x01); 495 /* 496 * wait for ack 497 */ 498 if(!i2c_getack()) 499 error = 1; 500 /* 501 * fetch register 502 */ 503 b = i2c_inbyte(); 504 /* 505 * last received byte needs to be nacked 506 * instead of acked 507 */ 508 i2c_sendnack(); 509 /* 510 * end sequence 511 */ 512 i2c_stop(); 513 /* 514 * enable interrupt again 515 */ 516 local_irq_restore(flags); 517 518 } while(error && cntr--); 519 520 return b; 521} 522 523static int 524i2c_open(struct inode *inode, struct file *filp) 525{ 526 return 0; 527} 528 529static int 530i2c_release(struct inode *inode, struct file *filp) 531{ 532 return 0; 533} 534 535/* Main device API. ioctl's to write or read to/from i2c registers. 536 */ 537 538static int 539i2c_ioctl(struct inode *inode, struct file *file, 540 unsigned int cmd, unsigned long arg) 541{ 542 if(_IOC_TYPE(cmd) != ETRAXI2C_IOCTYPE) { 543 return -EINVAL; 544 } 545 546 switch (_IOC_NR(cmd)) { 547 case I2C_WRITEREG: 548 /* write to an i2c slave */ 549 D(printk("i2cw %d %d %d\n", 550 I2C_ARGSLAVE(arg), 551 I2C_ARGREG(arg), 552 I2C_ARGVALUE(arg))); 553 554 return i2c_writereg(I2C_ARGSLAVE(arg), 555 I2C_ARGREG(arg), 556 I2C_ARGVALUE(arg)); 557 case I2C_READREG: 558 { 559 unsigned char val; 560 /* read from an i2c slave */ 561 D(printk("i2cr %d %d ", 562 I2C_ARGSLAVE(arg), 563 I2C_ARGREG(arg))); 564 val = i2c_readreg(I2C_ARGSLAVE(arg), I2C_ARGREG(arg)); 565 D(printk("= %d\n", val)); 566 return val; 567 } 568 default: 569 return -EINVAL; 570 571 } 572 573 return 0; 574} 575 576static const struct file_operations i2c_fops = { 577 owner: THIS_MODULE, 578 ioctl: i2c_ioctl, 579 open: i2c_open, 580 release: i2c_release, 581}; 582 583int __init 584i2c_init(void) 585{ 586 int res; 587 588 /* Setup and enable the Port B I2C interface */ 589 590 crisv32_io_get_name(&cris_i2c_data, CONFIG_ETRAX_I2C_DATA_PORT); 591 crisv32_io_get_name(&cris_i2c_clk, CONFIG_ETRAX_I2C_CLK_PORT); 592 593 /* register char device */ 594 595 res = register_chrdev(I2C_MAJOR, i2c_name, &i2c_fops); 596 if(res < 0) { 597 printk(KERN_ERR "i2c: couldn't get a major number.\n"); 598 return res; 599 } 600 601 printk(KERN_INFO "I2C driver v2.2, (c) 1999-2001 Axis Communications AB\n"); 602 603 return 0; 604} 605 606/* this makes sure that i2c_init is called during boot */ 607 608module_init(i2c_init); 609 610/****************** END OF FILE i2c.c ********************************/ 611