LXR linux/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/errno.h>
  31#include <linux/kernel.h>
  32#include <linux/fs.h>
  33#include <linux/string.h>
  34#include <linux/init.h>
  35#include <linux/mutex.h>
  36
  37#include <asm/etraxi2c.h>
  38
  39#include <asm/io.h>
  40#include <asm/delay.h>
  41
  42#include "i2c.h"
  43
  44/****************** I2C DEFINITION SECTION *************************/
  45
  46#define D(x)
  47
  48#define I2C_MAJOR 123  /* LOCAL/EXPERIMENTAL */
  49static DEFINE_MUTEX(i2c_mutex);
  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
  82static DEFINE_SPINLOCK(i2c_lock); /* Protect directions etc */
  83
  84/****************** VARIABLE SECTION ************************************/
  85
  86static struct crisv32_iopin cris_i2c_clk;
  87static struct crisv32_iopin cris_i2c_data;
  88
  89/****************** FUNCTION DEFINITION SECTION *************************/
  90
  91
  92/* generate i2c start condition */
  93
  94void
  95i2c_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
 119void
 120i2c_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
 146void
 147i2c_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
 178unsigned char
 179i2c_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
 235int
 236i2c_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*#--------------------------------------------------------------------------*/
 323void
 324i2c_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*#--------------------------------------------------------------------------*/
 359void
 360i2c_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*#--------------------------------------------------------------------------*/
 390int
 391i2c_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_irqsave(&i2c_lock, flags);
 399
 400        do {
 401                error = 0;
 402
 403                i2c_start();
 404                /*
 405                 * send slave address
 406                 */
 407                i2c_outbyte((theSlave & 0xfe));
 408                /*
 409                 * wait for ack
 410                 */
 411                if (!i2c_getack())
 412                        error = 1;
 413                /*
 414                 * send data
 415                 */
 416                for (bytes_wrote = 0; bytes_wrote < nbytes; bytes_wrote++) {
 417                        memcpy(&value, data + bytes_wrote, sizeof value);
 418                        i2c_outbyte(value);
 419                        /*
 420                         * now it's time to wait for ack
 421                         */
 422                        if (!i2c_getack())
 423                                error |= 4;
 424                }
 425                /*
 426                 * end byte stream
 427                 */
 428                i2c_stop();
 429
 430        } while (error && cntr--);
 431
 432        i2c_delay(CLOCK_LOW_TIME);
 433
 434        spin_unlock_irqrestore(&i2c_lock, flags);
 435
 436        return -error;
 437}
 438
 439/*#---------------------------------------------------------------------------
 440*#
 441*# FUNCTION NAME: i2c_read
 442*#
 443*# DESCRIPTION  : Reads a value from an I2C device
 444*#
 445*#--------------------------------------------------------------------------*/
 446int
 447i2c_read(unsigned char theSlave, void *data, size_t nbytes)
 448{
 449        unsigned char b = 0;
 450        unsigned char bytes_read = 0;
 451        int error, cntr = 3;
 452        unsigned long flags;
 453
 454        spin_lock_irqsave(&i2c_lock, flags);
 455
 456        do {
 457                error = 0;
 458                memset(data, 0, nbytes);
 459                /*
 460                 * generate start condition
 461                 */
 462                i2c_start();
 463                /*
 464                 * send slave address
 465                 */
 466                i2c_outbyte((theSlave | 0x01));
 467                /*
 468                 * wait for ack
 469                 */
 470                if (!i2c_getack())
 471                        error = 1;
 472                /*
 473                 * fetch data
 474                 */
 475                for (bytes_read = 0; bytes_read < nbytes; bytes_read++) {
 476                        b = i2c_inbyte();
 477                        memcpy(data + bytes_read, &b, sizeof b);
 478
 479                        if (bytes_read < (nbytes - 1))
 480                                i2c_sendack();
 481                }
 482                /*
 483                 * last received byte needs to be nacked
 484                 * instead of acked
 485                 */
 486                i2c_sendnack();
 487                /*
 488                 * end sequence
 489                 */
 490                i2c_stop();
 491        } while (error && cntr--);
 492
 493        spin_unlock_irqrestore(&i2c_lock, flags);
 494
 495        return -error;
 496}
 497
 498/*#---------------------------------------------------------------------------
 499*#
 500*# FUNCTION NAME: i2c_writereg
 501*#
 502*# DESCRIPTION  : Writes a value to an I2C device
 503*#
 504*#--------------------------------------------------------------------------*/
 505int
 506i2c_writereg(unsigned char theSlave, unsigned char theReg,
 507             unsigned char theValue)
 508{
 509        int error, cntr = 3;
 510        unsigned long flags;
 511
 512        spin_lock_irqsave(&i2c_lock, flags);
 513
 514        do {
 515                error = 0;
 516
 517                i2c_start();
 518                /*
 519                 * send slave address
 520                 */
 521                i2c_outbyte((theSlave & 0xfe));
 522                /*
 523                 * wait for ack
 524                 */
 525                if(!i2c_getack())
 526                        error = 1;
 527                /*
 528                 * now select register
 529                 */
 530                i2c_dir_out();
 531                i2c_outbyte(theReg);
 532                /*
 533                 * now it's time to wait for ack
 534                 */
 535                if(!i2c_getack())
 536                        error |= 2;
 537                /*
 538                 * send register register data
 539                 */
 540                i2c_outbyte(theValue);
 541                /*
 542                 * now it's time to wait for ack
 543                 */
 544                if(!i2c_getack())
 545                        error |= 4;
 546                /*
 547                 * end byte stream
 548                 */
 549                i2c_stop();
 550        } while(error && cntr--);
 551
 552        i2c_delay(CLOCK_LOW_TIME);
 553
 554        spin_unlock_irqrestore(&i2c_lock, flags);
 555
 556        return -error;
 557}
 558
 559/*#---------------------------------------------------------------------------
 560*#
 561*# FUNCTION NAME: i2c_readreg
 562*#
 563*# DESCRIPTION  : Reads a value from the decoder registers.
 564*#
 565*#--------------------------------------------------------------------------*/
 566unsigned char
 567i2c_readreg(unsigned char theSlave, unsigned char theReg)
 568{
 569        unsigned char b = 0;
 570        int error, cntr = 3;
 571        unsigned long flags;
 572
 573        spin_lock_irqsave(&i2c_lock, flags);
 574
 575        do {
 576                error = 0;
 577                /*
 578                 * generate start condition
 579                 */
 580                i2c_start();
 581
 582                /*
 583                 * send slave address
 584                 */
 585                i2c_outbyte((theSlave & 0xfe));
 586                /*
 587                 * wait for ack
 588                 */
 589                if(!i2c_getack())
 590                        error = 1;
 591                /*
 592                 * now select register
 593                 */
 594                i2c_dir_out();
 595                i2c_outbyte(theReg);
 596                /*
 597                 * now it's time to wait for ack
 598                 */
 599                if(!i2c_getack())
 600                        error |= 2;
 601                /*
 602                 * repeat start condition
 603                 */
 604                i2c_delay(CLOCK_LOW_TIME);
 605                i2c_start();
 606                /*
 607                 * send slave address
 608                 */
 609                i2c_outbyte(theSlave | 0x01);
 610                /*
 611                 * wait for ack
 612                 */
 613                if(!i2c_getack())
 614                        error |= 4;
 615                /*
 616                 * fetch register
 617                 */
 618                b = i2c_inbyte();
 619                /*
 620                 * last received byte needs to be nacked
 621                 * instead of acked
 622                 */
 623                i2c_sendnack();
 624                /*
 625                 * end sequence
 626                 */
 627                i2c_stop();
 628
 629        } while(error && cntr--);
 630
 631        spin_unlock_irqrestore(&i2c_lock, flags);
 632
 633        return b;
 634}
 635
 636static int
 637i2c_open(struct inode *inode, struct file *filp)
 638{
 639        return 0;
 640}
 641
 642static int
 643i2c_release(struct inode *inode, struct file *filp)
 644{
 645        return 0;
 646}
 647
 648/* Main device API. ioctl's to write or read to/from i2c registers.
 649 */
 650
 651static long
 652i2c_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 653{
 654        int ret;
 655        if(_IOC_TYPE(cmd) != ETRAXI2C_IOCTYPE) {
 656                return -ENOTTY;
 657        }
 658
 659        switch (_IOC_NR(cmd)) {
 660                case I2C_WRITEREG:
 661                        /* write to an i2c slave */
 662                        D(printk("i2cw %d %d %d\n",
 663                                 I2C_ARGSLAVE(arg),
 664                                 I2C_ARGREG(arg),
 665                                 I2C_ARGVALUE(arg)));
 666
 667                        mutex_lock(&i2c_mutex);
 668                        ret = i2c_writereg(I2C_ARGSLAVE(arg),
 669                                            I2C_ARGREG(arg),
 670                                            I2C_ARGVALUE(arg));
 671                        mutex_unlock(&i2c_mutex);
 672                        return ret;
 673
 674                case I2C_READREG:
 675                {
 676                        unsigned char val;
 677                        /* read from an i2c slave */
 678                        D(printk("i2cr %d %d ",
 679                                I2C_ARGSLAVE(arg),
 680                                I2C_ARGREG(arg)));
 681                        mutex_lock(&i2c_mutex);
 682                        val = i2c_readreg(I2C_ARGSLAVE(arg), I2C_ARGREG(arg));
 683                        mutex_unlock(&i2c_mutex);
 684                        D(printk("= %d\n", val));
 685                        return val;
 686                }
 687                default:
 688                        return -EINVAL;
 689
 690        }
 691
 692        return 0;
 693}
 694
 695static const struct file_operations i2c_fops = {
 696        .owner          = THIS_MODULE,
 697        .unlocked_ioctl = i2c_ioctl,
 698        .open           = i2c_open,
 699        .release        = i2c_release,
 700        .llseek         = noop_llseek,
 701};
 702
 703static int __init i2c_init(void)
 704{
 705        static int res;
 706        static int first = 1;
 707
 708        if (!first)
 709                return res;
 710
 711        first = 0;
 712
 713        /* Setup and enable the DATA and CLK pins */
 714
 715        res = crisv32_io_get_name(&cris_i2c_data,
 716                CONFIG_ETRAX_V32_I2C_DATA_PORT);
 717        if (res < 0)
 718                return res;
 719
 720        res = crisv32_io_get_name(&cris_i2c_clk, CONFIG_ETRAX_V32_I2C_CLK_PORT);
 721        crisv32_io_set_dir(&cris_i2c_clk, crisv32_io_dir_out);
 722
 723        return res;
 724}
 725
 726
 727static int __init i2c_register(void)
 728{
 729        int res;
 730
 731        res = i2c_init();
 732        if (res < 0)
 733                return res;
 734
 735        /* register char device */
 736
 737        res = register_chrdev(I2C_MAJOR, i2c_name, &i2c_fops);
 738        if (res < 0) {
 739                printk(KERN_ERR "i2c: couldn't get a major number.\n");
 740                return res;
 741        }
 742
 743        printk(KERN_INFO
 744                "I2C driver v2.2, (c) 1999-2007 Axis Communications AB\n");
 745
 746        return 0;
 747}
 748/* this makes sure that i2c_init is called during boot */
 749module_init(i2c_register);
 750
 751/****************** END OF FILE i2c.c ********************************/
 752