arch/cris/arch-v32/drivers/i2c.c

   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-2007 Axis Communications AB, LUND, SWEDEN
  23 *!
  24 *!***************************************************************************/
  25
  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 */
  50 static 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 static DEFINE_SPINLOCK(i2c_lock); /* Protect directions etc */
  83
  84 /****************** VARIABLE SECTION ************************************/
  85
  86 static struct crisv32_iopin cris_i2c_clk;
  87 static struct crisv32_iopin cris_i2c_data;
  88
  89 /****************** FUNCTION DEFINITION SECTION *************************/
  90
  91
  92 /* generate i2c start condition */
  93
  94 void
  95 i2c_start(void)
  96 {
  97         /*
  98          * SCL=1 SDA=1
  99          */
 100         i2c_dir_out();
 101         i2c_delay(CLOCK_HIGH_TIME/6);
 102         i2c_data(I2C_DATA_HIGH);
 103         i2c_clk(I2C_CLOCK_HIGH);
 104         i2c_delay(CLOCK_HIGH_TIME);
 105         /*
 106          * SCL=1 SDA=0
 107          */
 108         i2c_data(I2C_DATA_LOW);
 109         i2c_delay(START_CONDITION_HOLD_TIME);
 110         /*
 111          * SCL=0 SDA=0
 112          */
 113         i2c_clk(I2C_CLOCK_LOW);
 114         i2c_delay(CLOCK_LOW_TIME);
 115 }
 116
 117 /* generate i2c stop condition */
 118
 119 void
 120 i2c_stop(void)
 121 {
 122         i2c_dir_out();
 123
 124         /*
 125          * SCL=0 SDA=0
 126          */
 127         i2c_clk(I2C_CLOCK_LOW);
 128         i2c_data(I2C_DATA_LOW);
 129         i2c_delay(CLOCK_LOW_TIME*2);
 130         /*
 131          * SCL=1 SDA=0
 132          */
 133         i2c_clk(I2C_CLOCK_HIGH);
 134         i2c_delay(CLOCK_HIGH_TIME*2);
 135         /*
 136          * SCL=1 SDA=1
 137          */
 138         i2c_data(I2C_DATA_HIGH);
 139         i2c_delay(STOP_CONDITION_HOLD_TIME);
 140
 141         i2c_dir_in();
 142 }
 143
 144 /* write a byte to the i2c interface */
 145
 146 void
 147 i2c_outbyte(unsigned char x)
 148 {
 149         int i;
 150
 151         i2c_dir_out();
 152
 153         for (i = 0; i < 8; i++) {
 154                 if (x & 0x80) {
 155                         i2c_data(I2C_DATA_HIGH);
 156                 } else {
 157                         i2c_data(I2C_DATA_LOW);
 158                 }
 159
 160                 i2c_delay(CLOCK_LOW_TIME/2);
 161                 i2c_clk(I2C_CLOCK_HIGH);
 162                 i2c_delay(CLOCK_HIGH_TIME);
 163                 i2c_clk(I2C_CLOCK_LOW);
 164                 i2c_delay(CLOCK_LOW_TIME/2);
 165                 x <<= 1;
 166         }
 167         i2c_data(I2C_DATA_LOW);
 168         i2c_delay(CLOCK_LOW_TIME/2);
 169
 170         /*
 171          * enable input
 172          */
 173         i2c_dir_in();
 174 }
 175
 176 /* read a byte from the i2c interface */
 177
 178 unsigned char
 179 i2c_inbyte(void)
 180 {
 181         unsigned char aBitByte = 0;
 182         int i;
 183
 184         /* Switch off I2C to get bit */
 185         i2c_disable();
 186         i2c_dir_in();
 187         i2c_delay(CLOCK_HIGH_TIME/2);
 188
 189         /* Get bit */
 190         aBitByte |= i2c_getbit();
 191
 192         /* Enable I2C */
 193         i2c_enable();
 194         i2c_delay(CLOCK_LOW_TIME/2);
 195
 196         for (i = 1; i < 8; i++) {
 197                 aBitByte <<= 1;
 198                 /* Clock pulse */
 199                 i2c_clk(I2C_CLOCK_HIGH);
 200                 i2c_delay(CLOCK_HIGH_TIME);
 201                 i2c_clk(I2C_CLOCK_LOW);
 202                 i2c_delay(CLOCK_LOW_TIME);
 203
 204                 /* Switch off I2C to get bit */
 205                 i2c_disable();
 206                 i2c_dir_in();
 207                 i2c_delay(CLOCK_HIGH_TIME/2);
 208
 209                 /* Get bit */
 210                 aBitByte |= i2c_getbit();
 211
 212                 /* Enable I2C */
 213                 i2c_enable();
 214                 i2c_delay(CLOCK_LOW_TIME/2);
 215         }
 216         i2c_clk(I2C_CLOCK_HIGH);
 217         i2c_delay(CLOCK_HIGH_TIME);
 218
 219         /*
 220          * we leave the clock low, getbyte is usually followed
 221          * by sendack/nack, they assume the clock to be low
 222          */
 223         i2c_clk(I2C_CLOCK_LOW);
 224         return aBitByte;
 225 }
 226
 227 /*#---------------------------------------------------------------------------
 228 *#
 229 *# FUNCTION NAME: i2c_getack
 230 *#
 231 *# DESCRIPTION  : checks if ack was received from ic2
 232 *#
 233 *#--------------------------------------------------------------------------*/
 234
 235 int
 236 i2c_getack(void)
 237 {
 238         int ack = 1;
 239         /*
 240          * enable output
 241          */
 242         i2c_dir_out();
 243         /*
 244          * Release data bus by setting
 245          * data high
 246          */
 247         i2c_data(I2C_DATA_HIGH);
 248         /*
 249          * enable input
 250          */
 251         i2c_dir_in();
 252         i2c_delay(CLOCK_HIGH_TIME/4);
 253         /*
 254          * generate ACK clock pulse
 255          */
 256         i2c_clk(I2C_CLOCK_HIGH);
 257 #if 0
 258         /*
 259          * Use PORT PB instead of I2C
 260          * for input. (I2C not working)
 261          */
 262         i2c_clk(1);
 263         i2c_data(1);
 264         /*
 265          * switch off I2C
 266          */
 267         i2c_data(1);
 268         i2c_disable();
 269         i2c_dir_in();
 270 #endif
 271
 272         /*
 273          * now wait for ack
 274          */
 275         i2c_delay(CLOCK_HIGH_TIME/2);
 276         /*
 277          * check for ack
 278          */
 279         if (i2c_getbit())
 280                 ack = 0;
 281         i2c_delay(CLOCK_HIGH_TIME/2);
 282         if (!ack) {
 283                 if (!i2c_getbit()) /* receiver pulld SDA low */
 284                         ack = 1;
 285                 i2c_delay(CLOCK_HIGH_TIME/2);
 286         }
 287
 288    /*
 289     * our clock is high now, make sure data is low
 290     * before we enable our output. If we keep data high
 291     * and enable output, we would generate a stop condition.
 292     */
 293 #if 0
 294    i2c_data(I2C_DATA_LOW);
 295
 296         /*
 297          * end clock pulse
 298          */
 299         i2c_enable();
 300         i2c_dir_out();
 301 #endif
 302         i2c_clk(I2C_CLOCK_LOW);
 303         i2c_delay(CLOCK_HIGH_TIME/4);
 304         /*
 305          * enable output
 306          */
 307         i2c_dir_out();
 308         /*
 309          * remove ACK clock pulse
 310          */
 311         i2c_data(I2C_DATA_HIGH);
 312         i2c_delay(CLOCK_LOW_TIME/2);
 313         return ack;
 314 }
 315
 316 /*#---------------------------------------------------------------------------
 317 *#
 318 *# FUNCTION NAME: I2C::sendAck
 319 *#
 320 *# DESCRIPTION  : Send ACK on received data
 321 *#
 322 *#--------------------------------------------------------------------------*/
 323 void
 324 i2c_sendack(void)
 325 {
 326         /*
 327          * enable output
 328          */
 329         i2c_delay(CLOCK_LOW_TIME);
 330         i2c_dir_out();
 331         /*
 332          * set ack pulse high
 333          */
 334         i2c_data(I2C_DATA_LOW);
 335         /*
 336          * generate clock pulse
 337          */
 338         i2c_delay(CLOCK_HIGH_TIME/6);
 339         i2c_clk(I2C_CLOCK_HIGH);
 340         i2c_delay(CLOCK_HIGH_TIME);
 341         i2c_clk(I2C_CLOCK_LOW);
 342         i2c_delay(CLOCK_LOW_TIME/6);
 343         /*
 344          * reset data out
 345          */
 346         i2c_data(I2C_DATA_HIGH);
 347         i2c_delay(CLOCK_LOW_TIME);
 348
 349         i2c_dir_in();
 350 }
 351
 352 /*#---------------------------------------------------------------------------
 353 *#
 354 *# FUNCTION NAME: i2c_sendnack
 355 *#
 356 *# DESCRIPTION  : Sends NACK on received data
 357 *#
 358 *#--------------------------------------------------------------------------*/
 359 void
 360 i2c_sendnack(void)
 361 {
 362         /*
 363          * enable output
 364          */
 365         i2c_delay(CLOCK_LOW_TIME);
 366         i2c_dir_out();
 367         /*
 368          * set data high
 369          */
 370         i2c_data(I2C_DATA_HIGH);
 371         /*
 372          * generate clock pulse
 373          */
 374         i2c_delay(CLOCK_HIGH_TIME/6);
 375         i2c_clk(I2C_CLOCK_HIGH);
 376         i2c_delay(CLOCK_HIGH_TIME);
 377         i2c_clk(I2C_CLOCK_LOW);
 378         i2c_delay(CLOCK_LOW_TIME);
 379
 380         i2c_dir_in();
 381 }
 382
 383 /*#---------------------------------------------------------------------------
 384 *#
 385 *# FUNCTION NAME: i2c_write
 386 *#
 387 *# DESCRIPTION  : Writes a value to an I2C device
 388 *#
 389 *#--------------------------------------------------------------------------*/
 390 int
 391 i2c_write(unsigned char theSlave, void *data, size_t nbytes)
 392 {
 393         int error, cntr = 3;
 394         unsigned char bytes_wrote = 0;
 395         unsigned char value;
 396         unsigned long flags;
 397
 398         spin_lock(&i2c_lock);
 399
 400         do {
 401                 error = 0;
 402                 /*
 403                  * we don't like to be interrupted
 404                  */
 405                 local_irq_save(flags);
 406
 407                 i2c_start();
 408                 /*
 409                  * send slave address
 410                  */
 411                 i2c_outbyte((theSlave & 0xfe));
 412                 /*
 413                  * wait for ack
 414                  */
 415                 if (!i2c_getack())
 416                         error = 1;
 417                 /*
 418                  * send data
 419                  */
 420                 for (bytes_wrote = 0; bytes_wrote < nbytes; bytes_wrote++) {
 421                         memcpy(&value, data + bytes_wrote, sizeof value);
 422                         i2c_outbyte(value);
 423                         /*
 424                          * now it's time to wait for ack
 425                          */
 426                         if (!i2c_getack())
 427                                 error |= 4;
 428                 }
 429                 /*
 430                  * end byte stream
 431                  */
 432                 i2c_stop();
 433                 /*
 434                  * enable interrupt again
 435                  */
 436                 local_irq_restore(flags);
 437
 438         } while (error && cntr--);
 439
 440         i2c_delay(CLOCK_LOW_TIME);
 441
 442         spin_unlock(&i2c_lock);
 443
 444         return -error;
 445 }
 446
 447 /*#---------------------------------------------------------------------------
 448 *#
 449 *# FUNCTION NAME: i2c_read
 450 *#
 451 *# DESCRIPTION  : Reads a value from an I2C device
 452 *#
 453 *#--------------------------------------------------------------------------*/
 454 int
 455 i2c_read(unsigned char theSlave, void *data, size_t nbytes)
 456 {
 457         unsigned char b = 0;
 458         unsigned char bytes_read = 0;
 459         int error, cntr = 3;
 460         unsigned long flags;
 461
 462         spin_lock(&i2c_lock);
 463
 464         do {
 465                 error = 0;
 466                 memset(data, 0, nbytes);
 467                 /*
 468                  * we don't like to be interrupted
 469                  */
 470                 local_irq_save(flags);
 471                 /*
 472                  * generate start condition
 473                  */
 474                 i2c_start();
 475                 /*
 476                  * send slave address
 477                  */
 478                 i2c_outbyte((theSlave | 0x01));
 479                 /*
 480                  * wait for ack
 481                  */
 482                 if (!i2c_getack())
 483                         error = 1;
 484                 /*
 485                  * fetch data
 486                  */
 487                 for (bytes_read = 0; bytes_read < nbytes; bytes_read++) {
 488                         b = i2c_inbyte();
 489                         memcpy(data + bytes_read, &b, sizeof b);
 490
 491                         if (bytes_read < (nbytes - 1))
 492                                 i2c_sendack();
 493                 }
 494                 /*
 495                  * last received byte needs to be nacked
 496                  * instead of acked
 497                  */
 498                 i2c_sendnack();
 499                 /*
 500                  * end sequence
 501                  */
 502                 i2c_stop();
 503                 /*
 504                  * enable interrupt again
 505                  */
 506                 local_irq_restore(flags);
 507         } while (error && cntr--);
 508
 509         spin_unlock(&i2c_lock);
 510
 511         return -error;
 512 }
 513
 514 /*#---------------------------------------------------------------------------
 515 *#
 516 *# FUNCTION NAME: i2c_writereg
 517 *#
 518 *# DESCRIPTION  : Writes a value to an I2C device
 519 *#
 520 *#--------------------------------------------------------------------------*/
 521 int
 522 i2c_writereg(unsigned char theSlave, unsigned char theReg,
 523              unsigned char theValue)
 524 {
 525         int error, cntr = 3;
 526         unsigned long flags;
 527
 528         spin_lock(&i2c_lock);
 529
 530         do {
 531                 error = 0;
 532                 /*
 533                  * we don't like to be interrupted
 534                  */
 535                 local_irq_save(flags);
 536
 537                 i2c_start();
 538                 /*
 539                  * send slave address
 540                  */
 541                 i2c_outbyte((theSlave & 0xfe));
 542                 /*
 543                  * wait for ack
 544                  */
 545                 if(!i2c_getack())
 546                         error = 1;
 547                 /*
 548                  * now select register
 549                  */
 550                 i2c_dir_out();
 551                 i2c_outbyte(theReg);
 552                 /*
 553                  * now it's time to wait for ack
 554                  */
 555                 if(!i2c_getack())
 556                         error |= 2;
 557                 /*
 558                  * send register register data
 559                  */
 560                 i2c_outbyte(theValue);
 561                 /*
 562                  * now it's time to wait for ack
 563                  */
 564                 if(!i2c_getack())
 565                         error |= 4;
 566                 /*
 567                  * end byte stream
 568                  */
 569                 i2c_stop();
 570                 /*
 571                  * enable interrupt again
 572                  */
 573                 local_irq_restore(flags);
 574         } while(error && cntr--);
 575
 576         i2c_delay(CLOCK_LOW_TIME);
 577
 578         spin_unlock(&i2c_lock);
 579
 580         return -error;
 581 }
 582
 583 /*#---------------------------------------------------------------------------
 584 *#
 585 *# FUNCTION NAME: i2c_readreg
 586 *#
 587 *# DESCRIPTION  : Reads a value from the decoder registers.
 588 *#
 589 *#--------------------------------------------------------------------------*/
 590 unsigned char
 591 i2c_readreg(unsigned char theSlave, unsigned char theReg)
 592 {
 593         unsigned char b = 0;
 594         int error, cntr = 3;
 595         unsigned long flags;
 596
 597         spin_lock(&i2c_lock);
 598
 599         do {
 600                 error = 0;
 601                 /*
 602                  * we don't like to be interrupted
 603                  */
 604                 local_irq_save(flags);
 605                 /*
 606                  * generate start condition
 607                  */
 608                 i2c_start();
 609
 610                 /*
 611                  * send slave address
 612                  */
 613                 i2c_outbyte((theSlave & 0xfe));
 614                 /*
 615                  * wait for ack
 616                  */
 617                 if(!i2c_getack())
 618                         error = 1;
 619                 /*
 620                  * now select register
 621                  */
 622                 i2c_dir_out();
 623                 i2c_outbyte(theReg);
 624                 /*
 625                  * now it's time to wait for ack
 626                  */
 627                 if(!i2c_getack())
 628                         error |= 2;
 629                 /*
 630                  * repeat start condition
 631                  */
 632                 i2c_delay(CLOCK_LOW_TIME);
 633                 i2c_start();
 634                 /*
 635                  * send slave address
 636                  */
 637                 i2c_outbyte(theSlave | 0x01);
 638                 /*
 639                  * wait for ack
 640                  */
 641                 if(!i2c_getack())
 642                         error |= 4;
 643                 /*
 644                  * fetch register
 645                  */
 646                 b = i2c_inbyte();
 647                 /*
 648                  * last received byte needs to be nacked
 649                  * instead of acked
 650                  */
 651                 i2c_sendnack();
 652                 /*
 653                  * end sequence
 654                  */
 655                 i2c_stop();
 656                 /*
 657                  * enable interrupt again
 658                  */
 659                 local_irq_restore(flags);
 660
 661         } while(error && cntr--);
 662
 663         spin_unlock(&i2c_lock);
 664
 665         return b;
 666 }
 667
 668 static int
 669 i2c_open(struct inode *inode, struct file *filp)
 670 {
 671         return 0;
 672 }
 673
 674 static int
 675 i2c_release(struct inode *inode, struct file *filp)
 676 {
 677         return 0;
 678 }
 679
 680 /* Main device API. ioctl's to write or read to/from i2c registers.
 681  */
 682
 683 static int
 684 i2c_ioctl(struct inode *inode, struct file *file,
 685           unsigned int cmd, unsigned long arg)
 686 {
 687         if(_IOC_TYPE(cmd) != ETRAXI2C_IOCTYPE) {
 688                 return -EINVAL;
 689         }
 690
 691         switch (_IOC_NR(cmd)) {
 692                 case I2C_WRITEREG:
 693                         /* write to an i2c slave */
 694                         D(printk("i2cw %d %d %d\n",
 695                                  I2C_ARGSLAVE(arg),
 696                                  I2C_ARGREG(arg),
 697                                  I2C_ARGVALUE(arg)));
 698
 699                         return i2c_writereg(I2C_ARGSLAVE(arg),
 700                                             I2C_ARGREG(arg),
 701                                             I2C_ARGVALUE(arg));
 702                 case I2C_READREG:
 703                 {
 704                         unsigned char val;
 705                         /* read from an i2c slave */
 706                         D(printk("i2cr %d %d ",
 707                                 I2C_ARGSLAVE(arg),
 708                                 I2C_ARGREG(arg)));
 709                         val = i2c_readreg(I2C_ARGSLAVE(arg), I2C_ARGREG(arg));
 710                         D(printk("= %d\n", val));
 711                         return val;
 712                 }
 713                 default:
 714                         return -EINVAL;
 715
 716         }
 717
 718         return 0;
 719 }
 720
 721 static const struct file_operations i2c_fops = {
 722         .owner =    THIS_MODULE,
 723         .ioctl =    i2c_ioctl,
 724         .open =     i2c_open,
 725         .release =  i2c_release,
 726 };
 727
 728 int __init
 729 i2c_init(void)
 730 {
 731         static int res;
 732         static int first = 1;
 733
 734         if (!first)
 735                 return res;
 736
 737         first = 0;
 738
 739         /* Setup and enable the DATA and CLK pins */
 740
 741         res = crisv32_io_get_name(&cris_i2c_data,
 742                 CONFIG_ETRAX_V32_I2C_DATA_PORT);
 743         if (res < 0)
 744                 return res;
 745
 746         res = crisv32_io_get_name(&cris_i2c_clk, CONFIG_ETRAX_V32_I2C_CLK_PORT);
 747         crisv32_io_set_dir(&cris_i2c_clk, crisv32_io_dir_out);
 748
 749         return res;
 750 }
 751
 752
 753 int __init
 754 i2c_register(void)
 755 {
 756
 757         int res;
 758
 759         res = i2c_init();
 760         if (res < 0)
 761                 return res;
 762
 763         /* register char device */
 764
 765         res = register_chrdev(I2C_MAJOR, i2c_name, &i2c_fops);
 766         if(res < 0) {
 767                 printk(KERN_ERR "i2c: couldn't get a major number.\n");
 768                 return res;
 769         }
 770
 771         printk(KERN_INFO
 772                 "I2C driver v2.2, (c) 1999-2007 Axis Communications AB\n");
 773
 774         return 0;
 775 }
 776
 777 /* this makes sure that i2c_init is called during boot */
 778
 779 module_init(i2c_register);
 780
 781 /****************** END OF FILE i2c.c ********************************/