import clean BK tree at cset 1.3670

1 files changed, 7482 insertions, 0 deletions

diff --git a/packages/linux/linux-mtx-1-2.4.27/16-i2c.patch b/packages/linux/linux-mtx-1-2.4.27/16-i2c.patch
index e69de29bb2..cec737bdfe 100644
--- a/packages/linux/linux-mtx-1-2.4.27/16-i2c.patch
+++ b/packages/linux/linux-mtx-1-2.4.27/16-i2c.patch
@@ -0,0 +1,7482 @@
+--- linux-old/Documentation/Configure.help	Mon Dec 13 16:57:33 2004
++++ linux/Documentation/Configure.help	Mon Dec 13 19:26:23 2004
+@@ -19347,6 +19347,16 @@
+   <file:Documentation/modules.txt>.
+   The module will be called i2c-velleman.o.
+ 
++Basic I2C on Parallel Port adapter
++CONFIG_I2C_PPORT
++  This supports directly connecting I2C devices to the parallel port.
++  See <file:Documentation/i2c/i2c-pport> for more information.
++
++  This driver is also available as a module.  If you want to compile
++  it as a module, say M here and read
++  <file:Documentation/modules.txt>.
++  The module will be called i2c-pport.o.
++
+ I2C PCF 8584 interfaces
+ CONFIG_I2C_ALGOPCF
+   This allows you to use a range of I2C adapters called PCF adapters.
+@@ -19368,6 +19378,15 @@
+   <file:Documentation/modules.txt>.
+   The module will be called i2c-elektor.o.
+ 
++PCF on the EPP Parallel Port
++CONFIG_I2C_PCFEPP
++  This supports the PCF8584 connected to the parallel port.
++
++  This driver is also available as a module.  If you want to compile
++  it as a module, say M here and read
++  <file:Documentation/modules.txt>.
++  The module will be called i2c-pcf-epp.o.
++
+ ITE I2C Algorithm
+ CONFIG_ITE_I2C_ALGO
+   This supports the use the ITE8172 I2C interface found on some MIPS
+@@ -19405,6 +19424,51 @@
+   Supports the SGI interfaces like the ones found on SGI Indy VINO
+   or SGI O2 MACE.
+ 
++Motorola 8xx I2C algorithm
++CONFIG_I2C_ALGO8XX
++  This is the algorithm that allows you to use Motorola 8xx I2C adapters.
++
++  This driver is also available as a module.  If you want to compile
++  it as a module, say M here and read
++  <file:Documentation/modules.txt>.
++  The module will be called i2c-algo-8xx.o.
++
++Motorola 8xx I2C interface
++CONFIG_I2C_RPXLITE
++  This supports the Motorola 8xx I2C device.
++
++  This driver is also available as a module.  If you want to compile
++  it as a module, say M here and read
++  <file:Documentation/modules.txt>.
++  The module will be called i2c-rpx.o.
++
++IBM 405 I2C algorithm
++CONFIG_I2C_IBM_OCP_ALGO
++  This is the algorithm that allows you to use IBM 405 I2C adapters.
++
++  This driver is also available as a module.  If you want to compile
++  it as a module, say M here and read
++  <file:Documentation/modules.txt>.
++  The module will be called i2c-algo-ibm_ocp.o.
++
++IBM 405 I2C interface
++CONFIG_I2C_IBM_OCP_ADAP
++  This supports the IBM 405 I2C device.
++
++  This driver is also available as a module.  If you want to compile
++  it as a module, say M here and read
++  <file:Documentation/modules.txt>.
++  The module will be called i2c-adap-ibm_ocp.o.
++
++StrongARM SA-1110 interface
++CONFIG_I2C_FRODO
++  This supports the StrongARM SA-1110 Development Board.
++
++  This driver is also available as a module.  If you want to compile
++  it as a module, say M here and read
++  <file:Documentation/modules.txt>.
++  The module will be called i2c-frodo.o.
++
+ I2C device interface
+ CONFIG_I2C_CHARDEV
+   Say Y here to use i2c-* device files, usually found in the /dev
+--- linux-old/Documentation/i2c/dev-interface	Mon Dec 22 22:44:34 2003
++++ linux/Documentation/i2c/dev-interface	Mon Dec 13 19:26:23 2004
+@@ -89,6 +89,11 @@
+   Selects ten bit addresses if select not equals 0, selects normal 7 bit
+   addresses if select equals 0. Default 0.
+ 
++ioctl(file,I2C_PEC,long select)
++  Selects SMBus PEC (packet error checking) generation and verification
++  if select not equals 0, disables if select equals 0. Default 0.
++  Used only for SMBus transactions.
++
+ ioctl(file,I2C_FUNCS,unsigned long *funcs)
+   Gets the adapter functionality and puts it in *funcs.
+ 
+--- linux-old/Documentation/i2c/i2c-pport	Thu Jan  1 00:00:00 1970
++++ linux/Documentation/i2c/i2c-pport	Mon Dec 13 19:26:24 2004
+@@ -0,0 +1,67 @@
++Parallel Port Adapters
++----------------------
++If you are installing parallel port adapters it means you are probably messing 
++around with wires and IC's and the like. If you have purchased a card that 
++provides an external i2c/smbus this will require combined algorithm and 
++adapter code in a single module.
++If you are doing it yourself by using the parallel port there 
++are basically 2 options.
++
++1) Using the parallel port and using the i2c-pport adapter module and the 
++i2c-algo-bit algorithm module together to enable you to wire up your parallel 
++port to act as an i2c/smbus. This provides a bus that will enable most 
++sensors to work but doesn't support the entire i2c/smbus capability.
++
++2) Using the parallel port to interface to a Philips PCF8584 parallel to i2c 
++adapter chip. You will need to build a bit of a circuit to do this. This 
++configuration needs the i2c-pcf-epp adapter module and the i2c-algo-pcf 
++algorithm module. This support almost all of the i2c/smbus capabilities.
++
++
++i2c-pport Documentation
++-----------------------
++This is a primitive parallel port driver for the i2c bus, which exploits 
++features of modern bidirectional parallel ports. 
++
++Bidirectional ports have particular bits connected in following way:
++   
++                        |
++            /-----|     R
++         --o|     |-----|
++      read  \-----|     /------- Out pin
++                      |/
++                   - -|\
++                write   V
++                        |
++                       ---  
++
++
++It means when output is set to 1 we can read the port. Therefore 
++we can use 2 pins of parallel port as SDA and SCL for i2c bus. It 
++is not necessary to add any external - additional parts, we can 
++read and write the same port simultaneously.
++	I only use register base+2 so it is possible to use all 
++8 data bits of parallel port for other applications (I have 
++connected EEPROM and LCD display). I do not use bit Enable Bi-directional
++ Port. The only disadvantage is we can only support 5V chips.
++
++Layout:
++
++Cannon 25 pin
++
++SDA - connect to pin 14 (Auto Linefeed)
++SCL - connect to pin 16 (Initialize Printer)
++GND - connect to pin 18-25
+++5V - use external supply (I use 5V from 3.5" floppy connector)
++      
++no pullups  requied
++
++Module parameters:
++
++base = 0xXXX
++XXX - 278 or 378
++
++That's all.
++
++Daniel Smolik
++marvin@sitour.cz
+--- linux-old/Documentation/i2c/i2c-protocol	Mon Dec 22 22:44:34 2003
++++ linux/Documentation/i2c/i2c-protocol	Mon Dec 13 19:26:24 2004
+@@ -65,3 +65,12 @@
+     need to emit an Rd instead of a Wr, or vice versa, you set this
+     flag. For example:
+       S Addr Rd [A] Data [A] Data [A] ... [A] Data [A] P
++
++  Flags I2C_M_IGNORE_NAK
++    Normally message is interrupted immediately if there is [NA] from the
++    client. Setting this flag treats any [NA] as [A], and all of
++    message is sent.
++    These messages may still fail to SCL lo->hi timeout.
++
++  Flags I2C_M_NO_RD_ACK
++    In a read message, master A/NA bit is skipped.
+--- linux-old/Documentation/i2c/summary	Tue Jan 20 15:10:28 2004
++++ linux/Documentation/i2c/summary	Mon Dec 13 19:26:24 2004
+@@ -59,16 +59,16 @@
+ i2c-algo-8xx:    An algorithm for CPM's I2C device in Motorola 8xx processors (NOT BUILT BY DEFAULT)
+ i2c-algo-bit:    A bit-banging algorithm
+ i2c-algo-pcf:    A PCF 8584 style algorithm
+-i2c-algo-ppc405: An algorithm for the I2C device in IBM 405xx processors (NOT BUILT BY DEFAULT)
++i2c-algo-ibm_ocp: An algorithm for the I2C device in IBM 4xx processors (NOT BUILT BY DEFAULT)
+ 
+ Adapter drivers
+ ---------------
+ 
+ i2c-elektor:     Elektor ISA card (uses i2c-algo-pcf)
+ i2c-elv:         ELV parallel port adapter (uses i2c-algo-bit)
+-i2c-pcf-epp:     PCF8584 on a EPP parallel port (uses i2c-algo-pcf) (BROKEN - missing i2c-pcf-epp.h)
++i2c-pcf-epp:     PCF8584 on a EPP parallel port (uses i2c-algo-pcf) (NOT mkpatched)
+ i2c-philips-par: Philips style parallel port adapter (uses i2c-algo-bit)
+-i2c-ppc405:      IBM 405xx processor I2C device (uses i2c-algo-ppc405) (NOT BUILT BY DEFAULT)
++i2c-adap-ibm_ocp: IBM 4xx processor I2C device (uses i2c-algo-ibm_ocp) (NOT BUILT BY DEFAULT)
+ i2c-pport:       Primitive parallel port adapter (uses i2c-algo-bit)
+ i2c-rpx:         RPX board Motorola 8xx I2C device (uses i2c-algo-8xx) (NOT BUILT BY DEFAULT)
+ i2c-velleman:    Velleman K8000 parallel port adapter (uses i2c-algo-bit)
+--- linux-old/Documentation/i2c/writing-clients	Mon Dec 22 22:44:34 2003
++++ linux/Documentation/i2c/writing-clients	Mon Dec 13 19:26:25 2004
+@@ -24,24 +24,24 @@
+ routines, a client structure specific information like the actual I2C
+ address.
+ 
+-  struct i2c_driver foo_driver
+-  {  
+-    /* name           */  "Foo version 2.3 and later driver",
+-    /* id             */  I2C_DRIVERID_FOO,
+-    /* flags          */  I2C_DF_NOTIFY,
+-    /* attach_adapter */  &foo_attach_adapter,
+-    /* detach_client  */  &foo_detach_client,
+-    /* command        */  &foo_command,   /* May be NULL */
+-    /* inc_use        */  &foo_inc_use,   /* May be NULL */
+-    /* dec_use        */  &foo_dec_use    /* May be NULL */
+-  }
++static struct i2c_driver foo_driver = {
++	.owner		= THIS_MODULE,
++	.name		= "Foo version 2.3 driver",
++	.id		= I2C_DRIVERID_FOO, /* from i2c-id.h, optional */
++	.flags		= I2C_DF_NOTIFY,
++	.attach_adapter	= &foo_attach_adapter,
++	.detach_client	= &foo_detach_client,
++	.command	= &foo_command /* may be NULL */
++}
+  
+ The name can be chosen freely, and may be upto 40 characters long. Please
+ use something descriptive here.
+ 
+-The id should be a unique ID. The range 0xf000 to 0xffff is reserved for
+-local use, and you can use one of those until you start distributing the
+-driver. Before you do that, contact the i2c authors to get your own ID(s).
++If used, the id should be a unique ID. The range 0xf000 to 0xffff is
++reserved for local use, and you can use one of those until you start
++distributing the driver, at which time you should contact the i2c authors
++to get your own ID(s). Note that most of the time you don't need an ID
++at all so you can just omit it.
+ 
+ Don't worry about the flags field; just put I2C_DF_NOTIFY into it. This
+ means that your driver will be notified when new adapters are found.
+@@ -50,43 +50,8 @@
+ All other fields are for call-back functions which will be explained 
+ below.
+ 
+-
+-Module usage count
+-==================
+-
+-If your driver can also be compiled as a module, there are moments at 
+-which the module can not be removed from memory. For example, when you
+-are doing a lengthy transaction, or when you create a /proc directory,
+-and some process has entered that directory (this last case is the
+-main reason why these call-backs were introduced).
+-
+-To increase or decrease the module usage count, you can use the
+-MOD_{INC,DEC}_USE_COUNT macros. They must be called from the module
+-which needs to get its usage count changed; that is why each driver
+-module has to implement its own callback.
+-
+-  void foo_inc_use (struct i2c_client *client)
+-  {
+-  #ifdef MODULE
+-    MOD_INC_USE_COUNT;
+-  #endif
+-  }
+-
+-  void foo_dec_use (struct i2c_client *client)
+-  {
+-  #ifdef MODULE
+-    MOD_DEC_USE_COUNT;
+-  #endif
+-  }
+-
+-Do not call these call-back functions directly; instead, use one of the
+-following functions defined in i2c.h:
+-  void i2c_inc_use_client(struct i2c_client *);
+-  void i2c_dec_use_client(struct i2c_client *);
+-
+-You should *not* increase the module count just because a device is
+-detected and a client created. This would make it impossible to remove
+-an adapter driver! 
++There use to be two additional fields in this structure, inc_use et dec_use,
++for module usage count, but these fields were obsoleted and removed.
+ 
+ 
+ Extra client data
+--- linux-old/drivers/i2c/i2c-adap-ibm_ocp.c	Thu Jan  1 00:00:00 1970
++++ linux/drivers/i2c/i2c-adap-ibm_ocp.c	Mon Dec 13 19:26:26 2004
+@@ -0,0 +1,346 @@
++/*
++   -------------------------------------------------------------------------
++   i2c-adap-ibm_ocp.c i2c-hw access for the IIC peripheral on the IBM PPC 405
++   -------------------------------------------------------------------------
++  
++   Ian DaSilva, MontaVista Software, Inc.
++   idasilva@mvista.com or source@mvista.com
++
++   Copyright 2000 MontaVista Software Inc.
++
++   Changes made to support the IIC peripheral on the IBM PPC 405 
++
++
++   ----------------------------------------------------------------------------
++   This file was highly leveraged from i2c-elektor.c, which was created
++   by Simon G. Vogl and Hans Berglund:
++
++ 
++     Copyright (C) 1995-97 Simon G. Vogl
++                   1998-99 Hans Berglund
++
++   With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
++   Frodo Looijaard <frodol@dds.nl>
++
++
++    This program is free software; you can redistribute it and/or modify
++    it under the terms of the GNU General Public License as published by
++    the Free Software Foundation; either version 2 of the License, or
++    (at your option) any later version.
++
++    This program is distributed in the hope that it will be useful,
++    but WITHOUT ANY WARRANTY; without even the implied warranty of
++    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++    GNU General Public License for more details.
++
++    You should have received a copy of the GNU General Public License
++    along with this program; if not, write to the Free Software
++    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++   ----------------------------------------------------------------------------
++
++   History: 01/20/12 - Armin
++   	akuster@mvista.com
++   	ported up to 2.4.16+	
++
++   Version 02/03/25 - Armin
++       converted to ocp format
++       removed commented out or #if 0 code
++
++   TODO: convert to ocp_register
++         add PM hooks
++
++*/
++
++
++#include <linux/kernel.h>
++#include <linux/ioport.h>
++#include <linux/module.h>
++#include <linux/delay.h>
++#include <linux/slab.h>
++#include <linux/init.h>
++#include <linux/i2c.h>
++#include <linux/i2c-algo-ibm_ocp.h>
++#include <asm/irq.h>
++#include <asm/io.h>
++#include <asm/ocp.h>
++
++/*
++ * This next section is configurable, and it is used to set the number
++ * of i2c controllers in the system.  The default number of instances is 1,
++ * however, this should be changed to reflect your system's configuration.
++ */ 
++
++/*
++ * The STB03xxx, with a PPC405 core, has two i2c controllers.
++ */
++//(sizeof(IIC_ADDR)/sizeof(struct iic_regs))
++extern iic_t *IIC_ADDR[];
++static struct iic_ibm iic_ibmocp_adaps[IIC_NUMS][5];
++
++static struct i2c_algo_iic_data *iic_ibmocp_data[IIC_NUMS];
++static struct i2c_adapter *iic_ibmocp_ops[IIC_NUMS];
++
++static int i2c_debug=0;
++static wait_queue_head_t iic_wait[IIC_NUMS];
++static int iic_pending;
++static spinlock_t irq_driver_lock = SPIN_LOCK_UNLOCKED;
++
++
++/* ----- global defines -----------------------------------------------	*/
++#define DEB(x)	if (i2c_debug>=1) x
++#define DEB2(x) if (i2c_debug>=2) x
++#define DEB3(x) if (i2c_debug>=3) x
++#define DEBE(x)	x	/* error messages 				*/
++
++/* ----- local functions ----------------------------------------------	*/
++
++//
++// Description: Write a byte to IIC hardware
++//
++static void iic_ibmocp_setbyte(void *data, int ctl, int val)
++{
++   // writeb resolves to a write to the specified memory location
++   // plus a call to eieio.  eieio ensures that all instructions
++   // preceding it are completed before any further stores are
++   // completed.
++   // Delays at this level (to protect writes) are not needed here.
++   writeb(val, ctl);
++}
++
++
++//
++// Description: Read a byte from IIC hardware
++//
++static int iic_ibmocp_getbyte(void *data, int ctl)
++{
++   int val;
++
++   val = readb(ctl);
++   return (val);
++}
++
++
++//
++// Description: Return our slave address.  This is the address
++// put on the I2C bus when another master on the bus wants to address us
++// as a slave
++//
++static int iic_ibmocp_getown(void *data)
++{
++   return(((struct iic_ibm *)(data))->iic_own);
++}
++
++
++//
++// Description: Return the clock rate
++//
++static int iic_ibmocp_getclock(void *data)
++{
++   return(((struct iic_ibm *)(data))->iic_clock);
++}
++
++
++
++//
++// Description:  Put this process to sleep.  We will wake up when the
++// IIC controller interrupts.
++//
++static void iic_ibmocp_waitforpin(void *data) {
++
++   int timeout = 2;
++   struct iic_ibm *priv_data = data;
++
++   //
++   // If interrupts are enabled (which they are), then put the process to
++   // sleep.  This process will be awakened by two events -- either the
++   // the IIC peripheral interrupts or the timeout expires. 
++   //
++   if (priv_data->iic_irq > 0) {
++      spin_lock_irq(&irq_driver_lock);
++      if (iic_pending == 0) {
++  	 interruptible_sleep_on_timeout(&(iic_wait[priv_data->index]), timeout*HZ );
++      } else
++ 	 iic_pending = 0;
++      spin_unlock_irq(&irq_driver_lock);
++   } else {
++      //
++      // If interrupts are not enabled then delay for a reasonable amount
++      // of time and return.  We expect that by time we return to the calling
++      // function that the IIC has finished our requested transaction and
++      // the status bit reflects this.
++      //
++      // udelay is probably not the best choice for this since it is
++      // the equivalent of a busy wait
++      //
++      udelay(100);
++   }
++   //printk("iic_ibmocp_waitforpin: exitting\n");
++}
++
++
++//
++// Description: The registered interrupt handler
++//
++static void iic_ibmocp_handler(int this_irq, void *dev_id, struct pt_regs *regs) 
++{
++   int ret;
++   struct iic_regs *iic;
++   struct iic_ibm *priv_data = dev_id;
++   iic = (struct iic_regs *) priv_data->iic_base;
++   iic_pending = 1;
++   DEB2(printk("iic_ibmocp_handler: in interrupt handler\n"));
++   // Read status register
++   ret = readb((int) &(iic->sts));
++   DEB2(printk("iic_ibmocp_handler: status = %x\n", ret));
++   // Clear status register.  See IBM PPC 405 reference manual for details
++   writeb(0x0a, (int) &(iic->sts));
++   wake_up_interruptible(&(iic_wait[priv_data->index]));
++}
++
++
++//
++// Description: This function is very hardware dependent.  First, we lock
++// the region of memory where out registers exist.  Next, we request our
++// interrupt line and register its associated handler.  Our IIC peripheral
++// uses interrupt number 2, as specified by the 405 reference manual.
++//
++static int iic_hw_resrc_init(int instance)
++{
++
++   DEB(printk("iic_hw_resrc_init: Physical Base address: 0x%x\n", (u32) IIC_ADDR[instance] ));
++   iic_ibmocp_adaps[instance]->iic_base = (u32)ioremap((unsigned long)IIC_ADDR[instance],PAGE_SIZE);
++
++   DEB(printk("iic_hw_resrc_init: ioremapped base address: 0x%x\n", iic_ibmocp_adaps[instance]->iic_base));
++
++   if (iic_ibmocp_adaps[instance]->iic_irq > 0) {
++	
++      if (request_irq(iic_ibmocp_adaps[instance]->iic_irq, iic_ibmocp_handler,
++       0, "IBM OCP IIC", iic_ibmocp_adaps[instance]) < 0) {
++         printk(KERN_ERR "iic_hw_resrc_init: Request irq%d failed\n",
++          iic_ibmocp_adaps[instance]->iic_irq);
++	 iic_ibmocp_adaps[instance]->iic_irq = 0;
++      } else {
++         DEB3(printk("iic_hw_resrc_init: Enabled interrupt\n"));
++      }
++   }
++   return 0;
++}
++
++
++//
++// Description: Release irq and memory
++//
++static void iic_ibmocp_release(void)
++{
++   int i;
++
++   for(i=0; i<IIC_NUMS; i++) {
++      struct iic_ibm *priv_data = (struct iic_ibm *)iic_ibmocp_data[i]->data;
++      if (priv_data->iic_irq > 0) {
++         disable_irq(priv_data->iic_irq);
++         free_irq(priv_data->iic_irq, 0);
++      }
++      kfree(iic_ibmocp_data[i]);
++      kfree(iic_ibmocp_ops[i]);
++   }
++}
++
++
++//
++// Description: Called when the module is loaded.  This function starts the
++// cascade of calls up through the heirarchy of i2c modules (i.e. up to the
++//  algorithm layer and into to the core layer)
++//
++static int __init iic_ibmocp_init(void) 
++{
++   int i;
++
++   printk(KERN_INFO "iic_ibmocp_init: IBM on-chip iic adapter module\n");
++ 
++   for(i=0; i<IIC_NUMS; i++) {
++      iic_ibmocp_data[i] = kmalloc(sizeof(struct i2c_algo_iic_data),GFP_KERNEL);
++      if(iic_ibmocp_data[i] == NULL) {
++         return -ENOMEM;
++      }
++      memset(iic_ibmocp_data[i], 0, sizeof(struct i2c_algo_iic_data));
++      
++      switch (i) {
++	      case 0:
++	       iic_ibmocp_adaps[i]->iic_irq = IIC_IRQ(0);
++	      break;
++	      case 1:
++	       iic_ibmocp_adaps[i]->iic_irq = IIC_IRQ(1);
++	      break;
++      }
++      iic_ibmocp_adaps[i]->iic_clock = IIC_CLOCK;
++      iic_ibmocp_adaps[i]->iic_own = IIC_OWN; 
++      iic_ibmocp_adaps[i]->index = i;
++ 
++      DEB(printk("irq %x\n", iic_ibmocp_adaps[i]->iic_irq));
++      DEB(printk("clock %x\n", iic_ibmocp_adaps[i]->iic_clock));
++      DEB(printk("own %x\n", iic_ibmocp_adaps[i]->iic_own));
++      DEB(printk("index %x\n", iic_ibmocp_adaps[i]->index));
++
++
++      iic_ibmocp_data[i]->data = (struct iic_regs *)iic_ibmocp_adaps[i]; 
++      iic_ibmocp_data[i]->setiic = iic_ibmocp_setbyte;
++      iic_ibmocp_data[i]->getiic = iic_ibmocp_getbyte;
++      iic_ibmocp_data[i]->getown = iic_ibmocp_getown;
++      iic_ibmocp_data[i]->getclock = iic_ibmocp_getclock;
++      iic_ibmocp_data[i]->waitforpin = iic_ibmocp_waitforpin;
++      iic_ibmocp_data[i]->udelay = 80;
++      iic_ibmocp_data[i]->mdelay = 80;
++      iic_ibmocp_data[i]->timeout = HZ;
++      
++            iic_ibmocp_ops[i] = kmalloc(sizeof(struct i2c_adapter), GFP_KERNEL);
++      if(iic_ibmocp_ops[i] == NULL) {
++         return -ENOMEM;
++      }
++      memset(iic_ibmocp_ops[i], 0, sizeof(struct i2c_adapter));
++      strcpy(iic_ibmocp_ops[i]->name, "IBM OCP IIC adapter");
++      iic_ibmocp_ops[i]->owner = THIS_MODULE;
++      iic_ibmocp_ops[i]->id = I2C_HW_OCP;
++      iic_ibmocp_ops[i]->algo = NULL;
++      iic_ibmocp_ops[i]->algo_data = iic_ibmocp_data[i];
++       
++      
++      init_waitqueue_head(&(iic_wait[i]));
++      if (iic_hw_resrc_init(i) == 0) {
++         if (i2c_ocp_add_bus(iic_ibmocp_ops[i]) < 0)
++         return -ENODEV;
++      } else {
++         return -ENODEV;
++      }
++      DEB(printk(KERN_INFO "iic_ibmocp_init: found device at %#x.\n\n", iic_ibmocp_adaps[i]->iic_base));
++   }
++   return 0;
++}
++
++
++static void __exit iic_ibmocp_exit(void)
++{
++   int i;
++
++   for(i=0; i<IIC_NUMS; i++) {
++      i2c_ocp_del_bus(iic_ibmocp_ops[i]);
++   }
++   iic_ibmocp_release();
++}
++
++//
++// If modules is NOT defined when this file is compiled, then the MODULE_*
++// macros will resolve to nothing
++//
++MODULE_AUTHOR("MontaVista Software <www.mvista.com>");
++MODULE_DESCRIPTION("I2C-Bus adapter routines for PPC 405 IIC bus adapter");
++MODULE_LICENSE("GPL");
++
++MODULE_PARM(base, "i");
++MODULE_PARM(irq, "i");
++MODULE_PARM(clock, "i");
++MODULE_PARM(own, "i");
++MODULE_PARM(i2c_debug,"i");
++
++
++module_init(iic_ibmocp_init);
++module_exit(iic_ibmocp_exit); 
+--- linux-old/drivers/i2c/i2c-algo-8xx.c	Thu Jan  1 00:00:00 1970
++++ linux/drivers/i2c/i2c-algo-8xx.c	Mon Dec 13 19:26:27 2004
+@@ -0,0 +1,616 @@
++/*
++ * i2c-algo-8xx.c i2x driver algorithms for MPC8XX CPM
++ * Copyright (c) 1999 Dan Malek (dmalek@jlc.net).
++ *
++    This program is free software; you can redistribute it and/or modify
++    it under the terms of the GNU General Public License as published by
++    the Free Software Foundation; either version 2 of the License, or
++    (at your option) any later version.
++
++    This program is distributed in the hope that it will be useful,
++    but WITHOUT ANY WARRANTY; without even the implied warranty of
++    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++    GNU General Public License for more details.
++
++    You should have received a copy of the GNU General Public License
++    along with this program; if not, write to the Free Software
++    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ * moved into proper i2c interface; separated out platform specific 
++ * parts into i2c-rpx.c
++ * Brad Parker (brad@heeltoe.com)
++ */
++
++// XXX todo
++// timeout sleep?
++
++/* $Id: i2c-algo-8xx.c,v 1.14 2003/07/25 07:56:42 khali Exp $ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/delay.h>
++#include <linux/slab.h>
++#include <linux/init.h>
++#include <linux/errno.h>
++#include <linux/sched.h>
++#include <linux/i2c.h>
++#include <linux/i2c-algo-8xx.h>
++#include <asm/mpc8xx.h>
++#include <asm/commproc.h>
++
++
++#define CPM_MAX_READ	513
++/* #define I2C_CHIP_ERRATA */ /* Try uncomment this if you have an older CPU(earlier than rev D4) */
++static wait_queue_head_t iic_wait;
++static ushort r_tbase, r_rbase;
++
++int cpm_debug = 0;
++
++static  void
++cpm_iic_interrupt(void *dev_id, struct pt_regs *regs)
++{
++	volatile i2c8xx_t *i2c = (i2c8xx_t *)dev_id;
++	if (cpm_debug > 1)
++		printk("cpm_iic_interrupt(dev_id=%p)\n", dev_id);
++#if 0
++	/* Chip errata, clear enable. This is not needed on rev D4 CPUs */
++        /* This should probably be removed and replaced by I2C_CHIP_ERRATA stuff */
++        /* Someone with a buggy CPU needs to confirm that */
++	i2c->i2c_i2mod &= ~1;
++#endif
++	/* Clear interrupt.
++	*/
++	i2c->i2c_i2cer = 0xff;
++
++	/* Get 'me going again.
++	*/
++	wake_up_interruptible(&iic_wait);
++}
++
++static void
++cpm_iic_init(struct i2c_algo_8xx_data *cpm)
++{
++	volatile iic_t		*iip = cpm->iip;
++	volatile i2c8xx_t	*i2c = cpm->i2c;
++	unsigned char brg;
++	bd_t *bd = (bd_t *)__res;
++
++	if (cpm_debug) printk(KERN_DEBUG "cpm_iic_init()\n");
++
++	/* Initialize the parameter ram.
++	 * We need to make sure many things are initialized to zero,
++	 * especially in the case of a microcode patch.
++	 */
++	iip->iic_rstate = 0;
++	iip->iic_rdp = 0;
++	iip->iic_rbptr = 0;
++	iip->iic_rbc = 0;
++	iip->iic_rxtmp = 0;
++	iip->iic_tstate = 0;
++	iip->iic_tdp = 0;
++	iip->iic_tbptr = 0;
++	iip->iic_tbc = 0;
++	iip->iic_txtmp = 0;
++
++	/* Set up the IIC parameters in the parameter ram.
++	*/
++	iip->iic_tbase = r_tbase = cpm->dp_addr;
++	iip->iic_rbase = r_rbase = cpm->dp_addr + sizeof(cbd_t)*2;
++
++	iip->iic_tfcr = SMC_EB;
++	iip->iic_rfcr = SMC_EB;
++
++	/* Set maximum receive size.
++	*/
++	iip->iic_mrblr = CPM_MAX_READ;
++
++	/* Initialize Tx/Rx parameters.
++	*/
++	if (cpm->reloc == 0) {
++		volatile cpm8xx_t *cp = cpm->cp;
++
++		cp->cp_cpcr =
++			mk_cr_cmd(CPM_CR_CH_I2C, CPM_CR_INIT_TRX) | CPM_CR_FLG;
++		while (cp->cp_cpcr & CPM_CR_FLG);
++	} else {
++		iip->iic_rbptr = iip->iic_rbase;
++		iip->iic_tbptr = iip->iic_tbase;
++		iip->iic_rstate	= 0;
++		iip->iic_tstate	= 0;
++	}
++
++	/* Select an arbitrary address.  Just make sure it is unique.
++	*/
++	i2c->i2c_i2add = 0xfe;
++
++	/* Make clock run at 60 KHz.
++	*/
++	brg = (unsigned char) (bd->bi_intfreq/(32*2*60000) -3);
++	i2c->i2c_i2brg = brg;
++
++	i2c->i2c_i2mod = 0x00; 
++	i2c->i2c_i2com = 0x01; /* Master mode */
++
++	/* Disable interrupts.
++	*/
++	i2c->i2c_i2cmr = 0;
++	i2c->i2c_i2cer = 0xff;
++
++	init_waitqueue_head(&iic_wait);
++
++	/* Install interrupt handler.
++	*/
++	if (cpm_debug) {
++		printk ("%s[%d] Install ISR for IRQ %d\n",
++			__func__,__LINE__, CPMVEC_I2C);
++	}
++	(*cpm->setisr)(CPMVEC_I2C, cpm_iic_interrupt, (void *)i2c);
++}
++
++
++static int
++cpm_iic_shutdown(struct i2c_algo_8xx_data *cpm)
++{
++	volatile i2c8xx_t *i2c = cpm->i2c;
++
++	/* Shut down IIC.
++	*/
++	i2c->i2c_i2mod &= ~1;
++	i2c->i2c_i2cmr = 0;
++	i2c->i2c_i2cer = 0xff;
++
++	return(0);
++}
++
++static void 
++cpm_reset_iic_params(volatile iic_t *iip)
++{
++	iip->iic_tbase = r_tbase;
++	iip->iic_rbase = r_rbase;
++
++	iip->iic_tfcr = SMC_EB;
++	iip->iic_rfcr = SMC_EB;
++
++	iip->iic_mrblr = CPM_MAX_READ;
++
++	iip->iic_rstate = 0;
++	iip->iic_rdp = 0;
++	iip->iic_rbptr = iip->iic_rbase;
++	iip->iic_rbc = 0;
++	iip->iic_rxtmp = 0;
++	iip->iic_tstate = 0;
++	iip->iic_tdp = 0;
++	iip->iic_tbptr = iip->iic_tbase;
++	iip->iic_tbc = 0;
++	iip->iic_txtmp = 0;
++}
++
++#define BD_SC_NAK		((ushort)0x0004) /* NAK - did not respond */
++#define BD_SC_OV		((ushort)0x0002) /* OV - receive overrun */
++#define CPM_CR_CLOSE_RXBD	((ushort)0x0007)
++
++static void force_close(struct i2c_algo_8xx_data *cpm)
++{
++	volatile i2c8xx_t *i2c = cpm->i2c;
++	if (cpm->reloc == 0) { /* micro code disabled */
++		volatile cpm8xx_t *cp = cpm->cp;
++
++		if (cpm_debug) printk("force_close()\n");
++		cp->cp_cpcr =
++			mk_cr_cmd(CPM_CR_CH_I2C, CPM_CR_CLOSE_RXBD) |
++			CPM_CR_FLG;
++
++		while (cp->cp_cpcr & CPM_CR_FLG);
++	}
++	i2c->i2c_i2cmr = 0x00;	/* Disable all interrupts */
++	i2c->i2c_i2cer = 0xff; 
++}
++
++
++/* Read from IIC...
++ * abyte = address byte, with r/w flag already set
++ */
++static int
++cpm_iic_read(struct i2c_algo_8xx_data *cpm, u_char abyte, char *buf, int count)
++{
++	volatile iic_t *iip = cpm->iip;
++	volatile i2c8xx_t *i2c = cpm->i2c;
++	volatile cpm8xx_t *cp = cpm->cp;
++	volatile cbd_t	*tbdf, *rbdf;
++	u_char *tb;
++	unsigned long flags, tmo;
++
++	if (count >= CPM_MAX_READ)
++		return -EINVAL;
++
++	/* check for and use a microcode relocation patch */
++	if (cpm->reloc) {
++		cpm_reset_iic_params(iip);
++	}
++
++	tbdf = (cbd_t *)&cp->cp_dpmem[iip->iic_tbase];
++	rbdf = (cbd_t *)&cp->cp_dpmem[iip->iic_rbase];
++
++	/* To read, we need an empty buffer of the proper length.
++	 * All that is used is the first byte for address, the remainder
++	 * is just used for timing (and doesn't really have to exist).
++	 */
++	tb = cpm->temp;
++	tb = (u_char *)(((uint)tb + 15) & ~15);
++	tb[0] = abyte;		/* Device address byte w/rw flag */
++
++	flush_dcache_range((unsigned long) tb, (unsigned long) (tb+1));
++
++	if (cpm_debug) printk("cpm_iic_read(abyte=0x%x)\n", abyte);
++
++	tbdf->cbd_bufaddr = __pa(tb);
++	tbdf->cbd_datlen = count + 1;
++	tbdf->cbd_sc =
++		BD_SC_READY | BD_SC_LAST |
++		BD_SC_WRAP | BD_IIC_START;
++
++	iip->iic_mrblr = count +1; /* prevent excessive read, +1
++				      is needed otherwise will the
++				      RXB interrupt come too early */
++
++	/* flush will invalidate too. */
++	flush_dcache_range((unsigned long) buf, (unsigned long) (buf+count));
++
++	rbdf->cbd_datlen = 0;
++	rbdf->cbd_bufaddr = __pa(buf);
++	rbdf->cbd_sc = BD_SC_EMPTY | BD_SC_WRAP| BD_SC_INTRPT;
++	if(count > 16){
++		/* Chip bug, set enable here */
++		local_irq_save(flags);
++		i2c->i2c_i2cmr = 0x13;	/* Enable some interupts */
++		i2c->i2c_i2cer = 0xff;
++		i2c->i2c_i2mod |= 1;	/* Enable */
++		i2c->i2c_i2com |= 0x80;	/* Begin transmission */
++
++		/* Wait for IIC transfer */
++		tmo = interruptible_sleep_on_timeout(&iic_wait,1*HZ);
++		local_irq_restore(flags);
++	} else { /* busy wait for small transfers, its faster */
++		i2c->i2c_i2cmr = 0x00;	/* Disable I2C interupts */
++		i2c->i2c_i2cer = 0xff;
++		i2c->i2c_i2mod |= 1;	/* Enable */
++		i2c->i2c_i2com |= 0x80;	/* Begin transmission */
++		tmo = jiffies + 1*HZ; 
++		while(!(i2c->i2c_i2cer & 0x11 || time_after(jiffies, tmo))); /* Busy wait, with a timeout */
++	}		
++
++	if (signal_pending(current) || !tmo){
++		force_close(cpm);
++		if(cpm_debug) 
++			printk("IIC read: timeout!\n");
++		return -EIO;
++	}
++#ifdef I2C_CHIP_ERRATA
++	/* Chip errata, clear enable. This is not needed on rev D4 CPUs.
++	 Disabling I2C too early may cause too short stop condition */
++	udelay(4);
++	i2c->i2c_i2mod &= ~1;
++#endif
++	if (cpm_debug) {
++		printk("tx sc %04x, rx sc %04x\n",
++		       tbdf->cbd_sc, rbdf->cbd_sc);
++	}
++
++	if (tbdf->cbd_sc & BD_SC_READY) {
++		printk("IIC read; complete but tbuf ready\n");
++		force_close(cpm);
++		printk("tx sc %04x, rx sc %04x\n",
++		       tbdf->cbd_sc, rbdf->cbd_sc);
++	}
++
++	if (tbdf->cbd_sc & BD_SC_NAK) {
++		if (cpm_debug)
++			printk("IIC read; no ack\n");
++		return -EREMOTEIO;
++	}
++
++	if (rbdf->cbd_sc & BD_SC_EMPTY) {
++		/* force_close(cpm); */
++		if (cpm_debug){
++			printk("IIC read; complete but rbuf empty\n");
++			printk("tx sc %04x, rx sc %04x\n",
++			       tbdf->cbd_sc, rbdf->cbd_sc);
++		}
++		return -EREMOTEIO;
++	}
++
++	if (rbdf->cbd_sc & BD_SC_OV) {
++		if (cpm_debug)
++			printk("IIC read; Overrun\n");
++		return -EREMOTEIO;;
++	}
++
++	if (cpm_debug) printk("read %d bytes\n", rbdf->cbd_datlen);
++
++	if (rbdf->cbd_datlen < count) {
++		if (cpm_debug)
++			printk("IIC read; short, wanted %d got %d\n",
++			       count, rbdf->cbd_datlen);
++		return 0;
++	}
++
++	return count;
++}
++
++/* Write to IIC...
++ * addr = address byte, with r/w flag already set
++ */
++static int
++cpm_iic_write(struct i2c_algo_8xx_data *cpm, u_char abyte, char *buf,int count)
++{
++	volatile iic_t *iip = cpm->iip;
++	volatile i2c8xx_t *i2c = cpm->i2c;
++	volatile cpm8xx_t *cp = cpm->cp;
++	volatile cbd_t	*tbdf;
++	u_char *tb;
++	unsigned long flags, tmo;
++
++	/* check for and use a microcode relocation patch */
++	if (cpm->reloc) {
++		cpm_reset_iic_params(iip);
++	}
++	tb = cpm->temp;
++	tb = (u_char *)(((uint)tb + 15) & ~15);
++	*tb = abyte;		/* Device address byte w/rw flag */
++
++	flush_dcache_range((unsigned long) tb, (unsigned long) (tb+1));
++	flush_dcache_range((unsigned long) buf, (unsigned long) (buf+count));
++
++	if (cpm_debug) printk("cpm_iic_write(abyte=0x%x)\n", abyte);
++
++	/* set up 2 descriptors */
++	tbdf = (cbd_t *)&cp->cp_dpmem[iip->iic_tbase];
++
++	tbdf[0].cbd_bufaddr = __pa(tb);
++	tbdf[0].cbd_datlen = 1;
++	tbdf[0].cbd_sc = BD_SC_READY | BD_IIC_START;
++
++	tbdf[1].cbd_bufaddr = __pa(buf);
++	tbdf[1].cbd_datlen = count;
++	tbdf[1].cbd_sc = BD_SC_READY | BD_SC_INTRPT | BD_SC_LAST | BD_SC_WRAP;
++
++	if(count > 16){
++		/* Chip bug, set enable here */
++		local_irq_save(flags);
++		i2c->i2c_i2cmr = 0x13;	/* Enable some interupts */
++		i2c->i2c_i2cer = 0xff;
++		i2c->i2c_i2mod |= 1;	/* Enable */
++		i2c->i2c_i2com |= 0x80;	/* Begin transmission */
++		
++		/* Wait for IIC transfer */
++		tmo = interruptible_sleep_on_timeout(&iic_wait,1*HZ);
++		local_irq_restore(flags);
++	} else {  /* busy wait for small transfers, its faster */
++		i2c->i2c_i2cmr = 0x00;	/* Disable I2C interupts */
++		i2c->i2c_i2cer = 0xff;
++		i2c->i2c_i2mod |= 1;	/* Enable */
++		i2c->i2c_i2com |= 0x80;	/* Begin transmission */
++		tmo = jiffies + 1*HZ; 
++		while(!(i2c->i2c_i2cer & 0x12 || time_after(jiffies, tmo))); /* Busy wait, with a timeout */
++	}		
++
++	if (signal_pending(current) || !tmo){
++		force_close(cpm);
++		if(cpm_debug && !tmo) 
++			printk("IIC write: timeout!\n");
++		return -EIO;
++	}
++	
++#if I2C_CHIP_ERRATA
++	/* Chip errata, clear enable. This is not needed on rev D4 CPUs.
++	 Disabling I2C too early may cause too short stop condition */
++	udelay(4);
++	i2c->i2c_i2mod &= ~1;
++#endif
++	if (cpm_debug) {
++		printk("tx0 sc %04x, tx1 sc %04x\n",
++		       tbdf[0].cbd_sc, tbdf[1].cbd_sc);
++	}
++
++	if (tbdf->cbd_sc & BD_SC_NAK) {
++		if (cpm_debug) 
++			printk("IIC write; no ack\n");
++		return 0;
++	}
++	  
++	if (tbdf->cbd_sc & BD_SC_READY) {
++		if (cpm_debug)
++			printk("IIC write; complete but tbuf ready\n");
++		return 0;
++	}
++
++	return count;
++}
++
++/* See if an IIC address exists..
++ * addr = 7 bit address, unshifted
++ */
++static int
++cpm_iic_tryaddress(struct i2c_algo_8xx_data *cpm, int addr)
++{
++	volatile iic_t *iip = cpm->iip;
++	volatile i2c8xx_t *i2c = cpm->i2c;
++	volatile cpm8xx_t *cp = cpm->cp;
++	volatile cbd_t *tbdf, *rbdf;
++	u_char *tb;
++	unsigned long flags, len, tmo;
++
++	if (cpm_debug > 1)
++		printk("cpm_iic_tryaddress(cpm=%p,addr=%d)\n", cpm, addr);
++
++	/* check for and use a microcode relocation patch */
++	if (cpm->reloc) {
++		cpm_reset_iic_params(iip);
++	}
++
++	if (cpm_debug && addr == 0) {
++		printk("iip %p, dp_addr 0x%x\n", cpm->iip, cpm->dp_addr);
++		printk("iic_tbase %d, r_tbase %d\n", iip->iic_tbase, r_tbase);
++	}
++
++	tbdf = (cbd_t *)&cp->cp_dpmem[iip->iic_tbase];
++	rbdf = (cbd_t *)&cp->cp_dpmem[iip->iic_rbase];
++
++	tb = cpm->temp;
++	tb = (u_char *)(((uint)tb + 15) & ~15);
++
++	/* do a simple read */
++	tb[0] = (addr << 1) | 1;	/* device address (+ read) */
++	len = 2;
++
++	flush_dcache_range((unsigned long) tb, (unsigned long) (tb+2));
++
++	tbdf->cbd_bufaddr = __pa(tb);
++	tbdf->cbd_datlen = len;
++	tbdf->cbd_sc =
++		BD_SC_READY | BD_SC_LAST |
++		BD_SC_WRAP | BD_IIC_START;
++
++	rbdf->cbd_datlen = 0;
++	rbdf->cbd_bufaddr = __pa(tb+2);
++	rbdf->cbd_sc = BD_SC_EMPTY | BD_SC_WRAP | BD_SC_INTRPT;
++
++	local_irq_save(flags);
++	i2c->i2c_i2cmr = 0x13;	/* Enable some interupts */
++	i2c->i2c_i2cer = 0xff;
++	i2c->i2c_i2mod |= 1;	/* Enable */
++	i2c->i2c_i2com |= 0x80;	/* Begin transmission */
++
++	if (cpm_debug > 1) printk("about to sleep\n");
++
++	/* wait for IIC transfer */
++	tmo = interruptible_sleep_on_timeout(&iic_wait,1*HZ);
++	local_irq_restore(flags);
++
++#ifdef I2C_CHIP_ERRATA
++	/* Chip errata, clear enable. This is not needed on rev D4 CPUs.
++	 Disabling I2C too early may cause too short stop condition */
++	udelay(4);
++	i2c->i2c_i2mod &= ~1;
++#endif
++
++	if (signal_pending(current) || !tmo){
++		force_close(cpm);
++		if(cpm_debug && !tmo) 
++			printk("IIC tryaddress: timeout!\n");
++		return -EIO;
++	}
++
++	if (cpm_debug > 1) printk("back from sleep\n");
++
++	if (tbdf->cbd_sc & BD_SC_NAK) {
++		if (cpm_debug > 1) printk("IIC try; no ack\n");
++		return 0;
++	}
++	  
++	if (tbdf->cbd_sc & BD_SC_READY) {
++		printk("IIC try; complete but tbuf ready\n");
++	}
++	
++	return 1;
++}
++
++static int cpm_xfer(struct i2c_adapter *adap,
++		    struct i2c_msg msgs[], 
++		    int num)
++{
++	struct i2c_algo_8xx_data *cpm = adap->algo_data;
++	struct i2c_msg *pmsg;
++	int i, ret;
++	u_char addr;
++    
++	for (i = 0; i < num; i++) {
++		pmsg = &msgs[i];
++
++		if (cpm_debug)
++			printk("i2c-algo-8xx.o: "
++			       "#%d addr=0x%x flags=0x%x len=%d\n buf=%lx\n",
++			       i, pmsg->addr, pmsg->flags, pmsg->len, (unsigned long)pmsg->buf);
++
++		addr = pmsg->addr << 1;
++		if (pmsg->flags & I2C_M_RD )
++			addr |= 1;
++		if (pmsg->flags & I2C_M_REV_DIR_ADDR )
++			addr ^= 1;
++    
++		if (!(pmsg->flags & I2C_M_NOSTART)) {
++		}
++		if (pmsg->flags & I2C_M_RD ) {
++			/* read bytes into buffer*/
++			ret = cpm_iic_read(cpm, addr, pmsg->buf, pmsg->len);
++			if (cpm_debug)
++				printk("i2c-algo-8xx.o: read %d bytes\n", ret);
++			if (ret < pmsg->len ) {
++				return (ret<0)? ret : -EREMOTEIO;
++			}
++		} else {
++			/* write bytes from buffer */
++			ret = cpm_iic_write(cpm, addr, pmsg->buf, pmsg->len);
++			if (cpm_debug)
++				printk("i2c-algo-8xx.o: wrote %d\n", ret);
++			if (ret < pmsg->len ) {
++				return (ret<0) ? ret : -EREMOTEIO;
++			}
++		}
++	}
++	return (num);
++}
++
++static u32 cpm_func(struct i2c_adapter *adap)
++{
++	return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR | 
++	       I2C_FUNC_PROTOCOL_MANGLING; 
++}
++
++/* -----exported algorithm data: -------------------------------------	*/
++
++static struct i2c_algorithm cpm_algo = {
++	.owner		= THIS_MODULE,
++	.name		= "MPC8xx CPM algorithm",
++	.id		= I2C_ALGO_MPC8XX,
++	.master_xfer	= cpm_xfer,
++	.functionality	= cpm_func,
++};
++
++/* 
++ * registering functions to load algorithms at runtime 
++ */
++int i2c_8xx_add_bus(struct i2c_adapter *adap)
++{
++	int i;
++	struct i2c_algo_8xx_data *cpm = adap->algo_data;
++
++	if (cpm_debug)
++		printk("i2c-algo-8xx.o: hw routines for %s registered.\n",
++		       adap->name);
++
++	/* register new adapter to i2c module... */
++
++	adap->id |= cpm_algo.id;
++	adap->algo = &cpm_algo;
++
++	i2c_add_adapter(adap);
++	cpm_iic_init(cpm);
++}
++
++
++int i2c_8xx_del_bus(struct i2c_adapter *adap)
++{
++	struct i2c_algo_8xx_data *cpm = adap->algo_data;
++
++	cpm_iic_shutdown(cpm);
++
++	return i2c_del_adapter(adap);
++}
++
++EXPORT_SYMBOL(i2c_8xx_add_bus);
++EXPORT_SYMBOL(i2c_8xx_del_bus);
++
++MODULE_AUTHOR("Brad Parker <brad@heeltoe.com>");
++MODULE_DESCRIPTION("I2C-Bus MPC8XX algorithm");
++MODULE_LICENSE("GPL");
+--- linux-old/include/linux/i2c-algo-8xx.h	Thu Jan  1 00:00:00 1970
++++ linux/include/linux/i2c-algo-8xx.h	Mon Dec 13 19:26:27 2004
+@@ -0,0 +1,43 @@
++/* ------------------------------------------------------------------------- */
++/* i2c-algo-8xx.h i2c driver algorithms for MPX8XX CPM			     */
++/*
++    This program is free software; you can redistribute it and/or modify
++    it under the terms of the GNU General Public License as published by
++    the Free Software Foundation; either version 2 of the License, or
++    (at your option) any later version.
++
++    This program is distributed in the hope that it will be useful,
++    but WITHOUT ANY WARRANTY; without even the implied warranty of
++    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++    GNU General Public License for more details.
++
++    You should have received a copy of the GNU General Public License
++    along with this program; if not, write to the Free Software
++    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
++/* ------------------------------------------------------------------------- */
++
++/* $Id: i2c-algo-8xx.h,v 1.7 2003/08/01 20:56:38 khali Exp $ */
++
++#ifndef _LINUX_I2C_ALGO_8XX_H
++#define _LINUX_I2C_ALGO_8XX_H
++
++#include "asm/commproc.h"
++
++struct i2c_algo_8xx_data {
++	uint dp_addr;
++	int reloc;
++	volatile i2c8xx_t *i2c;
++	volatile iic_t	*iip;
++	volatile cpm8xx_t *cp;
++
++	int	(*setisr) (int irq,
++			   void (*func)(void *, void *),
++			   void *data);
++
++	u_char	temp[513];
++};
++
++int i2c_8xx_add_bus(struct i2c_adapter *);
++int i2c_8xx_del_bus(struct i2c_adapter *);
++
++#endif /* _LINUX_I2C_ALGO_8XX_H */
+--- linux-old/drivers/i2c/i2c-algo-bit.c	Tue Jan 20 15:10:31 2004
++++ linux/drivers/i2c/i2c-algo-bit.c	Mon Dec 13 19:26:27 2004
+@@ -18,24 +18,22 @@
+     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.		     */
+ /* ------------------------------------------------------------------------- */
+ 
+-/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
+-   Frodo Looijaard <frodol@dds.nl> */
++/* With some changes from Frodo Looijaard <frodol@dds.nl>, Kyösti Mälkki
++   <kmalkki@cc.hut.fi> and Jean Delvare <khali@linux-fr.org> */
+ 
+-/* $Id: i2c-algo-bit.c,v 1.30 2001/07/29 02:44:25 mds Exp $ */
++/* $Id: i2c-algo-bit.c,v 1.50 2003/12/22 20:03:39 khali Exp $ */
+ 
+ #include <linux/kernel.h>
+ #include <linux/module.h>
+ #include <linux/delay.h>
+ #include <linux/slab.h>
+ #include <linux/init.h>
+-#include <asm/uaccess.h>
+-#include <linux/ioport.h>
+ #include <linux/errno.h>
+ #include <linux/sched.h>
+-
+ #include <linux/i2c.h>
+ #include <linux/i2c-algo-bit.h>
+ 
++
+ /* ----- global defines ----------------------------------------------- */
+ #define DEB(x) if (i2c_debug>=1) x;
+ #define DEB2(x) if (i2c_debug>=2) x;
+@@ -43,27 +41,13 @@
+ #define DEBPROTO(x) if (i2c_debug>=9) { x; }
+  	/* debug the protocol by showing transferred bits */
+ 
+-/* debugging - slow down transfer to have a look at the data .. 	*/
+-/* I use this with two leds&resistors, each one connected to sda,scl 	*/
+-/* respectively. This makes sure that the algorithm works. Some chips   */
+-/* might not like this, as they have an internal timeout of some mils	*/
+-/*
+-#define SLO_IO      jif=jiffies;while(time_before_eq(jiffies, jif+i2c_table[minor].veryslow))\
+-                        if (need_resched) schedule();
+-*/
+-
+ 
+ /* ----- global variables ---------------------------------------------	*/
+ 
+-#ifdef SLO_IO
+-	int jif;
+-#endif
+-
+ /* module parameters:
+  */
+ static int i2c_debug;
+ static int bit_test;	/* see if the line-setting functions work	*/
+-static int bit_scan;	/* have a look at what's hanging 'round		*/
+ 
+ /* --- setting states on the bus with the right timing: ---------------	*/
+ 
+@@ -88,9 +72,6 @@
+ {
+ 	setscl(adap,0);
+ 	udelay(adap->udelay);
+-#ifdef SLO_IO
+-	SLO_IO
+-#endif
+ }
+ 
+ /*
+@@ -99,33 +80,35 @@
+  */
+ static inline int sclhi(struct i2c_algo_bit_data *adap)
+ {
+-	int start=jiffies;
++	int start;
+ 
+ 	setscl(adap,1);
+ 
+-	udelay(adap->udelay);
+-
+ 	/* Not all adapters have scl sense line... */
+-	if (adap->getscl == NULL )
++	if (adap->getscl == NULL ) {
++		udelay(adap->udelay);
+ 		return 0;
++	}
+ 
+- 	while (! getscl(adap) ) {	
++	start=jiffies;
++	while (! getscl(adap) ) {	
+  		/* the hw knows how to read the clock line,
+  		 * so we wait until it actually gets high.
+  		 * This is safer as some chips may hold it low
+  		 * while they are processing data internally. 
+  		 */
+-		setscl(adap,1);
+ 		if (time_after_eq(jiffies, start+adap->timeout)) {
+ 			return -ETIMEDOUT;
+ 		}
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
+ 		if (current->need_resched)
+ 			schedule();
++#else
++		cond_resched();
++#endif
+ 	}
+ 	DEBSTAT(printk(KERN_DEBUG "needed %ld jiffies\n", jiffies-start));
+-#ifdef SLO_IO
+-	SLO_IO
+-#endif
++	udelay(adap->udelay);
+ 	return 0;
+ } 
+ 
+@@ -144,7 +127,7 @@
+ 	/* scl, sda may not be high */
+ 	DEBPROTO(printk(" Sr "));
+ 	setsda(adap,1);
+-	setscl(adap,1);
++	sclhi(adap);
+ 	udelay(adap->udelay);
+ 	
+ 	sdalo(adap);
+@@ -178,7 +161,6 @@
+ 	struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
+ 
+ 	/* assert: scl is low */
+-	DEB2(printk(KERN_DEBUG " i2c_outb:%2.2X\n",c&0xff));
+ 	for ( i=7 ; i>=0 ; i-- ) {
+ 		sb = c & ( 1 << i );
+ 		setsda(adap,sb);
+@@ -186,6 +168,7 @@
+ 		DEBPROTO(printk(KERN_DEBUG "%d",sb!=0));
+ 		if (sclhi(adap)<0) { /* timed out */
+ 			sdahi(adap); /* we don't want to block the net */
++			DEB2(printk(KERN_DEBUG " i2c_outb: 0x%02x, timeout at bit #%d\n", c&0xff, i));
+ 			return -ETIMEDOUT;
+ 		};
+ 		/* do arbitration here: 
+@@ -196,11 +179,12 @@
+ 	}
+ 	sdahi(adap);
+ 	if (sclhi(adap)<0){ /* timeout */
++		DEB2(printk(KERN_DEBUG " i2c_outb: 0x%02x, timeout at ack\n", c&0xff));
+ 		return -ETIMEDOUT;
+ 	};
+ 	/* read ack: SDA should be pulled down by slave */
+ 	ack=getsda(adap);	/* ack: sda is pulled low ->success.	 */
+-	DEB2(printk(KERN_DEBUG " i2c_outb: getsda() =  0x%2.2x\n", ~ack ));
++	DEB2(printk(KERN_DEBUG " i2c_outb: 0x%02x , getsda() = %d\n", c & 0xff, ack));
+ 
+ 	DEBPROTO( printk(KERN_DEBUG "[%2.2x]",c&0xff) );
+ 	DEBPROTO(if (0==ack){ printk(KERN_DEBUG " A ");} else printk(KERN_DEBUG " NA ") );
+@@ -219,11 +203,10 @@
+ 	struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
+ 
+ 	/* assert: scl is low */
+-	DEB2(printk(KERN_DEBUG "i2c_inb.\n"));
+-
+ 	sdahi(adap);
+ 	for (i=0;i<8;i++) {
+ 		if (sclhi(adap)<0) { /* timeout */
++			DEB2(printk(KERN_DEBUG " i2c_inb: timeout at bit #%d\n", 7-i));
+ 			return -ETIMEDOUT;
+ 		};
+ 		indata *= 2;
+@@ -232,6 +215,8 @@
+ 		scllo(adap);
+ 	}
+ 	/* assert: scl is low */
++	DEB2(printk(KERN_DEBUG "i2c_inb: 0x%02x\n", indata & 0xff));
++
+ 	DEBPROTO(printk(KERN_DEBUG " 0x%02x", indata & 0xff));
+ 	return (int) (indata & 0xff);
+ }
+@@ -242,71 +227,75 @@
+  */
+ static int test_bus(struct i2c_algo_bit_data *adap, char* name) {
+ 	int scl,sda;
++
++	if (adap->getscl==NULL)
++		printk(KERN_INFO "i2c-algo-bit.o: Testing SDA only, "
++			"SCL is not readable.\n");
++
+ 	sda=getsda(adap);
+-	if (adap->getscl==NULL) {
+-		printk("i2c-algo-bit.o: Warning: Adapter can't read from clock line - skipping test.\n");
+-		return 0;		
+-	}
+-	scl=getscl(adap);
+-	printk("i2c-algo-bit.o: Adapter: %s scl: %d  sda: %d -- testing...\n",
+-	       name,getscl(adap),getsda(adap));
++	scl=(adap->getscl==NULL?1:getscl(adap));
++	printk(KERN_DEBUG "i2c-algo-bit.o: (0) scl=%d, sda=%d\n",scl,sda);
+ 	if (!scl || !sda ) {
+-		printk("i2c-algo-bit.o: %s seems to be busy.\n",name);
++		printk(KERN_WARNING "i2c-algo-bit.o: %s seems to be busy.\n", name);
+ 		goto bailout;
+ 	}
++
+ 	sdalo(adap);
+-	printk("i2c-algo-bit.o:1 scl: %d  sda: %d \n",getscl(adap),
+-	       getsda(adap));
+-	if ( 0 != getsda(adap) ) {
+-		printk("i2c-algo-bit.o: %s SDA stuck high!\n",name);
+-		sdahi(adap);
++	sda=getsda(adap);
++	scl=(adap->getscl==NULL?1:getscl(adap));
++	printk(KERN_DEBUG "i2c-algo-bit.o: (1) scl=%d, sda=%d\n",scl,sda);
++	if ( 0 != sda ) {
++		printk(KERN_WARNING "i2c-algo-bit.o: SDA stuck high!\n");
+ 		goto bailout;
+ 	}
+-	if ( 0 == getscl(adap) ) {
+-		printk("i2c-algo-bit.o: %s SCL unexpected low while pulling SDA low!\n",
+-			name);
++	if ( 0 == scl ) {
++		printk(KERN_WARNING "i2c-algo-bit.o: SCL unexpected low "
++			"while pulling SDA low!\n");
+ 		goto bailout;
+ 	}		
++
+ 	sdahi(adap);
+-	printk("i2c-algo-bit.o:2 scl: %d  sda: %d \n",getscl(adap),
+-	       getsda(adap));
+-	if ( 0 == getsda(adap) ) {
+-		printk("i2c-algo-bit.o: %s SDA stuck low!\n",name);
+-		sdahi(adap);
++	sda=getsda(adap);
++	scl=(adap->getscl==NULL?1:getscl(adap));
++	printk(KERN_DEBUG "i2c-algo-bit.o: (2) scl=%d, sda=%d\n",scl,sda);
++	if ( 0 == sda ) {
++		printk(KERN_WARNING "i2c-algo-bit.o: SDA stuck low!\n");
+ 		goto bailout;
+ 	}
+-	if ( 0 == getscl(adap) ) {
+-		printk("i2c-algo-bit.o: %s SCL unexpected low while SDA high!\n",
+-		       name);
+-	goto bailout;
++	if ( 0 == scl ) {
++		printk(KERN_WARNING "i2c-algo-bit.o: SCL unexpected low "
++			"while pulling SDA high!\n");
++		goto bailout;
+ 	}
++
+ 	scllo(adap);
+-	printk("i2c-algo-bit.o:3 scl: %d  sda: %d \n",getscl(adap),
+-	       getsda(adap));
+-	if ( 0 != getscl(adap) ) {
+-		printk("i2c-algo-bit.o: %s SCL stuck high!\n",name);
+-		sclhi(adap);
++	sda=getsda(adap);
++	scl=(adap->getscl==NULL?0:getscl(adap));
++	printk(KERN_DEBUG "i2c-algo-bit.o: (3) scl=%d, sda=%d\n",scl,sda);
++	if ( 0 != scl ) {
++		printk(KERN_WARNING "i2c-algo-bit.o: SCL stuck high!\n");
+ 		goto bailout;
+ 	}
+-	if ( 0 == getsda(adap) ) {
+-		printk("i2c-algo-bit.o: %s SDA unexpected low while pulling SCL low!\n",
+-			name);
++	if ( 0 == sda ) {
++		printk(KERN_WARNING "i2c-algo-bit.o: SDA unexpected low "
++			"while pulling SCL low!\n");
+ 		goto bailout;
+ 	}
++	
+ 	sclhi(adap);
+-	printk("i2c-algo-bit.o:4 scl: %d  sda: %d \n",getscl(adap),
+-	       getsda(adap));
+-	if ( 0 == getscl(adap) ) {
+-		printk("i2c-algo-bit.o: %s SCL stuck low!\n",name);
+-		sclhi(adap);
++	sda=getsda(adap);
++	scl=(adap->getscl==NULL?1:getscl(adap));
++	printk(KERN_DEBUG "i2c-algo-bit.o: (4) scl=%d, sda=%d\n",scl,sda);
++	if ( 0 == scl ) {
++		printk(KERN_WARNING "i2c-algo-bit.o: SCL stuck low!\n");
+ 		goto bailout;
+ 	}
+-	if ( 0 == getsda(adap) ) {
+-		printk("i2c-algo-bit.o: %s SDA unexpected low while SCL high!\n",
+-			name);
++	if ( 0 == sda ) {
++		printk(KERN_WARNING "i2c-algo-bit.o: SDA unexpected low "
++			"while pulling SCL high!\n");
+ 		goto bailout;
+ 	}
+-	printk("i2c-algo-bit.o: %s passed test.\n",name);
++	printk(KERN_INFO "i2c-algo-bit.o: %s passed test.\n",name);
+ 	return 0;
+ bailout:
+ 	sdahi(adap);
+@@ -340,16 +329,21 @@
+ 		i2c_start(adap);
+ 		udelay(adap->udelay);
+ 	}
+-	DEB2(if (i) printk(KERN_DEBUG "i2c-algo-bit.o: needed %d retries for %d\n",
+-	                   i,addr));
++	DEB2(if (i)
++	     printk(KERN_DEBUG "i2c-algo-bit.o: Used %d tries to %s client at 0x%02x : %s\n",
++		    i+1, addr & 1 ? "read" : "write", addr>>1,
++		    ret==1 ? "success" : ret==0 ? "no ack" : "failed, timeout?" )
++	    );
+ 	return ret;
+ }
+ 
+-static int sendbytes(struct i2c_adapter *i2c_adap,const char *buf, int count)
++static int sendbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
+ {
+ 	struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
+ 	char c;
+-	const char *temp = buf;
++	const char *temp = msg->buf;
++	int count = msg->len;
++	unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK; 
+ 	int retval;
+ 	int wrcount=0;
+ 
+@@ -358,7 +352,7 @@
+ 		DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: %s sendbytes: writing %2.2X\n",
+ 			    i2c_adap->name, c&0xff));
+ 		retval = i2c_outb(i2c_adap,c);
+-		if (retval>0) {
++		if ((retval>0) || (nak_ok && (retval==0)))  { /* ok or ignored NAK */
+ 			count--; 
+ 			temp++;
+ 			wrcount++;
+@@ -377,12 +371,18 @@
+ 	return wrcount;
+ }
+ 
+-static inline int readbytes(struct i2c_adapter *i2c_adap,char *buf,int count)
++static inline int readbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
+ {
+-	char *temp = buf;
+ 	int inval;
+ 	int rdcount=0;   	/* counts bytes read */
+ 	struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
++	char *temp = msg->buf;
++	int count = msg->len;
++	int recv_len = 0;
++
++	/* Receive [Count] for I2C_SMBUS_BLOCK_DATA or I2C_SMBUS_BLOCK_PROC_CALL protocol */
++	if (msg->flags & I2C_M_RECV_LEN)
++		recv_len = 1;
+ 
+ 	while (count > 0) {
+ 		inval = i2c_inb(i2c_adap);
+@@ -395,6 +395,20 @@
+ 			break;
+ 		}
+ 
++		if (recv_len) {
++			recv_len = 0;
++			/* [Count] should be between 1 and 31 (I2C_SMBUS_BLOCK_MAX - 1). */
++			if (inval > 0 && inval < I2C_SMBUS_BLOCK_MAX) {
++				count = inval + 1;	/* plus one for [Count] itself */
++				msg->len = count;
++				if (msg->flags & I2C_M_RECV_PEC)
++					count++; /* plus one for PEC */
++			} else {
++				printk(KERN_ERR "i2c-algo-bit.o: readbytes: bad block count (%d).\n", inval);
++				break;
++			}
++		}
++		
+ 		if ( count > 1 ) {		/* send ack */
+ 			sdalo(adap);
+ 			DEBPROTO(printk(" Am "));
+@@ -419,31 +433,34 @@
+  * try_address) and transmits the address in the necessary format to handle
+  * reads, writes as well as 10bit-addresses.
+  * returns:
+- *  0 everything went okay, the chip ack'ed
++ *  0 everything went okay, the chip ack'ed, or IGNORE_NAK flag was set
+  * -x an error occurred (like: -EREMOTEIO if the device did not answer, or
+  *	-ETIMEDOUT, for example if the lines are stuck...) 
+  */
+-static inline int bit_doAddress(struct i2c_adapter *i2c_adap,
+-                                struct i2c_msg *msg, int retries) 
++static inline int bit_doAddress(struct i2c_adapter *i2c_adap, struct i2c_msg *msg) 
+ {
+ 	unsigned short flags = msg->flags;
++	unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK;
+ 	struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
+ 
+ 	unsigned char addr;
+-	int ret;
++	int ret, retries;
++
++	retries = nak_ok ? 0 : i2c_adap->retries;
++	
+ 	if ( (flags & I2C_M_TEN)  ) { 
+ 		/* a ten bit address */
+ 		addr = 0xf0 | (( msg->addr >> 7) & 0x03);
+ 		DEB2(printk(KERN_DEBUG "addr0: %d\n",addr));
+ 		/* try extended address code...*/
+ 		ret = try_address(i2c_adap, addr, retries);
+-		if (ret!=1) {
++		if ((ret != 1) && !nak_ok)  {
+ 			printk(KERN_ERR "died at extended address code.\n");
+ 			return -EREMOTEIO;
+ 		}
+ 		/* the remaining 8 bit address */
+ 		ret = i2c_outb(i2c_adap,msg->addr & 0x7f);
+-		if (ret != 1) {
++		if ((ret != 1) && !nak_ok) {
+ 			/* the chip did not ack / xmission error occurred */
+ 			printk(KERN_ERR "died at 2nd address code.\n");
+ 			return -EREMOTEIO;
+@@ -453,7 +470,7 @@
+ 			/* okay, now switch into reading mode */
+ 			addr |= 0x01;
+ 			ret = try_address(i2c_adap, addr, retries);
+-			if (ret!=1) {
++			if ((ret!=1) && !nak_ok) {
+ 				printk(KERN_ERR "died at extended address code.\n");
+ 				return -EREMOTEIO;
+ 			}
+@@ -465,10 +482,10 @@
+ 		if (flags & I2C_M_REV_DIR_ADDR )
+ 			addr ^= 1;
+ 		ret = try_address(i2c_adap, addr, retries);
+-		if (ret!=1) {
++		if ((ret!=1) && !nak_ok)
+ 			return -EREMOTEIO;
+-		}
+ 	}
++
+ 	return 0;
+ }
+ 
+@@ -479,16 +496,18 @@
+ 	struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
+ 	
+ 	int i,ret;
++	unsigned short nak_ok;
+ 
+ 	i2c_start(adap);
+ 	for (i=0;i<num;i++) {
+ 		pmsg = &msgs[i];
++		nak_ok = pmsg->flags & I2C_M_IGNORE_NAK; 
+ 		if (!(pmsg->flags & I2C_M_NOSTART)) {
+ 			if (i) {
+ 				i2c_repstart(adap);
+ 			}
+-			ret = bit_doAddress(i2c_adap,pmsg,i2c_adap->retries);
+-			if (ret != 0) {
++			ret = bit_doAddress(i2c_adap, pmsg);
++			if ((ret != 0) && !nak_ok) {
+ 				DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: NAK from device addr %2.2x msg #%d\n",
+ 					msgs[i].addr,i));
+ 				return (ret<0) ? ret : -EREMOTEIO;
+@@ -496,14 +515,14 @@
+ 		}
+ 		if (pmsg->flags & I2C_M_RD ) {
+ 			/* read bytes into buffer*/
+-			ret = readbytes(i2c_adap,pmsg->buf,pmsg->len);
++			ret = readbytes(i2c_adap, pmsg);
+ 			DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: read %d bytes.\n",ret));
+ 			if (ret < pmsg->len ) {
+ 				return (ret<0)? ret : -EREMOTEIO;
+ 			}
+ 		} else {
+ 			/* write bytes from buffer */
+-			ret = sendbytes(i2c_adap,pmsg->buf,pmsg->len);
++			ret = sendbytes(i2c_adap, pmsg);
+ 			DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: wrote %d bytes.\n",ret));
+ 			if (ret < pmsg->len ) {
+ 				return (ret<0) ? ret : -EREMOTEIO;
+@@ -514,30 +533,25 @@
+ 	return num;
+ }
+ 
+-static int algo_control(struct i2c_adapter *adapter, 
+-	unsigned int cmd, unsigned long arg)
+-{
+-	return 0;
+-}
+-
+-static u32 bit_func(struct i2c_adapter *adap)
++static u32 bit_func(struct i2c_adapter *i2c_adap)
+ {
+ 	return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR | 
+-	       I2C_FUNC_PROTOCOL_MANGLING;
++	       I2C_FUNC_PROTOCOL_MANGLING |
++	       I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
++	       I2C_FUNC_SMBUS_READ_BLOCK_DATA |
++	       I2C_FUNC_SMBUS_BLOCK_PROC_CALL_PEC |
++	       I2C_FUNC_SMBUS_READ_BLOCK_DATA_PEC;
+ }
+ 
+ 
+ /* -----exported algorithm data: -------------------------------------	*/
+ 
+ static struct i2c_algorithm i2c_bit_algo = {
+-	"Bit-shift algorithm",
+-	I2C_ALGO_BIT,
+-	bit_xfer,
+-	NULL,
+-	NULL,				/* slave_xmit		*/
+-	NULL,				/* slave_recv		*/
+-	algo_control,			/* ioctl		*/
+-	bit_func,			/* functionality	*/
++	.owner		= THIS_MODULE,
++	.name		= "Bit-shift algorithm",
++	.id		= I2C_ALGO_BIT,
++	.master_xfer	= bit_xfer,
++	.functionality	= bit_func,
+ };
+ 
+ /* 
+@@ -545,7 +559,6 @@
+  */
+ int i2c_bit_add_bus(struct i2c_adapter *adap)
+ {
+-	int i;
+ 	struct i2c_algo_bit_data *bit_adap = adap->algo_data;
+ 
+ 	if (bit_test) {
+@@ -565,78 +578,26 @@
+ 	adap->timeout = 100;	/* default values, should	*/
+ 	adap->retries = 3;	/* be replaced by defines	*/
+ 
+-	/* scan bus */
+-	if (bit_scan) {
+-		int ack;
+-		printk(KERN_INFO " i2c-algo-bit.o: scanning bus %s.\n",
+-		       adap->name);
+-		for (i = 0x00; i < 0xff; i+=2) {
+-			i2c_start(bit_adap);
+-			ack = i2c_outb(adap,i);
+-			i2c_stop(bit_adap);
+-			if (ack>0) {
+-				printk("(%02x)",i>>1); 
+-			} else 
+-				printk("."); 
+-		}
+-		printk("\n");
+-	}
+-
+-#ifdef MODULE
+-	MOD_INC_USE_COUNT;
+-#endif
+ 	i2c_add_adapter(adap);
+-
+ 	return 0;
+ }
+ 
+ 
+ int i2c_bit_del_bus(struct i2c_adapter *adap)
+ {
+-	int res;
+-
+-	if ((res = i2c_del_adapter(adap)) < 0)
+-		return res;
+-
+-	DEB2(printk("i2c-algo-bit.o: adapter unregistered: %s\n",adap->name));
+-
+-#ifdef MODULE
+-	MOD_DEC_USE_COUNT;
+-#endif
+-	return 0;
+-}
+-
+-int __init i2c_algo_bit_init (void)
+-{
+-	printk(KERN_INFO "i2c-algo-bit.o: i2c bit algorithm module\n");
+-	return 0;
++	return i2c_del_adapter(adap);
+ }
+ 
+-
+-
+ EXPORT_SYMBOL(i2c_bit_add_bus);
+ EXPORT_SYMBOL(i2c_bit_del_bus);
+ 
+-#ifdef MODULE
+ MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
+ MODULE_DESCRIPTION("I2C-Bus bit-banging algorithm");
+ MODULE_LICENSE("GPL");
+ 
+ MODULE_PARM(bit_test, "i");
+-MODULE_PARM(bit_scan, "i");
+ MODULE_PARM(i2c_debug,"i");
+ 
+ MODULE_PARM_DESC(bit_test, "Test the lines of the bus to see if it is stuck");
+-MODULE_PARM_DESC(bit_scan, "Scan for active chips on the bus");
+ MODULE_PARM_DESC(i2c_debug,
+             "debug level - 0 off; 1 normal; 2,3 more verbose; 9 bit-protocol");
+-
+-int init_module(void) 
+-{
+-	return i2c_algo_bit_init();
+-}
+-
+-void cleanup_module(void) 
+-{
+-}
+-#endif
+--- linux-old/include/linux/i2c-algo-bit.h	Sat Feb  5 06:47:38 2000
++++ linux/include/linux/i2c-algo-bit.h	Mon Dec 13 19:26:28 2004
+@@ -21,12 +21,10 @@
+ /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
+    Frodo Looijaard <frodol@dds.nl> */
+ 
+-/* $Id: i2c-algo-bit.h,v 1.7 1999/12/21 23:45:58 frodo Exp $ */
++/* $Id: i2c-algo-bit.h,v 1.11 2003/07/25 07:56:42 khali Exp $ */
+ 
+-#ifndef I2C_ALGO_BIT_H
+-#define I2C_ALGO_BIT_H 1
+-
+-#include <linux/i2c.h>
++#ifndef _LINUX_I2C_ALGO_BIT_H
++#define _LINUX_I2C_ALGO_BIT_H
+ 
+ /* --- Defines for bit-adapters ---------------------------------------	*/
+ /*
+@@ -42,9 +40,10 @@
+ 	int  (*getscl) (void *data);
+ 
+ 	/* local settings */
+-	int udelay;
+-	int mdelay;
+-	int timeout;
++	int udelay;		/* half-clock-cycle time in microsecs */
++				/* i.e. clock is (500 / udelay) KHz */
++	int mdelay;		/* in millisecs, unused */
++	int timeout;		/* in jiffies */
+ };
+ 
+ #define I2C_BIT_ADAP_MAX	16
+@@ -52,4 +51,4 @@
+ int i2c_bit_add_bus(struct i2c_adapter *);
+ int i2c_bit_del_bus(struct i2c_adapter *);
+ 
+-#endif /* I2C_ALGO_BIT_H */
++#endif /* _LINUX_I2C_ALGO_BIT_H */
+--- linux-old/drivers/i2c/i2c-algo-ibm_ocp.c	Thu Jan  1 00:00:00 1970
++++ linux/drivers/i2c/i2c-algo-ibm_ocp.c	Mon Dec 13 19:26:29 2004
+@@ -0,0 +1,901 @@
++/*
++   -------------------------------------------------------------------------
++   i2c-algo-ibm_ocp.c i2c driver algorithms for IBM PPC 405 adapters	    
++   -------------------------------------------------------------------------
++      
++   Ian DaSilva, MontaVista Software, Inc.
++   idasilva@mvista.com or source@mvista.com
++
++   Copyright 2000 MontaVista Software Inc.
++
++   Changes made to support the IIC peripheral on the IBM PPC 405
++
++
++   ---------------------------------------------------------------------------
++   This file was highly leveraged from i2c-algo-pcf.c, which was created
++   by Simon G. Vogl and Hans Berglund:
++
++
++     Copyright (C) 1995-1997 Simon G. Vogl
++                   1998-2000 Hans Berglund
++
++   With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and 
++   Frodo Looijaard <frodol@dds.nl> ,and also from Martin Bailey
++   <mbailey@littlefeet-inc.com>
++
++
++    This program is free software; you can redistribute it and/or modify
++    it under the terms of the GNU General Public License as published by
++    the Free Software Foundation; either version 2 of the License, or
++    (at your option) any later version.
++
++    This program is distributed in the hope that it will be useful,
++    but WITHOUT ANY WARRANTY; without even the implied warranty of
++    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++    GNU General Public License for more details.
++
++    You should have received a copy of the GNU General Public License
++    along with this program; if not, write to the Free Software
++    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++   ---------------------------------------------------------------------------
++
++   History: 01/20/12 - Armin
++   	akuster@mvista.com
++   	ported up to 2.4.16+	
++
++   Version 02/03/25 - Armin
++       converted to ocp format
++       removed commented out or #if 0 code
++       added Gérard Basler's fix to iic_combined_transaction() such that it 
++       returns the number of successfully completed transfers .
++*/
++
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/delay.h>
++#include <linux/slab.h>
++#include <linux/init.h>
++#include <linux/errno.h>
++#include <linux/sched.h>
++#include <linux/i2c.h>
++#include <linux/i2c-algo-ibm_ocp.h>
++#include <asm/ocp.h>
++
++
++/* ----- global defines ----------------------------------------------- */
++#define DEB(x) if (i2c_debug>=1) x
++#define DEB2(x) if (i2c_debug>=2) x
++#define DEB3(x) if (i2c_debug>=3) x /* print several statistical values*/
++#define DEBPROTO(x) if (i2c_debug>=9) x;
++ 	/* debug the protocol by showing transferred bits */
++#define DEF_TIMEOUT 5
++
++
++/* ----- global variables ---------------------------------------------	*/
++
++
++/* module parameters:
++ */
++static int i2c_debug=0;
++
++/* --- setting states on the bus with the right timing: ---------------	*/
++
++#define iic_outb(adap, reg, val) adap->setiic(adap->data, (int) &(reg), val)
++#define iic_inb(adap, reg) adap->getiic(adap->data, (int) &(reg))
++
++#define IICO_I2C_SDAHIGH	0x0780
++#define IICO_I2C_SDALOW		0x0781
++#define IICO_I2C_SCLHIGH	0x0782
++#define IICO_I2C_SCLLOW		0x0783
++#define IICO_I2C_LINEREAD	0x0784
++
++#define IIC_SINGLE_XFER		0
++#define IIC_COMBINED_XFER	1
++
++#define IIC_ERR_LOST_ARB        -2
++#define IIC_ERR_INCOMPLETE_XFR  -3
++#define IIC_ERR_NACK            -1
++
++/* --- other auxiliary functions --------------------------------------	*/
++
++
++//
++// Description: Puts this process to sleep for a period equal to timeout 
++//
++static inline void iic_sleep(unsigned long timeout)
++{
++	schedule_timeout( timeout * HZ);
++}
++
++
++//
++// Description: This performs the IBM PPC 405 IIC initialization sequence
++// as described in the PPC405GP data book.
++//
++static int iic_init (struct i2c_algo_iic_data *adap)
++{
++	struct iic_regs *iic;	
++	struct iic_ibm *adap_priv_data = adap->data;
++	unsigned short	retval;
++	iic = (struct iic_regs *) adap_priv_data->iic_base;
++
++        /* Clear master low master address */
++        iic_outb(adap,iic->lmadr, 0);
++
++        /* Clear high master address */
++        iic_outb(adap,iic->hmadr, 0);
++
++        /* Clear low slave address */
++        iic_outb(adap,iic->lsadr, 0);
++
++        /* Clear high slave address */
++        iic_outb(adap,iic->hsadr, 0);
++
++        /* Clear status */
++        iic_outb(adap,iic->sts, 0x0a);
++
++        /* Clear extended status */
++        iic_outb(adap,iic->extsts, 0x8f);
++
++        /* Set clock division */
++        iic_outb(adap,iic->clkdiv, 0x04);
++
++	retval = iic_inb(adap, iic->clkdiv);
++	DEB(printk("iic_init: CLKDIV register = %x\n", retval));
++
++        /* Enable interrupts on Requested Master Transfer Complete */
++        iic_outb(adap,iic->intmsk, 0x01);
++
++        /* Clear transfer count */
++        iic_outb(adap,iic->xfrcnt, 0x0);
++
++        /* Clear extended control and status */
++        iic_outb(adap,iic->xtcntlss, 0xf0);
++
++        /* Set mode control (flush master data buf, enable hold SCL, exit */
++        /* unknown state.                                                 */
++        iic_outb(adap,iic->mdcntl, 0x47);
++
++        /* Clear control register */
++        iic_outb(adap,iic->cntl, 0x0);
++
++        DEB2(printk(KERN_DEBUG "iic_init: Initialized IIC on PPC 405\n"));
++        return 0;
++}
++
++
++//
++// Description: After we issue a transaction on the IIC bus, this function
++// is called.  It puts this process to sleep until we get an interrupt from
++// from the controller telling us that the transaction we requested in complete.
++//
++static int wait_for_pin(struct i2c_algo_iic_data *adap, int *status) 
++{
++
++	int timeout = DEF_TIMEOUT;
++	int retval;
++	struct iic_regs *iic;
++	struct iic_ibm *adap_priv_data = adap->data;
++	iic = (struct iic_regs *) adap_priv_data->iic_base;
++
++
++	*status = iic_inb(adap, iic->sts);
++#ifndef STUB_I2C
++
++	while (timeout-- && (*status & 0x01)) {
++	   adap->waitforpin(adap->data);
++	   *status = iic_inb(adap, iic->sts);
++	}
++#endif
++	if (timeout <= 0) {
++	   /* Issue stop signal on the bus, and force an interrupt */
++           retval = iic_inb(adap, iic->cntl);
++           iic_outb(adap, iic->cntl, retval | 0x80);
++           /* Clear status register */
++	   iic_outb(adap, iic->sts, 0x0a);
++	   /* Exit unknown bus state */
++	   retval = iic_inb(adap, iic->mdcntl);
++	   iic_outb(adap, iic->mdcntl, (retval | 0x02));
++
++	   // Check the status of the controller.  Does it still see a
++	   // pending transfer, even though we've tried to stop any
++	   // ongoing transaction?
++           retval = iic_inb(adap, iic->sts);
++           retval = retval & 0x01;
++           if(retval) {
++	      // The iic controller is hosed.  It is not responding to any
++	      // of our commands.  We have already tried to force it into
++	      // a known state, but it has not worked.  Our only choice now
++	      // is a soft reset, which will clear all registers, and force
++	      // us to re-initialize the controller.
++	      /* Soft reset */
++              iic_outb(adap, iic->xtcntlss, 0x01);
++              udelay(500);
++              iic_init(adap);
++	      /* Is the pending transfer bit in the sts reg finally cleared? */
++              retval = iic_inb(adap, iic->sts);
++              retval = retval & 0x01;
++              if(retval) {
++                 printk(KERN_CRIT "The IIC Controller is hosed.  A processor reset is required\n");
++              }
++	      // For some reason, even though the interrupt bit in this
++	      // register was set during iic_init, it didn't take.  We
++	      // need to set it again.  Don't ask me why....this is just what
++	      // I saw when testing timeouts.
++              iic_outb(adap, iic->intmsk, 0x01);
++           }
++	   return(-1);
++	}
++	else
++	   return(0);
++}
++
++
++//------------------------------------
++// Utility functions
++//
++
++
++//
++// Description: Look at the status register to see if there was an error
++// in the requested transaction.  If there is, look at the extended status
++// register and determine the exact cause.
++//
++int analyze_status(struct i2c_algo_iic_data *adap, int *error_code)
++{
++   int ret;
++   struct iic_regs *iic;
++   struct iic_ibm *adap_priv_data = adap->data;
++   iic = (struct iic_regs *) adap_priv_data->iic_base;
++
++	
++   ret = iic_inb(adap, iic->sts);
++   if(ret & 0x04) {
++      // Error occurred
++      ret = iic_inb(adap, iic->extsts);
++      if(ret & 0x04) {
++         // Lost arbitration
++         *error_code =  IIC_ERR_LOST_ARB;
++      }
++      if(ret & 0x02) {
++         // Incomplete transfer
++         *error_code = IIC_ERR_INCOMPLETE_XFR;
++      }
++      if(ret & 0x01) {
++         // Master transfer aborted by a NACK during the transfer of the 
++	 // address byte
++         *error_code = IIC_ERR_NACK;
++      }
++      return -1;
++   }
++   return 0;
++}
++
++
++//
++// Description: This function is called by the upper layers to do the
++// grunt work for a master send transaction
++//
++static int iic_sendbytes(struct i2c_adapter *i2c_adap,const char *buf,
++                         int count, int xfer_flag)
++{
++	struct iic_regs *iic;
++	struct i2c_algo_iic_data *adap = i2c_adap->algo_data;
++	struct iic_ibm *adap_priv_data = adap->data;
++	int wrcount, status, timeout;
++	int loops, remainder, i, j;
++	int ret, error_code;
++  	iic = (struct iic_regs *) adap_priv_data->iic_base;
++
++ 
++	if( count == 0 ) return 0;
++	wrcount = 0;
++	loops =  count / 4;
++	remainder = count % 4;
++
++	if((loops > 1) && (remainder == 0)) {
++	   for(i=0; i<(loops-1); i++) {
++       	      //
++   	      // Write four bytes to master data buffer
++	      //
++	      for(j=0; j<4; j++) {
++   	         iic_outb(adap, iic->mdbuf, 
++	         buf[wrcount++]);
++  	      }
++	      //
++	      // Issue command to IICO device to begin transmission
++	      //
++	      iic_outb(adap, iic->cntl, 0x35);
++	      //
++	      // Wait for transmission to complete.  When it does, 
++	      //loop to the top of the for statement and write the 
++	      // next four bytes.
++	      //
++	      timeout = wait_for_pin(adap, &status);
++	      if(timeout < 0) {
++	         //
++	         // Error handling
++	         //
++                 //printk(KERN_ERR "Error: write timeout\n");
++                 return wrcount;
++	      }
++	      ret = analyze_status(adap, &error_code);
++	      if(ret < 0) {
++                 if(error_code == IIC_ERR_INCOMPLETE_XFR) {
++                    // Return the number of bytes transferred
++                    ret = iic_inb(adap, iic->xfrcnt);
++                    ret = ret & 0x07;
++                    return (wrcount-4+ret);
++                 }
++                 else return error_code;
++              }
++           }
++	}
++	else if((loops >= 1) && (remainder > 0)){
++	   //printk(KERN_DEBUG "iic_sendbytes: (loops >= 1)\n");
++	   for(i=0; i<loops; i++) {
++              //
++              // Write four bytes to master data buffer
++              //
++              for(j=0; j<4; j++) {
++                 iic_outb(adap, iic->mdbuf,
++                 buf[wrcount++]);
++              }
++              //
++              // Issue command to IICO device to begin transmission
++              //
++              iic_outb(adap, iic->cntl, 0x35);
++              //
++              // Wait for transmission to complete.  When it does,
++              //loop to the top of the for statement and write the
++              // next four bytes.
++              //
++              timeout = wait_for_pin(adap, &status);
++              if(timeout < 0) {
++                 //
++                 // Error handling
++                 //
++                 //printk(KERN_ERR "Error: write timeout\n");
++                 return wrcount;
++              }
++              ret = analyze_status(adap, &error_code);
++              if(ret < 0) {
++                 if(error_code == IIC_ERR_INCOMPLETE_XFR) {
++                    // Return the number of bytes transferred
++                    ret = iic_inb(adap, iic->xfrcnt);
++                    ret = ret & 0x07;
++                    return (wrcount-4+ret);
++                 }
++                 else return error_code;
++              }
++           }
++        }
++
++	//printk(KERN_DEBUG "iic_sendbytes: expedite write\n");
++	if(remainder == 0) remainder = 4;
++	// remainder = remainder - 1;
++	//
++	// Write the remaining bytes (less than or equal to 4)
++	//
++	for(i=0; i<remainder; i++) {
++	   iic_outb(adap, iic->mdbuf, buf[wrcount++]);
++	   //printk(KERN_DEBUG "iic_sendbytes:  data transferred = %x, wrcount = %d\n", buf[wrcount-1], (wrcount-1));
++	}
++        //printk(KERN_DEBUG "iic_sendbytes: Issuing write\n");
++
++        if(xfer_flag == IIC_COMBINED_XFER) {
++           iic_outb(adap, iic->cntl, (0x09 | ((remainder-1) << 4)));
++        }
++	else {
++           iic_outb(adap, iic->cntl, (0x01 | ((remainder-1) << 4)));
++        }
++	DEB2(printk(KERN_DEBUG "iic_sendbytes: Waiting for interrupt\n"));
++	timeout = wait_for_pin(adap, &status);
++        if(timeout < 0) {
++       	   //
++           // Error handling
++           //
++           //printk(KERN_ERR "Error: write timeout\n");
++           return wrcount;
++        }
++        ret = analyze_status(adap, &error_code);
++        if(ret < 0) {
++           if(error_code == IIC_ERR_INCOMPLETE_XFR) {
++              // Return the number of bytes transferred
++              ret = iic_inb(adap, iic->xfrcnt);
++              ret = ret & 0x07;
++              return (wrcount-4+ret);
++           }
++           else return error_code;
++        }
++	DEB2(printk(KERN_DEBUG "iic_sendbytes: Got interrupt\n"));
++	return wrcount;
++}
++
++
++//
++// Description: Called by the upper layers to do the grunt work for
++// a master read transaction.
++//
++static int iic_readbytes(struct i2c_adapter *i2c_adap, char *buf, int count, int xfer_type)
++{
++	struct iic_regs *iic;
++	int rdcount=0, i, status, timeout;
++	struct i2c_algo_iic_data *adap = i2c_adap->algo_data;
++	struct iic_ibm *adap_priv_data = adap->data;
++	int loops, remainder, j;
++        int ret, error_code;
++	iic = (struct iic_regs *) adap_priv_data->iic_base;
++
++	if(count == 0) return 0;
++	loops = count / 4;
++	remainder = count % 4;
++
++	//printk(KERN_DEBUG "iic_readbytes: loops = %d, remainder = %d\n", loops, remainder);
++
++	if((loops > 1) && (remainder == 0)) {
++	//printk(KERN_DEBUG "iic_readbytes: (loops > 1) && (remainder == 0)\n");
++	   for(i=0; i<(loops-1); i++) {
++	      //
++              // Issue command to begin master read (4 bytes maximum)
++              //
++	      //printk(KERN_DEBUG "--->Issued read command\n");
++	      iic_outb(adap, iic->cntl, 0x37);
++	      //
++              // Wait for transmission to complete.  When it does,
++              // loop to the top of the for statement and write the
++              // next four bytes.
++              //
++	      //printk(KERN_DEBUG "--->Waiting for interrupt\n");
++              timeout = wait_for_pin(adap, &status);
++              if(timeout < 0) {
++	         // Error Handler
++		 //printk(KERN_ERR "Error: read timed out\n");
++                 return rdcount;
++	      }
++              //printk(KERN_DEBUG "--->Got interrupt\n");
++
++              ret = analyze_status(adap, &error_code);
++	      if(ret < 0) {
++                 if(error_code == IIC_ERR_INCOMPLETE_XFR)
++                    return rdcount;
++                 else
++                    return error_code;
++              }
++
++	      for(j=0; j<4; j++) {
++                 // Wait for data to shuffle to top of data buffer
++                 // This value needs to optimized.
++		 udelay(1);
++	         buf[rdcount] = iic_inb(adap, iic->mdbuf);
++	         rdcount++;
++		 //printk(KERN_DEBUG "--->Read one byte\n");
++              }
++           }
++	}
++
++	else if((loops >= 1) && (remainder > 0)){
++	//printk(KERN_DEBUG "iic_readbytes: (loops >=1) && (remainder > 0)\n");
++	   for(i=0; i<loops; i++) {
++              //
++              // Issue command to begin master read (4 bytes maximum)
++              //
++              //printk(KERN_DEBUG "--->Issued read command\n");
++              iic_outb(adap, iic->cntl, 0x37);
++              //
++              // Wait for transmission to complete.  When it does,
++              // loop to the top of the for statement and write the
++              // next four bytes.
++              //
++              //printk(KERN_DEBUG "--->Waiting for interrupt\n");
++              timeout = wait_for_pin(adap, &status);
++              if(timeout < 0) {
++                 // Error Handler
++                 //printk(KERN_ERR "Error: read timed out\n");
++                 return rdcount;
++              }
++              //printk(KERN_DEBUG "--->Got interrupt\n");
++
++              ret = analyze_status(adap, &error_code);
++              if(ret < 0) {
++                 if(error_code == IIC_ERR_INCOMPLETE_XFR)
++                    return rdcount;
++                 else
++                    return error_code;
++              }
++
++              for(j=0; j<4; j++) {
++                 // Wait for data to shuffle to top of data buffer
++                 // This value needs to optimized.
++                 udelay(1);
++                 buf[rdcount] = iic_inb(adap, iic->mdbuf);
++                 rdcount++;
++                 //printk(KERN_DEBUG "--->Read one byte\n");
++              }
++           }
++        }
++
++	//printk(KERN_DEBUG "iic_readbytes: expedite read\n");
++	if(remainder == 0) remainder = 4;
++	DEB2(printk(KERN_DEBUG "iic_readbytes: writing %x to IICO_CNTL\n", (0x03 | ((remainder-1) << 4))));
++
++	if(xfer_type == IIC_COMBINED_XFER) {
++	   iic_outb(adap, iic->cntl, (0x0b | ((remainder-1) << 4)));
++        }
++        else {
++	   iic_outb(adap, iic->cntl, (0x03 | ((remainder-1) << 4)));
++        }
++	DEB2(printk(KERN_DEBUG "iic_readbytes: Wait for pin\n"));
++        timeout = wait_for_pin(adap, &status);
++	DEB2(printk(KERN_DEBUG "iic_readbytes: Got the interrupt\n"));
++        if(timeout < 0) {
++           // Error Handler
++	   //printk(KERN_ERR "Error: read timed out\n");
++           return rdcount;
++        }
++
++        ret = analyze_status(adap, &error_code);
++        if(ret < 0) {
++           if(error_code == IIC_ERR_INCOMPLETE_XFR)
++              return rdcount;
++           else
++              return error_code;
++        }
++
++	//printk(KERN_DEBUG "iic_readbyte: Begin reading data buffer\n");
++	for(i=0; i<remainder; i++) {
++	   buf[rdcount] = iic_inb(adap, iic->mdbuf);
++	   // printk(KERN_DEBUG "iic_readbytes:  Character read = %x\n", buf[rdcount]);
++           rdcount++;
++	}
++
++	return rdcount;
++}
++
++
++//
++// Description:  This function implements combined transactions.  Combined
++// transactions consist of combinations of reading and writing blocks of data.
++// Each transfer (i.e. a read or a write) is separated by a repeated start
++// condition.
++//
++static int iic_combined_transaction(struct i2c_adapter *i2c_adap, struct i2c_msg msgs[], int num) 
++{
++   int i;
++   struct i2c_msg *pmsg;
++   int ret;
++
++   DEB2(printk(KERN_DEBUG "Beginning combined transaction\n"));
++	for(i=0; i < num; i++) {
++		pmsg = &msgs[i];
++		if(pmsg->flags & I2C_M_RD) {
++
++			// Last read or write segment needs to be terminated with a stop
++			if(i < num-1) {
++				DEB2(printk(KERN_DEBUG "This one is a read\n"));
++			}
++			else {
++				DEB2(printk(KERN_DEBUG "Doing the last read\n"));
++			}
++			ret = iic_readbytes(i2c_adap, pmsg->buf, pmsg->len, (i < num-1) ? IIC_COMBINED_XFER : IIC_SINGLE_XFER);
++
++			if (ret != pmsg->len) {
++				DEB2(printk("i2c-algo-ppc405.o: fail: "
++							"only read %d bytes.\n",ret));
++				return i;
++			}
++			else {
++				DEB2(printk("i2c-algo-ppc405.o: read %d bytes.\n",ret));
++			}
++		}
++		else if(!(pmsg->flags & I2C_M_RD)) {
++
++			// Last read or write segment needs to be terminated with a stop
++			if(i < num-1) {
++				DEB2(printk(KERN_DEBUG "This one is a write\n"));
++			}
++			else {
++				DEB2(printk(KERN_DEBUG "Doing the last write\n"));
++			}
++			ret = iic_sendbytes(i2c_adap, pmsg->buf, pmsg->len, (i < num-1) ? IIC_COMBINED_XFER : IIC_SINGLE_XFER);
++
++			if (ret != pmsg->len) {
++				DEB2(printk("i2c-algo-ppc405.o: fail: "
++							"only wrote %d bytes.\n",ret));
++				return i;
++			}
++			else {
++				DEB2(printk("i2c-algo-ppc405.o: wrote %d bytes.\n",ret));
++			}
++		}
++	}
++ 
++	return num;
++}
++
++
++//
++// Description: Whenever we initiate a transaction, the first byte clocked
++// onto the bus after the start condition is the address (7 bit) of the
++// device we want to talk to.  This function manipulates the address specified
++// so that it makes sense to the hardware when written to the IIC peripheral.
++//
++// Note: 10 bit addresses are not supported in this driver, although they are
++// supported by the hardware.  This functionality needs to be implemented.
++//
++static inline int iic_doAddress(struct i2c_algo_iic_data *adap,
++                                struct i2c_msg *msg, int retries) 
++{
++	struct iic_regs *iic;
++	unsigned short flags = msg->flags;
++	unsigned char addr;
++	struct iic_ibm *adap_priv_data = adap->data;
++	iic = (struct iic_regs *) adap_priv_data->iic_base;
++
++//
++// The following segment for 10 bit addresses needs to be ported
++//
++/* Ten bit addresses not supported right now
++	if ( (flags & I2C_M_TEN)  ) { 
++		// a ten bit address
++		addr = 0xf0 | (( msg->addr >> 7) & 0x03);
++		DEB2(printk(KERN_DEBUG "addr0: %d\n",addr));
++		// try extended address code...
++		ret = try_address(adap, addr, retries);
++		if (ret!=1) {
++			printk(KERN_ERR "iic_doAddress: died at extended address code.\n");
++			return -EREMOTEIO;
++		}
++		// the remaining 8 bit address
++		iic_outb(adap,msg->addr & 0x7f);
++		// Status check comes here
++		if (ret != 1) {
++			printk(KERN_ERR "iic_doAddress: died at 2nd address code.\n");
++			return -EREMOTEIO;
++		}
++		if ( flags & I2C_M_RD ) {
++			i2c_repstart(adap);
++			// okay, now switch into reading mode
++			addr |= 0x01;
++			ret = try_address(adap, addr, retries);
++			if (ret!=1) {
++				printk(KERN_ERR "iic_doAddress: died at extended address code.\n");
++				return -EREMOTEIO;
++			}
++		}
++	} else ----------> // normal 7 bit address
++
++Ten bit addresses not supported yet */
++
++	addr = ( msg->addr << 1 );
++	if (flags & I2C_M_RD )
++		addr |= 1;
++	if (flags & I2C_M_REV_DIR_ADDR )
++		addr ^= 1;
++	//
++	// Write to the low slave address
++	//
++	iic_outb(adap, iic->lmadr, addr);
++	//
++	// Write zero to the high slave register since we are
++	// only using 7 bit addresses
++	//
++	iic_outb(adap, iic->hmadr, 0);
++
++	return 0;
++}
++
++
++//
++// Description: Prepares the controller for a transaction (clearing status
++// registers, data buffers, etc), and then calls either iic_readbytes or
++// iic_sendbytes to do the actual transaction.
++//
++static int iic_xfer(struct i2c_adapter *i2c_adap,
++		    struct i2c_msg msgs[], 
++		    int num)
++{
++	struct iic_regs *iic;
++	struct i2c_algo_iic_data *adap = i2c_adap->algo_data;
++	struct iic_ibm *adap_priv_data = adap->data;
++	struct i2c_msg *pmsg;
++	int i = 0;
++	int ret;
++	iic = (struct iic_regs *) adap_priv_data->iic_base;
++
++	pmsg = &msgs[i];
++
++	//
++	// Clear status register
++	//
++	DEB2(printk(KERN_DEBUG "iic_xfer: iic_xfer: Clearing status register\n"));
++	iic_outb(adap, iic->sts, 0x0a);
++
++	//
++	// Wait for any pending transfers to complete
++	//
++	DEB2(printk(KERN_DEBUG "iic_xfer: Waiting for any pending transfers to complete\n"));
++	while((ret = iic_inb(adap, iic->sts)) == 0x01) {
++		;
++	}
++
++	//
++	// Flush master data buf
++	//
++	DEB2(printk(KERN_DEBUG "iic_xfer: Clearing master data buffer\n"));		
++	ret = iic_inb(adap, iic->mdcntl);
++	iic_outb(adap, iic->mdcntl, ret | 0x40);
++
++	//
++	// Load slave address
++	//
++	DEB2(printk(KERN_DEBUG "iic_xfer: Loading slave address\n"));
++	ret = iic_doAddress(adap, pmsg, i2c_adap->retries);
++
++        //
++        // Check to see if the bus is busy
++        //
++        ret = iic_inb(adap, iic->extsts);
++        // Mask off the irrelevent bits
++        ret = ret & 0x70;
++        // When the bus is free, the BCS bits in the EXTSTS register are 0b100
++        if(ret != 0x40) return IIC_ERR_LOST_ARB;
++
++	//
++	// Combined transaction (read and write)
++	//
++	if(num > 1) {
++           DEB2(printk(KERN_DEBUG "iic_xfer: Call combined transaction\n"));
++           ret = iic_combined_transaction(i2c_adap, msgs, num);
++        }
++	//
++	// Read only
++	//
++	else if((num == 1) && (pmsg->flags & I2C_M_RD)) {
++	   //
++	   // Tell device to begin reading data from the  master data 
++	   //
++	   DEB2(printk(KERN_DEBUG "iic_xfer: Call adapter's read\n"));
++	   ret = iic_readbytes(i2c_adap, pmsg->buf, pmsg->len, IIC_SINGLE_XFER);
++	} 
++        //
++	// Write only
++	//
++	else if((num == 1 ) && (!(pmsg->flags & I2C_M_RD))) {
++	   //
++	   // Write data to master data buffers and tell our device
++	   // to begin transmitting
++	   //
++	   DEB2(printk(KERN_DEBUG "iic_xfer: Call adapter's write\n"));
++	   ret = iic_sendbytes(i2c_adap, pmsg->buf, pmsg->len, IIC_SINGLE_XFER);
++	}	
++
++	return ret;   
++}
++
++
++//
++// Description: Implements device specific ioctls.  Higher level ioctls can
++// be found in i2c-core.c and are typical of any i2c controller (specifying
++// slave address, timeouts, etc).  These ioctls take advantage of any hardware
++// features built into the controller for which this algorithm-adapter set
++// was written.  These ioctls allow you to take control of the data and clock
++// lines on the IBM PPC 405 IIC controller and set the either high or low,
++// similar to a GPIO pin.
++//
++static int algo_control(struct i2c_adapter *adapter, 
++	unsigned int cmd, unsigned long arg)
++{
++	struct iic_regs *iic;
++	struct i2c_algo_iic_data *adap = adapter->algo_data;
++	struct iic_ibm *adap_priv_data = adap->data;
++	int ret=0;
++	int lines;
++	iic = (struct iic_regs *) adap_priv_data->iic_base;
++
++	lines = iic_inb(adap, iic->directcntl);
++
++	if (cmd == IICO_I2C_SDAHIGH) {
++	      lines = lines & 0x01;
++	      if( lines ) lines = 0x04;
++	      else lines = 0;
++	      iic_outb(adap, iic->directcntl,(0x08|lines));
++	}
++	else if (cmd == IICO_I2C_SDALOW) {
++	      lines = lines & 0x01;
++	      if( lines ) lines = 0x04;
++              else lines = 0;
++              iic_outb(adap, iic->directcntl,(0x00|lines));
++	}
++	else if (cmd == IICO_I2C_SCLHIGH) {
++              lines = lines & 0x02;
++              if( lines ) lines = 0x08;
++              else lines = 0;
++              iic_outb(adap, iic->directcntl,(0x04|lines));
++	}
++	else if (cmd == IICO_I2C_SCLLOW) {
++              lines = lines & 0x02;
++	      if( lines ) lines = 0x08;
++              else lines = 0;
++              iic_outb(adap, iic->directcntl,(0x00|lines));
++	}
++	else if (cmd == IICO_I2C_LINEREAD) {
++	      ret = lines;
++	}
++	return ret;
++}
++
++
++static u32 iic_func(struct i2c_adapter *adap)
++{
++	return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR | 
++	       I2C_FUNC_PROTOCOL_MANGLING; 
++}
++
++
++/* -----exported algorithm data: -------------------------------------	*/
++
++static struct i2c_algorithm iic_algo = {
++	.owner		= THIS_MODULE,
++	.name		= "IBM on-chip IIC algorithm",
++	.id		= I2C_ALGO_OCP,
++	.master_xfer	= iic_xfer,
++	.algo_control	= algo_control,
++	.functionality	= iic_func,
++};
++
++/* 
++ * registering functions to load algorithms at runtime 
++ */
++
++
++//
++// Description: Register bus structure
++//
++int i2c_ocp_add_bus(struct i2c_adapter *adap)
++{
++	struct i2c_algo_iic_data *iic_adap = adap->algo_data;
++
++	DEB2(printk(KERN_DEBUG "i2c-algo-iic.o: hw routines for %s registered.\n",
++	            adap->name));
++
++	/* register new adapter to i2c module... */
++
++	adap->id |= iic_algo.id;
++	adap->algo = &iic_algo;
++
++	adap->timeout = 100;	/* default values, should	*/
++	adap->retries = 3;		/* be replaced by defines	*/
++
++	iic_init(iic_adap);
++	i2c_add_adapter(adap);
++	return 0;
++}
++
++
++//
++// Done
++//
++int i2c_ocp_del_bus(struct i2c_adapter *adap)
++{
++	return i2c_del_adapter(adap);
++}
++
++
++EXPORT_SYMBOL(i2c_ocp_add_bus);
++EXPORT_SYMBOL(i2c_ocp_del_bus);
++
++//
++// The MODULE_* macros resolve to nothing if MODULES is not defined
++// when this file is compiled.
++//
++MODULE_AUTHOR("MontaVista Software <www.mvista.com>");
++MODULE_DESCRIPTION("PPC 405 iic algorithm");
++MODULE_LICENSE("GPL");
++
++MODULE_PARM(i2c_debug,"i");
++
++MODULE_PARM_DESC(i2c_debug,
++        "debug level - 0 off; 1 normal; 2,3 more verbose; 9 iic-protocol");
++
+--- linux-old/include/linux/i2c-algo-ibm_ocp.h	Thu Jan  1 00:00:00 1970
++++ linux/include/linux/i2c-algo-ibm_ocp.h	Mon Dec 13 19:26:29 2004
+@@ -0,0 +1,52 @@
++/* ------------------------------------------------------------------------- */
++/* i2c-algo-ibm_ocp.h i2c driver algorithms for IBM PPC 405 IIC adapters         */
++/* ------------------------------------------------------------------------- */
++/*   Copyright (C) 1995-97 Simon G. Vogl
++                   1998-99 Hans Berglund
++
++    This program is free software; you can redistribute it and/or modify
++    it under the terms of the GNU General Public License as published by
++    the Free Software Foundation; either version 2 of the License, or
++    (at your option) any later version.
++
++    This program is distributed in the hope that it will be useful,
++    but WITHOUT ANY WARRANTY; without even the implied warranty of
++    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++    GNU General Public License for more details.
++
++    You should have received a copy of the GNU General Public License
++    along with this program; if not, write to the Free Software
++    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
++/* ------------------------------------------------------------------------- */
++
++/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
++   Frodo Looijaard <frodol@dds.nl> */
++
++/* Modifications by MontaVista Software, August 2000
++   Changes made to support the IIC peripheral on the IBM PPC 405 */
++
++#ifndef _LINUX_I2C_ALGO_IBM_OCP_H
++#define _LINUX_I2C_ALGO_IBM_OCP_H
++
++struct i2c_algo_iic_data {
++	struct iic_regs *data;		/* private data for lolevel routines	*/
++	void (*setiic) (void *data, int ctl, int val);
++	int  (*getiic) (void *data, int ctl);
++	int  (*getown) (void *data);
++	int  (*getclock) (void *data);
++	void (*waitforpin) (void *data);     
++
++	/* local settings */
++	int udelay;
++	int mdelay;
++	int timeout;
++};
++
++
++#define I2C_IIC_ADAP_MAX	16
++
++
++int i2c_ocp_add_bus(struct i2c_adapter *);
++int i2c_ocp_del_bus(struct i2c_adapter *);
++
++#endif /* _LINUX_I2C_ALGO_IBM_OCP_H */
+--- linux-old/drivers/i2c/i2c-algo-pcf.c	Tue Jan 20 15:10:31 2004
++++ linux/drivers/i2c/i2c-algo-pcf.c	Mon Dec 13 19:26:29 2004
+@@ -32,14 +32,11 @@
+ #include <linux/delay.h>
+ #include <linux/slab.h>
+ #include <linux/init.h>
+-#include <asm/uaccess.h>
+-#include <linux/ioport.h>
+ #include <linux/errno.h>
+ #include <linux/sched.h>
+-
+ #include <linux/i2c.h>
+ #include <linux/i2c-algo-pcf.h>
+-#include "i2c-pcf8584.h"
++
+ 
+ /* ----- global defines ----------------------------------------------- */
+ #define DEB(x) if (i2c_debug>=1) x
+@@ -52,7 +49,6 @@
+ /* module parameters:
+  */
+ static int i2c_debug=0;
+-static int pcf_scan=0;	/* have a look at what's hanging 'round		*/
+ 
+ /* --- setting states on the bus with the right timing: ---------------	*/
+ 
+@@ -149,8 +145,7 @@
+ 	set_pcf(adap, 1, I2C_PCF_PIN);
+ 	/* check to see S1 now used as R/W ctrl -
+ 	   PCF8584 does that when ESO is zero */
+-	/* PCF also resets PIN bit */
+-	if ((temp = get_pcf(adap, 1)) != (0)) {
++	if (((temp = get_pcf(adap, 1)) & 0x7f) != (0)) {
+ 		DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S0 (0x%02x).\n", temp));
+ 		return -ENXIO; /* definetly not PCF8584 */
+ 	}
+@@ -166,7 +161,7 @@
+ 	/* S1=0xA0, next byte in S2					*/
+ 	set_pcf(adap, 1, I2C_PCF_PIN | I2C_PCF_ES1);
+ 	/* check to see S2 now selected */
+-	if ((temp = get_pcf(adap, 1)) != I2C_PCF_ES1) {
++	if (((temp = get_pcf(adap, 1)) & 0x7f) != I2C_PCF_ES1) {
+ 		DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S2 (0x%02x).\n", temp));
+ 		return -ENXIO;
+ 	}
+@@ -427,12 +422,6 @@
+ 	return (i);
+ }
+ 
+-static int algo_control(struct i2c_adapter *adapter, 
+-	unsigned int cmd, unsigned long arg)
+-{
+-	return 0;
+-}
+-
+ static u32 pcf_func(struct i2c_adapter *adap)
+ {
+ 	return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR | 
+@@ -442,14 +431,11 @@
+ /* -----exported algorithm data: -------------------------------------	*/
+ 
+ static struct i2c_algorithm pcf_algo = {
+-	"PCF8584 algorithm",
+-	I2C_ALGO_PCF,
+-	pcf_xfer,
+-	NULL,
+-	NULL,				/* slave_xmit		*/
+-	NULL,				/* slave_recv		*/
+-	algo_control,			/* ioctl		*/
+-	pcf_func,			/* functionality	*/
++	.owner		= THIS_MODULE,
++	.name		= "PCF8584 algorithm",
++	.id		= I2C_ALGO_PCF,
++	.master_xfer	= pcf_xfer,
++	.functionality	= pcf_func,
+ };
+ 
+ /* 
+@@ -457,7 +443,7 @@
+  */
+ int i2c_pcf_add_bus(struct i2c_adapter *adap)
+ {
+-	int i, status;
++	int i;
+ 	struct i2c_algo_pcf_data *pcf_adap = adap->algo_data;
+ 
+ 	DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: hw routines for %s registered.\n",
+@@ -475,81 +461,23 @@
+ 		return i;
+ 	}
+ 
+-#ifdef MODULE
+-	MOD_INC_USE_COUNT;
+-#endif
+-
+ 	i2c_add_adapter(adap);
+-
+-	/* scan bus */
+-	if (pcf_scan) {
+-		printk(KERN_INFO " i2c-algo-pcf.o: scanning bus %s.\n",
+-		       adap->name);
+-		for (i = 0x00; i < 0xff; i+=2) {
+-			if (wait_for_bb(pcf_adap)) {
+-    			printk(KERN_INFO " i2c-algo-pcf.o: scanning bus %s - TIMEOUTed.\n",
+-		           adap->name);
+-			    break;
+-			}
+-			i2c_outb(pcf_adap, i);
+-			i2c_start(pcf_adap);
+-			if ((wait_for_pin(pcf_adap, &status) >= 0) && 
+-			    ((status & I2C_PCF_LRB) == 0)) { 
+-				printk("(%02x)",i>>1); 
+-			} else {
+-				printk("."); 
+-			}
+-			i2c_stop(pcf_adap);
+-			udelay(pcf_adap->udelay);
+-		}
+-		printk("\n");
+-	}
+ 	return 0;
+ }
+ 
+ 
+ int i2c_pcf_del_bus(struct i2c_adapter *adap)
+ {
+-	int res;
+-	if ((res = i2c_del_adapter(adap)) < 0)
+-		return res;
+-	DEB2(printk("i2c-algo-pcf.o: adapter unregistered: %s\n",adap->name));
+-
+-#ifdef MODULE
+-	MOD_DEC_USE_COUNT;
+-#endif
+-	return 0;
+-}
+-
+-int __init i2c_algo_pcf_init (void)
+-{
+-	printk("i2c-algo-pcf.o: i2c pcf8584 algorithm module\n");
+-	return 0;
++	return i2c_del_adapter(adap);
+ }
+ 
+-
+ EXPORT_SYMBOL(i2c_pcf_add_bus);
+ EXPORT_SYMBOL(i2c_pcf_del_bus);
+ 
+-#ifdef MODULE
+ MODULE_AUTHOR("Hans Berglund <hb@spacetec.no>");
+ MODULE_DESCRIPTION("I2C-Bus PCF8584 algorithm");
+ MODULE_LICENSE("GPL");
+ 
+-MODULE_PARM(pcf_scan, "i");
+ MODULE_PARM(i2c_debug,"i");
+-
+-MODULE_PARM_DESC(pcf_scan, "Scan for active chips on the bus");
+ MODULE_PARM_DESC(i2c_debug,
+         "debug level - 0 off; 1 normal; 2,3 more verbose; 9 pcf-protocol");
+-
+-
+-int init_module(void) 
+-{
+-	return i2c_algo_pcf_init();
+-}
+-
+-void cleanup_module(void) 
+-{
+-}
+-#endif
+--- linux-old/include/linux/i2c-algo-pcf.h	Thu Mar 23 02:26:01 2000
++++ linux/include/linux/i2c-algo-pcf.h	Mon Dec 13 19:26:30 2004
+@@ -22,13 +22,12 @@
+ /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
+    Frodo Looijaard <frodol@dds.nl> */
+ 
+-/* $Id: i2c-algo-pcf.h,v 1.7 2000/02/27 23:02:45 frodo Exp $ */
++/* $Id: i2c-algo-pcf.h,v 1.9 2003/07/25 07:56:42 khali Exp $ */
+ 
+-#ifndef I2C_ALGO_PCF_H
+-#define I2C_ALGO_PCF_H 1
++#ifndef _LINUX_I2C_ALGO_PCF_H
++#define _LINUX_I2C_ALGO_PCF_H
+ 
+-/* --- Defines for pcf-adapters ---------------------------------------	*/
+-#include <linux/i2c.h>
++#include <linux/i2c-pcf8584.h>
+ 
+ struct i2c_algo_pcf_data {
+ 	void *data;		/* private data for lolevel routines	*/
+@@ -49,4 +48,4 @@
+ int i2c_pcf_add_bus(struct i2c_adapter *);
+ int i2c_pcf_del_bus(struct i2c_adapter *);
+ 
+-#endif /* I2C_ALGO_PCF_H */
++#endif /* _LINUX_I2C_ALGO_PCF_H */
+--- linux-old/drivers/i2c/i2c-core.c	Wed Jul  7 00:38:02 2004
++++ linux/drivers/i2c/i2c-core.c	Mon Dec 13 19:26:31 2004
+@@ -18,56 +18,33 @@
+ /* ------------------------------------------------------------------------- */
+ 
+ /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
+-   All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl> */
++   All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
++   SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com>                */
+ 
+-/* $Id: i2c-core.c,v 1.64 2001/08/13 01:35:56 mds Exp $ */
++/* i2c-core.c,v 1.91.2.2 2003/01/21 10:00:19 kmalkki Exp */
+ 
+ #include <linux/module.h>
+ #include <linux/kernel.h>
+ #include <linux/errno.h>
+ #include <linux/slab.h>
+ #include <linux/proc_fs.h>
+-#include <linux/config.h>
+-
+-#include <linux/i2c.h>
+-
+-/* ----- compatibility stuff ----------------------------------------------- */
+-
+ #include <linux/init.h>
+-
++#include <linux/i2c.h>
+ #include <asm/uaccess.h>
+ 
+ /* ----- global defines ---------------------------------------------------- */
+ 
+-/* exclusive access to the bus */
+-#define I2C_LOCK(adap) down(&adap->lock)
+-#define I2C_UNLOCK(adap) up(&adap->lock) 
+-
+-#define ADAP_LOCK()	down(&adap_lock)
+-#define ADAP_UNLOCK()	up(&adap_lock)
+-
+-#define DRV_LOCK()	down(&driver_lock)
+-#define DRV_UNLOCK()	up(&driver_lock)
+-
+ #define DEB(x) if (i2c_debug>=1) x;
+ #define DEB2(x) if (i2c_debug>=2) x;
+ 
+ /* ----- global variables -------------------------------------------------- */
+ 
+-/**** lock for writing to global variables: the adapter & driver list */
+-struct semaphore adap_lock;
+-struct semaphore driver_lock;
+-
+-/**** adapter list */
++DECLARE_MUTEX(core_lists);
+ static struct i2c_adapter *adapters[I2C_ADAP_MAX];
+-static int adap_count;
+-
+-/**** drivers list */
+ static struct i2c_driver *drivers[I2C_DRIVER_MAX];
+-static int driver_count;
+ 
+ /**** debug level */
+-static int i2c_debug=1;
++static int i2c_debug;
+ 
+ /* ---------------------------------------------------
+  * /proc entry declarations
+@@ -75,10 +52,6 @@
+  */
+ 
+ #ifdef CONFIG_PROC_FS
+-
+-static int i2cproc_init(void);
+-static int i2cproc_cleanup(void);
+-
+ static ssize_t i2cproc_bus_read(struct file * file, char * buf,size_t count, 
+                                 loff_t *ppos);
+ static int read_bus_i2c(char *buf, char **start, off_t offset, int len,
+@@ -87,15 +60,11 @@
+ /* To implement the dynamic /proc/bus/i2c-? files, we need our own 
+    implementation of the read hook */
+ static struct file_operations i2cproc_operations = {
+-	read:		i2cproc_bus_read,
++	.read		= i2cproc_bus_read,
+ };
+ 
+-static int i2cproc_initialized = 0;
+-
+-#else /* undef CONFIG_PROC_FS */
+-
+-#define i2cproc_init() 0
+-#define i2cproc_cleanup() 0
++static int i2cproc_register(struct i2c_adapter *adap, int bus);
++static void i2cproc_remove(int bus);
+ 
+ #endif /* CONFIG_PROC_FS */
+ 
+@@ -112,9 +81,9 @@
+  */
+ int i2c_add_adapter(struct i2c_adapter *adap)
+ {
+-	int i,j,res;
++	int i,j,res = 0;
+ 
+-	ADAP_LOCK();
++	down(&core_lists);
+ 	for (i = 0; i < I2C_ADAP_MAX; i++)
+ 		if (NULL == adapters[i])
+ 			break;
+@@ -125,68 +94,39 @@
+ 		res = -ENOMEM;
+ 		goto ERROR0;
+ 	}
++	
++#ifdef CONFIG_PROC_FS
++	res = i2cproc_register(adap, i);
++	if (res<0)
++	    goto ERROR0;
++#endif /* def CONFIG_PROC_FS */
+ 
+ 	adapters[i] = adap;
+-	adap_count++;
+-	ADAP_UNLOCK();
+ 	
+ 	/* init data types */
+-	init_MUTEX(&adap->lock);
+-
+-#ifdef CONFIG_PROC_FS
+-
+-	if (i2cproc_initialized) {
+-		char name[8];
+-		struct proc_dir_entry *proc_entry;
+-
+-		sprintf(name,"i2c-%d", i);
+-
+-		proc_entry = create_proc_entry(name,0,proc_bus);
+-		if (! proc_entry) {
+-			printk("i2c-core.o: Could not create /proc/bus/%s\n",
+-			       name);
+-			res = -ENOENT;
+-			goto ERROR1;
+-		}
+-
+-		proc_entry->proc_fops = &i2cproc_operations;
+-		proc_entry->owner = THIS_MODULE;
+-		adap->inode = proc_entry->low_ino;
+-	}
+-
+-#endif /* def CONFIG_PROC_FS */
++	init_MUTEX(&adap->bus);
++	init_MUTEX(&adap->list);
+ 
+ 	/* inform drivers of new adapters */
+-	DRV_LOCK();	
+ 	for (j=0;j<I2C_DRIVER_MAX;j++)
+ 		if (drivers[j]!=NULL && 
+ 		    (drivers[j]->flags&(I2C_DF_NOTIFY|I2C_DF_DUMMY)))
+ 			/* We ignore the return code; if it fails, too bad */
+ 			drivers[j]->attach_adapter(adap);
+-	DRV_UNLOCK();
+ 	
+ 	DEB(printk(KERN_DEBUG "i2c-core.o: adapter %s registered as adapter %d.\n",
+ 	           adap->name,i));
+-
+-	return 0;	
+-
+-
+-ERROR1:
+-	ADAP_LOCK();
+-	adapters[i] = NULL;
+-	adap_count--;
+ ERROR0:
+-	ADAP_UNLOCK();
++	up(&core_lists);
+ 	return res;
+ }
+ 
+ 
+ int i2c_del_adapter(struct i2c_adapter *adap)
+ {
+-	int i,j,res;
+-
+-	ADAP_LOCK();
++	int i,j,res = 0;
+ 
++	down(&core_lists);
+ 	for (i = 0; i < I2C_ADAP_MAX; i++)
+ 		if (adap == adapters[i])
+ 			break;
+@@ -202,20 +142,17 @@
+ 	 * *detach* it! Of course, each dummy driver should know about
+ 	 * this or hell will break loose...
+ 	 */
+-	DRV_LOCK();
+ 	for (j = 0; j < I2C_DRIVER_MAX; j++) 
+ 		if (drivers[j] && (drivers[j]->flags & I2C_DF_DUMMY))
+ 			if ((res = drivers[j]->attach_adapter(adap))) {
+ 				printk(KERN_WARNING "i2c-core.o: can't detach adapter %s "
+ 				       "while detaching driver %s: driver not "
+ 				       "detached!",adap->name,drivers[j]->name);
+-				goto ERROR1;	
++				goto ERROR0;
+ 			}
+-	DRV_UNLOCK();
+-
+ 
+ 	/* detach any active clients. This must be done first, because
+-	 * it can fail; in which case we give upp. */
++	 * it can fail; in which case we give up. */
+ 	for (j=0;j<I2C_CLIENT_MAX;j++) {
+ 		struct i2c_client *client = adap->clients[j];
+ 		if (client!=NULL)
+@@ -231,26 +168,15 @@
+ 				goto ERROR0;
+ 			}
+ 	}
++
+ #ifdef CONFIG_PROC_FS
+-	if (i2cproc_initialized) {
+-		char name[8];
+-		sprintf(name,"i2c-%d", i);
+-		remove_proc_entry(name,proc_bus);
+-	}
++	i2cproc_remove(i);
+ #endif /* def CONFIG_PROC_FS */
+ 
+ 	adapters[i] = NULL;
+-	adap_count--;
+-	
+-	ADAP_UNLOCK();	
+ 	DEB(printk(KERN_DEBUG "i2c-core.o: adapter unregistered: %s\n",adap->name));
+-	return 0;
+-
+ ERROR0:
+-	ADAP_UNLOCK();
+-	return res;
+-ERROR1:
+-	DRV_UNLOCK();
++	up(&core_lists);
+ 	return res;
+ }
+ 
+@@ -264,7 +190,8 @@
+ int i2c_add_driver(struct i2c_driver *driver)
+ {
+ 	int i;
+-	DRV_LOCK();
++
++	down(&core_lists);
+ 	for (i = 0; i < I2C_DRIVER_MAX; i++)
+ 		if (NULL == drivers[i])
+ 			break;
+@@ -273,19 +200,12 @@
+ 		       " i2c-core.o: register_driver(%s) "
+ 		       "- enlarge I2C_DRIVER_MAX.\n",
+ 			driver->name);
+-		DRV_UNLOCK();
++		up(&core_lists);
+ 		return -ENOMEM;
+ 	}
+-
+ 	drivers[i] = driver;
+-	driver_count++;
+-	
+-	DRV_UNLOCK();	/* driver was successfully added */
+-	
+ 	DEB(printk(KERN_DEBUG "i2c-core.o: driver %s registered.\n",driver->name));
+ 	
+-	ADAP_LOCK();
+-
+ 	/* now look for instances of driver on our adapters
+ 	 */
+ 	if (driver->flags& (I2C_DF_NOTIFY|I2C_DF_DUMMY)) {
+@@ -294,15 +214,15 @@
+ 				/* Ignore errors */
+ 				driver->attach_adapter(adapters[i]);
+ 	}
+-	ADAP_UNLOCK();
++	up(&core_lists);
+ 	return 0;
+ }
+ 
+ int i2c_del_driver(struct i2c_driver *driver)
+ {
+-	int i,j,k,res;
++	int i,j,k,res = 0;
+ 
+-	DRV_LOCK();
++	down(&core_lists);
+ 	for (i = 0; i < I2C_DRIVER_MAX; i++)
+ 		if (driver == drivers[i])
+ 			break;
+@@ -310,7 +230,7 @@
+ 		printk(KERN_WARNING " i2c-core.o: unregister_driver: "
+ 				    "[%s] not found\n",
+ 			driver->name);
+-		DRV_UNLOCK();
++		up(&core_lists);
+ 		return -ENODEV;
+ 	}
+ 	/* Have a look at each adapter, if clients of this driver are still
+@@ -322,7 +242,6 @@
+ 	 * invalid operation might (will!) result, when using stale client
+ 	 * pointers.
+ 	 */
+-	ADAP_LOCK(); /* should be moved inside the if statement... */
+ 	for (k=0;k<I2C_ADAP_MAX;k++) {
+ 		struct i2c_adapter *adap = adapters[k];
+ 		if (adap == NULL) /* skip empty entries. */
+@@ -341,8 +260,7 @@
+ 				       "not be detached properly; driver "
+ 				       "not unloaded!",driver->name,
+ 				       adap->name);
+-				ADAP_UNLOCK();
+-				return res;
++				goto ERROR0;
+ 			}
+ 		} else {
+ 			for (j=0;j<I2C_CLIENT_MAX;j++) { 
+@@ -359,37 +277,47 @@
+ 						       "unregistering driver "
+ 						       "`%s', the client at "
+ 						       "address %02x of "
+-						       "adapter `%s' could not"
+-						       "be detached; driver"
++						       "adapter `%s' could not "
++						       "be detached; driver "
+ 						       "not unloaded!",
+ 						       driver->name,
+ 						       client->addr,
+ 						       adap->name);
+-						ADAP_UNLOCK();
+-						return res;
++						goto ERROR0;
+ 					}
+ 				}
+ 			}
+ 		}
+ 	}
+-	ADAP_UNLOCK();
+ 	drivers[i] = NULL;
+-	driver_count--;
+-	DRV_UNLOCK();
+-	
+ 	DEB(printk(KERN_DEBUG "i2c-core.o: driver unregistered: %s\n",driver->name));
+-	return 0;
++
++ERROR0:
++	up(&core_lists);
++	return res;
+ }
+ 
+-int i2c_check_addr (struct i2c_adapter *adapter, int addr)
++static int __i2c_check_addr (struct i2c_adapter *adapter, int addr)
+ {
+ 	int i;
+ 	for (i = 0; i < I2C_CLIENT_MAX ; i++) 
+ 		if (adapter->clients[i] && (adapter->clients[i]->addr == addr))
+ 			return -EBUSY;
++
+ 	return 0;
+ }
+ 
++int i2c_check_addr (struct i2c_adapter *adapter, int addr)
++{
++	int rval;
++
++	down(&adapter->list);
++	rval = __i2c_check_addr(adapter, addr);
++	up(&adapter->list);
++
++	return rval;
++}
++
+ int i2c_attach_client(struct i2c_client *client)
+ {
+ 	struct i2c_adapter *adapter = client->adapter;
+@@ -398,6 +326,7 @@
+ 	if (i2c_check_addr(client->adapter,client->addr))
+ 		return -EBUSY;
+ 
++	down(&adapter->list);
+ 	for (i = 0; i < I2C_CLIENT_MAX; i++)
+ 		if (NULL == adapter->clients[i])
+ 			break;
+@@ -405,11 +334,11 @@
+ 		printk(KERN_WARNING 
+ 		       " i2c-core.o: attach_client(%s) - enlarge I2C_CLIENT_MAX.\n",
+ 			client->name);
++		up(&adapter->list);
+ 		return -ENOMEM;
+ 	}
+-
+ 	adapter->clients[i] = client;
+-	adapter->client_count++;
++	up(&adapter->list);
+ 	
+ 	if (adapter->client_register) 
+ 		if (adapter->client_register(client)) 
+@@ -431,16 +360,6 @@
+ 	struct i2c_adapter *adapter = client->adapter;
+ 	int i,res;
+ 
+-	for (i = 0; i < I2C_CLIENT_MAX; i++)
+-		if (client == adapter->clients[i])
+-			break;
+-	if (I2C_CLIENT_MAX == i) {
+-		printk(KERN_WARNING " i2c-core.o: unregister_client "
+-				    "[%s] not found\n",
+-			client->name);
+-		return -ENODEV;
+-	}
+-	
+ 	if( (client->flags & I2C_CLIENT_ALLOW_USE) && 
+ 	    (client->usage_count>0))
+ 		return -EBUSY;
+@@ -452,33 +371,41 @@
+ 			return res;
+ 		}
+ 
++	down(&adapter->list);
++	for (i = 0; i < I2C_CLIENT_MAX; i++)
++		if (client == adapter->clients[i])
++			break;
++	if (I2C_CLIENT_MAX == i) {
++		printk(KERN_WARNING " i2c-core.o: unregister_client "
++				    "[%s] not found\n",
++			client->name);
++		up(&adapter->list);
++		return -ENODEV;
++	}
+ 	adapter->clients[i] = NULL;
+-	adapter->client_count--;
++	up(&adapter->list);
+ 
+ 	DEB(printk(KERN_DEBUG "i2c-core.o: client [%s] unregistered.\n",client->name));
+ 	return 0;
+ }
+ 
+-void i2c_inc_use_client(struct i2c_client *client)
++static void i2c_inc_use_client(struct i2c_client *client)
+ {
+-
+-	if (client->driver->inc_use != NULL)
+-		client->driver->inc_use(client);
+-
+-	if (client->adapter->inc_use != NULL)
+-		client->adapter->inc_use(client->adapter);
++	if(client->driver->owner)
++		__MOD_INC_USE_COUNT(client->driver->owner);
++	if(client->adapter->owner)
++		__MOD_INC_USE_COUNT(client->adapter->owner);
+ }
+ 
+-void i2c_dec_use_client(struct i2c_client *client)
++static void i2c_dec_use_client(struct i2c_client *client)
+ {
+-	
+-	if (client->driver->dec_use != NULL)
+-		client->driver->dec_use(client);
+-
+-	if (client->adapter->dec_use != NULL)
+-		client->adapter->dec_use(client->adapter);
++	if(client->driver->owner)
++		__MOD_DEC_USE_COUNT(client->driver->owner);
++	if(client->adapter->owner)
++		__MOD_DEC_USE_COUNT(client->adapter->owner);
+ }
+ 
++#if 0 /* just forget about this for now --km */
+ struct i2c_client *i2c_get_client(int driver_id, int adapter_id, 
+ 					struct i2c_client *prev)
+ {
+@@ -545,18 +472,17 @@
+ 
+ 	return 0;
+ }
++#endif
+ 
+ int i2c_use_client(struct i2c_client *client)
+ {
+-	if(client->flags & I2C_CLIENT_ALLOW_USE) {
+-		if (client->flags & I2C_CLIENT_ALLOW_MULTIPLE_USE) 
++	if (client->flags & I2C_CLIENT_ALLOW_USE) {
++		if (client->flags & I2C_CLIENT_ALLOW_MULTIPLE_USE)
++			client->usage_count++;
++		else if (client->usage_count > 0) 
++			return -EBUSY;
++		else 
+ 			client->usage_count++;
+-		else {
+-			if(client->usage_count > 0) 
+-				return -EBUSY;
+-			 else 
+-				client->usage_count++;
+-		}
+ 	}
+ 
+ 	i2c_inc_use_client(client);
+@@ -589,12 +515,13 @@
+ #ifdef CONFIG_PROC_FS
+ 
+ /* This function generates the output for /proc/bus/i2c */
+-int read_bus_i2c(char *buf, char **start, off_t offset, int len, int *eof, 
++static int read_bus_i2c(char *buf, char **start, off_t offset, int len, int *eof, 
+                  void *private)
+ {
+ 	int i;
+ 	int nr = 0;
+ 	/* Note that it is safe to write a `little' beyond len. Yes, really. */
++	down(&core_lists);
+ 	for (i = 0; (i < I2C_ADAP_MAX) && (nr < len); i++)
+ 		if (adapters[i]) {
+ 			nr += sprintf(buf+nr, "i2c-%d\t", i);
+@@ -611,6 +538,7 @@
+ 			              adapters[i]->name,
+ 			              adapters[i]->algo->name);
+ 		}
++	up(&core_lists);
+ 	return nr;
+ }
+ 
+@@ -621,98 +549,125 @@
+ 	struct inode * inode = file->f_dentry->d_inode;
+ 	char *kbuf;
+ 	struct i2c_client *client;
++	struct i2c_adapter *adap;
+ 	int i,j,k,order_nr,len=0;
+ 	size_t len_total;
+ 	int order[I2C_CLIENT_MAX];
++#define OUTPUT_LENGTH_PER_LINE 70
+ 
+-	if (count > 4000)
+-		return -EINVAL; 
+ 	len_total = file->f_pos + count;
+-	/* Too bad if this gets longer (unlikely) */
+-	if (len_total > 4000)
+-		len_total = 4000;
+-	for (i = 0; i < I2C_ADAP_MAX; i++)
+-		if (adapters[i]->inode == inode->i_ino) {
+-		/* We need a bit of slack in the kernel buffer; this makes the
+-		   sprintf safe. */
+-			if (! (kbuf = kmalloc(count + 80,GFP_KERNEL)))
+-				return -ENOMEM;
+-			/* Order will hold the indexes of the clients
+-			   sorted by address */
+-			order_nr=0;
+-			for (j = 0; j < I2C_CLIENT_MAX; j++) {
+-				if ((client = adapters[i]->clients[j]) && 
+-				    (client->driver->id != I2C_DRIVERID_I2CDEV))  {
+-					for(k = order_nr; 
+-					    (k > 0) && 
+-					    adapters[i]->clients[order[k-1]]->
+-					             addr > client->addr; 
+-					    k--)
+-						order[k] = order[k-1];
+-					order[k] = j;
+-					order_nr++;
+-				}
+-			}
+-
+-
+-			for (j = 0; (j < order_nr) && (len < len_total); j++) {
+-				client = adapters[i]->clients[order[j]];
+-				len += sprintf(kbuf+len,"%02x\t%-32s\t%-32s\n",
+-				              client->addr,
+-				              client->name,
+-				              client->driver->name);
+-			}
+-			len = len - file->f_pos;
+-			if (len > count)
+-				len = count;
+-			if (len < 0) 
+-				len = 0;
+-			if (copy_to_user (buf,kbuf+file->f_pos, len)) {
+-				kfree(kbuf);
+-				return -EFAULT;
+-			}
+-			file->f_pos += len;
+-			kfree(kbuf);
+-			return len;
+-		}
+-	return -ENOENT;
++	if (len_total > (I2C_CLIENT_MAX * OUTPUT_LENGTH_PER_LINE) )
++		/* adjust to maximum file size */
++		len_total = (I2C_CLIENT_MAX * OUTPUT_LENGTH_PER_LINE);
++
++	down(&core_lists);
++	/* adap = file->private_data; ?? --km */
++	for (i = 0; i < I2C_ADAP_MAX; i++) {
++	    adap = adapters[i];
++	    if (adap && (adap->inode == inode->i_ino))
++		break;
++	}
++	if ( I2C_ADAP_MAX == i ) {
++	    up(&core_lists);
++	    return -ENOENT;
++	}
++
++	/* We need a bit of slack in the kernel buffer; this makes the
++	   sprintf safe. */
++	if (! (kbuf = kmalloc(len_total +
++			      OUTPUT_LENGTH_PER_LINE,
++			      GFP_KERNEL)))
++	    return -ENOMEM;
++
++	/* Order will hold the indexes of the clients
++	   sorted by address */
++	order_nr=0;
++	down(&adap->list);
++	for (j = 0; j < I2C_CLIENT_MAX; j++) {
++	    if ((client = adap->clients[j]) && 
++		(client->driver->id != I2C_DRIVERID_I2CDEV))  {
++		for(k = order_nr; 
++		    (k > 0) && 
++			adap->clients[order[k-1]]->
++			addr > client->addr; 
++		    k--)
++		    order[k] = order[k-1];
++		order[k] = j;
++		order_nr++;
++	    }
++	}
++
++
++	for (j = 0; (j < order_nr) && (len < len_total); j++) {
++	    client = adap->clients[order[j]];
++	    len += sprintf(kbuf+len,"%02x\t%-32s\t%-32s\n",
++			   client->addr,
++			   client->name,
++			   client->driver->name);
++	}
++	up(&adap->list);
++	up(&core_lists);
++	
++	len = len - file->f_pos;
++	if (len > count)
++	    len = count;
++	if (len < 0) 
++	    len = 0;
++	if (copy_to_user (buf,kbuf+file->f_pos, len)) {
++	    kfree(kbuf);
++	    return -EFAULT;
++	}
++	file->f_pos += len;
++	kfree(kbuf);
++	return len;
++}
++
++static int i2cproc_register(struct i2c_adapter *adap, int bus)
++{
++	char name[8];
++	struct proc_dir_entry *proc_entry;
++
++	sprintf(name,"i2c-%d", bus);
++	proc_entry = create_proc_entry(name,0,proc_bus);
++	if (! proc_entry) {
++		printk(KERN_ERR "i2c-core.o: Could not create /proc/bus/%s\n",
++		       name);
++		return -ENOENT;
++	}
++	    
++	proc_entry->proc_fops = &i2cproc_operations;
++	proc_entry->owner = adap->owner;
++	adap->inode = proc_entry->low_ino;
++	return 0;
+ }
+ 
+-int i2cproc_init(void)
++static void i2cproc_remove(int bus)
+ {
++	char name[8];
++	sprintf(name,"i2c-%d", bus);
++	remove_proc_entry(name, proc_bus);
++}
+ 
++static int __init i2cproc_init(void)
++{
+ 	struct proc_dir_entry *proc_bus_i2c;
+ 
+-	i2cproc_initialized = 0;
+-
+-	if (! proc_bus) {
+-		printk("i2c-core.o: /proc/bus/ does not exist");
+-		i2cproc_cleanup();
+-		return -ENOENT;
+- 	} 
+ 	proc_bus_i2c = create_proc_entry("i2c",0,proc_bus);
+ 	if (!proc_bus_i2c) {
+ 		printk(KERN_ERR "i2c-core.o: Could not create /proc/bus/i2c");
+-		i2cproc_cleanup();
+ 		return -ENOENT;
+  	}
++
+ 	proc_bus_i2c->read_proc = &read_bus_i2c;
+ 	proc_bus_i2c->owner = THIS_MODULE;
+-	i2cproc_initialized += 2;
+ 	return 0;
+ }
+ 
+-int i2cproc_cleanup(void)
++static void __exit i2cproc_cleanup(void)
+ {
+-
+-	if (i2cproc_initialized >= 1) {
+-		remove_proc_entry("i2c",proc_bus);
+-		i2cproc_initialized -= 2;
+-	}
+-	return 0;
++	remove_proc_entry("i2c",proc_bus);
+ }
+ 
+-
+ #endif /* def CONFIG_PROC_FS */
+ 
+ /* ----------------------------------------------------
+@@ -728,9 +683,9 @@
+  	 	DEB2(printk(KERN_DEBUG "i2c-core.o: master_xfer: %s with %d msgs.\n",
+ 		            adap->name,num));
+ 
+-		I2C_LOCK(adap);
++		down(&adap->bus);
+ 		ret = adap->algo->master_xfer(adap,msgs,num);
+-		I2C_UNLOCK(adap);
++		up(&adap->bus);
+ 
+ 		return ret;
+ 	} else {
+@@ -755,9 +710,9 @@
+ 		DEB2(printk(KERN_DEBUG "i2c-core.o: master_send: writing %d bytes on %s.\n",
+ 			count,client->adapter->name));
+ 	
+-		I2C_LOCK(adap);
++		down(&adap->bus);
+ 		ret = adap->algo->master_xfer(adap,&msg,1);
+-		I2C_UNLOCK(adap);
++		up(&adap->bus);
+ 
+ 		/* if everything went ok (i.e. 1 msg transmitted), return #bytes
+ 		 * transmitted, else error code.
+@@ -785,9 +740,9 @@
+ 		DEB2(printk(KERN_DEBUG "i2c-core.o: master_recv: reading %d bytes on %s.\n",
+ 			count,client->adapter->name));
+ 	
+-		I2C_LOCK(adap);
++		down(&adap->bus);
+ 		ret = adap->algo->master_xfer(adap,&msg,1);
+-		I2C_UNLOCK(adap);
++		up(&adap->bus);
+ 	
+ 		DEB2(printk(KERN_DEBUG "i2c-core.o: master_recv: return:%d (count:%d, addr:0x%02x)\n",
+ 			ret, count, client->addr));
+@@ -965,6 +920,123 @@
+ 
+ /* The SMBus parts */
+ 
++#define POLY    (0x1070U << 3) 
++static u8
++crc8(u16 data)
++{
++	int i;
++  
++	for(i = 0; i < 8; i++) {
++		if (data & 0x8000) 
++			data = data ^ POLY;
++		data = data << 1;
++	}
++	return (u8)(data >> 8);
++}
++
++/* CRC over count bytes in the first array plus the bytes in the rest
++   array if it is non-null. rest[0] is the (length of rest) - 1
++   and is included. */
++u8 i2c_smbus_partial_pec(u8 crc, int count, u8 *first, u8 *rest)
++{
++	int i;
++
++	for(i = 0; i < count; i++)
++		crc = crc8((crc ^ first[i]) << 8);
++	if(rest != NULL)
++		for(i = 0; i <= rest[0]; i++)
++			crc = crc8((crc ^ rest[i]) << 8);
++	return crc;
++}
++
++u8 i2c_smbus_pec(int count, u8 *first, u8 *rest)
++{
++	return i2c_smbus_partial_pec(0, count, first, rest);
++}
++
++/* Returns new "size" (transaction type)
++   Note that we convert byte to byte_data and byte_data to word_data
++   rather than invent new xxx_PEC transactions. */
++int i2c_smbus_add_pec(u16 addr, u8 command, int size,
++                      union i2c_smbus_data *data)
++{
++	u8 buf[3];
++
++	buf[0] = addr << 1;
++	buf[1] = command;
++	switch(size) {
++		case I2C_SMBUS_BYTE:
++			data->byte = i2c_smbus_pec(2, buf, NULL);
++			size = I2C_SMBUS_BYTE_DATA;
++			break;
++		case I2C_SMBUS_BYTE_DATA:
++			buf[2] = data->byte;
++			data->word = buf[2] ||
++			            (i2c_smbus_pec(3, buf, NULL) << 8);
++			size = I2C_SMBUS_WORD_DATA;
++			break;
++		case I2C_SMBUS_WORD_DATA:
++			/* unsupported */
++			break;
++		case I2C_SMBUS_BLOCK_DATA:
++			data->block[data->block[0] + 1] =
++			             i2c_smbus_pec(2, buf, data->block);
++			size = I2C_SMBUS_BLOCK_DATA_PEC;
++			break;
++	}
++	return size;	
++}
++
++int i2c_smbus_check_pec(u16 addr, u8 command, int size, u8 partial,
++                        union i2c_smbus_data *data)
++{
++	u8 buf[3], rpec, cpec;
++
++	buf[1] = command;
++	switch(size) {
++		case I2C_SMBUS_BYTE_DATA:
++			buf[0] = (addr << 1) | 1;
++			cpec = i2c_smbus_pec(2, buf, NULL);
++			rpec = data->byte;
++			break;
++		case I2C_SMBUS_WORD_DATA:
++			buf[0] = (addr << 1) | 1;
++			buf[2] = data->word & 0xff;
++			cpec = i2c_smbus_pec(3, buf, NULL);
++			rpec = data->word >> 8;
++			break;
++		case I2C_SMBUS_WORD_DATA_PEC:
++			/* unsupported */
++			cpec = rpec = 0;
++			break;
++		case I2C_SMBUS_PROC_CALL_PEC:
++			/* unsupported */
++			cpec = rpec = 0;
++			break;
++		case I2C_SMBUS_BLOCK_DATA_PEC:
++			buf[0] = (addr << 1);
++			buf[2] = (addr << 1) | 1;
++			cpec = i2c_smbus_pec(3, buf, data->block);
++			rpec = data->block[data->block[0] + 1];
++			break;
++		case I2C_SMBUS_BLOCK_PROC_CALL_PEC:
++			buf[0] = (addr << 1) | 1;
++			rpec = i2c_smbus_partial_pec(partial, 1,
++			                             buf, data->block);
++			cpec = data->block[data->block[0] + 1];
++			break;
++		default:
++			cpec = rpec = 0;
++			break;
++	}
++	if(rpec != cpec) {
++		DEB(printk(KERN_DEBUG "i2c-core.o: Bad PEC 0x%02x vs. 0x%02x\n",
++		           rpec, cpec));
++		return -1;
++	}
++	return 0;	
++}
++
+ extern s32 i2c_smbus_write_quick(struct i2c_client * client, u8 value)
+ {
+ 	return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
+@@ -983,8 +1055,9 @@
+ 
+ extern s32 i2c_smbus_write_byte(struct i2c_client * client, u8 value)
+ {
++	union i2c_smbus_data data;	/* only for PEC */
+ 	return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
+-	                      I2C_SMBUS_WRITE,value, I2C_SMBUS_BYTE,NULL);
++	                      I2C_SMBUS_WRITE,value, I2C_SMBUS_BYTE,&data);
+ }
+ 
+ extern s32 i2c_smbus_read_byte_data(struct i2c_client * client, u8 command)
+@@ -1072,6 +1145,43 @@
+ 	                      I2C_SMBUS_BLOCK_DATA,&data);
+ }
+ 
++/* Returns the number of read bytes */
++extern s32 i2c_smbus_block_process_call(struct i2c_client * client,
++                                        u8 command, u8 length, u8 *values)
++{
++	union i2c_smbus_data data;
++	int i;
++	if (length > I2C_SMBUS_BLOCK_MAX - 1)
++		return -1;
++	data.block[0] = length;
++	for (i = 1; i <= length; i++)
++		data.block[i] = values[i-1];
++	if(i2c_smbus_xfer(client->adapter,client->addr,client->flags,
++	                  I2C_SMBUS_WRITE, command,
++	                  I2C_SMBUS_BLOCK_PROC_CALL, &data))
++		return -1;
++	for (i = 1; i <= data.block[0]; i++)
++		values[i-1] = data.block[i];
++	return data.block[0];
++}
++
++/* Returns the number of read bytes */
++extern s32 i2c_smbus_read_i2c_block_data(struct i2c_client * client,
++                                         u8 command, u8 *values)
++{
++	union i2c_smbus_data data;
++	int i;
++	if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
++	                      I2C_SMBUS_READ,command,
++	                      I2C_SMBUS_I2C_BLOCK_DATA,&data))
++		return -1;
++	else {
++		for (i = 1; i <= data.block[0]; i++)
++			values[i-1] = data.block[i];
++		return data.block[0];
++	}
++}
++
+ extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client * client,
+                                           u8 command, u8 length, u8 *values)
+ {
+@@ -1098,13 +1208,13 @@
+ 	  need to use only one message; when reading, we need two. We initialize
+ 	  most things with sane defaults, to keep the code below somewhat
+ 	  simpler. */
+-	unsigned char msgbuf0[34];
+-	unsigned char msgbuf1[34];
++	unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+2];
++	unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
+ 	int num = read_write == I2C_SMBUS_READ?2:1;
+ 	struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 }, 
+ 	                          { addr, flags | I2C_M_RD, 0, msgbuf1 }
+ 	                        };
+-	int i;
++	int i, len;
+ 
+ 	msgbuf0[0] = command;
+ 	switch(size) {
+@@ -1140,16 +1250,30 @@
+ 		break;
+ 	case I2C_SMBUS_PROC_CALL:
+ 		num = 2; /* Special case */
++		read_write = I2C_SMBUS_READ;
+ 		msg[0].len = 3;
+ 		msg[1].len = 2;
+ 		msgbuf0[1] = data->word & 0xff;
+ 		msgbuf0[2] = (data->word >> 8) & 0xff;
+ 		break;
+ 	case I2C_SMBUS_BLOCK_DATA:
++	case I2C_SMBUS_BLOCK_DATA_PEC:
+ 		if (read_write == I2C_SMBUS_READ) {
+-			printk(KERN_ERR "i2c-core.o: Block read not supported "
+-			       "under I2C emulation!\n");
+-			return -1;
++			/* I2C_FUNC_SMBUS_EMUL doesn't include I2C_FUNC_SMBUS_READ_BLOCK_DATA */
++			if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_READ_BLOCK_DATA)) {
++				printk(KERN_ERR "i2c-core.o: Block read not supported "
++				       "under I2C emulation!\n");
++				return -1;
++			}
++			/* set send message */
++			msg[0].len = 1;
++			/* set recv message */
++			msg[1].flags |= I2C_M_RECV_LEN;
++			msg[1].len = I2C_SMBUS_BLOCK_MAX + 1;
++			if (size == I2C_SMBUS_BLOCK_DATA_PEC) {
++				msg[1].len++;
++				msg[1].flags |= I2C_M_RECV_PEC;
++			}
+ 		} else {
+ 			msg[0].len = data->block[0] + 2;
+ 			if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
+@@ -1158,10 +1282,57 @@
+ 				       data->block[0]);
+ 				return -1;
+ 			}
++			if(size == I2C_SMBUS_BLOCK_DATA_PEC)
++				(msg[0].len)++;
+ 			for (i = 1; i <= msg[0].len; i++)
+ 				msgbuf0[i] = data->block[i-1];
+ 		}
+ 		break;
++	case I2C_SMBUS_BLOCK_PROC_CALL:
++	case I2C_SMBUS_BLOCK_PROC_CALL_PEC:
++		/* I2C_FUNC_SMBUS_EMUL doesn't include I2C_FUNC_SMBUS_BLOCK_PROC_CALL */
++		if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BLOCK_PROC_CALL)) {
++			printk(KERN_ERR "i2c-core.o: adapter doesn't support block process call!\n");
++			return -1;
++		}
++
++		/* Another special case */
++		num = 2;
++		read_write = I2C_SMBUS_READ;
++		
++		/* set send message */
++		msg[0].len = data->block[0] + 2;
++		if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
++			printk(KERN_ERR "i2c-core.o: smbus_access called with "
++				"invalid block write size (%d)\n", data->block[0]);
++			return -1;
++		}
++		for (i = 1; i <= msg[0].len; i++)
++			msgbuf0[i] = data->block[i-1];
++		
++		/* set recv message */
++		msg[1].flags |= I2C_M_RECV_LEN;
++		msg[1].len = I2C_SMBUS_BLOCK_MAX + 1;
++		if (size == I2C_SMBUS_BLOCK_PROC_CALL_PEC) {
++			msg[1].len++;
++			msg[1].flags |= I2C_M_RECV_PEC;
++		}
++		break;
++	case I2C_SMBUS_I2C_BLOCK_DATA:
++		if (read_write == I2C_SMBUS_READ) {
++			msg[1].len = I2C_SMBUS_I2C_BLOCK_MAX;
++		} else {
++			msg[0].len = data->block[0] + 1;
++			if (msg[0].len > I2C_SMBUS_I2C_BLOCK_MAX + 1) {
++				printk("i2c-core.o: i2c_smbus_xfer_emulated called with "
++				       "invalid block write size (%d)\n",
++				       data->block[0]);
++				return -1;
++			}
++			for (i = 1; i <= data->block[0]; i++)
++				msgbuf0[i] = data->block[i];
++		}
++		break;
+ 	default:
+ 		printk(KERN_ERR "i2c-core.o: smbus_access called with invalid size (%d)\n",
+ 		       size);
+@@ -1183,25 +1354,72 @@
+ 			case I2C_SMBUS_PROC_CALL:
+ 				data->word = msgbuf1[0] | (msgbuf1[1] << 8);
+ 				break;
++			case I2C_SMBUS_I2C_BLOCK_DATA:
++				/* fixed at 32 for now */
++				data->block[0] = I2C_SMBUS_I2C_BLOCK_MAX;
++				for (i = 0; i < I2C_SMBUS_I2C_BLOCK_MAX; i++)
++					data->block[i+1] = msgbuf1[i];
++				break;
++			case I2C_SMBUS_BLOCK_DATA:
++			case I2C_SMBUS_BLOCK_PROC_CALL:
++			case I2C_SMBUS_BLOCK_DATA_PEC:
++			case I2C_SMBUS_BLOCK_PROC_CALL_PEC:
++				len = msgbuf1[0] + 1;
++				if(size == I2C_SMBUS_BLOCK_DATA_PEC ||
++				   size == I2C_SMBUS_BLOCK_PROC_CALL_PEC)
++					len++;
++				for (i = 0; i < len; i++)
++					data->block[i] = msgbuf1[i];
++				break;
+ 		}
+ 	return 0;
+ }
+ 
+ 
+-s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
++s32 i2c_smbus_xfer(struct i2c_adapter * adap, u16 addr, unsigned short flags,
+                    char read_write, u8 command, int size, 
+                    union i2c_smbus_data * data)
+ {
+ 	s32 res;
+-	flags = flags & I2C_M_TEN;
+-	if (adapter->algo->smbus_xfer) {
+-		I2C_LOCK(adapter);
+-		res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
++	int swpec = 0;
++	u8 partial = 0;
++
++	flags &= I2C_M_TEN | I2C_CLIENT_PEC;
++	if((flags & I2C_CLIENT_PEC) &&
++	   !(i2c_check_functionality(adap, I2C_FUNC_SMBUS_HWPEC_CALC))) {
++		swpec = 1;
++		if(read_write == I2C_SMBUS_READ &&
++		   size == I2C_SMBUS_BLOCK_DATA)
++			size = I2C_SMBUS_BLOCK_DATA_PEC;
++		else if(size == I2C_SMBUS_PROC_CALL)
++			size = I2C_SMBUS_PROC_CALL_PEC;
++		else if(size == I2C_SMBUS_BLOCK_PROC_CALL) {
++			i2c_smbus_add_pec(addr, command,
++		                          I2C_SMBUS_BLOCK_DATA, data);
++			partial = data->block[data->block[0] + 1];
++			size = I2C_SMBUS_BLOCK_PROC_CALL_PEC;
++		} else if(read_write == I2C_SMBUS_WRITE &&
++		          size != I2C_SMBUS_QUICK &&
++		          size != I2C_SMBUS_I2C_BLOCK_DATA)
++			size = i2c_smbus_add_pec(addr, command, size, data);
++	}
++
++	if (adap->algo->smbus_xfer) {
++		down(&adap->bus);
++		res = adap->algo->smbus_xfer(adap,addr,flags,read_write,
+ 		                                command,size,data);
+-		I2C_UNLOCK(adapter);
++		up(&adap->bus);
+ 	} else
+-		res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
++		res = i2c_smbus_xfer_emulated(adap,addr,flags,read_write,
+ 	                                      command,size,data);
++
++	if(res >= 0 && swpec &&
++	   size != I2C_SMBUS_QUICK && size != I2C_SMBUS_I2C_BLOCK_DATA &&
++	   (read_write == I2C_SMBUS_READ || size == I2C_SMBUS_PROC_CALL_PEC ||
++	    size == I2C_SMBUS_BLOCK_PROC_CALL_PEC)) {
++		if(i2c_smbus_check_pec(addr, command, size, partial, data))
++			return -1;
++	}
+ 	return res;
+ }
+ 
+@@ -1228,143 +1446,37 @@
+ 	printk(KERN_INFO "i2c-core.o: i2c core module version %s (%s)\n", I2C_VERSION, I2C_DATE);
+ 	memset(adapters,0,sizeof(adapters));
+ 	memset(drivers,0,sizeof(drivers));
+-	adap_count=0;
+-	driver_count=0;
+ 
+-	init_MUTEX(&adap_lock);
+-	init_MUTEX(&driver_lock);
+-	
+-	i2cproc_init();
+-	
++#ifdef CONFIG_PROC_FS
++	return i2cproc_init();
++#else
+ 	return 0;
+-}
+-
+-#ifndef MODULE
+-#ifdef CONFIG_I2C_CHARDEV
+-	extern int i2c_dev_init(void);
+-#endif
+-#ifdef CONFIG_I2C_ALGOBIT
+-	extern int i2c_algo_bit_init(void);
+-#endif
+-#ifdef CONFIG_I2C_PHILIPSPAR
+-	extern int i2c_bitlp_init(void);
+-#endif
+-#ifdef CONFIG_I2C_ELV
+-	extern int i2c_bitelv_init(void);
+-#endif
+-#ifdef CONFIG_I2C_VELLEMAN
+-	extern int i2c_bitvelle_init(void);
+-#endif
+-#ifdef CONFIG_I2C_BITVIA
+-	extern int i2c_bitvia_init(void);
+-#endif
+-
+-#ifdef CONFIG_I2C_ALGOPCF
+-	extern int i2c_algo_pcf_init(void);	
+-#endif
+-#ifdef CONFIG_I2C_ELEKTOR
+-	extern int i2c_pcfisa_init(void);
+-#endif
+-
+-#ifdef CONFIG_I2C_ALGO8XX
+-	extern int i2c_algo_8xx_init(void);
+-#endif
+-#ifdef CONFIG_I2C_RPXLITE
+-	extern int i2c_rpx_init(void);
+-#endif
+-
+-#ifdef CONFIG_I2C_ALGO_SIBYTE
+-	extern int i2c_algo_sibyte_init(void);
+-	extern int i2c_sibyte_init(void);
+-#endif
+-#ifdef CONFIG_I2C_MAX1617
+-	extern int i2c_max1617_init(void);
+-#endif
+-#ifdef CONFIG_I2C_ALGO_AU1550
+-	extern int i2c_pb1550_init(void);
+ #endif
++}
+ 
+-#ifdef CONFIG_I2C_PROC
+-	extern int sensors_init(void);
++static void __exit i2c_exit(void) 
++{
++#ifdef CONFIG_PROC_FS
++	i2cproc_cleanup();
+ #endif
++}
+ 
+-/* This is needed for automatic patch generation: sensors code starts here */
+-/* This is needed for automatic patch generation: sensors code ends here   */
+-
++/* leave this in for now simply to make patching easier so we don't have
++   to remove the call in drivers/char/mem.c */
+ int __init i2c_init_all(void)
+ {
+-	/* --------------------- global ----- */
+-	i2c_init();
+-
+-#ifdef CONFIG_I2C_CHARDEV
+-	i2c_dev_init();
+-#endif
+-	/* --------------------- bit -------- */
+-#ifdef CONFIG_I2C_ALGOBIT
+-	i2c_algo_bit_init();
+-#endif
+-#ifdef CONFIG_I2C_PHILIPSPAR
+-	i2c_bitlp_init();
+-#endif
+-#ifdef CONFIG_I2C_ELV
+-	i2c_bitelv_init();
+-#endif
+-#ifdef CONFIG_I2C_VELLEMAN
+-	i2c_bitvelle_init();
+-#endif
+-
+-	/* --------------------- pcf -------- */
+-#ifdef CONFIG_I2C_ALGOPCF
+-	i2c_algo_pcf_init();	
+-#endif
+-#ifdef CONFIG_I2C_ELEKTOR
+-	i2c_pcfisa_init();
+-#endif
+-
+-	/* --------------------- 8xx -------- */
+-#ifdef CONFIG_I2C_ALGO8XX
+-	i2c_algo_8xx_init();
+-#endif
+-#ifdef CONFIG_I2C_RPXLITE
+-	i2c_rpx_init();
+-#endif
+-
+-	/* --------------------- SiByte -------- */
+-#ifdef CONFIG_I2C_ALGO_SIBYTE
+-	i2c_algo_sibyte_init();
+-	i2c_sibyte_init();
+-#endif
+-#ifdef CONFIG_I2C_MAX1617
+-	i2c_max1617_init();
+-#endif
+-
+-#ifdef CONFIG_I2C_ALGO_AU1550
+-	i2c_pb1550_init();
+-#endif
+-
+-	/* -------------- proc interface ---- */
+-#ifdef CONFIG_I2C_PROC
+-	sensors_init();
+-#endif
+-/* This is needed for automatic patch generation: sensors code starts here */
+-/* This is needed for automatic patch generation: sensors code ends here */
+-
+ 	return 0;
+ }
+ 
+-#endif
+-
+-
+-
+ EXPORT_SYMBOL(i2c_add_adapter);
+ EXPORT_SYMBOL(i2c_del_adapter);
+ EXPORT_SYMBOL(i2c_add_driver);
+ EXPORT_SYMBOL(i2c_del_driver);
+ EXPORT_SYMBOL(i2c_attach_client);
+ EXPORT_SYMBOL(i2c_detach_client);
+-EXPORT_SYMBOL(i2c_inc_use_client);
+-EXPORT_SYMBOL(i2c_dec_use_client);
++#if 0
+ EXPORT_SYMBOL(i2c_get_client);
++#endif
+ EXPORT_SYMBOL(i2c_use_client);
+ EXPORT_SYMBOL(i2c_release_client);
+ EXPORT_SYMBOL(i2c_check_addr);
+@@ -1388,11 +1500,12 @@
+ EXPORT_SYMBOL(i2c_smbus_process_call);
+ EXPORT_SYMBOL(i2c_smbus_read_block_data);
+ EXPORT_SYMBOL(i2c_smbus_write_block_data);
++EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
++EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
+ 
+ EXPORT_SYMBOL(i2c_get_functionality);
+ EXPORT_SYMBOL(i2c_check_functionality);
+ 
+-#ifdef MODULE
+ MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
+ MODULE_DESCRIPTION("I2C-Bus main module");
+ MODULE_LICENSE("GPL");
+@@ -1400,13 +1513,5 @@
+ MODULE_PARM(i2c_debug, "i");
+ MODULE_PARM_DESC(i2c_debug,"debug level");
+ 
+-int init_module(void) 
+-{
+-	return i2c_init();
+-}
+-
+-void cleanup_module(void) 
+-{
+-	i2cproc_cleanup();
+-}
+-#endif
++module_init(i2c_init);
++module_exit(i2c_exit);
+--- linux-old/drivers/i2c/i2c-dev.c	Tue Jan 20 15:10:31 2004
++++ linux/drivers/i2c/i2c-dev.c	Mon Dec 13 19:26:32 2004
+@@ -28,9 +28,8 @@
+ /* The devfs code is contributed by Philipp Matthias Hahn 
+    <pmhahn@titan.lahn.de> */
+ 
+-/* $Id: i2c-dev.c,v 1.40 2001/08/25 01:28:01 mds Exp $ */
++/* $Id: i2c-dev.c,v 1.57 2003/12/22 20:03:39 khali Exp $ */
+ 
+-#include <linux/config.h>
+ #include <linux/kernel.h>
+ #include <linux/module.h>
+ #include <linux/fs.h>
+@@ -39,21 +38,14 @@
+ #ifdef CONFIG_DEVFS_FS
+ #include <linux/devfs_fs_kernel.h>
+ #endif
+-
+-
+-/* If you want debugging uncomment: */
+-/* #define DEBUG */
+-
+ #include <linux/init.h>
+-#include <asm/uaccess.h>
+-
+ #include <linux/i2c.h>
+ #include <linux/i2c-dev.h>
++#include <asm/uaccess.h>
++
++/* If you want debugging uncomment: */
++/* #define DEBUG */
+ 
+-#ifdef MODULE
+-extern int init_module(void);
+-extern int cleanup_module(void);
+-#endif /* def MODULE */
+ 
+ /* struct file_operations changed too often in the 2.1 series for nice code */
+ 
+@@ -73,22 +65,14 @@
+ static int i2cdev_command(struct i2c_client *client, unsigned int cmd,
+                            void *arg);
+ 
+-#ifdef MODULE
+-static
+-#else
+-extern
+-#endif
+-       int __init i2c_dev_init(void);
+-static int i2cdev_cleanup(void);
+-
+ static struct file_operations i2cdev_fops = {
+-	owner:		THIS_MODULE,
+-	llseek:		no_llseek,
+-	read:		i2cdev_read,
+-	write:		i2cdev_write,
+-	ioctl:		i2cdev_ioctl,
+-	open:		i2cdev_open,
+-	release:	i2cdev_release,
++	.owner		= THIS_MODULE,
++	.llseek		= no_llseek,
++	.read		= i2cdev_read,
++	.write		= i2cdev_write,
++	.ioctl		= i2cdev_ioctl,
++	.open		= i2cdev_open,
++	.release	= i2cdev_release,
+ };
+ 
+ #define I2CDEV_ADAPS_MAX I2C_ADAP_MAX
+@@ -99,28 +83,22 @@
+ #endif
+ 
+ static struct i2c_driver i2cdev_driver = {
+-	name:		"i2c-dev dummy driver",
+-	id:		I2C_DRIVERID_I2CDEV,
+-	flags:		I2C_DF_DUMMY,
+-	attach_adapter:	i2cdev_attach_adapter,
+-	detach_client:	i2cdev_detach_client,
+-	command:	i2cdev_command,
+-/*	inc_use:	NULL,
+-	dec_use:	NULL, */
++	.owner		= THIS_MODULE, /* not really used */
++	.name		= "i2c-dev dummy driver",
++	.id		= I2C_DRIVERID_I2CDEV,
++	.flags		= I2C_DF_DUMMY,
++	.attach_adapter	= i2cdev_attach_adapter,
++	.detach_client	= i2cdev_detach_client,
++	.command	= i2cdev_command,
+ };
+ 
+ static struct i2c_client i2cdev_client_template = {
+-	name:		"I2C /dev entry",
+-	id:		1,
+-	flags:		0,
+-	addr:		-1,
+-/*	adapter:	NULL, */
+-	driver:		&i2cdev_driver,
+-/*	data:		NULL */
++	.name		= "I2C /dev entry",
++	.id		= 1,
++	.addr		= -1,
++	.driver		= &i2cdev_driver,
+ };
+ 
+-static int i2cdev_initialized;
+-
+ static ssize_t i2cdev_read (struct file *file, char *buf, size_t count,
+                             loff_t *offset)
+ {
+@@ -142,7 +120,7 @@
+ 		return -ENOMEM;
+ 
+ #ifdef DEBUG
+-	printk(KERN_DEBUG "i2c-dev.o: i2c-%d reading %d bytes.\n",MINOR(inode->i_rdev),
++	printk(KERN_DEBUG "i2c-dev.o: i2c-%d reading %d bytes.\n",minor(inode->i_rdev),
+ 	       count);
+ #endif
+ 
+@@ -177,7 +155,7 @@
+ 	}
+ 
+ #ifdef DEBUG
+-	printk(KERN_DEBUG "i2c-dev.o: i2c-%d writing %d bytes.\n",MINOR(inode->i_rdev),
++	printk(KERN_DEBUG "i2c-dev.o: i2c-%d writing %d bytes.\n",minor(inode->i_rdev),
+ 	       count);
+ #endif
+ 	ret = i2c_master_send(client,tmp,count);
+@@ -199,7 +177,7 @@
+ 
+ #ifdef DEBUG
+ 	printk(KERN_DEBUG "i2c-dev.o: i2c-%d ioctl, cmd: 0x%x, arg: %lx.\n", 
+-	       MINOR(inode->i_rdev),cmd, arg);
++	       minor(inode->i_rdev),cmd, arg);
+ #endif /* DEBUG */
+ 
+ 	switch ( cmd ) {
+@@ -218,6 +196,12 @@
+ 		else
+ 			client->flags &= ~I2C_M_TEN;
+ 		return 0;
++	case I2C_PEC:
++		if (arg)
++			client->flags |= I2C_CLIENT_PEC;
++		else
++			client->flags &= ~I2C_CLIENT_PEC;
++		return 0;
+ 	case I2C_FUNCS:
+ 		funcs = i2c_get_functionality(client->adapter);
+ 		return (copy_to_user((unsigned long *)arg,&funcs,
+@@ -318,7 +302,8 @@
+ 		    (data_arg.size != I2C_SMBUS_WORD_DATA) &&
+ 		    (data_arg.size != I2C_SMBUS_PROC_CALL) &&
+ 		    (data_arg.size != I2C_SMBUS_BLOCK_DATA) &&
+-		    (data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA)) {
++		    (data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA) &&
++		    (data_arg.size != I2C_SMBUS_BLOCK_PROC_CALL)) {
+ #ifdef DEBUG
+ 			printk(KERN_DEBUG "i2c-dev.o: size out of range (%x) in ioctl I2C_SMBUS.\n",
+ 			       data_arg.size);
+@@ -361,10 +346,11 @@
+ 		else if ((data_arg.size == I2C_SMBUS_WORD_DATA) || 
+ 		         (data_arg.size == I2C_SMBUS_PROC_CALL))
+ 			datasize = sizeof(data_arg.data->word);
+-		else /* size == I2C_SMBUS_BLOCK_DATA */
++		else /* size == smbus block, i2c block, or block proc. call */
+ 			datasize = sizeof(data_arg.data->block);
+ 
+ 		if ((data_arg.size == I2C_SMBUS_PROC_CALL) || 
++		    (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) || 
+ 		    (data_arg.read_write == I2C_SMBUS_WRITE)) {
+ 			if (copy_from_user(&temp, data_arg.data, datasize))
+ 				return -EFAULT;
+@@ -373,6 +359,7 @@
+ 		      data_arg.read_write,
+ 		      data_arg.command,data_arg.size,&temp);
+ 		if (! res && ((data_arg.size == I2C_SMBUS_PROC_CALL) || 
++		              (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) || 
+ 			      (data_arg.read_write == I2C_SMBUS_READ))) {
+ 			if (copy_to_user(data_arg.data, &temp, datasize))
+ 				return -EFAULT;
+@@ -387,7 +374,7 @@
+ 
+ int i2cdev_open (struct inode *inode, struct file *file)
+ {
+-	unsigned int minor = MINOR(inode->i_rdev);
++	unsigned int minor = minor(inode->i_rdev);
+ 	struct i2c_client *client;
+ 
+ 	if ((minor >= I2CDEV_ADAPS_MAX) || ! (i2cdev_adaps[minor])) {
+@@ -403,11 +390,13 @@
+ 	if(! (client = kmalloc(sizeof(struct i2c_client),GFP_KERNEL)))
+ 		return -ENOMEM;
+ 	memcpy(client,&i2cdev_client_template,sizeof(struct i2c_client));
++
++	/* registered with adapter, passed as client to user */
+ 	client->adapter = i2cdev_adaps[minor];
+ 	file->private_data = client;
+ 
+-	if (i2cdev_adaps[minor]->inc_use)
+-		i2cdev_adaps[minor]->inc_use(i2cdev_adaps[minor]);
++	if(client->adapter->owner)
++		__MOD_INC_USE_COUNT(client->adapter->owner);
+ 
+ #ifdef DEBUG
+ 	printk(KERN_DEBUG "i2c-dev.o: opened i2c-%d\n",minor);
+@@ -417,16 +406,19 @@
+ 
+ static int i2cdev_release (struct inode *inode, struct file *file)
+ {
+-	unsigned int minor = MINOR(inode->i_rdev);
+-	kfree(file->private_data);
+-	file->private_data=NULL;
++	struct i2c_client *client;
++#ifdef DEBUG
++	unsigned int minor = minor(inode->i_rdev);
++#endif
++
++	client = file->private_data;
++	file->private_data = NULL;
++	if(client->adapter->owner)
++		__MOD_DEC_USE_COUNT(client->adapter->owner);
++	kfree(client);
+ #ifdef DEBUG
+ 	printk(KERN_DEBUG "i2c-dev.o: Closed: i2c-%d\n", minor);
+ #endif
+-	lock_kernel();
+-	if (i2cdev_adaps[minor]->dec_use)
+-		i2cdev_adaps[minor]->dec_use(i2cdev_adaps[minor]);
+-	unlock_kernel();
+ 	return 0;
+ }
+ 
+@@ -451,7 +443,7 @@
+ 		devfs_i2c[i] = devfs_register (devfs_handle, name,
+ 			DEVFS_FL_DEFAULT, I2C_MAJOR, i,
+ 			S_IFCHR | S_IRUSR | S_IWUSR,
+-			&i2cdev_fops, NULL);
++			&i2cdev_fops, adap);
+ #endif
+ 		printk(KERN_DEBUG "i2c-dev.o: Registered '%s' as minor %d\n",adap->name,i);
+ 	} else {
+@@ -479,13 +471,12 @@
+ 	return -1;
+ }
+ 
+-int __init i2c_dev_init(void)
++static int __init i2c_dev_init(void)
+ {
+ 	int res;
+ 
+ 	printk(KERN_INFO "i2c-dev.o: i2c /dev entries driver module version %s (%s)\n", I2C_VERSION, I2C_DATE);
+ 
+-	i2cdev_initialized = 0;
+ #ifdef CONFIG_DEVFS_FS
+ 	if (devfs_register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops)) {
+ #else
+@@ -498,63 +489,31 @@
+ #ifdef CONFIG_DEVFS_FS
+ 	devfs_handle = devfs_mk_dir(NULL, "i2c", NULL);
+ #endif
+-	i2cdev_initialized ++;
+-
+ 	if ((res = i2c_add_driver(&i2cdev_driver))) {
+ 		printk(KERN_ERR "i2c-dev.o: Driver registration failed, module not inserted.\n");
+-		i2cdev_cleanup();
++#ifdef CONFIG_DEVFS_FS
++		devfs_unregister(devfs_handle);
++#endif
++		unregister_chrdev(I2C_MAJOR,"i2c");
+ 		return res;
+ 	}
+-	i2cdev_initialized ++;
+ 	return 0;
+ }
+ 
+-int i2cdev_cleanup(void)
++static void __exit i2c_dev_exit(void)
+ {
+-	int res;
+-
+-	if (i2cdev_initialized >= 2) {
+-		if ((res = i2c_del_driver(&i2cdev_driver))) {
+-			printk("i2c-dev.o: Driver deregistration failed, "
+-			       "module not removed.\n");
+-			return res;
+-		}
+-	i2cdev_initialized --;
+-	}
+-
+-	if (i2cdev_initialized >= 1) {
++	i2c_del_driver(&i2cdev_driver);
+ #ifdef CONFIG_DEVFS_FS
+-		devfs_unregister(devfs_handle);
+-		if ((res = devfs_unregister_chrdev(I2C_MAJOR, "i2c"))) {
+-#else
+-		if ((res = unregister_chrdev(I2C_MAJOR,"i2c"))) {
++	devfs_unregister(devfs_handle);
+ #endif
+-			printk("i2c-dev.o: unable to release major %d for i2c bus\n",
+-			       I2C_MAJOR);
+-			return res;
+-		}
+-		i2cdev_initialized --;
+-	}
+-	return 0;
++	unregister_chrdev(I2C_MAJOR,"i2c");
+ }
+ 
+ EXPORT_NO_SYMBOLS;
+ 
+-#ifdef MODULE
+-
+ MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and Simon G. Vogl <simon@tk.uni-linz.ac.at>");
+ MODULE_DESCRIPTION("I2C /dev entries driver");
+ MODULE_LICENSE("GPL");
+ 
+-int init_module(void)
+-{
+-	return i2c_dev_init();
+-}
+-
+-int cleanup_module(void)
+-{
+-	return i2cdev_cleanup();
+-}
+-
+-#endif /* def MODULE */
+-
++module_init(i2c_dev_init);
++module_exit(i2c_dev_exit);
+--- linux-old/include/linux/i2c-dev.h	Sat Jul  5 03:23:47 2003
++++ linux/include/linux/i2c-dev.h	Mon Dec 13 19:26:32 2004
+@@ -19,14 +19,16 @@
+     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+ 
+-/* $Id: i2c-dev.h,v 1.9 2001/08/15 03:04:58 mds Exp $ */
+-
+-#ifndef I2C_DEV_H
+-#define I2C_DEV_H
++/* $Id: i2c-dev.h,v 1.14 2003/07/25 07:56:42 khali Exp $ */
+ 
++#ifndef _LINUX_I2C_DEV_H
++#define _LINUX_I2C_DEV_H
+ 
+ #include <linux/types.h>
+-#include <linux/i2c.h>
++
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,18)
++#define minor(d) MINOR(d)
++#endif
+ 
+ /* Some IOCTL commands are defined in <linux/i2c.h> */
+ /* Note: 10-bit addresses are NOT supported! */
+@@ -45,137 +47,4 @@
+ 	__u32 nmsgs;		/* number of i2c_msgs */
+ };
+ 
+-#ifndef __KERNEL__
+-
+-#include <sys/ioctl.h>
+-
+-static inline __s32 i2c_smbus_access(int file, char read_write, __u8 command, 
+-                                     int size, union i2c_smbus_data *data)
+-{
+-	struct i2c_smbus_ioctl_data args;
+-
+-	args.read_write = read_write;
+-	args.command = command;
+-	args.size = size;
+-	args.data = data;
+-	return ioctl(file,I2C_SMBUS,&args);
+-}
+-
+-
+-static inline __s32 i2c_smbus_write_quick(int file, __u8 value)
+-{
+-	return i2c_smbus_access(file,value,0,I2C_SMBUS_QUICK,NULL);
+-}
+-	
+-static inline __s32 i2c_smbus_read_byte(int file)
+-{
+-	union i2c_smbus_data data;
+-	if (i2c_smbus_access(file,I2C_SMBUS_READ,0,I2C_SMBUS_BYTE,&data))
+-		return -1;
+-	else
+-		return 0x0FF & data.byte;
+-}
+-
+-static inline __s32 i2c_smbus_write_byte(int file, __u8 value)
+-{
+-	return i2c_smbus_access(file,I2C_SMBUS_WRITE,value,
+-	                        I2C_SMBUS_BYTE,NULL);
+-}
+-
+-static inline __s32 i2c_smbus_read_byte_data(int file, __u8 command)
+-{
+-	union i2c_smbus_data data;
+-	if (i2c_smbus_access(file,I2C_SMBUS_READ,command,
+-	                     I2C_SMBUS_BYTE_DATA,&data))
+-		return -1;
+-	else
+-		return 0x0FF & data.byte;
+-}
+-
+-static inline __s32 i2c_smbus_write_byte_data(int file, __u8 command, 
+-                                              __u8 value)
+-{
+-	union i2c_smbus_data data;
+-	data.byte = value;
+-	return i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
+-	                        I2C_SMBUS_BYTE_DATA, &data);
+-}
+-
+-static inline __s32 i2c_smbus_read_word_data(int file, __u8 command)
+-{
+-	union i2c_smbus_data data;
+-	if (i2c_smbus_access(file,I2C_SMBUS_READ,command,
+-	                     I2C_SMBUS_WORD_DATA,&data))
+-		return -1;
+-	else
+-		return 0x0FFFF & data.word;
+-}
+-
+-static inline __s32 i2c_smbus_write_word_data(int file, __u8 command, 
+-                                              __u16 value)
+-{
+-	union i2c_smbus_data data;
+-	data.word = value;
+-	return i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
+-	                        I2C_SMBUS_WORD_DATA, &data);
+-}
+-
+-static inline __s32 i2c_smbus_process_call(int file, __u8 command, __u16 value)
+-{
+-	union i2c_smbus_data data;
+-	data.word = value;
+-	if (i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
+-	                     I2C_SMBUS_PROC_CALL,&data))
+-		return -1;
+-	else
+-		return 0x0FFFF & data.word;
+-}
+-
+-
+-/* Returns the number of read bytes */
+-static inline __s32 i2c_smbus_read_block_data(int file, __u8 command, 
+-                                              __u8 *values)
+-{
+-	union i2c_smbus_data data;
+-	int i;
+-	if (i2c_smbus_access(file,I2C_SMBUS_READ,command,
+-	                     I2C_SMBUS_BLOCK_DATA,&data))
+-		return -1;
+-	else {
+-		for (i = 1; i <= data.block[0]; i++)
+-			values[i-1] = data.block[i];
+-			return data.block[0];
+-	}
+-}
+-
+-static inline __s32 i2c_smbus_write_block_data(int file, __u8 command, 
+-                                               __u8 length, __u8 *values)
+-{
+-	union i2c_smbus_data data;
+-	int i;
+-	if (length > 32)
+-		length = 32;
+-	for (i = 1; i <= length; i++)
+-		data.block[i] = values[i-1];
+-	data.block[0] = length;
+-	return i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
+-	                        I2C_SMBUS_BLOCK_DATA, &data);
+-}
+-
+-static inline __s32 i2c_smbus_write_i2c_block_data(int file, __u8 command,
+-                                               __u8 length, __u8 *values)
+-{
+-	union i2c_smbus_data data;
+-	int i;
+-	if (length > 32)
+-		length = 32;
+-	for (i = 1; i <= length; i++)
+-		data.block[i] = values[i-1];
+-	data.block[0] = length;
+-	return i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
+-	                        I2C_SMBUS_I2C_BLOCK_DATA, &data);
+-}
+-
+-#endif /* ndef __KERNEL__ */
+-
+-#endif
++#endif /* _LINUX_I2C_DEV_H */
+--- linux-old/drivers/i2c/i2c-elektor.c	Tue Jan 20 15:10:31 2004
++++ linux/drivers/i2c/i2c-elektor.c	Mon Dec 13 19:26:33 2004
+@@ -31,23 +31,22 @@
+ #include <linux/delay.h>
+ #include <linux/slab.h>
+ #include <linux/init.h>
++#include <linux/interrupt.h>
+ #include <linux/pci.h>
+-#include <asm/irq.h>
+-#include <asm/io.h>
+-
++#include <linux/wait.h>
+ #include <linux/i2c.h>
+ #include <linux/i2c-algo-pcf.h>
+-#include <linux/i2c-elektor.h>
+-#include "i2c-pcf8584.h"
++#include <asm/io.h>
++#include <asm/irq.h>
+ 
+ #define DEFAULT_BASE 0x330
+ 
+-static int base   = 0;
+-static int irq    = 0;
++static int base;
++static int irq;
+ static int clock  = 0x1c;
+ static int own    = 0x55;
+-static int mmapped = 0;
+-static int i2c_debug = 0;
++static int mmapped;
++static int i2c_debug;
+ 
+ /* vdovikin: removed static struct i2c_pcf_isa gpi; code - 
+   this module in real supports only one device, due to missing arguments
+@@ -56,6 +55,7 @@
+ 
+ static wait_queue_head_t pcf_wait;
+ static int pcf_pending;
++static spinlock_t irq_driver_lock = SPIN_LOCK_UNLOCKED;
+ 
+ /* ----- global defines -----------------------------------------------	*/
+ #define DEB(x)	if (i2c_debug>=1) x
+@@ -63,13 +63,24 @@
+ #define DEB3(x) if (i2c_debug>=3) x
+ #define DEBE(x)	x	/* error messages 				*/
+ 
++
++/* compatibility */
++#ifndef isa_readb
++#define isa_readb readb
++#endif
++
++#ifndef isa_writeb
++#define isa_writeb writeb
++#endif
++
+ /* ----- local functions ----------------------------------------------	*/
+ 
+ static void pcf_isa_setbyte(void *data, int ctl, int val)
+ {
+ 	int address = ctl ? (base + 1) : base;
+ 
+-	if (ctl && irq) {
++	/* enable irq if any specified for serial operation */
++	if (ctl && irq && (val & I2C_PCF_ESO)) {
+ 		val |= I2C_PCF_ENI;
+ 	}
+ 
+@@ -81,10 +92,10 @@
+ 		break;
+ 	case 2: /* double mapped I/O needed for UP2000 board,
+                    I don't know why this... */
+-		writeb(val, address);
++		isa_writeb(val, address);
+ 		/* fall */
+ 	case 1: /* memory mapped I/O */
+-		writeb(val, address);
++		isa_writeb(val, address);
+ 		break;
+ 	}
+ }
+@@ -92,7 +103,7 @@
+ static int pcf_isa_getbyte(void *data, int ctl)
+ {
+ 	int address = ctl ? (base + 1) : base;
+-	int val = mmapped ? readb(address) : inb(address);
++	int val = mmapped ? isa_readb(address) : inb(address);
+ 
+ 	DEB3(printk(KERN_DEBUG "i2c-elektor.o: Read 0x%X 0x%02X\n", address, val));
+ 
+@@ -115,12 +126,12 @@
+ 	int timeout = 2;
+ 
+ 	if (irq > 0) {
+-		cli();
++		spin_lock_irq(&irq_driver_lock);
+ 		if (pcf_pending == 0) {
+ 			interruptible_sleep_on_timeout(&pcf_wait, timeout*HZ );
+ 		} else
+ 			pcf_pending = 0;
+-		sti();
++		spin_unlock_irq(&irq_driver_lock);
+ 	} else {
+ 		udelay(100);
+ 	}
+@@ -136,13 +147,11 @@
+ static int pcf_isa_init(void)
+ {
+ 	if (!mmapped) {
+-		if (check_region(base, 2) < 0 ) {
++		if (!request_region(base, 2, "i2c (isa bus adapter)")) {
+ 			printk(KERN_ERR
+ 			       "i2c-elektor.o: requested I/O region (0x%X:2) "
+ 			       "is in use.\n", base);
+ 			return -ENODEV;
+-		} else {
+-			request_region(base, 2, "i2c (isa bus adapter)");
+ 		}
+ 	}
+ 	if (irq > 0) {
+@@ -156,70 +165,29 @@
+ }
+ 
+ 
+-static void __exit pcf_isa_exit(void)
+-{
+-	if (irq > 0) {
+-		disable_irq(irq);
+-		free_irq(irq, 0);
+-	}
+-	if (!mmapped) {
+-		release_region(base , 2);
+-	}
+-}
+-
+-
+-static int pcf_isa_reg(struct i2c_client *client)
+-{
+-	return 0;
+-}
+-
+-
+-static int pcf_isa_unreg(struct i2c_client *client)
+-{
+-	return 0;
+-}
+-
+-static void pcf_isa_inc_use(struct i2c_adapter *adap)
+-{
+-#ifdef MODULE
+-	MOD_INC_USE_COUNT;
+-#endif
+-}
+-
+-static void pcf_isa_dec_use(struct i2c_adapter *adap)
+-{
+-#ifdef MODULE
+-	MOD_DEC_USE_COUNT;
+-#endif
+-}
+-
+-
+ /* ------------------------------------------------------------------------
+  * Encapsulate the above functions in the correct operations structure.
+  * This is only done when more than one hardware adapter is supported.
+  */
+ static struct i2c_algo_pcf_data pcf_isa_data = {
+-	NULL,
+-	pcf_isa_setbyte,
+-	pcf_isa_getbyte,
+-	pcf_isa_getown,
+-	pcf_isa_getclock,
+-	pcf_isa_waitforpin,
+-	10, 10, 100,		/*	waits, timeout */
++	.setpcf	    = pcf_isa_setbyte,
++	.getpcf	    = pcf_isa_getbyte,
++	.getown	    = pcf_isa_getown,
++	.getclock   = pcf_isa_getclock,
++	.waitforpin = pcf_isa_waitforpin,
++	.udelay	    = 10,
++	.mdelay	    = 10,
++	.timeout    = HZ,
+ };
+ 
+ static struct i2c_adapter pcf_isa_ops = {
+-	"PCF8584 ISA adapter",
+-	I2C_HW_P_ELEK,
+-	NULL,
+-	&pcf_isa_data,
+-	pcf_isa_inc_use,
+-	pcf_isa_dec_use,
+-	pcf_isa_reg,
+-	pcf_isa_unreg,
++	.owner		   = THIS_MODULE,
++	.name		   = "PCF8584 ISA adapter",
++	.id		   = I2C_HW_P_ELEK,
++	.algo_data	   = &pcf_isa_data,
+ };
+ 
+-int __init i2c_pcfisa_init(void) 
++static int __init i2c_pcfisa_init(void) 
+ {
+ #ifdef __alpha__
+ 	/* check to see we have memory mapped PCF8584 connected to the 
+@@ -277,22 +245,41 @@
+ 	}
+ 
+ 	init_waitqueue_head(&pcf_wait);
+-	if (pcf_isa_init() == 0) {
+-		if (i2c_pcf_add_bus(&pcf_isa_ops) < 0)
+-			return -ENODEV;
+-	} else {
++	if (pcf_isa_init())
+ 		return -ENODEV;
+-	}
++	if (i2c_pcf_add_bus(&pcf_isa_ops) < 0)
++		goto fail;
+ 	
+ 	printk(KERN_DEBUG "i2c-elektor.o: found device at %#x.\n", base);
+ 
+ 	return 0;
++
++ fail:
++	if (irq > 0) {
++		disable_irq(irq);
++		free_irq(irq, 0);
++	}
++
++	if (!mmapped)
++		release_region(base , 2);
++	return -ENODEV;
+ }
+ 
++static void __exit i2c_pcfisa_exit(void)
++{
++	i2c_pcf_del_bus(&pcf_isa_ops);
++
++	if (irq > 0) {
++		disable_irq(irq);
++		free_irq(irq, 0);
++	}
++
++	if (!mmapped)
++		release_region(base , 2);
++}
+ 
+ EXPORT_NO_SYMBOLS;
+ 
+-#ifdef MODULE
+ MODULE_AUTHOR("Hans Berglund <hb@spacetec.no>");
+ MODULE_DESCRIPTION("I2C-Bus adapter routines for PCF8584 ISA bus adapter");
+ MODULE_LICENSE("GPL");
+@@ -304,15 +291,5 @@
+ MODULE_PARM(mmapped, "i");
+ MODULE_PARM(i2c_debug, "i");
+ 
+-int init_module(void) 
+-{
+-	return i2c_pcfisa_init();
+-}
+-
+-void cleanup_module(void) 
+-{
+-	i2c_pcf_del_bus(&pcf_isa_ops);
+-	pcf_isa_exit();
+-}
+-
+-#endif
++module_init(i2c_pcfisa_init);
++module_exit(i2c_pcfisa_exit);
+--- linux-old/include/linux/i2c-elektor.h	Tue Nov  6 00:55:29 2001
++++ linux/include/linux/i2c-elektor.h	Mon Dec 13 19:26:33 2004
+@@ -1,47 +0,0 @@
+-/* ------------------------------------------------------------------------- */
+-/* i2c-elektor.c i2c-hw access for PCF8584 style isa bus adaptes             */
+-/* ------------------------------------------------------------------------- */
+-/*   Copyright (C) 1995-97 Simon G. Vogl
+-                   1998-99 Hans Berglund
+-
+-    This program is free software; you can redistribute it and/or modify
+-    it under the terms of the GNU General Public License as published by
+-    the Free Software Foundation; either version 2 of the License, or
+-    (at your option) any later version.
+-
+-    This program is distributed in the hope that it will be useful,
+-    but WITHOUT ANY WARRANTY; without even the implied warranty of
+-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-    GNU General Public License for more details.
+-
+-    You should have received a copy of the GNU General Public License
+-    along with this program; if not, write to the Free Software
+-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
+-/* ------------------------------------------------------------------------- */
+-
+-/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
+-   Frodo Looijaard <frodol@dds.nl> */
+-
+-/* $Id: i2c-elektor.h,v 1.5 2001/06/05 01:46:33 mds Exp $ */
+-
+-#ifndef I2C_PCF_ELEKTOR_H
+-#define I2C_PCF_ELEKTOR_H 1
+-
+-/*
+- * This struct contains the hw-dependent functions of PCF8584 adapters to
+- * manipulate the registers, and to init any hw-specific features.
+- * vdovikin: removed: this module in real supports only one device,
+- * due to missing arguments in some functions, called from the algo-pcf module.
+- * Sometimes it's need to be rewriten -
+- * but for now just remove this for simpler reading */
+-
+-/*
+-struct i2c_pcf_isa {
+-	int pi_base;
+-	int pi_irq;
+-	int pi_clock;
+-	int pi_own;
+-};
+-*/
+-
+-#endif /* PCF_ELEKTOR_H */
+--- linux-old/drivers/i2c/i2c-elv.c	Tue Jan 20 15:10:31 2004
++++ linux/drivers/i2c/i2c-elv.c	Mon Dec 13 19:26:33 2004
+@@ -21,21 +21,18 @@
+ /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
+    Frodo Looijaard <frodol@dds.nl> */
+ 
+-/* $Id: i2c-elv.c,v 1.17 2001/07/29 02:44:25 mds Exp $ */
++/* $Id: i2c-elv.c,v 1.29 2003/12/22 20:03:11 khali Exp $ */
+ 
+ #include <linux/kernel.h>
+ #include <linux/module.h>
+ #include <linux/delay.h>
+ #include <linux/slab.h>
+ #include <linux/init.h>
+-
+-#include <asm/uaccess.h>
+-
+ #include <linux/ioport.h>
+-#include <asm/io.h>
+ #include <linux/errno.h>
+ #include <linux/i2c.h>
+ #include <linux/i2c-algo-bit.h>
++#include <asm/io.h>
+ 
+ #define DEFAULT_BASE 0x378
+ static int base=0;
+@@ -89,58 +86,31 @@
+ 
+ static int bit_elv_init(void)
+ {
+-	if (check_region(base,(base == 0x3bc)? 3 : 8) < 0 ) {
+-		return -ENODEV;	
+-	} else {
+-						/* test for ELV adap. 	*/
+-		if (inb(base+1) & 0x80) {	/* BUSY should be high	*/
+-			DEBINIT(printk(KERN_DEBUG "i2c-elv.o: Busy was low.\n"));
+-			return -ENODEV;
+-		} else {
+-			outb(0x0c,base+2);	/* SLCT auf low		*/
+-			udelay(400);
+-			if ( !(inb(base+1) && 0x10) ) {
+-				outb(0x04,base+2);
+-				DEBINIT(printk(KERN_DEBUG "i2c-elv.o: Select was high.\n"));
+-				return -ENODEV;
+-			}
+-		}
+-		request_region(base,(base == 0x3bc)? 3 : 8,
+-			"i2c (ELV adapter)");
+-		PortData = 0;
+-		bit_elv_setsda((void*)base,1);
+-		bit_elv_setscl((void*)base,1);
++	if (!request_region(base, (base == 0x3bc) ? 3 : 8,
++				"i2c (ELV adapter)"))
++		return -ENODEV;
++
++	if (inb(base+1) & 0x80) {	/* BUSY should be high	*/
++		DEBINIT(printk(KERN_DEBUG "i2c-elv.o: Busy was low.\n"));
++		goto fail;
++	} 
++
++	outb(0x0c,base+2);	/* SLCT auf low		*/
++	udelay(400);
++	if (!(inb(base+1) && 0x10)) {
++		outb(0x04,base+2);
++		DEBINIT(printk(KERN_DEBUG "i2c-elv.o: Select was high.\n"));
++		goto fail;
+ 	}
+-	return 0;
+-}
+-
+-static void __exit bit_elv_exit(void)
+-{
+-	release_region( base , (base == 0x3bc)? 3 : 8 );
+-}
+-
+-static int bit_elv_reg(struct i2c_client *client)
+-{
+-	return 0;
+-}
+ 
+-static int bit_elv_unreg(struct i2c_client *client)
+-{
++	PortData = 0;
++	bit_elv_setsda((void*)base,1);
++	bit_elv_setscl((void*)base,1);
+ 	return 0;
+-}
+ 
+-static void bit_elv_inc_use(struct i2c_adapter *adap)
+-{
+-#ifdef MODULE
+-	MOD_INC_USE_COUNT;
+-#endif
+-}
+-
+-static void bit_elv_dec_use(struct i2c_adapter *adap)
+-{
+-#ifdef MODULE
+-	MOD_DEC_USE_COUNT;
+-#endif
++fail:
++	release_region(base , (base == 0x3bc) ? 3 : 8);
++	return -ENODEV;
+ }
+ 
+ /* ------------------------------------------------------------------------
+@@ -148,26 +118,23 @@
+  * This is only done when more than one hardware adapter is supported.
+  */
+ static struct i2c_algo_bit_data bit_elv_data = {
+-	NULL,
+-	bit_elv_setsda,
+-	bit_elv_setscl,
+-	bit_elv_getsda,
+-	bit_elv_getscl,
+-	80, 80, 100,		/*	waits, timeout */
++	.setsda		= bit_elv_setsda,
++	.setscl		= bit_elv_setscl,
++	.getsda		= bit_elv_getsda,
++	.getscl		= bit_elv_getscl,
++	.udelay		= 80,
++	.mdelay		= 80,
++	.timeout	= HZ
+ };
+ 
+ static struct i2c_adapter bit_elv_ops = {
+-	"ELV Parallel port adaptor",
+-	I2C_HW_B_ELV,
+-	NULL,
+-	&bit_elv_data,
+-	bit_elv_inc_use,
+-	bit_elv_dec_use,
+-	bit_elv_reg,
+-	bit_elv_unreg,	
++	.owner		= THIS_MODULE,
++	.name		= "ELV Parallel port adaptor",
++	.id		= I2C_HW_B_ELV,
++	.algo_data	= &bit_elv_data,
+ };
+ 
+-int __init i2c_bitelv_init(void)
++static int __init i2c_bitelv_init(void)
+ {
+ 	printk(KERN_INFO "i2c-elv.o: i2c ELV parallel port adapter module version %s (%s)\n", I2C_VERSION, I2C_DATE);
+ 	if (base==0) {
+@@ -193,25 +160,19 @@
+ 	return 0;
+ }
+ 
++static void __exit i2c_bitelv_exit(void)
++{
++	i2c_bit_del_bus(&bit_elv_ops);
++	release_region(base, (base == 0x3bc) ? 3 : 8);
++}
+ 
+ EXPORT_NO_SYMBOLS;
+ 
+-#ifdef MODULE
+ MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
+ MODULE_DESCRIPTION("I2C-Bus adapter routines for ELV parallel port adapter");
+ MODULE_LICENSE("GPL");
+ 
+ MODULE_PARM(base, "i");
+ 
+-int init_module(void)
+-{
+-	return i2c_bitelv_init();
+-}
+-
+-void cleanup_module(void)
+-{
+-	i2c_bit_del_bus(&bit_elv_ops);
+-	bit_elv_exit();
+-}
+-
+-#endif
++module_init(i2c_bitelv_init);
++module_exit(i2c_bitelv_exit);
+--- linux-old/drivers/i2c/i2c-frodo.c	Thu Jan  1 00:00:00 1970
++++ linux/drivers/i2c/i2c-frodo.c	Mon Dec 13 19:26:33 2004
+@@ -0,0 +1,83 @@
++
++/*
++ * linux/drivers/i2c/i2c-frodo.c
++ *
++ * Author: Abraham van der Merwe <abraham@2d3d.co.za>
++ *
++ * An I2C adapter driver for the 2d3D, Inc. StrongARM SA-1110
++ * Development board (Frodo).
++ *
++ * This source code is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public License
++ * version 2 as published by the Free Software Foundation.
++ */
++
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/init.h>
++#include <linux/delay.h>
++#include <linux/i2c.h>
++#include <linux/i2c-algo-bit.h>
++#include <asm/hardware.h>
++
++
++static void frodo_setsda (void *data,int state)
++{
++	if (state)
++		FRODO_CPLD_I2C |= FRODO_I2C_SDA_OUT;
++	else
++		FRODO_CPLD_I2C &= ~FRODO_I2C_SDA_OUT;
++}
++
++static void frodo_setscl (void *data,int state)
++{
++	if (state)
++		FRODO_CPLD_I2C |= FRODO_I2C_SCL_OUT;
++	else
++		FRODO_CPLD_I2C &= ~FRODO_I2C_SCL_OUT;
++}
++
++static int frodo_getsda (void *data)
++{
++	return ((FRODO_CPLD_I2C & FRODO_I2C_SDA_IN) != 0);
++}
++
++static int frodo_getscl (void *data)
++{
++	return ((FRODO_CPLD_I2C & FRODO_I2C_SCL_IN) != 0);
++}
++
++static struct i2c_algo_bit_data bit_frodo_data = {
++	.setsda		= frodo_setsda,
++	.setscl		= frodo_setscl,
++	.getsda		= frodo_getsda,
++	.getscl		= frodo_getscl,
++	.udelay		= 80,
++	.mdelay		= 80,
++	.timeout	= HZ
++};
++
++static struct i2c_adapter frodo_ops = {
++	.owner			= THIS_MODULE,
++	.name			= "Frodo adapter driver",
++	.id			= I2C_HW_B_FRODO,
++	.algo_data		= &bit_frodo_data,
++};
++
++static int __init i2c_frodo_init (void)
++{
++	return i2c_bit_add_bus(&frodo_ops);
++}
++
++static void __exit i2c_frodo_exit (void)
++{
++	i2c_bit_del_bus(&frodo_ops);
++}
++
++MODULE_AUTHOR ("Abraham van der Merwe <abraham@2d3d.co.za>");
++MODULE_DESCRIPTION ("I2C-Bus adapter routines for Frodo");
++MODULE_LICENSE ("GPL");
++
++module_init (i2c_frodo_init);
++module_exit (i2c_frodo_exit);
++
+--- linux-old/include/linux/i2c-id.h	Wed Jul  7 00:38:02 2004
++++ linux/include/linux/i2c-id.h	Mon Dec 13 19:26:33 2004
+@@ -20,10 +20,11 @@
+     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.		     */
+ /* ------------------------------------------------------------------------- */
+ 
+-/* $Id: i2c-id.h,v 1.35 2001/08/12 17:22:20 mds Exp $ */
++/* $Id: i2c-id.h,v 1.92 2004/07/27 18:15:06 mmh Exp $ */
++
++#ifndef LINUX_I2C_ID_H
++#define LINUX_I2C_ID_H
+ 
+-#ifndef I2C_ID_H
+-#define I2C_ID_H
+ /*
+  * This file is part of the i2c-bus package and contains the identifier
+  * values for drivers, adapters and other folk populating these serial
+@@ -90,10 +91,25 @@
+ #define I2C_DRIVERID_DRP3510	43     /* ADR decoder (Astra Radio)	*/
+ #define I2C_DRIVERID_SP5055	44     /* Satellite tuner		*/
+ #define I2C_DRIVERID_STV0030	45     /* Multipurpose switch		*/
++#define I2C_DRIVERID_SAA7108	46     /* video decoder, image scaler   */
++#define I2C_DRIVERID_DS1307	47     /* DS1307 real time clock	*/
+ #define I2C_DRIVERID_ADV7175	48     /* ADV 7175/7176 video encoder	*/
+-#define I2C_DRIVERID_MAX1617	56     /* temp sensor			*/
+-#define I2C_DRIVERID_SAA7191	57     /* video decoder                 */
+-#define I2C_DRIVERID_INDYCAM	58     /* SGI IndyCam			*/
++#define I2C_DRIVERID_ZR36067	49     /* Zoran 36067 video encoder	*/
++#define I2C_DRIVERID_ZR36120	50     /* Zoran 36120 video encoder	*/
++#define I2C_DRIVERID_24LC32A	51	/* Microchip 24LC32A 32k EEPROM	*/
++#define I2C_DRIVERID_STM41T00	52	/* real time clock		*/
++#define I2C_DRIVERID_UDA1342	53	/* UDA1342 audio codec		*/
++#define I2C_DRIVERID_ADV7170	54	/* video encoder		*/
++#define I2C_DRIVERID_RADEON	55	/* I2C bus on Radeon boards	*/
++#define I2C_DRIVERID_MAX1617	56	/* temp sensor			*/
++#define I2C_DRIVERID_SAA7191	57	/* video encoder		*/
++#define I2C_DRIVERID_INDYCAM	58	/* SGI IndyCam			*/
++#define I2C_DRIVERID_BT832	59	/* CMOS camera video processor  */
++#define I2C_DRIVERID_TDA9887	60	/* TDA988x IF-PLL demodulator	*/
++#define I2C_DRIVERID_OVCAMCHIP	61	/* OmniVision CMOS image sens.	*/
++#define I2C_DRIVERID_TDA7313	62	/* TDA7313 audio processor	*/
++#define I2C_DRIVERID_MAX6900	63	/* MAX6900 real-time clock	*/
++
+ 
+ #define I2C_DRIVERID_EXP0	0xF0	/* experimental use id's	*/
+ #define I2C_DRIVERID_EXP1	0xF1
+@@ -102,6 +118,8 @@
+ 
+ #define I2C_DRIVERID_I2CDEV	900
+ #define I2C_DRIVERID_I2CPROC	901
++#define I2C_DRIVERID_ARP        902    /* SMBus ARP Client              */
++#define I2C_DRIVERID_ALERT      903    /* SMBus Alert Responder Client  */
+ 
+ /* IDs --   Use DRIVERIDs 1000-1999 for sensors. 
+    These were originally in sensors.h in the lm_sensors package */
+@@ -131,6 +149,28 @@
+ #define I2C_DRIVERID_ADM1024 1025
+ #define I2C_DRIVERID_IT87 1026
+ #define I2C_DRIVERID_CH700X 1027 /* single driver for CH7003-7009 digital pc to tv encoders */
++#define I2C_DRIVERID_FSCPOS 1028
++#define I2C_DRIVERID_FSCSCY 1029
++#define I2C_DRIVERID_PCF8591 1030
++#define I2C_DRIVERID_SMSC47M1 1031
++#define I2C_DRIVERID_VT1211 1032
++#define I2C_DRIVERID_LM92 1033
++#define I2C_DRIVERID_VT8231 1034
++#define I2C_DRIVERID_SMARTBATT 1035
++#define I2C_DRIVERID_BMCSENSORS 1036
++#define I2C_DRIVERID_FS451 1037
++#define I2C_DRIVERID_W83627HF 1038
++#define I2C_DRIVERID_LM85 1039
++#define I2C_DRIVERID_LM83 1040
++#define I2C_DRIVERID_SAA1064 1041
++#define I2C_DRIVERID_LM90 1042
++#define I2C_DRIVERID_ASB100 1043
++#define I2C_DRIVERID_MAX6650 1044
++#define I2C_DRIVERID_XEONTEMP 1045
++#define I2C_DRIVERID_FSCHER 1046
++#define I2C_DRIVERID_W83L785TS 1047
++#define I2C_DRIVERID_ADM1026 1048
++#define I2C_DRIVERID_LM93 1049
+ 
+ /*
+  * ---- Adapter types ----------------------------------------------------
+@@ -147,16 +187,21 @@
+ #define I2C_ALGO_ISA 	0x050000	/* lm_sensors ISA pseudo-adapter */
+ #define I2C_ALGO_SAA7146 0x060000	/* SAA 7146 video decoder bus	*/
+ #define I2C_ALGO_ACB 	0x070000	/* ACCESS.bus algorithm         */
+-
++#define I2C_ALGO_IIC    0x080000 	/* ITE IIC bus */
++#define I2C_ALGO_SAA7134 0x090000
++#define I2C_ALGO_MPC824X 0x0a0000	/* Motorola 8240 / 8245         */
++#define I2C_ALGO_IPMI 	0x0b0000	/* IPMI dummy adapter */
++#define I2C_ALGO_IPMB 	0x0c0000	/* IPMB adapter */
++#define I2C_ALGO_MPC107 0x0d0000
+ #define I2C_ALGO_EC     0x100000        /* ACPI embedded controller     */
+ 
+ #define I2C_ALGO_MPC8XX 0x110000	/* MPC8xx PowerPC I2C algorithm */
+-
+-#define I2C_ALGO_SIBYTE 0x120000	/* Broadcom SiByte SOCs		*/
+-
+-#define I2C_ALGO_SGI	0x130000	/* SGI algorithm		*/
+-
+-#define I2C_ALGO_AU1550	0x140000	/* Alchemy Au1550 PSC		*/
++#define I2C_ALGO_OCP    0x120000	/* IBM or otherwise On-chip I2C algorithm */
++#define I2C_ALGO_BITHS	0x130000	/* enhanced bit style adapters	*/
++#define I2C_ALGO_OCP_IOP3XX  0x140000	/* XSCALE IOP3XX On-chip I2C alg */
++#define I2C_ALGO_SIBYTE	0x150000	/* Broadcom SiByte SOCs         */
++#define I2C_ALGO_SGI	0x160000	/* SGI algorithm                */
++#define I2C_ALGO_USB	0x170000	/* USB algorithm		*/
+ 
+ #define I2C_ALGO_EXP	0x800000	/* experimental			*/
+ 
+@@ -184,21 +229,46 @@
+ #define I2C_HW_B_I810	0x0a	/* Intel I810 				*/
+ #define I2C_HW_B_VOO	0x0b	/* 3dfx Voodoo 3 / Banshee      	*/
+ #define I2C_HW_B_PPORT  0x0c	/* Primitive parallel port adapter	*/
++#define I2C_HW_B_SAVG	0x0d	/* Savage 4                     	*/
++#define I2C_HW_B_SCX200	0x0e	/* Nat'l Semi SCx200 I2C        	*/
+ #define I2C_HW_B_RIVA	0x10	/* Riva based graphics cards		*/
+ #define I2C_HW_B_IOC	0x11	/* IOC bit-wiggling			*/
+ #define I2C_HW_B_TSUNA  0x12	/* DEC Tsunami chipset			*/
++#define I2C_HW_B_FRODO  0x13    /* 2d3D, Inc. SA-1110 Development Board */
++#define I2C_HW_B_OMAHA  0x14    /* Omaha I2C interface (ARM)		*/
++#define I2C_HW_B_GUIDE  0x15    /* Guide bit-basher			*/
++#define I2C_HW_B_IXP2000 0x16	/* GPIO on IXP2000 systems              */
++#define I2C_HW_B_IXP425 0x17	/* GPIO on IXP425 systems		*/
++#define I2C_HW_B_S3VIA	0x18	/* S3Via ProSavage adapter		*/
++#define I2C_HW_B_ZR36067 0x19	/* Zoran-36057/36067 based boards	*/
++#define I2C_HW_B_PCILYNX 0x1a	/* TI PCILynx I2C adapter		*/
+ 
+ /* --- PCF 8584 based algorithms					*/
+ #define I2C_HW_P_LP	0x00	/* Parallel port interface		*/
+ #define I2C_HW_P_ISA	0x01	/* generic ISA Bus inteface card	*/
+ #define I2C_HW_P_ELEK	0x02	/* Elektor ISA Bus inteface card	*/
+ 
++/* --- USB based adapters						*/
++#define I2C_HW_USB_USBVISION	0x00
++
+ /* --- ACPI Embedded controller algorithms                              */
+ #define I2C_HW_ACPI_EC          0x00
+ 
++/* --- MPC824x PowerPC adapters						*/
++#define I2C_HW_MPC824X 0x00	/* Motorola 8240 / 8245                 */
++
+ /* --- MPC8xx PowerPC adapters						*/
+ #define I2C_HW_MPC8XX_EPON 0x00	/* Eponymous MPC8xx I2C adapter 	*/
+ 
++/* --- ITE based algorithms						*/
++#define I2C_HW_I_IIC	0x00	/* controller on the ITE */
++
++/* --- PowerPC on-chip adapters						*/
++#define I2C_HW_OCP 0x00	/* IBM on-chip I2C adapter 	*/
++
++/* --- XSCALE on-chip adapters                          */
++#define I2C_HW_IOP321 0x00
++
+ /* --- Broadcom SiByte adapters						*/
+ #define I2C_HW_SIBYTE	0x00
+ 
+@@ -206,9 +276,6 @@
+ #define I2C_HW_SGI_VINO	0x00
+ #define I2C_HW_SGI_MACE	0x01
+ 
+-/* --- Au1550 PSC adapters						*/
+-#define I2C_HW_AU1550_PSC	0x00
+-
+ /* --- SMBus only adapters						*/
+ #define I2C_HW_SMBUS_PIIX4	0x00
+ #define I2C_HW_SMBUS_ALI15X3	0x01
+@@ -218,9 +285,27 @@
+ #define I2C_HW_SMBUS_AMD756	0x05
+ #define I2C_HW_SMBUS_SIS5595	0x06
+ #define I2C_HW_SMBUS_ALI1535	0x07
++#define I2C_HW_SMBUS_SIS630	0x08
++#define I2C_HW_SMBUS_SIS645	0x09
++#define I2C_HW_SMBUS_AMD8111	0x0a
++#define I2C_HW_SMBUS_SCX200	0x0b
++#define I2C_HW_SMBUS_NFORCE2	0x0c
+ #define I2C_HW_SMBUS_W9968CF	0x0d
++#define I2C_HW_SMBUS_OV511	0x0e	/* OV511(+) USB 1.1 webcam ICs	*/
++#define I2C_HW_SMBUS_OV518	0x0f	/* OV518(+) USB 1.1 webcam ICs	*/
++#define I2C_HW_SMBUS_OV519	0x10	/* OV519 USB 1.1 webcam IC	*/
++#define I2C_HW_SMBUS_OVFX2	0x11	/* Cypress/OmniVision FX2 webcam */
+ 
+ /* --- ISA pseudo-adapter						*/
+ #define I2C_HW_ISA 0x00
+ 
+-#endif /* I2C_ID_H */
++/* --- IPMI pseudo-adapter						*/
++#define I2C_HW_IPMI 0x00
++
++/* --- IPMB adapter						*/
++#define I2C_HW_IPMB 0x00
++
++/* --- MCP107 adapter */
++#define I2C_HW_MPC107 0x00
++
++#endif /* LINUX_I2C_ID_H */
+--- linux-old/drivers/i2c/i2c-pcf-epp.c	Thu Jan  1 00:00:00 1970
++++ linux/drivers/i2c/i2c-pcf-epp.c	Mon Dec 13 19:26:34 2004
+@@ -0,0 +1,281 @@
++/* ------------------------------------------------------------------------- */
++/* i2c-pcf-epp.c i2c-hw access for PCF8584 style EPP parallel port adapters  */
++/* ------------------------------------------------------------------------- */
++/*   Copyright (C) 1998-99 Hans Berglund
++
++    This program is free software; you can redistribute it and/or modify
++    it under the terms of the GNU General Public License as published by
++    the Free Software Foundation; either version 2 of the License, or
++    (at your option) any later version.
++
++    This program is distributed in the hope that it will be useful,
++    but WITHOUT ANY WARRANTY; without even the implied warranty of
++    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++    GNU General Public License for more details.
++
++    You should have received a copy of the GNU General Public License
++    along with this program; if not, write to the Free Software
++    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.		     */
++/* ------------------------------------------------------------------------- */
++
++/* With some changes from Ryosuke Tajima <rosk@jsk.t.u-tokyo.ac.jp> */
++
++#include <linux/kernel.h>
++#include <linux/ioport.h>
++#include <linux/module.h>
++#include <linux/delay.h>
++#include <linux/slab.h>
++#include <linux/init.h>
++#include <linux/parport.h>
++#include <linux/i2c.h>
++#include <linux/i2c-algo-pcf.h>
++#include <asm/irq.h>
++#include <asm/io.h>
++
++
++struct  i2c_pcf_epp {
++  int pe_base;
++  int pe_irq;
++  int pe_clock;
++  int pe_own;
++} ;
++
++#define DEFAULT_BASE 0x378
++#define DEFAULT_IRQ      7
++#define DEFAULT_CLOCK 0x1c
++#define DEFAULT_OWN   0x55
++
++static int base  = 0;
++static int irq   = 0;
++static int clock = 0;
++static int own   = 0;
++static int i2c_debug=0;
++static struct i2c_pcf_epp gpe;
++static wait_queue_head_t pcf_wait;
++static int pcf_pending;
++static spinlock_t irq_driver_lock = SPIN_LOCK_UNLOCKED;
++
++/* ----- global defines -----------------------------------------------	*/
++#define DEB(x)	if (i2c_debug>=1) x
++#define DEB2(x) if (i2c_debug>=2) x
++#define DEB3(x) if (i2c_debug>=3) x
++#define DEBE(x)	x	/* error messages 				*/
++
++/* --- Convenience defines for the EPP/SPP port:			*/
++#define BASE	((struct i2c_pcf_epp *)(data))->pe_base
++// #define DATA	BASE			/* SPP data port */
++#define STAT	(BASE+1)		/* SPP status port */
++#define CTRL	(BASE+2)		/* SPP control port */
++#define EADD	(BASE+3)		/* EPP address port */
++#define EDAT	(BASE+4)		/* EPP data port */
++
++/* ----- local functions ----------------------------------------------	*/
++
++static void pcf_epp_setbyte(void *data, int ctl, int val)
++{
++  if (ctl) {
++    if (gpe.pe_irq > 0) {
++      DEB3(printk(KERN_DEBUG "i2c-pcf-epp.o: Write control 0x%x\n",
++		  val|I2C_PCF_ENI));
++      // set A0 pin HIGH
++      outb(inb(CTRL) | PARPORT_CONTROL_INIT, CTRL);
++      // DEB3(printk(KERN_DEBUG "i2c-pcf-epp.o: CTRL port = 0x%x\n", inb(CTRL)));
++      // DEB3(printk(KERN_DEBUG "i2c-pcf-epp.o: STAT port = 0x%x\n", inb(STAT)));
++      
++      // EPP write data cycle
++      outb(val | I2C_PCF_ENI, EDAT);
++    } else {
++      DEB3(printk(KERN_DEBUG "i2c-pcf-epp.o: Write control 0x%x\n", val));
++      // set A0 pin HIGH
++      outb(inb(CTRL) | PARPORT_CONTROL_INIT, CTRL);
++      outb(val, CTRL);
++    }
++  } else {
++    DEB3(printk(KERN_DEBUG "i2c-pcf-epp.o: Write data 0x%x\n", val));
++    // set A0 pin LO
++    outb(inb(CTRL) & ~PARPORT_CONTROL_INIT, CTRL);
++    // DEB3(printk(KERN_DEBUG "i2c-pcf-epp.o: CTRL port = 0x%x\n", inb(CTRL)));
++    // DEB3(printk(KERN_DEBUG "i2c-pcf-epp.o: STAT port = 0x%x\n", inb(STAT)));
++    outb(val, EDAT);
++  }
++}
++
++static int pcf_epp_getbyte(void *data, int ctl)
++{
++  int val;
++
++  if (ctl) {
++    // set A0 pin HIGH
++    outb(inb(CTRL) | PARPORT_CONTROL_INIT, CTRL);
++    val = inb(EDAT);
++    DEB3(printk(KERN_DEBUG "i2c-pcf-epp.o: Read control 0x%x\n", val));
++  } else {
++    // set A0 pin LOW
++    outb(inb(CTRL) & ~PARPORT_CONTROL_INIT, CTRL);
++    val = inb(EDAT);
++    DEB3(printk(KERN_DEBUG "i2c-pcf-epp.o: Read data 0x%x\n", val));
++  }
++  return (val);
++}
++
++static int pcf_epp_getown(void *data)
++{
++  return (gpe.pe_own);
++}
++
++
++static int pcf_epp_getclock(void *data)
++{
++  return (gpe.pe_clock);
++}
++
++#if 0
++static void pcf_epp_sleep(unsigned long timeout)
++{
++  schedule_timeout( timeout * HZ);
++}
++#endif
++
++static void pcf_epp_waitforpin(void) {
++  int timeout = 10;
++
++  if (gpe.pe_irq > 0) {
++    spin_lock_irq(&irq_driver_lock);
++    if (pcf_pending == 0) {
++      interruptible_sleep_on_timeout(&pcf_wait, timeout*HZ);
++      //udelay(100);
++    } else {
++      pcf_pending = 0;
++    }
++    spin_unlock_irq(&irq_driver_lock);
++  } else {
++    udelay(100);
++  }
++}
++
++static void pcf_epp_handler(int this_irq, void *dev_id, struct pt_regs *regs) {
++  pcf_pending = 1;
++  wake_up_interruptible(&pcf_wait);
++  DEB3(printk(KERN_DEBUG "i2c-pcf-epp.o: in interrupt handler.\n"));
++}
++
++
++static int pcf_epp_init(void *data)
++{
++  if (check_region(gpe.pe_base, 5) < 0 ) {
++    
++    printk(KERN_WARNING "Could not request port region with base 0x%x\n", gpe.pe_base);
++    return -ENODEV;
++  } else {
++    request_region(gpe.pe_base, 5, "i2c (EPP parallel port adapter)");
++  }
++
++  DEB3(printk(KERN_DEBUG "i2c-pcf-epp.o: init status port = 0x%x\n", inb(0x379)));
++  
++  if (gpe.pe_irq > 0) {
++    if (request_irq(gpe.pe_irq, pcf_epp_handler, 0, "PCF8584", 0) < 0) {
++      printk(KERN_NOTICE "i2c-pcf-epp.o: Request irq%d failed\n", gpe.pe_irq);
++      gpe.pe_irq = 0;
++    } else
++      disable_irq(gpe.pe_irq);
++      enable_irq(gpe.pe_irq);
++  }
++  // EPP mode initialize
++  // enable interrupt from nINTR pin
++  outb(inb(CTRL)|0x14, CTRL);
++  // clear ERROR bit of STAT
++  outb(inb(STAT)|0x01, STAT);
++  outb(inb(STAT)&~0x01,STAT);
++  
++  return 0;
++}
++
++/* ------------------------------------------------------------------------
++ * Encapsulate the above functions in the correct operations structure.
++ * This is only done when more than one hardware adapter is supported.
++ */
++static struct i2c_algo_pcf_data pcf_epp_data = {
++	.setpcf	    = pcf_epp_setbyte,
++	.getpcf	    = pcf_epp_getbyte,
++	.getown	    = pcf_epp_getown,
++	.getclock   = pcf_epp_getclock,
++	.waitforpin = pcf_epp_waitforpin,
++	.udelay	    = 80,
++	.mdelay	    = 80,
++	.timeout    = HZ,
++};
++
++static struct i2c_adapter pcf_epp_ops = {
++	.owner		= THIS_MODULE,
++	.name		= "PCF8584 EPP adapter",
++	.id		= I2C_HW_P_LP,
++	.algo_data	= &pcf_epp_data,
++};
++
++static int __init i2c_pcfepp_init(void) 
++{
++  struct i2c_pcf_epp *pepp = &gpe;
++
++  printk(KERN_DEBUG "i2c-pcf-epp.o: i2c pcf8584-epp adapter module version %s (%s)\n", I2C_VERSION, I2C_DATE);
++  if (base == 0)
++    pepp->pe_base = DEFAULT_BASE;
++  else
++    pepp->pe_base = base;
++
++  if (irq == 0)
++    pepp->pe_irq = DEFAULT_IRQ;
++  else if (irq<0) {
++    // switch off irq
++    pepp->pe_irq=0;
++  } else {
++    pepp->pe_irq = irq;
++  }
++  if (clock == 0)
++    pepp->pe_clock = DEFAULT_CLOCK;
++  else
++    pepp->pe_clock = clock;
++
++  if (own == 0)
++    pepp->pe_own = DEFAULT_OWN;
++  else
++    pepp->pe_own = own;
++
++  pcf_epp_data.data = (void *)pepp;
++  init_waitqueue_head(&pcf_wait);
++  if (pcf_epp_init(pepp) == 0) {
++    int ret;
++    if ( (ret = i2c_pcf_add_bus(&pcf_epp_ops)) < 0) {
++      printk(KERN_WARNING "i2c_pcf_add_bus caused an error: %d\n",ret);
++      release_region(pepp->pe_base , 5);
++      return ret;
++    }
++  } else {
++    
++    return -ENODEV;
++  }
++  printk(KERN_DEBUG "i2c-pcf-epp.o: found device at %#x.\n", pepp->pe_base);
++  return 0;
++}
++
++static void __exit pcf_epp_exit(void)
++{
++  i2c_pcf_del_bus(&pcf_epp_ops);
++  if (gpe.pe_irq > 0) {
++    disable_irq(gpe.pe_irq);
++    free_irq(gpe.pe_irq, 0);
++  }
++  release_region(gpe.pe_base , 5);
++}
++
++MODULE_AUTHOR("Hans Berglund <hb@spacetec.no> \n modified by Ryosuke Tajima <rosk@jsk.t.u-tokyo.ac.jp>");
++MODULE_DESCRIPTION("I2C-Bus adapter routines for PCF8584 EPP parallel port adapter");
++MODULE_LICENSE("GPL");
++
++MODULE_PARM(base, "i");
++MODULE_PARM(irq, "i");
++MODULE_PARM(clock, "i");
++MODULE_PARM(own, "i");
++MODULE_PARM(i2c_debug, "i");
++
++module_init(i2c_pcfepp_init);
++module_exit(pcf_epp_exit);
+--- linux-old/include/linux/i2c-pcf8584.h	Thu Jan  1 00:00:00 1970
++++ linux/include/linux/i2c-pcf8584.h	Mon Dec 13 19:26:34 2004
+@@ -0,0 +1,78 @@
++/* -------------------------------------------------------------------- */
++/* i2c-pcf8584.h: PCF 8584 global defines				*/
++/* -------------------------------------------------------------------- */
++/*   Copyright (C) 1996 Simon G. Vogl
++                   1999 Hans Berglund
++
++    This program is free software; you can redistribute it and/or modify
++    it under the terms of the GNU General Public License as published by
++    the Free Software Foundation; either version 2 of the License, or
++    (at your option) any later version.
++
++    This program is distributed in the hope that it will be useful,
++    but WITHOUT ANY WARRANTY; without even the implied warranty of
++    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++    GNU General Public License for more details.
++
++    You should have received a copy of the GNU General Public License
++    along with this program; if not, write to the Free Software
++    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.		*/
++/* --------------------------------------------------------------------	*/
++
++/* With some changes from Frodo Looijaard <frodol@dds.nl> */
++
++/* $Id: i2c-pcf8584.h,v 1.6 2003/07/25 07:56:42 khali Exp $ */
++
++#ifndef _LINUX_I2C_PCF8584_H
++#define _LINUX_I2C_PCF8584_H
++
++/* ----- Control register bits ----------------------------------------	*/
++#define I2C_PCF_PIN	0x80
++#define I2C_PCF_ESO	0x40
++#define I2C_PCF_ES1	0x20
++#define I2C_PCF_ES2	0x10
++#define I2C_PCF_ENI	0x08
++#define I2C_PCF_STA	0x04
++#define I2C_PCF_STO	0x02
++#define I2C_PCF_ACK	0x01
++
++#define I2C_PCF_START    (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_STA | I2C_PCF_ACK)
++#define I2C_PCF_STOP     (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_STO | I2C_PCF_ACK)
++#define I2C_PCF_REPSTART (              I2C_PCF_ESO | I2C_PCF_STA | I2C_PCF_ACK)
++#define I2C_PCF_IDLE     (I2C_PCF_PIN | I2C_PCF_ESO               | I2C_PCF_ACK)
++
++/* ----- Status register bits -----------------------------------------	*/
++/*#define I2C_PCF_PIN  0x80    as above*/
++
++#define I2C_PCF_INI 0x40   /* 1 if not initialized */
++#define I2C_PCF_STS 0x20
++#define I2C_PCF_BER 0x10
++#define I2C_PCF_AD0 0x08
++#define I2C_PCF_LRB 0x08
++#define I2C_PCF_AAS 0x04
++#define I2C_PCF_LAB 0x02
++#define I2C_PCF_BB  0x01
++
++/* ----- Chip clock frequencies ---------------------------------------	*/
++#define I2C_PCF_CLK3	0x00
++#define I2C_PCF_CLK443	0x10
++#define I2C_PCF_CLK6	0x14
++#define I2C_PCF_CLK	0x18
++#define I2C_PCF_CLK12	0x1c
++
++/* ----- transmission frequencies -------------------------------------	*/
++#define I2C_PCF_TRNS90 0x00	/*  90 kHz */
++#define I2C_PCF_TRNS45 0x01	/*  45 kHz */
++#define I2C_PCF_TRNS11 0x02	/*  11 kHz */
++#define I2C_PCF_TRNS15 0x03	/* 1.5 kHz */
++
++
++/* ----- Access to internal registers according to ES1,ES2 ------------	*/
++/* they are mapped to the data port ( a0 = 0 ) 				*/
++/* available when ESO == 0 :						*/
++
++#define I2C_PCF_OWNADR	0
++#define I2C_PCF_INTREG	I2C_PCF_ES2
++#define I2C_PCF_CLKREG	I2C_PCF_ES1
++
++#endif /* _LINUX_I2C_PCF8584_H */
+--- linux-old/drivers/i2c/i2c-philips-par.c	Fri Feb 20 01:22:16 2004
++++ linux/drivers/i2c/i2c-philips-par.c	Mon Dec 13 19:26:34 2004
+@@ -21,7 +21,7 @@
+ /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
+    Frodo Looijaard <frodol@dds.nl> */
+ 
+-/* $Id: i2c-philips-par.c,v 1.18 2000/07/06 19:21:49 frodo Exp $ */
++/* $Id: i2c-philips-par.c,v 1.33 2004/01/23 20:22:53 khali Exp $ */
+ 
+ #include <linux/kernel.h>
+ #include <linux/ioport.h>
+@@ -29,14 +29,10 @@
+ #include <linux/init.h>
+ #include <linux/stddef.h>
+ #include <linux/parport.h>
+-
++#include <linux/slab.h>
+ #include <linux/i2c.h>
+ #include <linux/i2c-algo-bit.h>
+ 
+-#ifndef __exit
+-#define __exit __init
+-#endif
+-
+ static int type;
+ 
+ struct i2c_par
+@@ -130,59 +126,34 @@
+ 			             PARPORT_STATUS_BUSY) ? 0 : 1;
+ }
+ 
+-static int bit_lp_reg(struct i2c_client *client)
+-{
+-	return 0;
+-}
+-
+-static int bit_lp_unreg(struct i2c_client *client)
+-{
+-	return 0;
+-}
+-
+-static void bit_lp_inc_use(struct i2c_adapter *adap)
+-{
+-	MOD_INC_USE_COUNT;
+-}
+-
+-static void bit_lp_dec_use(struct i2c_adapter *adap)
+-{
+-	MOD_DEC_USE_COUNT;
+-}
+-
+ /* ------------------------------------------------------------------------
+  * Encapsulate the above functions in the correct operations structure.
+  * This is only done when more than one hardware adapter is supported.
+  */
+  
+ static struct i2c_algo_bit_data bit_lp_data = {
+-	NULL,
+-	bit_lp_setsda,
+-	bit_lp_setscl,
+-	bit_lp_getsda,
+-	bit_lp_getscl,
+-	80, 80, 100,		/*	waits, timeout */
++	.setsda		= bit_lp_setsda,
++	.setscl		= bit_lp_setscl,
++	.getsda		= bit_lp_getsda,
++	.getscl		= bit_lp_getscl,
++	.udelay		= 80,
++	.mdelay		= 80,
++	.timeout	= HZ
+ }; 
+ 
+ static struct i2c_algo_bit_data bit_lp_data2 = {
+-	NULL,
+-	bit_lp_setsda2,
+-	bit_lp_setscl2,
+-	bit_lp_getsda2,
+-	NULL,
+-	80, 80, 100,		/*	waits, timeout */
++	.setsda		= bit_lp_setsda2,
++	.setscl		= bit_lp_setscl2,
++	.getsda		= bit_lp_getsda2,
++	.udelay		= 80,
++	.mdelay		= 80,
++	.timeout	= HZ
+ }; 
+ 
+ static struct i2c_adapter bit_lp_ops = {
+-	"Philips Parallel port adapter",
+-	I2C_HW_B_LP,
+-	NULL,
+-	NULL,
+-	bit_lp_inc_use,
+-	bit_lp_dec_use,
+-	bit_lp_reg,
+-
+-	bit_lp_unreg,
++	.owner		= THIS_MODULE,
++	.name		= "Philips Parallel port adapter",
++	.id		= I2C_HW_B_LP,
+ };
+ 
+ static void i2c_parport_attach (struct parport *port)
+@@ -202,6 +173,7 @@
+ 						NULL);
+ 	if (!adapter->pdev) {
+ 		printk(KERN_ERR "i2c-philips-par: Unable to register with parport.\n");
++		kfree(adapter);
+ 		return;
+ 	}
+ 
+@@ -210,8 +182,12 @@
+ 	adapter->bit_lp_data = type ? bit_lp_data2 : bit_lp_data;
+ 	adapter->bit_lp_data.data = port;
+ 
++	if (parport_claim_or_block(adapter->pdev) < 0 ) {
++		printk(KERN_ERR "i2c-philips-par: Could not claim parallel port.\n");
++		kfree(adapter);
++		return;
++	}
+ 	/* reset hardware to sane state */
+-	parport_claim_or_block(adapter->pdev);
+ 	adapter->bit_lp_data.setsda(port, 1);
+ 	adapter->bit_lp_data.setscl(port, 1);
+ 	parport_release(adapter->pdev);
+@@ -257,7 +233,7 @@
+ 	NULL
+ };
+ 
+-int __init i2c_bitlp_init(void)
++static int __init i2c_bitlp_init(void)
+ {
+ 	printk(KERN_INFO "i2c-philips-par.o: i2c Philips parallel port adapter module version %s (%s)\n", I2C_VERSION, I2C_DATE);
+ 
+@@ -266,7 +242,7 @@
+ 	return 0;
+ }
+ 
+-void __exit i2c_bitlp_exit(void)
++static void __exit i2c_bitlp_exit(void)
+ {
+ 	parport_unregister_driver(&i2c_driver);
+ }
+@@ -279,14 +255,5 @@
+ 
+ MODULE_PARM(type, "i");
+ 
+-#ifdef MODULE
+-int init_module(void)
+-{
+-	return i2c_bitlp_init();
+-}
+-
+-void cleanup_module(void)
+-{
+-	i2c_bitlp_exit();
+-}
+-#endif
++module_init(i2c_bitlp_init);
++module_exit(i2c_bitlp_exit);
+--- linux-old/drivers/i2c/i2c-pport.c	Thu Jan  1 00:00:00 1970
++++ linux/drivers/i2c/i2c-pport.c	Mon Dec 13 19:26:34 2004
+@@ -0,0 +1,169 @@
++/* ------------------------------------------------------------------------- */
++/* i2c-pport.c i2c-hw access  for primitive i2c par. port adapter	     */
++/* ------------------------------------------------------------------------- */
++/*   Copyright (C) 2001    Daniel Smolik
++
++    This program is free software; you can redistribute it and/or modify
++    it under the terms of the GNU General Public License as published by
++    the Free Software Foundation; either version 2 of the License, or
++    (at your option) any later version.
++
++    This program is distributed in the hope that it will be useful,
++    but WITHOUT ANY WARRANTY; without even the implied warranty of
++    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++    GNU General Public License for more details.
++
++    You should have received a copy of the GNU General Public License
++    along with this program; if not, write to the Free Software
++    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.		     */
++/* ------------------------------------------------------------------------- */
++
++/*
++	See doc/i2c-pport for instructions on wiring to the
++	parallel port connector.
++
++	Cut & paste :-)  based on Velleman K8000 driver by Simon G. Vogl
++
++	Note that SDA is hardware inverted.
++*/
++
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/delay.h>
++#include <linux/slab.h>
++#include <linux/init.h>
++#include <linux/ioport.h>
++#include <linux/errno.h>
++#include <linux/i2c.h>
++#include <linux/i2c-algo-bit.h>
++#include <asm/io.h>
++
++
++#define DEFAULT_BASE 0x378
++static int base = DEFAULT_BASE;
++static unsigned char PortData = 0;
++
++/* ----- global defines -----------------------------------------------	*/
++#define DEB(x)		/* should be reasonable open, close &c. 	*/
++#define DEB2(x) 	/* low level debugging - very slow 		*/
++#define DEBE(x)	x	/* error messages 				*/
++#define DEBINIT(x) x	/* detection status messages			*/
++
++/* --- Convenience defines for the parallel port:			*/
++#define BASE	(unsigned int)(data)
++#define DATA	BASE			/* Centronics data port		*/
++#define STAT	(BASE+1)		/* Centronics status port	*/
++#define CTRL	(BASE+2)		/* Centronics control port	*/
++
++/* we will use SDA - Auto Linefeed(14)       POUT (ctrl bit 1) */
++/* we will use SCL - Initialize printer(16)  BUSY (ctrl bit 2) */
++
++#define  SET_SCL    | 0x04
++#define  CLR_SCL    & 0xFB
++
++#define  SET_SDA    & 0xFD
++#define  CLR_SDA    | 0x02
++
++
++/* ----- local functions ----------------------------------------------	*/
++
++
++static void bit_pport_setscl(void *data, int state)
++{
++	if (state) {
++		PortData = PortData SET_SCL;
++	} else {
++		PortData = PortData CLR_SCL; 
++	}
++	outb(PortData, CTRL);
++}
++
++static void bit_pport_setsda(void *data, int state)
++{
++	if (state) {
++		PortData = PortData SET_SDA;
++	} else {
++		PortData = PortData CLR_SDA;
++	}
++	outb(PortData, CTRL);
++} 
++
++static int bit_pport_getscl(void *data)
++{
++	return ( 4 == ( (inb_p(CTRL)) & 0x04 ) );
++}
++
++static int bit_pport_getsda(void *data)
++{
++	return ( 0 == ( (inb_p(CTRL)) & 0x02 ) );
++}
++
++static int bit_pport_init(void)
++{
++	if (!request_region((base+2),1, "i2c (PPORT adapter)")) {
++		return -ENODEV;	
++	}
++
++	PortData = inb(base+2);
++	bit_pport_setsda((void*)base, 1);
++	bit_pport_setscl((void*)base, 1);
++
++	return 0;
++}
++
++
++/* ------------------------------------------------------------------------
++ * Encapsulate the above functions in the correct operations structure.
++ * This is only done when more than one hardware adapter is supported.
++ */
++static struct i2c_algo_bit_data bit_pport_data = {
++	.setsda		= bit_pport_setsda,
++	.setscl		= bit_pport_setscl,
++	.getsda		= bit_pport_getsda,
++	.getscl		= bit_pport_getscl,
++	.udelay		= 40,
++	.mdelay		= 80,
++	.timeout	= HZ
++};
++
++static struct i2c_adapter bit_pport_ops = {
++	.owner		= THIS_MODULE,
++	.name		= "Primitive Parallel port adaptor",
++	.id		= I2C_HW_B_PPORT,
++	.algo_data	= &bit_pport_data,
++};
++
++static int __init i2c_bitpport_init(void)
++{
++	printk("i2c-pport.o: i2c Primitive parallel port adapter module version %s (%s)\n", I2C_VERSION, I2C_DATE);
++
++	bit_pport_data.data = (void*)base;
++	if (bit_pport_init() < 0)
++		return -ENODEV;
++
++	if (i2c_bit_add_bus(&bit_pport_ops) < 0) {
++		release_region(base+2, 1);
++		return -ENODEV;
++	}
++
++	printk("i2c-pport.o: found device at %#x.\n",base);
++	return 0;
++}
++
++static void __exit i2c_bitpport_exit(void)
++{
++	i2c_bit_del_bus(&bit_pport_ops);
++	release_region((base+2),1);
++}
++
++EXPORT_NO_SYMBOLS;
++
++MODULE_AUTHOR("Daniel Smolik <marvin@sitour.cz>");
++MODULE_DESCRIPTION("I2C-Bus adapter routines for Primitive parallel port adapter");
++MODULE_LICENSE("GPL");
++
++MODULE_PARM(base, "i");
++
++module_init(i2c_bitpport_init);
++module_exit(i2c_bitpport_exit);
+--- linux-old/drivers/i2c/i2c-proc.c	Tue Jan 20 15:10:31 2004
++++ linux/drivers/i2c/i2c-proc.c	Mon Dec 13 19:26:35 2004
+@@ -23,29 +23,26 @@
+     This driver puts entries in /proc/sys/dev/sensors for each I2C device
+ */
+ 
++#include <linux/config.h>
+ #include <linux/module.h>
+ #include <linux/kernel.h>
+ #include <linux/slab.h>
+ #include <linux/ctype.h>
+ #include <linux/sysctl.h>
+ #include <linux/proc_fs.h>
++#include <linux/init.h>
+ #include <linux/ioport.h>
+-#include <asm/uaccess.h>
+-
+ #include <linux/i2c.h>
+ #include <linux/i2c-proc.h>
++#include <asm/uaccess.h>
+ 
+-#include <linux/init.h>
+-
+-#ifndef THIS_MODULE
+-#define THIS_MODULE NULL
++#ifndef CONFIG_SYSCTL
++#error Your kernel lacks sysctl support (CONFIG_SYSCTL)!
+ #endif
+ 
+-static int i2c_create_name(char **name, const char *prefix,
+-			       struct i2c_adapter *adapter, int addr);
+ static int i2c_parse_reals(int *nrels, void *buffer, int bufsize,
+ 			       long *results, int magnitude);
+-static int i2c_write_reals(int nrels, void *buffer, int *bufsize,
++static int i2c_write_reals(int nrels, void *buffer, size_t *bufsize,
+ 			       long *results, int magnitude);
+ static int i2c_proc_chips(ctl_table * ctl, int write,
+ 			      struct file *filp, void *buffer,
+@@ -55,22 +52,10 @@
+ 				void *newval, size_t newlen,
+ 				void **context);
+ 
+-int __init sensors_init(void);
+-
+ #define SENSORS_ENTRY_MAX 20
+ static struct ctl_table_header *i2c_entries[SENSORS_ENTRY_MAX];
+ 
+ static struct i2c_client *i2c_clients[SENSORS_ENTRY_MAX];
+-static unsigned short i2c_inodes[SENSORS_ENTRY_MAX];
+-
+-static ctl_table sysctl_table[] = {
+-	{CTL_DEV, "dev", NULL, 0, 0555},
+-	{0},
+-	{DEV_SENSORS, "sensors", NULL, 0, 0555},
+-	{0},
+-	{0, NULL, NULL, 0, 0555},
+-	{0}
+-};
+ 
+ static ctl_table i2c_proc_dev_sensors[] = {
+ 	{SENSORS_CHIPS, "chips", NULL, 0, 0644, NULL, &i2c_proc_chips,
+@@ -91,31 +76,45 @@
+ 
+ 
+ static struct ctl_table_header *i2c_proc_header;
+-static int i2c_initialized;
+ 
+ /* This returns a nice name for a new directory; for example lm78-isa-0310
+    (for a LM78 chip on the ISA bus at port 0x310), or lm75-i2c-3-4e (for
+    a LM75 chip on the third i2c bus at address 0x4e).  
+    name is allocated first. */
+-int i2c_create_name(char **name, const char *prefix,
+-			struct i2c_adapter *adapter, int addr)
++static char *generate_name(struct i2c_client *client, const char *prefix)
+ {
+-	char name_buffer[50];
+-	int id;
+-	if (i2c_is_isa_adapter(adapter))
++	struct i2c_adapter *adapter = client->adapter;
++	int addr = client->addr;
++	char name_buffer[50], *name;
++
++	if (i2c_is_isa_adapter(adapter)) {
+ 		sprintf(name_buffer, "%s-isa-%04x", prefix, addr);
+-	else {
+-		if ((id = i2c_adapter_id(adapter)) < 0)
+-			return -ENOENT;
++	} else if (adapter->algo->smbus_xfer || adapter->algo->master_xfer) {
++		int id = i2c_adapter_id(adapter);
++		if (id < 0)
++			return ERR_PTR(-ENOENT);
+ 		sprintf(name_buffer, "%s-i2c-%d-%02x", prefix, id, addr);
++	} else {	/* dummy adapter, generate prefix */
++		int end, i;
++
++		sprintf(name_buffer, "%s-", prefix);
++		end = strlen(name_buffer);
++
++		for (i = 0; i < 32; i++) {
++			if (adapter->algo->name[i] == ' ')
++				break;
++			name_buffer[end++] = tolower(adapter->algo->name[i]);
++		}
++
++		name_buffer[end] = 0;
++		sprintf(name_buffer + end, "-%04x", addr);
+ 	}
+-	*name = kmalloc(strlen(name_buffer) + 1, GFP_KERNEL);
+-	if (!*name) {
+-		printk (KERN_WARNING "i2c_create_name: not enough memory\n");
+-		return -ENOMEM;
+-	}
+-	strcpy(*name, name_buffer);
+-	return 0;
++
++	name = kmalloc(strlen(name_buffer) + 1, GFP_KERNEL);
++	if (!name)
++		return ERR_PTR(-ENOMEM);
++	strcpy(name, name_buffer);
++	return name;
+ }
+ 
+ /* This rather complex function must be called when you want to add an entry
+@@ -124,139 +123,91 @@
+    ctl_template should be a template of the newly created directory. It is
+    copied in memory. The extra2 field of each file is set to point to client.
+    If any driver wants subdirectories within the newly created directory,
+-   this function must be updated! 
+-   controlling_mod is the controlling module. It should usually be
+-   THIS_MODULE when calling. Note that this symbol is not defined in
+-   kernels before 2.3.13; define it to NULL in that case. We will not use it
+-   for anything older than 2.3.27 anyway. */
++   this function must be updated!  */
+ int i2c_register_entry(struct i2c_client *client, const char *prefix,
+-			   ctl_table * ctl_template,
+-			   struct module *controlling_mod)
++		       struct ctl_table *ctl_template)
+ {
+-	int i, res, len, id;
+-	ctl_table *new_table;
+-	char *name;
+-	struct ctl_table_header *new_header;
+-
+-	if ((res = i2c_create_name(&name, prefix, client->adapter,
+-				       client->addr))) return res;
++	struct { struct ctl_table root[2], dev[2], sensors[2]; } *tbl;
++	struct ctl_table_header *hdr;
++	struct ctl_table *tmp, *leaf;
++	const char *name;
++	int id, len = 0;
+ 
+-	for (id = 0; id < SENSORS_ENTRY_MAX; id++)
+-		if (!i2c_entries[id]) {
+-			break;
+-		}
+-	if (id == SENSORS_ENTRY_MAX) {
+-		kfree(name);
+-		return -ENOMEM;
+-	}
+-	id += 256;
++	name = generate_name(client, prefix);
++	if (IS_ERR(name))
++		return PTR_ERR(name);
+ 
+-	len = 0;
+-	while (ctl_template[len].procname)
+-		len++;
+-	len += 7;
+-	if (!(new_table = kmalloc(sizeof(ctl_table) * len, GFP_KERNEL))) {
+-		kfree(name);
+-		return -ENOMEM;
+-	}
+-
+-	memcpy(new_table, sysctl_table, 6 * sizeof(ctl_table));
+-	new_table[0].child = &new_table[2];
+-	new_table[2].child = &new_table[4];
+-	new_table[4].child = &new_table[6];
+-	new_table[4].procname = name;
+-	new_table[4].ctl_name = id;
+-	memcpy(new_table + 6, ctl_template, (len - 6) * sizeof(ctl_table));
+-	for (i = 6; i < len; i++)
+-		new_table[i].extra2 = client;
+-
+-	if (!(new_header = register_sysctl_table(new_table, 0))) {
+-		kfree(new_table);
+-		kfree(name);
+-		return -ENOMEM;
++	for (id = 0; id < SENSORS_ENTRY_MAX; id++) {
++		if (!i2c_entries[id])
++			goto free_slot;
+ 	}
+ 
+-	i2c_entries[id - 256] = new_header;
++	goto out_free_name;
+ 
+-	i2c_clients[id - 256] = client;
+-#ifdef DEBUG
+-	if (!new_header || !new_header->ctl_table ||
+-	    !new_header->ctl_table->child ||
+-	    !new_header->ctl_table->child->child ||
+-	    !new_header->ctl_table->child->child->de) {
+-		printk
+-		    ("i2c-proc.o: NULL pointer when trying to install fill_inode fix!\n");
+-		return id;
+-	}
+-#endif				/* DEBUG */
+-	i2c_inodes[id - 256] =
+-	    new_header->ctl_table->child->child->de->low_ino;
+-	new_header->ctl_table->child->child->de->owner = controlling_mod;
+-
+-	return id;
++ free_slot:
++	while (ctl_template[len].ctl_name)
++		len++;
++	tbl = kmalloc(sizeof(*tbl) + sizeof(ctl_table) * (len + 1), 
++				  GFP_KERNEL);
++	if (!tbl)
++		goto out_free_name;
++	memset(tbl, 0, sizeof(*tbl));
++
++	/* The client sysctls */
++	leaf = (struct ctl_table *) (tbl + 1);
++	memcpy(leaf, ctl_template, sizeof(ctl_table) * (len+1));
++	for (tmp = leaf; tmp->ctl_name; tmp++)
++		tmp->extra2 = client;
++
++	tbl->sensors->ctl_name = id+256;
++	tbl->sensors->procname = name;
++	tbl->sensors->mode = 0555;
++	tbl->sensors->child = leaf;
++
++	tbl->dev->ctl_name = DEV_SENSORS;
++	tbl->dev->procname = "sensors";
++	tbl->dev->mode = 0555;
++	tbl->dev->child = tbl->sensors;
++
++	tbl->root->ctl_name = CTL_DEV;
++	tbl->root->procname = "dev";
++	tbl->root->mode = 0555;
++	tbl->root->child = tbl->dev;
++
++	hdr = register_sysctl_table(tbl->root, 0);
++	if (!hdr)
++		goto out_free_tbl;
++
++	i2c_entries[id] = hdr;
++	i2c_clients[id] = client;
++
++	return (id + 256);	/* XXX(hch) why?? */
++
++ out_free_tbl:
++	kfree(tbl);
++ out_free_name:
++	kfree(name);
++	return -ENOMEM;
+ }
+ 
+ void i2c_deregister_entry(int id)
+ {
+-	ctl_table *table;
+-	char *temp;
+ 	id -= 256;
+-	if (i2c_entries[id]) {
+-		table = i2c_entries[id]->ctl_table;
+-		unregister_sysctl_table(i2c_entries[id]);
+-		/* 2-step kfree needed to keep gcc happy about const points */
+-		(const char *) temp = table[4].procname;
+-		kfree(temp);
+-		kfree(table);
+-		i2c_entries[id] = NULL;
+-		i2c_clients[id] = NULL;
+-	}
+-}
+ 
+-/* Monitor access for /proc/sys/dev/sensors; make unloading i2c-proc.o 
+-   impossible if some process still uses it or some file in it */
+-void i2c_fill_inode(struct inode *inode, int fill)
+-{
+-	if (fill)
+-		MOD_INC_USE_COUNT;
+-	else
+-		MOD_DEC_USE_COUNT;
+-}
+-
+-/* Monitor access for /proc/sys/dev/sensors/ directories; make unloading
+-   the corresponding module impossible if some process still uses it or
+-   some file in it */
+-void i2c_dir_fill_inode(struct inode *inode, int fill)
+-{
+-	int i;
+-	struct i2c_client *client;
++	if (i2c_entries[id]) {
++		struct ctl_table_header *hdr = i2c_entries[id];
++		struct ctl_table *tbl = hdr->ctl_table;
+ 
+-#ifdef DEBUG
+-	if (!inode) {
+-		printk("i2c-proc.o: Warning: inode NULL in fill_inode()\n");
+-		return;
++		unregister_sysctl_table(hdr);
++		kfree(tbl->child->child->procname);
++		kfree(tbl); /* actually the whole anonymous struct */
+ 	}
+-#endif				/* def DEBUG */
+ 
+-	for (i = 0; i < SENSORS_ENTRY_MAX; i++)
+-		if (i2c_clients[i]
+-		    && (i2c_inodes[i] == inode->i_ino)) break;
+-#ifdef DEBUG
+-	if (i == SENSORS_ENTRY_MAX) {
+-		printk
+-		    ("i2c-proc.o: Warning: inode (%ld) not found in fill_inode()\n",
+-		     inode->i_ino);
+-		return;
+-	}
+-#endif				/* def DEBUG */
+-	client = i2c_clients[i];
+-	if (fill)
+-		client->driver->inc_use(client);
+-	else
+-		client->driver->dec_use(client);
++	i2c_entries[id] = NULL;
++	i2c_clients[id] = NULL;
+ }
+ 
+-int i2c_proc_chips(ctl_table * ctl, int write, struct file *filp,
++static int i2c_proc_chips(ctl_table * ctl, int write, struct file *filp,
+ 		       void *buffer, size_t * lenp)
+ {
+ 	char BUF[SENSORS_PREFIX_MAX + 30];
+@@ -294,7 +245,7 @@
+ 	return 0;
+ }
+ 
+-int i2c_sysctl_chips(ctl_table * table, int *name, int nlen,
++static int i2c_sysctl_chips(ctl_table * table, int *name, int nlen,
+ 			 void *oldval, size_t * oldlenp, void *newval,
+ 			 size_t newlen, void **context)
+ {
+@@ -456,7 +407,7 @@
+    WARNING! This is tricky code. I have tested it, but there may still be
+             hidden bugs in it, even leading to crashes and things!
+ */
+-int i2c_parse_reals(int *nrels, void *buffer, int bufsize,
++static int i2c_parse_reals(int *nrels, void *buffer, int bufsize,
+ 			 long *results, int magnitude)
+ {
+ 	int maxels, min, mag;
+@@ -557,7 +508,7 @@
+ 	return 0;
+ }
+ 
+-int i2c_write_reals(int nrels, void *buffer, int *bufsize,
++static int i2c_write_reals(int nrels, void *buffer, size_t *bufsize,
+ 			 long *results, int magnitude)
+ {
+ #define BUFLEN 20
+@@ -646,6 +597,7 @@
+ 					I2C_FUNC_SMBUS_QUICK)) return -1;
+ 
+ 	for (addr = 0x00; addr <= (is_isa ? 0xffff : 0x7f); addr++) {
++		/* XXX: WTF is going on here??? */
+ 		if ((is_isa && check_region(addr, 1)) ||
+ 		    (!is_isa && i2c_check_addr(adapter, addr)))
+ 			continue;
+@@ -846,46 +798,33 @@
+ 	return 0;
+ }
+ 
+-int __init sensors_init(void)
++static int __init i2c_proc_init(void)
+ {
+ 	printk(KERN_INFO "i2c-proc.o version %s (%s)\n", I2C_VERSION, I2C_DATE);
+-	i2c_initialized = 0;
+ 	if (!
+ 	    (i2c_proc_header =
+-	     register_sysctl_table(i2c_proc, 0))) return -ENOMEM;
++	     register_sysctl_table(i2c_proc, 0))) {
++		printk(KERN_ERR "i2c-proc.o: error: sysctl interface not supported by kernel!\n");
++		return -EPERM;
++	}
+ 	i2c_proc_header->ctl_table->child->de->owner = THIS_MODULE;
+-	i2c_initialized++;
+ 	return 0;
+ }
+ 
++static void __exit i2c_proc_exit(void)
++{
++	unregister_sysctl_table(i2c_proc_header);
++}
++
++EXPORT_SYMBOL(i2c_register_entry);
+ EXPORT_SYMBOL(i2c_deregister_entry);
+-EXPORT_SYMBOL(i2c_detect);
+ EXPORT_SYMBOL(i2c_proc_real);
+-EXPORT_SYMBOL(i2c_register_entry);
+ EXPORT_SYMBOL(i2c_sysctl_real);
+-
+-#ifdef MODULE
++EXPORT_SYMBOL(i2c_detect);
+ 
+ MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
+ MODULE_DESCRIPTION("i2c-proc driver");
+ MODULE_LICENSE("GPL");
+ 
+-int i2c_cleanup(void)
+-{
+-	if (i2c_initialized >= 1) {
+-		unregister_sysctl_table(i2c_proc_header);
+-		i2c_initialized--;
+-	}
+-	return 0;
+-}
+-
+-int init_module(void)
+-{
+-	return sensors_init();
+-}
+-
+-int cleanup_module(void)
+-{
+-	return i2c_cleanup();
+-}
+-#endif				/* MODULE */
++module_init(i2c_proc_init);
++module_exit(i2c_proc_exit);
+--- linux-old/include/linux/i2c-proc.h	Tue Nov  6 00:55:29 2001
++++ linux/include/linux/i2c-proc.h	Mon Dec 13 19:26:36 2004
+@@ -1,6 +1,7 @@
+ /*
+-    sensors.h - Part of lm_sensors, Linux kernel modules for hardware
+-                monitoring
++    i2c-proc.h - Part of the i2c package
++    was originally sensors.h - Part of lm_sensors, Linux kernel modules
++                               for hardware monitoring
+     Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
+ 
+     This program is free software; you can redistribute it and/or modify
+@@ -18,14 +19,9 @@
+     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+ 
+-#ifndef SENSORS_SENSORS_H
+-#define SENSORS_SENSORS_H
++#ifndef _LINUX_I2C_PROC_H
++#define _LINUX_I2C_PROC_H
+ 
+-#ifdef __KERNEL__
+-
+-/* Next two must be included before sysctl.h can be included, in 2.0 kernels */
+-#include <linux/types.h>
+-#include <linux/fs.h>
+ #include <linux/sysctl.h>
+ 
+ /* The type of callback functions used in sensors_{proc,sysctl}_real */
+@@ -73,8 +69,7 @@
+    these functions must be updated! */
+ extern int i2c_register_entry(struct i2c_client *client,
+ 				  const char *prefix,
+-				  ctl_table * ctl_template,
+-				  struct module *controlling_mod);
++				  ctl_table * ctl_template);
+ 
+ extern void i2c_deregister_entry(int id);
+ 
+@@ -347,6 +342,31 @@
+                                                  {NULL}}; \
+   SENSORS_INSMOD
+ 
++#define SENSORS_INSMOD_8(chip1,chip2,chip3,chip4,chip5,chip6,chip7,chip8) \
++  enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6, chip7, chip8 }; \
++  SENSORS_MODULE_PARM(force, \
++                      "List of adapter,address pairs to boldly assume " \
++                      "to be present"); \
++  SENSORS_MODULE_PARM_FORCE(chip1); \
++  SENSORS_MODULE_PARM_FORCE(chip2); \
++  SENSORS_MODULE_PARM_FORCE(chip3); \
++  SENSORS_MODULE_PARM_FORCE(chip4); \
++  SENSORS_MODULE_PARM_FORCE(chip5); \
++  SENSORS_MODULE_PARM_FORCE(chip6); \
++  SENSORS_MODULE_PARM_FORCE(chip7); \
++  SENSORS_MODULE_PARM_FORCE(chip8); \
++  static struct i2c_force_data forces[] = {{force,any_chip}, \
++                                                 {force_ ## chip1,chip1}, \
++                                                 {force_ ## chip2,chip2}, \
++                                                 {force_ ## chip3,chip3}, \
++                                                 {force_ ## chip4,chip4}, \
++                                                 {force_ ## chip5,chip5}, \
++                                                 {force_ ## chip6,chip6}, \
++                                                 {force_ ## chip7,chip7}, \
++                                                 {force_ ## chip8,chip8}, \
++                                                 {NULL}}; \
++  SENSORS_INSMOD
++
+ typedef int i2c_found_addr_proc(struct i2c_adapter *adapter,
+ 				    int addr, unsigned short flags,
+ 				    int kind);
+@@ -362,7 +382,7 @@
+ 
+ /* This macro is used to scale user-input to sensible values in almost all
+    chip drivers. */
+-extern inline int SENSORS_LIMIT(long value, long low, long high)
++static inline int SENSORS_LIMIT(long value, long low, long high)
+ {
+ 	if (value < low)
+ 		return low;
+@@ -372,8 +392,6 @@
+ 		return value;
+ }
+ 
+-#endif				/* def __KERNEL__ */
+-
+ 
+ /* The maximum length of the prefix */
+ #define SENSORS_PREFIX_MAX 20
+@@ -392,5 +410,5 @@
+ 	char name[SENSORS_PREFIX_MAX + 13];
+ };
+ 
+-#endif				/* def SENSORS_SENSORS_H */
++#endif				/* def _LINUX_I2C_PROC_H */
+ 
+--- linux-old/drivers/i2c/i2c-rpx.c	Thu Jan  1 00:00:00 1970
++++ linux/drivers/i2c/i2c-rpx.c	Mon Dec 13 19:26:36 2004
+@@ -0,0 +1,101 @@
++/*
++ * Embedded Planet RPX Lite MPC8xx CPM I2C interface.
++ * Copyright (c) 1999 Dan Malek (dmalek@jlc.net).
++ *
++ * moved into proper i2c interface;
++ * Brad Parker (brad@heeltoe.com)
++ *
++ * RPX lite specific parts of the i2c interface
++ * Update:  There actually isn't anything RPXLite-specific about this module.
++ * This should work for most any 8xx board.  The console messages have been 
++ * changed to eliminate RPXLite references.
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/init.h>
++#include <linux/stddef.h>
++#include <linux/i2c.h>
++#include <linux/i2c-algo-8xx.h>
++#include <asm/mpc8xx.h>
++#include <asm/commproc.h>
++
++
++static void
++rpx_iic_init(struct i2c_algo_8xx_data *data)
++{
++	volatile cpm8xx_t *cp;
++	volatile immap_t *immap;
++
++	cp = cpmp;	/* Get pointer to Communication Processor */
++	immap = (immap_t *)IMAP_ADDR;	/* and to internal registers */
++
++	data->iip = (iic_t *)&cp->cp_dparam[PROFF_IIC];
++
++	/* Check for and use a microcode relocation patch.
++	*/
++	if ((data->reloc = data->iip->iic_rpbase))
++		data->iip = (iic_t *)&cp->cp_dpmem[data->iip->iic_rpbase];
++		
++	data->i2c = (i2c8xx_t *)&(immap->im_i2c);
++	data->cp = cp;
++
++	/* Initialize Port B IIC pins.
++	*/
++	cp->cp_pbpar |= 0x00000030;
++	cp->cp_pbdir |= 0x00000030;
++	cp->cp_pbodr |= 0x00000030;
++
++	/* Allocate space for two transmit and two receive buffer
++	 * descriptors in the DP ram.
++	 */
++	data->dp_addr = m8xx_cpm_dpalloc(sizeof(cbd_t) * 4);
++
++	/* ptr to i2c area */
++	data->i2c = (i2c8xx_t *)&(((immap_t *)IMAP_ADDR)->im_i2c);
++}
++
++static int rpx_install_isr(int irq, void (*func)(void *, void *), void *data)
++{
++	/* install interrupt handler */
++	cpm_install_handler(irq, (void (*)(void *, struct pt_regs *)) func, data);
++
++	return 0;
++}
++
++static struct i2c_algo_8xx_data rpx_data = {
++	.setisr = rpx_install_isr
++};
++
++static struct i2c_adapter rpx_ops = {
++	.owner		= THIS_MODULE,
++	.name		= "m8xx",
++	.id		= I2C_HW_MPC8XX_EPON,
++	.algo_data	= &rpx_data,
++};
++
++static int __init i2c_rpx_init(void)
++{
++	printk("i2c-rpx.o: i2c MPC8xx module version %s (%s)\n", I2C_VERSION, I2C_DATE);
++
++	/* reset hardware to sane state */
++	rpx_iic_init(&rpx_data);
++
++	if (i2c_8xx_add_bus(&rpx_ops) < 0) {
++		printk("i2c-rpx: Unable to register with I2C\n");
++		return -ENODEV;
++	}
++
++	return 0;
++}
++
++static void __exit i2c_rpx_exit(void)
++{
++	i2c_8xx_del_bus(&rpx_ops);
++}
++
++MODULE_AUTHOR("Dan Malek <dmalek@jlc.net>");
++MODULE_DESCRIPTION("I2C-Bus adapter routines for MPC8xx boards");
++
++module_init(i2c_rpx_init);
++module_exit(i2c_rpx_exit);
+--- linux-old/drivers/i2c/i2c-velleman.c	Tue Jan 20 15:10:31 2004
++++ linux/drivers/i2c/i2c-velleman.c	Mon Dec 13 19:26:36 2004
+@@ -18,18 +18,18 @@
+     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.		     */
+ /* ------------------------------------------------------------------------- */
+ 
+-/* $Id: i2c-velleman.c,v 1.19 2000/01/24 02:06:33 mds Exp $ */
++/* $Id: i2c-velleman.c,v 1.33 2003/12/24 17:49:44 khali Exp $ */
+ 
+ #include <linux/kernel.h>
+ #include <linux/ioport.h>
+ #include <linux/module.h>
+ #include <linux/init.h>
+-#include <linux/string.h>  /* for 2.0 kernels to get NULL   */
+-#include <asm/errno.h>     /* for 2.0 kernels to get ENODEV */
+-#include <asm/io.h>
+-
++#include <linux/errno.h>
++#include <linux/delay.h>
+ #include <linux/i2c.h>
+ #include <linux/i2c-algo-bit.h>
++#include <asm/io.h>
++#include <asm/param.h> /* for HZ */
+ 
+ /* ----- global defines -----------------------------------------------	*/
+ #define DEB(x)		/* should be reasonable open, close &c. 	*/
+@@ -90,75 +90,38 @@
+ 
+ static int bit_velle_init(void)
+ {
+-	if (check_region(base,(base == 0x3bc)? 3 : 8) < 0 ) {
+-		DEBE(printk("i2c-velleman.o: Port %#x already in use.\n",
+-		     base));
++	if (!request_region(base, (base == 0x3bc) ? 3 : 8, 
++			"i2c (Vellemann adapter)"))
+ 		return -ENODEV;
+-	} else {
+-		request_region(base, (base == 0x3bc)? 3 : 8, 
+-			"i2c (Vellemann adapter)");
+-		bit_velle_setsda((void*)base,1);
+-		bit_velle_setscl((void*)base,1);
+-	}
+-	return 0;
+-}
+ 
+-static void __exit bit_velle_exit(void)
+-{	
+-	release_region( base , (base == 0x3bc)? 3 : 8 );
+-}
+-
+-
+-static int bit_velle_reg(struct i2c_client *client)
+-{
+-	return 0;
+-}
+-
+-static int bit_velle_unreg(struct i2c_client *client)
+-{
++	bit_velle_setsda((void*)base,1);
++	bit_velle_setscl((void*)base,1);
+ 	return 0;
+ }
+ 
+-static void bit_velle_inc_use(struct i2c_adapter *adap)
+-{
+-#ifdef MODULE
+-	MOD_INC_USE_COUNT;
+-#endif
+-}
+-
+-static void bit_velle_dec_use(struct i2c_adapter *adap)
+-{
+-#ifdef MODULE
+-	MOD_DEC_USE_COUNT;
+-#endif
+-}
+-
+ /* ------------------------------------------------------------------------
+  * Encapsulate the above functions in the correct operations structure.
+  * This is only done when more than one hardware adapter is supported.
+  */
+ 
+ static struct i2c_algo_bit_data bit_velle_data = {
+-	NULL,
+-	bit_velle_setsda,
+-	bit_velle_setscl,
+-	bit_velle_getsda,
+-	bit_velle_getscl,
+-	10, 10, 100,		/*	waits, timeout */
++	.setsda		= bit_velle_setsda,
++	.setscl		= bit_velle_setscl,
++	.getsda		= bit_velle_getsda,
++	.getscl		= bit_velle_getscl,
++	.udelay		= 10,
++	.mdelay		= 10,
++	.timeout	= HZ
+ };
+ 
+ static struct i2c_adapter bit_velle_ops = {
+-	"Velleman K8000",
+-	I2C_HW_B_VELLE,
+-	NULL,
+-	&bit_velle_data,
+-	bit_velle_inc_use,
+-	bit_velle_dec_use,
+-	bit_velle_reg,
+-	bit_velle_unreg,
++	.owner		= THIS_MODULE,
++	.name		= "Velleman K8000",
++	.id		= I2C_HW_B_VELLE,
++	.algo_data	= &bit_velle_data,
+ };
+ 
+-int __init  i2c_bitvelle_init(void)
++static int __init i2c_bitvelle_init(void)
+ {
+ 	printk(KERN_INFO "i2c-velleman.o: i2c Velleman K8000 adapter module version %s (%s)\n", I2C_VERSION, I2C_DATE);
+ 	if (base==0) {
+@@ -184,24 +147,19 @@
+ 	return 0;
+ }
+ 
++static void __exit i2c_bitvelle_exit(void)
++{	
++	i2c_bit_del_bus(&bit_velle_ops);
++	release_region(base, (base == 0x3bc) ? 3 : 8);
++}
++
+ EXPORT_NO_SYMBOLS;
+ 
+-#ifdef MODULE
+ MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
+ MODULE_DESCRIPTION("I2C-Bus adapter routines for Velleman K8000 adapter");
+ MODULE_LICENSE("GPL");
+ 
+ MODULE_PARM(base, "i");
+ 
+-int init_module(void) 
+-{
+-	return i2c_bitvelle_init();
+-}
+-
+-void cleanup_module(void) 
+-{
+-	i2c_bit_del_bus(&bit_velle_ops);
+-	bit_velle_exit();
+-}
+-
+-#endif
++module_init(i2c_bitvelle_init);
++module_exit(i2c_bitvelle_exit);
+--- linux-old/include/linux/i2c.h	Tue Jan 20 15:10:34 2004
++++ linux/include/linux/i2c.h	Mon Dec 13 19:26:37 2004
+@@ -23,36 +23,33 @@
+ /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and
+    Frodo Looijaard <frodol@dds.nl> */
+ 
+-/* $Id: i2c.h,v 1.46 2001/08/31 00:04:07 phil Exp $ */
++/* $Id: i2c.h,v 1.80 2004/10/07 23:47:17 phil Exp $ */
+ 
+-#ifndef I2C_H
+-#define I2C_H
++#ifndef _LINUX_I2C_H
++#define _LINUX_I2C_H
+ 
+-#define I2C_DATE "20010830"
+-#define I2C_VERSION "2.6.1"
++#define I2C_DATE "20041007"
++#define I2C_VERSION "2.8.8"
+ 
+-#include <linux/i2c-id.h>	/* id values of adapters et. al. 	*/
++#include <linux/module.h>
+ #include <linux/types.h>
+-
+-
+-struct i2c_msg;
+-
+-
+-#ifdef __KERNEL__
+-
+-/* --- Includes and compatibility declarations ------------------------ */
+-
++#include <linux/errno.h>
++#include <linux/sched.h>
+ #include <asm/semaphore.h>
+-#include <linux/config.h>
++#include <linux/i2c-id.h>
++
++#include <linux/version.h>
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,10)
++#define MODULE_LICENSE(x)
++#endif
+ 
+ /* --- General options ------------------------------------------------	*/
+ 
+-#define I2C_ALGO_MAX	4		/* control memory consumption	*/
+-#define I2C_ADAP_MAX	16
++#define I2C_ADAP_MAX	16		/* control memory consumption	*/
+ #define I2C_DRIVER_MAX	16
+ #define I2C_CLIENT_MAX	32
+-#define I2C_DUMMY_MAX 4
+ 
++struct i2c_msg;
+ struct i2c_algorithm;
+ struct i2c_adapter;
+ struct i2c_client;
+@@ -60,7 +57,6 @@
+ struct i2c_client_address_data;
+ union i2c_smbus_data;
+ 
+-
+ /*
+  * The master routines are the ones normally used to transmit data to devices
+  * on a bus (or read from them). Apart from two basic transfer functions to 
+@@ -113,6 +109,8 @@
+ extern s32 i2c_smbus_write_block_data(struct i2c_client * client,
+                                       u8 command, u8 length,
+                                       u8 *values);
++extern s32 i2c_smbus_read_i2c_block_data(struct i2c_client * client,
++                                         u8 command, u8 *values);
+ extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client * client,
+                                           u8 command, u8 length,
+                                           u8 *values);
+@@ -125,6 +123,7 @@
+  */
+ 
+ struct i2c_driver {
++	struct module *owner;
+ 	char name[32];
+ 	int id;
+ 	unsigned int flags;		/* div., see below		*/
+@@ -148,18 +147,6 @@
+ 	 * with the device.
+ 	 */
+ 	int (*command)(struct i2c_client *client,unsigned int cmd, void *arg);
+-	
+-	/* These two are mainly used for bookkeeping & dynamic unloading of 
+-	 * kernel modules. inc_use tells the driver that a client is being  
+-	 * used by another module & that it should increase its ref. counter.
+-	 * dec_use is the inverse operation.
+-	 * NB: Make sure you have no circular dependencies, or else you get a 
+-	 * deadlock when trying to unload the modules.
+-	* You should use the i2c_{inc,dec}_use_client functions instead of
+-	* calling this function directly.
+-	 */
+-	void (*inc_use)(struct i2c_client *client);
+-	void (*dec_use)(struct i2c_client *client);
+ };
+ 
+ /*
+@@ -192,6 +179,7 @@
+  * to name two of the most common.
+  */
+ struct i2c_algorithm {
++	struct module *owner;			/* future use --km	*/
+ 	char name[32];				/* textual description 	*/
+ 	unsigned int id;
+ 
+@@ -221,16 +209,13 @@
+  * with the access algorithms necessary to access it.
+  */
+ struct i2c_adapter {
++	struct module *owner;
+ 	char name[32];	/* some useful name to identify the adapter	*/
+ 	unsigned int id;/* == is algo->id | hwdep.struct->id, 		*/
+ 			/* for registered values see below		*/
+ 	struct i2c_algorithm *algo;/* the algorithm to access the bus	*/
+ 	void *algo_data;
+ 
+-	/* --- These may be NULL, but should increase the module use count */
+-	void (*inc_use)(struct i2c_adapter *);
+-	void (*dec_use)(struct i2c_adapter *);
+-
+ 	/* --- administration stuff. */
+ 	int (*client_register)(struct i2c_client *);
+ 	int (*client_unregister)(struct i2c_client *);
+@@ -241,11 +226,11 @@
+ 			/* and can be set via the i2c_ioctl call	*/
+ 
+ 			/* data fields that are valid for all devices	*/
+-	struct semaphore lock;  
++	struct semaphore bus;
++	struct semaphore list;  
+ 	unsigned int flags;/* flags specifying div. data		*/
+ 
+ 	struct i2c_client *clients[I2C_CLIENT_MAX];
+-	int client_count;
+ 
+ 	int timeout;
+ 	int retries;
+@@ -264,6 +249,9 @@
+ #define I2C_CLIENT_ALLOW_USE		0x01	/* Client allows access */
+ #define I2C_CLIENT_ALLOW_MULTIPLE_USE 	0x02  	/* Allow multiple access-locks */
+ 						/* on an i2c_client */
++#define I2C_CLIENT_PEC  0x04			/* Use Packet Error Checking */
++#define I2C_CLIENT_TEN	0x10			/* we have a ten bit chip address	*/
++						/* Must equal I2C_M_TEN below */
+ 
+ /* i2c_client_address_data is the struct for holding default client
+  * addresses for a driver and for the parameters supplied on the
+@@ -302,12 +290,6 @@
+ extern int i2c_attach_client(struct i2c_client *);
+ extern int i2c_detach_client(struct i2c_client *);
+ 
+-/* Only call these if you grab a resource that makes unloading the
+-   client and the adapter it is on completely impossible. Like when a
+-   /proc directory is entered. */
+-extern void i2c_inc_use_client(struct i2c_client *);
+-extern void i2c_dec_use_client(struct i2c_client *);
+-
+ /* New function: This is to get an i2c_client-struct for controlling the 
+    client either by using i2c_control-function or having the 
+    client-module export functions that can be used with the i2c_client
+@@ -341,6 +323,15 @@
+ 		struct i2c_client_address_data *address_data,
+ 		i2c_client_found_addr_proc *found_proc);
+ 
++static inline int i2c_client_command(struct i2c_client *client,
++				     unsigned int cmd, void *arg)
++{
++	if (client->driver && client->driver->command)
++		return client->driver->command(client, cmd, arg);
++	else
++		return -EINVAL;
++}
++
+ /* An ioctl like call to set div. parameters of the adapter.
+  */
+ extern int i2c_control(struct i2c_client *,unsigned int, unsigned long);
+@@ -358,8 +349,6 @@
+ /* Return 1 if adapter supports everything we need, 0 if not. */
+ extern int i2c_check_functionality (struct i2c_adapter *adap, u32 func);
+ 
+-#endif /* __KERNEL__ */
+-
+ /*
+  * I2C Message - used for pure i2c transaction, also from /dev interface
+  */
+@@ -370,15 +359,28 @@
+ #define I2C_M_RD	0x01
+ #define I2C_M_NOSTART	0x4000
+ #define I2C_M_REV_DIR_ADDR	0x2000
++#define I2C_M_IGNORE_NAK	0x1000
++#define I2C_M_NO_RD_ACK		0x0800
++#define I2C_M_RECV_LEN		0x0400 /* length will be first received byte */
++#define I2C_M_RECV_PEC		0x0200 /* receive one more than the returned
++					  length byte for the PEC */
+ 	__u16 len;		/* msg length				*/
+ 	__u8 *buf;		/* pointer to msg data			*/
++	int err;
++	short done;
+ };
+ 
+ /* To determine what functionality is present */
+ 
+ #define I2C_FUNC_I2C			0x00000001
+ #define I2C_FUNC_10BIT_ADDR		0x00000002
+-#define I2C_FUNC_PROTOCOL_MANGLING	0x00000004 /* I2C_M_{REV_DIR_ADDR,NOSTART} */
++#define I2C_FUNC_PROTOCOL_MANGLING	0x00000004 /* I2C_M_{REV_DIR_ADDR,NOSTART,..} */
++#define I2C_FUNC_SMBUS_HWPEC_CALC	0x00000008 /* SMBus 2.0 */
++#define I2C_FUNC_SMBUS_READ_WORD_DATA_PEC  0x00000800 /* SMBus 2.0 */ 
++#define I2C_FUNC_SMBUS_WRITE_WORD_DATA_PEC 0x00001000 /* SMBus 2.0 */ 
++#define I2C_FUNC_SMBUS_PROC_CALL_PEC	0x00002000 /* SMBus 2.0 */
++#define I2C_FUNC_SMBUS_BLOCK_PROC_CALL_PEC 0x00004000 /* SMBus 2.0 */
++#define I2C_FUNC_SMBUS_BLOCK_PROC_CALL	0x00008000 /* SMBus 2.0 */
+ #define I2C_FUNC_SMBUS_QUICK		0x00010000 
+ #define I2C_FUNC_SMBUS_READ_BYTE	0x00020000 
+ #define I2C_FUNC_SMBUS_WRITE_BYTE	0x00040000 
+@@ -389,8 +391,12 @@
+ #define I2C_FUNC_SMBUS_PROC_CALL	0x00800000 
+ #define I2C_FUNC_SMBUS_READ_BLOCK_DATA	0x01000000 
+ #define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA 0x02000000 
+-#define I2C_FUNC_SMBUS_READ_I2C_BLOCK	0x04000000 /* New I2C-like block */
+-#define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK	0x08000000 /* transfer */
++#define I2C_FUNC_SMBUS_READ_I2C_BLOCK	0x04000000 /* I2C-like block xfer  */
++#define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK	0x08000000 /* w/ 1-byte reg. addr. */
++#define I2C_FUNC_SMBUS_READ_I2C_BLOCK_2	 0x10000000 /* I2C-like block xfer  */
++#define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2 0x20000000 /* w/ 2-byte reg. addr. */
++#define I2C_FUNC_SMBUS_READ_BLOCK_DATA_PEC  0x40000000 /* SMBus 2.0 */
++#define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC 0x80000000 /* SMBus 2.0 */
+ 
+ #define I2C_FUNC_SMBUS_BYTE I2C_FUNC_SMBUS_READ_BYTE | \
+                             I2C_FUNC_SMBUS_WRITE_BYTE
+@@ -402,13 +408,28 @@
+                                   I2C_FUNC_SMBUS_WRITE_BLOCK_DATA
+ #define I2C_FUNC_SMBUS_I2C_BLOCK I2C_FUNC_SMBUS_READ_I2C_BLOCK | \
+                                   I2C_FUNC_SMBUS_WRITE_I2C_BLOCK
++#define I2C_FUNC_SMBUS_I2C_BLOCK_2 I2C_FUNC_SMBUS_READ_I2C_BLOCK_2 | \
++                                   I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2
++#define I2C_FUNC_SMBUS_BLOCK_DATA_PEC I2C_FUNC_SMBUS_READ_BLOCK_DATA_PEC | \
++                                      I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC
++#define I2C_FUNC_SMBUS_WORD_DATA_PEC  I2C_FUNC_SMBUS_READ_WORD_DATA_PEC | \
++                                      I2C_FUNC_SMBUS_WRITE_WORD_DATA_PEC
++
++#define I2C_FUNC_SMBUS_READ_BYTE_PEC		I2C_FUNC_SMBUS_READ_BYTE_DATA
++#define I2C_FUNC_SMBUS_WRITE_BYTE_PEC		I2C_FUNC_SMBUS_WRITE_BYTE_DATA
++#define I2C_FUNC_SMBUS_READ_BYTE_DATA_PEC	I2C_FUNC_SMBUS_READ_WORD_DATA
++#define I2C_FUNC_SMBUS_WRITE_BYTE_DATA_PEC	I2C_FUNC_SMBUS_WRITE_WORD_DATA
++#define I2C_FUNC_SMBUS_BYTE_PEC			I2C_FUNC_SMBUS_BYTE_DATA
++#define I2C_FUNC_SMBUS_BYTE_DATA_PEC		I2C_FUNC_SMBUS_WORD_DATA
+ 
+ #define I2C_FUNC_SMBUS_EMUL I2C_FUNC_SMBUS_QUICK | \
+                             I2C_FUNC_SMBUS_BYTE | \
+                             I2C_FUNC_SMBUS_BYTE_DATA | \
+                             I2C_FUNC_SMBUS_WORD_DATA | \
+                             I2C_FUNC_SMBUS_PROC_CALL | \
+-                            I2C_FUNC_SMBUS_WRITE_BLOCK_DATA
++                            I2C_FUNC_SMBUS_WRITE_BLOCK_DATA | \
++                            I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC | \
++                            I2C_FUNC_SMBUS_I2C_BLOCK
+ 
+ /* 
+  * Data for SMBus Messages 
+@@ -418,8 +439,9 @@
+ union i2c_smbus_data {
+ 	__u8 byte;
+ 	__u16 word;
+-	__u8 block[I2C_SMBUS_BLOCK_MAX + 2]; /* block[0] is used for length */
++	__u8 block[I2C_SMBUS_BLOCK_MAX + 3]; /* block[0] is used for length */
+ 	                  /* one more for read length in block process call */
++	                                            /* and one more for PEC */
+ };
+ 
+ /* smbus_access read or write markers */
+@@ -435,6 +457,11 @@
+ #define I2C_SMBUS_PROC_CALL	    4
+ #define I2C_SMBUS_BLOCK_DATA	    5
+ #define I2C_SMBUS_I2C_BLOCK_DATA    6
++#define I2C_SMBUS_BLOCK_PROC_CALL   7		/* SMBus 2.0 */
++#define I2C_SMBUS_BLOCK_DATA_PEC    8		/* SMBus 2.0 */
++#define I2C_SMBUS_PROC_CALL_PEC     9		/* SMBus 2.0 */
++#define I2C_SMBUS_BLOCK_PROC_CALL_PEC  10	/* SMBus 2.0 */
++#define I2C_SMBUS_WORD_DATA_PEC	   11		/* SMBus 2.0 */
+ 
+ 
+ /* ----- commands for the ioctl like i2c_command call:
+@@ -460,6 +487,7 @@
+ 
+ #define I2C_FUNCS	0x0705	/* Get the adapter functionality */
+ #define I2C_RDWR	0x0707	/* Combined R/W transfer (one stop only)*/
++#define I2C_PEC		0x0708	/* != 0 for SMBus PEC                   */
+ #if 0
+ #define I2C_ACK_TEST	0x0710	/* See if a slave is at a specific address */
+ #endif
+@@ -475,16 +503,6 @@
+ 
+ #define I2C_MAJOR	89		/* Device major number		*/
+ 
+-#ifdef __KERNEL__
+-
+-#  ifndef NULL
+-#    define NULL ( (void *) 0 )
+-#  endif
+-
+-#  ifndef ENODEV
+-#    include <asm/errno.h>
+-#  endif
+-
+ /* These defines are used for probing i2c client addresses */
+ /* Default fill of many variables */
+ #define I2C_CLIENT_DEFAULTS {I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
+@@ -546,5 +564,11 @@
+ #define i2c_is_isa_adapter(adapptr) \
+         ((adapptr)->algo->id == I2C_ALGO_ISA)
+ 
+-#endif /* def __KERNEL__ */
+-#endif /* I2C_H */
++/* Tiny delay function used by the i2c bus drivers */
++static inline void i2c_delay(signed long timeout)
++{
++	set_current_state(TASK_INTERRUPTIBLE);
++	schedule_timeout(timeout);
++}
++
++#endif /* _LINUX_I2C_H */