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