release/src-rt-6.x/linux/linux-2.6/arch/cris/arch-v10/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 *! $Log: i2c.c,v $
  15 *! Revision 1.13  2005/03/07 13:13:07  starvik
  16 *! Added spinlocks to protect states etc
  17 *!
  18 *! Revision 1.12  2005/01/05 06:11:22  starvik
  19 *! No need to do local_irq_disable after local_irq_save.
  20 *!
  21 *! Revision 1.11  2004/12/13 12:21:52  starvik
  22 *! Added I/O and DMA allocators from Linux 2.4
  23 *!
  24 *! Revision 1.9  2004/08/24 06:49:14  starvik
  25 *! Whitespace cleanup
  26 *!
  27 *! Revision 1.8  2004/06/08 08:48:26  starvik
  28 *! Removed unused code
  29 *!
  30 *! Revision 1.7  2004/05/28 09:26:59  starvik
  31 *! Modified I2C initialization to work in 2.6.
  32 *!
  33 *! Revision 1.6  2004/05/14 07:58:03  starvik
  34 *! Merge of changes from 2.4
  35 *!
  36 *! Revision 1.4  2002/12/11 13:13:57  starvik
  37 *! Added arch/ to v10 specific includes
  38 *! Added fix from Linux 2.4 in serial.c (flush_to_flip_buffer)
  39 *!
  40 *! Revision 1.3  2002/11/20 11:56:11  starvik
  41 *! Merge of Linux 2.5.48
  42 *!
  43 *! Revision 1.2  2002/11/18 13:16:06  starvik
  44 *! Linux 2.5 port of latest 2.4 drivers
  45 *!
  46 *! Revision 1.9  2002/10/31 15:32:26  starvik
  47 *! Update Port B register and shadow even when running with hardware support
  48 *!   to avoid glitches when reading bits
  49 *! Never set direction to out in i2c_inbyte
  50 *! Removed incorrect clock toggling at end of i2c_inbyte
  51 *!
  52 *! Revision 1.8  2002/08/13 06:31:53  starvik
  53 *! Made SDA and SCL line configurable
  54 *! Modified i2c_inbyte to work with PCF8563
  55 *!
  56 *! Revision 1.7  2001/04/04 13:11:36  markusl
  57 *! Updated according to review remarks
  58 *!
  59 *! Revision 1.6  2001/03/19 12:43:00  markusl
  60 *! Made some symbols unstatic (used by the eeprom driver)
  61 *!
  62 *! Revision 1.5  2001/02/27 13:52:48  bjornw
  63 *! malloc.h -> slab.h
  64 *!
  65 *! Revision 1.4  2001/02/15 07:17:40  starvik
  66 *! Corrected usage if port_pb_i2c_shadow
  67 *!
  68 *! Revision 1.3  2001/01/26 17:55:13  bjornw
  69 *! * Made I2C_USES_PB_NOT_PB_I2C a CONFIG option instead of assigning it
  70 *!   magically. Config.in needs to set it for the options that need it, like
  71 *!   Dallas 1302 support. Actually, it should be default since it screws up
  72 *!   the PB bits even if you don't use I2C..
  73 *! * Include linux/config.h to get the above
  74 *!
  75 *! Revision 1.2  2001/01/18 15:49:30  bjornw
  76 *! 2.4 port of I2C including some cleanups (untested of course)
  77 *!
  78 *! Revision 1.1  2001/01/18 15:35:25  bjornw
  79 *! Verbatim copy of the Etrax i2c driver, 2.0 elinux version
  80 *!
  81 *!
  82 *! ---------------------------------------------------------------------------
  83 *!
  84 *! (C) Copyright 1999-2002 Axis Communications AB, LUND, SWEDEN
  85 *!
  86 *!***************************************************************************/
  87 /* $Id: i2c.c,v 1.13 2005/03/07 13:13:07 starvik Exp $ */
  88
  89 /****************** INCLUDE FILES SECTION ***********************************/
  90
  91 #include <linux/module.h>
  92 #include <linux/sched.h>
  93 #include <linux/slab.h>
  94 #include <linux/errno.h>
  95 #include <linux/kernel.h>
  96 #include <linux/fs.h>
  97 #include <linux/string.h>
  98 #include <linux/init.h>
  99
 100 #include <asm/etraxi2c.h>
 101
 102 #include <asm/system.h>
 103 #include <asm/arch/svinto.h>
 104 #include <asm/io.h>
 105 #include <asm/delay.h>
 106 #include <asm/arch/io_interface_mux.h>
 107
 108 #include "i2c.h"
 109
 110 /****************** I2C DEFINITION SECTION *************************/
 111
 112 #define D(x)
 113
 114 #define I2C_MAJOR 123  /* LOCAL/EXPERIMENTAL */
 115 static const char i2c_name[] = "i2c";
 116
 117 #define CLOCK_LOW_TIME            8
 118 #define CLOCK_HIGH_TIME           8
 119 #define START_CONDITION_HOLD_TIME 8
 120 #define STOP_CONDITION_HOLD_TIME  8
 121 #define ENABLE_OUTPUT 0x01
 122 #define ENABLE_INPUT 0x00
 123 #define I2C_CLOCK_HIGH 1
 124 #define I2C_CLOCK_LOW 0
 125 #define I2C_DATA_HIGH 1
 126 #define I2C_DATA_LOW 0
 127
 128 #ifdef CONFIG_ETRAX_I2C_USES_PB_NOT_PB_I2C
 129 /* Use PB and not PB_I2C */
 130 #ifndef CONFIG_ETRAX_I2C_DATA_PORT
 131 #define CONFIG_ETRAX_I2C_DATA_PORT 0
 132 #endif
 133 #ifndef CONFIG_ETRAX_I2C_CLK_PORT
 134 #define CONFIG_ETRAX_I2C_CLK_PORT 1
 135 #endif
 136
 137 #define SDABIT CONFIG_ETRAX_I2C_DATA_PORT
 138 #define SCLBIT CONFIG_ETRAX_I2C_CLK_PORT
 139 #define i2c_enable()
 140 #define i2c_disable()
 141
 142 /* enable or disable output-enable, to select output or input on the i2c bus */
 143
 144 #define i2c_dir_out() \
 145   REG_SHADOW_SET(R_PORT_PB_DIR, port_pb_dir_shadow, SDABIT, 1)
 146 #define i2c_dir_in()  \
 147   REG_SHADOW_SET(R_PORT_PB_DIR, port_pb_dir_shadow, SDABIT, 0)
 148
 149 /* control the i2c clock and data signals */
 150
 151 #define i2c_clk(x) \
 152   REG_SHADOW_SET(R_PORT_PB_DATA, port_pb_data_shadow, SCLBIT, x)
 153 #define i2c_data(x) \
 154   REG_SHADOW_SET(R_PORT_PB_DATA, port_pb_data_shadow, SDABIT, x)
 155
 156 /* read a bit from the i2c interface */
 157
 158 #define i2c_getbit() (((*R_PORT_PB_READ & (1 << SDABIT))) >> SDABIT)
 159
 160 #else
 161 /* enable or disable the i2c interface */
 162
 163 #define i2c_enable() *R_PORT_PB_I2C = (port_pb_i2c_shadow |= IO_MASK(R_PORT_PB_I2C, i2c_en))
 164 #define i2c_disable() *R_PORT_PB_I2C = (port_pb_i2c_shadow &= ~IO_MASK(R_PORT_PB_I2C, i2c_en))
 165
 166 /* enable or disable output-enable, to select output or input on the i2c bus */
 167
 168 #define i2c_dir_out() \
 169         *R_PORT_PB_I2C = (port_pb_i2c_shadow &= ~IO_MASK(R_PORT_PB_I2C, i2c_oe_)); \
 170         REG_SHADOW_SET(R_PORT_PB_DIR, port_pb_dir_shadow, 0, 1);
 171 #define i2c_dir_in() \
 172         *R_PORT_PB_I2C = (port_pb_i2c_shadow |= IO_MASK(R_PORT_PB_I2C, i2c_oe_)); \
 173         REG_SHADOW_SET(R_PORT_PB_DIR, port_pb_dir_shadow, 0, 0);
 174
 175 /* control the i2c clock and data signals */
 176
 177 #define i2c_clk(x) \
 178         *R_PORT_PB_I2C = (port_pb_i2c_shadow = (port_pb_i2c_shadow & \
 179        ~IO_MASK(R_PORT_PB_I2C, i2c_clk)) | IO_FIELD(R_PORT_PB_I2C, i2c_clk, (x))); \
 180        REG_SHADOW_SET(R_PORT_PB_DATA, port_pb_data_shadow, 1, x);
 181
 182 #define i2c_data(x) \
 183         *R_PORT_PB_I2C = (port_pb_i2c_shadow = (port_pb_i2c_shadow & \
 184            ~IO_MASK(R_PORT_PB_I2C, i2c_d)) | IO_FIELD(R_PORT_PB_I2C, i2c_d, (x))); \
 185         REG_SHADOW_SET(R_PORT_PB_DATA, port_pb_data_shadow, 0, x);
 186
 187 /* read a bit from the i2c interface */
 188
 189 #define i2c_getbit() (*R_PORT_PB_READ & 0x1)
 190 #endif
 191
 192 /* use the kernels delay routine */
 193
 194 #define i2c_delay(usecs) udelay(usecs)
 195
 196 static DEFINE_SPINLOCK(i2c_lock); /* Protect directions etc */
 197
 198 /****************** FUNCTION DEFINITION SECTION *************************/
 199
 200
 201 /* generate i2c start condition */
 202
 203 void
 204 i2c_start(void)
 205 {
 206         /*
 207          * SCL=1 SDA=1
 208          */
 209         i2c_dir_out();
 210         i2c_delay(CLOCK_HIGH_TIME/6);
 211         i2c_data(I2C_DATA_HIGH);
 212         i2c_clk(I2C_CLOCK_HIGH);
 213         i2c_delay(CLOCK_HIGH_TIME);
 214         /*
 215          * SCL=1 SDA=0
 216          */
 217         i2c_data(I2C_DATA_LOW);
 218         i2c_delay(START_CONDITION_HOLD_TIME);
 219         /*
 220          * SCL=0 SDA=0
 221          */
 222         i2c_clk(I2C_CLOCK_LOW);
 223         i2c_delay(CLOCK_LOW_TIME);
 224 }
 225
 226 /* generate i2c stop condition */
 227
 228 void
 229 i2c_stop(void)
 230 {
 231         i2c_dir_out();
 232
 233         /*
 234          * SCL=0 SDA=0
 235          */
 236         i2c_clk(I2C_CLOCK_LOW);
 237         i2c_data(I2C_DATA_LOW);
 238         i2c_delay(CLOCK_LOW_TIME*2);
 239         /*
 240          * SCL=1 SDA=0
 241          */
 242         i2c_clk(I2C_CLOCK_HIGH);
 243         i2c_delay(CLOCK_HIGH_TIME*2);
 244         /*
 245          * SCL=1 SDA=1
 246          */
 247         i2c_data(I2C_DATA_HIGH);
 248         i2c_delay(STOP_CONDITION_HOLD_TIME);
 249
 250         i2c_dir_in();
 251 }
 252
 253 /* write a byte to the i2c interface */
 254
 255 void
 256 i2c_outbyte(unsigned char x)
 257 {
 258         int i;
 259
 260         i2c_dir_out();
 261
 262         for (i = 0; i < 8; i++) {
 263                 if (x & 0x80) {
 264                         i2c_data(I2C_DATA_HIGH);
 265                 } else {
 266                         i2c_data(I2C_DATA_LOW);
 267                 }
 268
 269                 i2c_delay(CLOCK_LOW_TIME/2);
 270                 i2c_clk(I2C_CLOCK_HIGH);
 271                 i2c_delay(CLOCK_HIGH_TIME);
 272                 i2c_clk(I2C_CLOCK_LOW);
 273                 i2c_delay(CLOCK_LOW_TIME/2);
 274                 x <<= 1;
 275         }
 276         i2c_data(I2C_DATA_LOW);
 277         i2c_delay(CLOCK_LOW_TIME/2);
 278
 279         /*
 280          * enable input
 281          */
 282         i2c_dir_in();
 283 }
 284
 285 /* read a byte from the i2c interface */
 286
 287 unsigned char
 288 i2c_inbyte(void)
 289 {
 290         unsigned char aBitByte = 0;
 291         int i;
 292
 293         /* Switch off I2C to get bit */
 294         i2c_disable();
 295         i2c_dir_in();
 296         i2c_delay(CLOCK_HIGH_TIME/2);
 297
 298         /* Get bit */
 299         aBitByte |= i2c_getbit();
 300
 301         /* Enable I2C */
 302         i2c_enable();
 303         i2c_delay(CLOCK_LOW_TIME/2);
 304
 305         for (i = 1; i < 8; i++) {
 306                 aBitByte <<= 1;
 307                 /* Clock pulse */
 308                 i2c_clk(I2C_CLOCK_HIGH);
 309                 i2c_delay(CLOCK_HIGH_TIME);
 310                 i2c_clk(I2C_CLOCK_LOW);
 311                 i2c_delay(CLOCK_LOW_TIME);
 312
 313                 /* Switch off I2C to get bit */
 314                 i2c_disable();
 315                 i2c_dir_in();
 316                 i2c_delay(CLOCK_HIGH_TIME/2);
 317
 318                 /* Get bit */
 319                 aBitByte |= i2c_getbit();
 320
 321                 /* Enable I2C */
 322                 i2c_enable();
 323                 i2c_delay(CLOCK_LOW_TIME/2);
 324         }
 325         i2c_clk(I2C_CLOCK_HIGH);
 326         i2c_delay(CLOCK_HIGH_TIME);
 327
 328         /*
 329          * we leave the clock low, getbyte is usually followed
 330          * by sendack/nack, they assume the clock to be low
 331          */
 332         i2c_clk(I2C_CLOCK_LOW);
 333         return aBitByte;
 334 }
 335
 336 /*#---------------------------------------------------------------------------
 337 *#
 338 *# FUNCTION NAME: i2c_getack
 339 *#
 340 *# DESCRIPTION  : checks if ack was received from ic2
 341 *#
 342 *#--------------------------------------------------------------------------*/
 343
 344 int
 345 i2c_getack(void)
 346 {
 347         int ack = 1;
 348         /*
 349          * enable output
 350          */
 351         i2c_dir_out();
 352         /*
 353          * Release data bus by setting
 354          * data high
 355          */
 356         i2c_data(I2C_DATA_HIGH);
 357         /*
 358          * enable input
 359          */
 360         i2c_dir_in();
 361         i2c_delay(CLOCK_HIGH_TIME/4);
 362         /*
 363          * generate ACK clock pulse
 364          */
 365         i2c_clk(I2C_CLOCK_HIGH);
 366         /*
 367          * Use PORT PB instead of I2C
 368          * for input. (I2C not working)
 369          */
 370         i2c_clk(1);
 371         i2c_data(1);
 372         /*
 373          * switch off I2C
 374          */
 375         i2c_data(1);
 376         i2c_disable();
 377         i2c_dir_in();
 378         /*
 379          * now wait for ack
 380          */
 381         i2c_delay(CLOCK_HIGH_TIME/2);
 382         /*
 383          * check for ack
 384          */
 385         if(i2c_getbit())
 386                 ack = 0;
 387         i2c_delay(CLOCK_HIGH_TIME/2);
 388         if(!ack){
 389                 if(!i2c_getbit()) /* receiver pulld SDA low */
 390                         ack = 1;
 391                 i2c_delay(CLOCK_HIGH_TIME/2);
 392         }
 393
 394         /*
 395          * our clock is high now, make sure data is low
 396          * before we enable our output. If we keep data high
 397          * and enable output, we would generate a stop condition.
 398          */
 399         i2c_data(I2C_DATA_LOW);
 400
 401         /*
 402          * end clock pulse
 403          */
 404         i2c_enable();
 405         i2c_dir_out();
 406         i2c_clk(I2C_CLOCK_LOW);
 407         i2c_delay(CLOCK_HIGH_TIME/4);
 408         /*
 409          * enable output
 410          */
 411         i2c_dir_out();
 412         /*
 413          * remove ACK clock pulse
 414          */
 415         i2c_data(I2C_DATA_HIGH);
 416         i2c_delay(CLOCK_LOW_TIME/2);
 417         return ack;
 418 }
 419
 420 /*#---------------------------------------------------------------------------
 421 *#
 422 *# FUNCTION NAME: I2C::sendAck
 423 *#
 424 *# DESCRIPTION  : Send ACK on received data
 425 *#
 426 *#--------------------------------------------------------------------------*/
 427 void
 428 i2c_sendack(void)
 429 {
 430         /*
 431          * enable output
 432          */
 433         i2c_delay(CLOCK_LOW_TIME);
 434         i2c_dir_out();
 435         /*
 436          * set ack pulse high
 437          */
 438         i2c_data(I2C_DATA_LOW);
 439         /*
 440          * generate clock pulse
 441          */
 442         i2c_delay(CLOCK_HIGH_TIME/6);
 443         i2c_clk(I2C_CLOCK_HIGH);
 444         i2c_delay(CLOCK_HIGH_TIME);
 445         i2c_clk(I2C_CLOCK_LOW);
 446         i2c_delay(CLOCK_LOW_TIME/6);
 447         /*
 448          * reset data out
 449          */
 450         i2c_data(I2C_DATA_HIGH);
 451         i2c_delay(CLOCK_LOW_TIME);
 452
 453         i2c_dir_in();
 454 }
 455
 456 /*#---------------------------------------------------------------------------
 457 *#
 458 *# FUNCTION NAME: i2c_sendnack
 459 *#
 460 *# DESCRIPTION  : Sends NACK on received data
 461 *#
 462 *#--------------------------------------------------------------------------*/
 463 void
 464 i2c_sendnack(void)
 465 {
 466         /*
 467          * enable output
 468          */
 469         i2c_delay(CLOCK_LOW_TIME);
 470         i2c_dir_out();
 471         /*
 472          * set data high
 473          */
 474         i2c_data(I2C_DATA_HIGH);
 475         /*
 476          * generate clock pulse
 477          */
 478         i2c_delay(CLOCK_HIGH_TIME/6);
 479         i2c_clk(I2C_CLOCK_HIGH);
 480         i2c_delay(CLOCK_HIGH_TIME);
 481         i2c_clk(I2C_CLOCK_LOW);
 482         i2c_delay(CLOCK_LOW_TIME);
 483
 484         i2c_dir_in();
 485 }
 486
 487 /*#---------------------------------------------------------------------------
 488 *#
 489 *# FUNCTION NAME: i2c_writereg
 490 *#
 491 *# DESCRIPTION  : Writes a value to an I2C device
 492 *#
 493 *#--------------------------------------------------------------------------*/
 494 int
 495 i2c_writereg(unsigned char theSlave, unsigned char theReg,
 496              unsigned char theValue)
 497 {
 498         int error, cntr = 3;
 499         unsigned long flags;
 500
 501         spin_lock(&i2c_lock);
 502
 503         do {
 504                 error = 0;
 505                 /*
 506                  * we don't like to be interrupted
 507                  */
 508                 local_irq_save(flags);
 509
 510                 i2c_start();
 511                 /*
 512                  * send slave address
 513                  */
 514                 i2c_outbyte((theSlave & 0xfe));
 515                 /*
 516                  * wait for ack
 517                  */
 518                 if(!i2c_getack())
 519                         error = 1;
 520                 /*
 521                  * now select register
 522                  */
 523                 i2c_dir_out();
 524                 i2c_outbyte(theReg);
 525                 /*
 526                  * now it's time to wait for ack
 527                  */
 528                 if(!i2c_getack())
 529                         error |= 2;
 530                 /*
 531                  * send register register data
 532                  */
 533                 i2c_outbyte(theValue);
 534                 /*
 535                  * now it's time to wait for ack
 536                  */
 537                 if(!i2c_getack())
 538                         error |= 4;
 539                 /*
 540                  * end byte stream
 541                  */
 542                 i2c_stop();
 543                 /*
 544                  * enable interrupt again
 545                  */
 546                 local_irq_restore(flags);
 547
 548         } while(error && cntr--);
 549
 550         i2c_delay(CLOCK_LOW_TIME);
 551
 552         spin_unlock(&i2c_lock);
 553
 554         return -error;
 555 }
 556
 557 /*#---------------------------------------------------------------------------
 558 *#
 559 *# FUNCTION NAME: i2c_readreg
 560 *#
 561 *# DESCRIPTION  : Reads a value from the decoder registers.
 562 *#
 563 *#--------------------------------------------------------------------------*/
 564 unsigned char
 565 i2c_readreg(unsigned char theSlave, unsigned char theReg)
 566 {
 567         unsigned char b = 0;
 568         int error, cntr = 3;
 569         unsigned long flags;
 570
 571         spin_lock(&i2c_lock);
 572
 573         do {
 574                 error = 0;
 575                 /*
 576                  * we don't like to be interrupted
 577                  */
 578                 local_irq_save(flags);
 579                 /*
 580                  * generate start condition
 581                  */
 582                 i2c_start();
 583
 584                 /*
 585                  * send slave address
 586                  */
 587                 i2c_outbyte((theSlave & 0xfe));
 588                 /*
 589                  * wait for ack
 590                  */
 591                 if(!i2c_getack())
 592                         error = 1;
 593                 /*
 594                  * now select register
 595                  */
 596                 i2c_dir_out();
 597                 i2c_outbyte(theReg);
 598                 /*
 599                  * now it's time to wait for ack
 600                  */
 601                 if(!i2c_getack())
 602                         error = 1;
 603                 /*
 604                  * repeat start condition
 605                  */
 606                 i2c_delay(CLOCK_LOW_TIME);
 607                 i2c_start();
 608                 /*
 609                  * send slave address
 610                  */
 611                 i2c_outbyte(theSlave | 0x01);
 612                 /*
 613                  * wait for ack
 614                  */
 615                 if(!i2c_getack())
 616                         error = 1;
 617                 /*
 618                  * fetch register
 619                  */
 620                 b = i2c_inbyte();
 621                 /*
 622                  * last received byte needs to be nacked
 623                  * instead of acked
 624                  */
 625                 i2c_sendack();
 626                 /*
 627                  * end sequence
 628                  */
 629                 i2c_stop();
 630                 /*
 631                  * enable interrupt again
 632                  */
 633                 local_irq_restore(flags);
 634
 635         } while(error && cntr--);
 636
 637         spin_unlock(&i2c_lock);
 638
 639         return b;
 640 }
 641
 642 static int
 643 i2c_open(struct inode *inode, struct file *filp)
 644 {
 645         return 0;
 646 }
 647
 648 static int
 649 i2c_release(struct inode *inode, struct file *filp)
 650 {
 651         return 0;
 652 }
 653
 654 /* Main device API. ioctl's to write or read to/from i2c registers.
 655  */
 656
 657 static int
 658 i2c_ioctl(struct inode *inode, struct file *file,
 659           unsigned int cmd, unsigned long arg)
 660 {
 661         if(_IOC_TYPE(cmd) != ETRAXI2C_IOCTYPE) {
 662                 return -EINVAL;
 663         }
 664
 665         switch (_IOC_NR(cmd)) {
 666                 case I2C_WRITEREG:
 667                         /* write to an i2c slave */
 668                         D(printk("i2cw %d %d %d\n",
 669                                  I2C_ARGSLAVE(arg),
 670                                  I2C_ARGREG(arg),
 671                                  I2C_ARGVALUE(arg)));
 672
 673                         return i2c_writereg(I2C_ARGSLAVE(arg),
 674                                             I2C_ARGREG(arg),
 675                                             I2C_ARGVALUE(arg));
 676                 case I2C_READREG:
 677                 {
 678                         unsigned char val;
 679                         /* read from an i2c slave */
 680                         D(printk("i2cr %d %d ",
 681                                 I2C_ARGSLAVE(arg),
 682                                 I2C_ARGREG(arg)));
 683                         val = i2c_readreg(I2C_ARGSLAVE(arg), I2C_ARGREG(arg));
 684                         D(printk("= %d\n", val));
 685                         return val;
 686                 }
 687                 default:
 688                         return -EINVAL;
 689
 690         }
 691
 692         return 0;
 693 }
 694
 695 static const struct file_operations i2c_fops = {
 696         .owner    = THIS_MODULE,
 697         .ioctl    = i2c_ioctl,
 698         .open     = i2c_open,
 699         .release  = i2c_release,
 700 };
 701
 702 int __init
 703 i2c_init(void)
 704 {
 705         static int res = 0;
 706         static int first = 1;
 707
 708         if (!first) {
 709                 return res;
 710         }
 711
 712         /* Setup and enable the Port B I2C interface */
 713
 714 #ifndef CONFIG_ETRAX_I2C_USES_PB_NOT_PB_I2C
 715         if ((res = cris_request_io_interface(if_i2c, "I2C"))) {
 716                 printk(KERN_CRIT "i2c_init: Failed to get IO interface\n");
 717                 return res;
 718         }
 719
 720         *R_PORT_PB_I2C = port_pb_i2c_shadow |=
 721                 IO_STATE(R_PORT_PB_I2C, i2c_en,  on) |
 722                 IO_FIELD(R_PORT_PB_I2C, i2c_d,   1)  |
 723                 IO_FIELD(R_PORT_PB_I2C, i2c_clk, 1)  |
 724                 IO_STATE(R_PORT_PB_I2C, i2c_oe_, enable);
 725
 726         port_pb_dir_shadow &= ~IO_MASK(R_PORT_PB_DIR, dir0);
 727         port_pb_dir_shadow &= ~IO_MASK(R_PORT_PB_DIR, dir1);
 728
 729         *R_PORT_PB_DIR = (port_pb_dir_shadow |=
 730                           IO_STATE(R_PORT_PB_DIR, dir0, input)  |
 731                           IO_STATE(R_PORT_PB_DIR, dir1, output));
 732 #else
 733         if ((res = cris_io_interface_allocate_pins(if_i2c,
 734                                                    'b',
 735                                                    CONFIG_ETRAX_I2C_DATA_PORT,
 736                                                    CONFIG_ETRAX_I2C_DATA_PORT))) {
 737                 printk(KERN_WARNING "i2c_init: Failed to get IO pin for I2C data port\n");
 738                 return res;
 739         } else if ((res = cris_io_interface_allocate_pins(if_i2c,
 740                                                           'b',
 741                                                           CONFIG_ETRAX_I2C_CLK_PORT,
 742                                                           CONFIG_ETRAX_I2C_CLK_PORT))) {
 743                 cris_io_interface_free_pins(if_i2c,
 744                                             'b',
 745                                             CONFIG_ETRAX_I2C_DATA_PORT,
 746                                             CONFIG_ETRAX_I2C_DATA_PORT);
 747                 printk(KERN_WARNING "i2c_init: Failed to get IO pin for I2C clk port\n");
 748         }
 749 #endif
 750
 751         return res;
 752 }
 753
 754 static int __init
 755 i2c_register(void)
 756 {
 757         int res;
 758
 759         res = i2c_init();
 760         if (res < 0)
 761                 return res;
 762         res = register_chrdev(I2C_MAJOR, i2c_name, &i2c_fops);
 763         if(res < 0) {
 764                 printk(KERN_ERR "i2c: couldn't get a major number.\n");
 765                 return res;
 766         }
 767
 768         printk(KERN_INFO "I2C driver v2.2, (c) 1999-2004 Axis Communications AB\n");
 769
 770         return 0;
 771 }
 772
 773 /* this makes sure that i2c_register is called during boot */
 774
 775 module_init(i2c_register);
 776
 777 /****************** END OF FILE i2c.c ********************************/