Changeset 3765

Show
Ignore:
Timestamp:
01/21/03 09:08:16 (12 years ago)
Author:
kmalkki
Message:

(Kyösti) More cleanups

Redo i2c-core locks.

No longer pass controlling_mod in i2cproc_register_entry, use
client->driver->owner instead.

Comment out or remove obsolete parts of mkpatch for 2.5.
Currently it does not touch kernel build/configure system at all.

Cleanup #include order. Note that kernel headers are not to be
included for userland utilities, to promote binary compatibility of
utilities across kernel versions.

Remove bus_scans. Remove empty and unused algo_control and
debugging code that would not compile if uncommented.

Location:
i2c/trunk
Files:
33 modified

Legend:

Unmodified
Added
Removed
  • i2c/trunk/kernel/Module.mk

    r3758 r3765  
    5959KERNELINCLUDES += $(MODULE_DIR)/i2c-algo-pcf.h 
    6060endif 
     61# will not build outside kernel tree  
    6162ifneq ($(shell if grep -q '^CONFIG_I2C_ELEKTOR=y' $(LINUX)/.config; then echo 1; fi),1) 
    62 KERNELTARGETS += $(MODULE_DIR)/i2c-elektor.o 
    63 KERNELINCLUDES += $(MODULE_DIR)/i2c-pcf8584.h 
     63#KERNELTARGETS += $(MODULE_DIR)/i2c-elektor.o 
     64#KERNELINCLUDES += $(MODULE_DIR)/i2c-pcf8584.h 
    6465endif 
    6566ifneq ($(shell if grep -q '^CONFIG_I2C_PROC=y' $(LINUX)/.config; then echo 1; fi),1) 
     
    7374# No CONFIG option for this yet (not in mkpatch) 
    7475# 
    75 KERNELTARGETS += $(MODULE_DIR)/i2c-pcf-epp.o 
     76# will not build outside kernel tree  
     77#KERNELTARGETS += $(MODULE_DIR)/i2c-pcf-epp.o 
    7678# 
    77 # following require kernel 2.4.3 or higher... 
     79# following require kernel 2.4.3 or higher... and PPC 
    7880# 
    7981#ifneq ($(shell if grep -q '^CONFIG_I2C_ALGO8XX=y' $(LINUX)/.config; then echo 1; fi),1) 
    80 KERNELTARGETS += $(MODULE_DIR)/i2c-algo-8xx.o 
    81 KERNELINCLUDES += $(MODULE_DIR)/i2c-algo-8xx.h 
     82#KERNELTARGETS += $(MODULE_DIR)/i2c-algo-8xx.o 
     83#KERNELINCLUDES += $(MODULE_DIR)/i2c-algo-8xx.h 
    8284#endif 
    8385#ifneq ($(shell if grep -q '^CONFIG_I2C_RPXLITE=y' $(LINUX)/.config; then echo 1; fi),1) 
    84 KERNELTARGETS += $(MODULE_DIR)/i2c-rpx.o 
     86#KERNELTARGETS += $(MODULE_DIR)/i2c-rpx.o 
    8587#endif 
    8688 
  • i2c/trunk/kernel/i2c-adap-ibm_ocp.c

    r3759 r3765  
    5858#include <linux/delay.h> 
    5959#include <linux/slab.h> 
    60 #include <linux/version.h> 
    6160#include <linux/init.h> 
     61#include "i2c.h" 
     62#include "i2c-algo-ibm_ocp.h" 
    6263#include <asm/irq.h> 
    6364#include <asm/io.h> 
    6465#include <asm/ocp.h> 
    65  
    66 #include "i2c.h" 
    67 #include "i2c-algo-ibm_ocp.h" 
    68  
    69 MODULE_LICENSE("GPL"); 
    7066 
    7167/* 
     
    144140} 
    145141 
    146  
    147 #if 0 
    148 static void iic_ibmocp_sleep(unsigned long timeout) 
    149 { 
    150    schedule_timeout( timeout * HZ); 
    151 } 
    152 #endif 
    153142 
    154143 
     
    345334MODULE_AUTHOR("MontaVista Software <www.mvista.com>"); 
    346335MODULE_DESCRIPTION("I2C-Bus adapter routines for PPC 405 IIC bus adapter"); 
     336MODULE_LICENSE("GPL"); 
     337 
    347338MODULE_PARM(base, "i"); 
    348339MODULE_PARM(irq, "i"); 
  • i2c/trunk/kernel/i2c-algo-8xx.c

    r3761 r3765  
    3131#include <linux/delay.h> 
    3232#include <linux/slab.h> 
    33 #include <linux/version.h> 
    3433#include <linux/init.h> 
    35 #include <asm/uaccess.h> 
    36 #include <linux/ioport.h> 
    3734#include <linux/errno.h> 
    3835#include <linux/sched.h> 
    39  
     36#include "i2c.h" 
     37#include "i2c-algo-8xx.h" 
    4038#include <asm/mpc8xx.h> 
    4139#include <asm/commproc.h> 
    4240 
    43 #include "i2c.h" 
    44 #include "i2c-algo-8xx.h" 
    4541 
    4642#define CPM_MAX_READ    513 
     
    4945static ushort r_tbase, r_rbase; 
    5046 
    51 int cpm_scan = 0; 
    5247int cpm_debug = 0; 
    5348 
     
    7469 
    7570static void 
    76 cpm_iic_init(struct i2c_algo_8xx_data *cpm_adap) 
    77 { 
    78         volatile iic_t          *iip = cpm_adap->iip; 
    79         volatile i2c8xx_t       *i2c = cpm_adap->i2c; 
     71cpm_iic_init(struct i2c_algo_8xx_data *cpm) 
     72{ 
     73        volatile iic_t          *iip = cpm->iip; 
     74        volatile i2c8xx_t       *i2c = cpm->i2c; 
    8075        unsigned char brg; 
    8176        bd_t *bd = (bd_t *)__res; 
     
    10095        /* Set up the IIC parameters in the parameter ram. 
    10196        */ 
    102         iip->iic_tbase = r_tbase = cpm_adap->dp_addr; 
    103         iip->iic_rbase = r_rbase = cpm_adap->dp_addr + sizeof(cbd_t)*2; 
     97        iip->iic_tbase = r_tbase = cpm->dp_addr; 
     98        iip->iic_rbase = r_rbase = cpm->dp_addr + sizeof(cbd_t)*2; 
    10499 
    105100        iip->iic_tfcr = SMC_EB; 
     
    112107        /* Initialize Tx/Rx parameters. 
    113108        */ 
    114         if (cpm_adap->reloc == 0) { 
    115                 volatile cpm8xx_t *cp = cpm_adap->cp; 
     109        if (cpm->reloc == 0) { 
     110                volatile cpm8xx_t *cp = cpm->cp; 
    116111 
    117112                cp->cp_cpcr = 
     
    150145                        __func__,__LINE__, CPMVEC_I2C); 
    151146        } 
    152         (*cpm_adap->setisr)(CPMVEC_I2C, cpm_iic_interrupt, (void *)i2c); 
     147        (*cpm->setisr)(CPMVEC_I2C, cpm_iic_interrupt, (void *)i2c); 
    153148} 
    154149 
    155150 
    156151static int 
    157 cpm_iic_shutdown(struct i2c_algo_8xx_data *cpm_adap) 
    158 { 
    159         volatile i2c8xx_t *i2c = cpm_adap->i2c; 
     152cpm_iic_shutdown(struct i2c_algo_8xx_data *cpm) 
     153{ 
     154        volatile i2c8xx_t *i2c = cpm->i2c; 
    160155 
    161156        /* Shut down IIC. 
     
    521516} 
    522517 
    523 static int cpm_xfer(struct i2c_adapter *i2c_adap, 
     518static int cpm_xfer(struct i2c_adapter *adap, 
    524519                    struct i2c_msg msgs[],  
    525520                    int num) 
    526521{ 
    527         struct i2c_algo_8xx_data *adap = i2c_adap->algo_data; 
     522        struct i2c_algo_8xx_data *cpm = adap->algo_data; 
    528523        struct i2c_msg *pmsg; 
    529524        int i, ret; 
     
    548543                if (pmsg->flags & I2C_M_RD ) { 
    549544                        /* read bytes into buffer*/ 
    550                         ret = cpm_iic_read(adap, addr, pmsg->buf, pmsg->len); 
     545                        ret = cpm_iic_read(cpm, addr, pmsg->buf, pmsg->len); 
    551546                        if (cpm_debug) 
    552547                                printk("i2c-algo-8xx.o: read %d bytes\n", ret); 
     
    556551                } else { 
    557552                        /* write bytes from buffer */ 
    558                         ret = cpm_iic_write(adap, addr, pmsg->buf, pmsg->len); 
     553                        ret = cpm_iic_write(cpm, addr, pmsg->buf, pmsg->len); 
    559554                        if (cpm_debug) 
    560555                                printk("i2c-algo-8xx.o: wrote %d\n", ret); 
     
    567562} 
    568563 
    569 static int algo_control(struct i2c_adapter *adapter,  
    570         unsigned int cmd, unsigned long arg) 
    571 { 
    572         return 0; 
    573 } 
    574  
    575564static u32 cpm_func(struct i2c_adapter *adap) 
    576565{ 
     
    582571 
    583572static struct i2c_algorithm cpm_algo = { 
     573        .owner          = THIS_MODULE, 
    584574        .name           = "MPC8xx CPM algorithm", 
    585575        .id             = I2C_ALGO_MPC8XX, 
    586576        .master_xfer    = cpm_xfer, 
    587         .algo_control   = algo_control, 
    588577        .functionality  = cpm_func, 
    589578}; 
     
    595584{ 
    596585        int i; 
    597         struct i2c_algo_8xx_data *cpm_adap = adap->algo_data; 
     586        struct i2c_algo_8xx_data *cpm = adap->algo_data; 
    598587 
    599588        if (cpm_debug) 
     
    607596 
    608597        i2c_add_adapter(adap); 
    609         cpm_iic_init(cpm_adap); 
    610  
    611         /* scan bus */ 
    612         if (cpm_scan) { 
    613                 printk(KERN_INFO " i2c-algo-8xx.o: scanning bus %s...\n", 
    614                        adap->name); 
    615                 for (i = 0; i < 128; i++) { 
    616                         if (cpm_iic_tryaddress(cpm_adap, i)) { 
    617                                 printk("(%02x)",i<<1);  
    618                         } 
    619                 } 
    620                 printk("\n"); 
    621         } 
    622         return 0; 
     598        cpm_iic_init(cpm); 
    623599} 
    624600 
     
    626602int i2c_8xx_del_bus(struct i2c_adapter *adap) 
    627603{ 
    628         int res; 
    629         struct i2c_algo_8xx_data *cpm_adap = adap->algo_data; 
    630  
    631         cpm_iic_shutdown(cpm_adap); 
    632  
    633         if ((res = i2c_del_adapter(adap)) < 0) 
    634                 return res; 
    635  
    636         printk("i2c-algo-8xx.o: adapter unregistered: %s\n",adap->name); 
    637  
    638         return 0; 
     604        struct i2c_algo_8xx_data *cpm = adap->algo_data; 
     605 
     606        cpm_iic_shutdown(cpm); 
     607 
     608        return i2c_del_adapter(adap); 
    639609} 
    640610 
  • i2c/trunk/kernel/i2c-algo-8xx.h

    r3759 r3765  
    1919/* $Id$ */ 
    2020 
    21 #ifndef I2C_ALGO_8XX_H 
    22 #define I2C_ALGO_8XX_H 1 
    23  
    24 #include "i2c.h" 
     21#ifndef _LINUX_I2C_ALGO_8XX_H 
     22#define _LINUX_I2C_ALGO_8XX_H 
    2523 
    2624struct i2c_algo_8xx_data { 
     
    4139int i2c_8xx_del_bus(struct i2c_adapter *); 
    4240 
    43 #endif /* I2C_ALGO_8XX_H */ 
     41#endif /* _LINUX_I2C_ALGO_8XX_H */ 
  • i2c/trunk/kernel/i2c-algo-bit.c

    r3758 r3765  
    2828#include <linux/delay.h> 
    2929#include <linux/slab.h> 
    30 #include <linux/version.h> 
    3130#include <linux/init.h> 
    32 #include <asm/uaccess.h> 
    33 #include <linux/ioport.h> 
    3431#include <linux/errno.h> 
    3532#include <linux/sched.h> 
    36  
    3733#include "i2c.h" 
    3834#include "i2c-algo-bit.h" 
     35 
    3936 
    4037/* ----- global defines ----------------------------------------------- */ 
     
    4542        /* debug the protocol by showing transferred bits */ 
    4643 
    47 /* debugging - slow down transfer to have a look at the data ..         */ 
    48 /* I use this with two leds&resistors, each one connected to sda,scl    */ 
    49 /* respectively. This makes sure that the algorithm works. Some chips   */ 
    50 /* might not like this, as they have an internal timeout of some mils   */ 
    51 /* 
    52 #define SLO_IO      jif=jiffies;while(time_before_eq(jiffies, jif+i2c_table[minor].veryslow))\ 
    53                         cond_resched(); 
    54 */ 
    55  
    5644 
    5745/* ----- global variables --------------------------------------------- */ 
    58  
    59 #ifdef SLO_IO 
    60         int jif; 
    61 #endif 
    6246 
    6347/* module parameters: 
     
    6549static int i2c_debug; 
    6650static int bit_test;    /* see if the line-setting functions work       */ 
    67 static int bit_scan;    /* have a look at what's hanging 'round         */ 
    6851 
    6952/* --- setting states on the bus with the right timing: --------------- */ 
     
    9073        setscl(adap,0); 
    9174        udelay(adap->udelay); 
    92 #ifdef SLO_IO 
    93         SLO_IO 
    94 #endif 
    9575} 
    9676 
     
    11696                 * while they are processing data internally.  
    11797                 */ 
    118                 if ( time_after_eq(jiffies, start+adap->timeout) ) { 
     98                if (time_after_eq(jiffies, start+adap->timeout)) { 
    11999                        return -ETIMEDOUT; 
    120100                } 
     
    123103        DEBSTAT(printk(KERN_DEBUG "needed %ld jiffies\n", jiffies-start)); 
    124104        udelay(adap->udelay); 
    125 #ifdef SLO_IO 
    126         SLO_IO 
    127 #endif 
    128105        return 0; 
    129106}  
     
    465442                        ret = try_address(i2c_adap, addr, retries); 
    466443                        if ((ret!=1) && !nak_ok) { 
    467                             printk(KERN_ERR "died at extended address code.\n"); 
    468                             return -EREMOTEIO; 
     444                                printk(KERN_ERR "died at extended address code.\n"); 
     445                                return -EREMOTEIO; 
    469446                        } 
    470447                } 
     
    527504} 
    528505 
    529 static int algo_control(struct i2c_adapter *i2c_adap,  
    530         unsigned int cmd, unsigned long arg) 
    531 { 
    532         return 0; 
    533 } 
    534  
    535 static u32 bit_func(struct i2c_adapter *i2c_adap) 
     506static u32 bit_func(struct i2c_adapter *adap) 
    536507{ 
    537508        return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR |  
     
    543514 
    544515static struct i2c_algorithm i2c_bit_algo = { 
     516        .owner          = THIS_MODULE, 
    545517        .name           = "Bit-shift algorithm", 
    546518        .id             = I2C_ALGO_BIT, 
    547519        .master_xfer    = bit_xfer, 
    548         .algo_control   = algo_control, 
    549520        .functionality  = bit_func, 
    550521}; 
     
    553524 * registering functions to load algorithms at runtime  
    554525 */ 
    555 int i2c_bit_add_bus(struct i2c_adapter *i2c_adap) 
     526int i2c_bit_add_bus(struct i2c_adapter *adap) 
    556527{ 
    557528        int i; 
    558         struct i2c_algo_bit_data *adap = i2c_adap->algo_data; 
     529        struct i2c_algo_bit_data *bit_adap = adap->algo_data; 
    559530 
    560531        if (bit_test) { 
    561                 int ret = test_bus(adap, i2c_adap->name); 
     532                int ret = test_bus(bit_adap, adap->name); 
    562533                if (ret<0) 
    563534                        return -ENODEV; 
     
    565536 
    566537        DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: hw routines for %s registered.\n", 
    567                     i2c_adap->name)); 
     538                    adap->name)); 
    568539 
    569540        /* register new adapter to i2c module... */ 
    570541 
    571         i2c_adap->id |= i2c_bit_algo.id; 
    572         i2c_adap->algo = &i2c_bit_algo; 
    573  
    574         i2c_adap->timeout = HZ; /* default values, should       */ 
    575         i2c_adap->retries = 3;  /* be replaced by defines       */ 
    576  
    577         /* scan bus */ 
    578         if (bit_scan) { 
    579                 int ack; 
    580                 printk(KERN_INFO " i2c-algo-bit.o: scanning bus %s.\n", 
    581                        i2c_adap->name); 
    582                 for (i = 0x00; i < 0xff; i+=2) { 
    583                         i2c_start(adap); 
    584                         ack = i2c_outb(i2c_adap,i); 
    585                         i2c_stop(adap); 
    586                         if (ack>0) { 
    587                                 printk("(%02x)",i>>1);  
    588                         } else  
    589                                 printk(".");  
    590                 } 
    591                 printk("\n"); 
    592         } 
    593  
    594         i2c_add_adapter(i2c_adap); 
     542        adap->id |= i2c_bit_algo.id; 
     543        adap->algo = &i2c_bit_algo; 
     544 
     545        adap->timeout = 100;    /* default values, should       */ 
     546        adap->retries = 3;      /* be replaced by defines       */ 
     547 
     548        i2c_add_adapter(adap); 
    595549        return 0; 
    596550} 
    597551 
    598552 
    599 int i2c_bit_del_bus(struct i2c_adapter *i2c_adap) 
    600 { 
    601         int res; 
    602  
    603         if ((res = i2c_del_adapter(i2c_adap)) < 0) 
    604                 return res; 
    605  
    606         DEB2(printk(KERN_DEBUG "i2c-algo-bit.o: adapter unregistered: %s\n",i2c_adap->name)); 
    607  
    608         return 0; 
    609 } 
    610  
     553int i2c_bit_del_bus(struct i2c_adapter *adap) 
     554{ 
     555        return i2c_del_adapter(adap); 
     556} 
    611557 
    612558EXPORT_SYMBOL(i2c_bit_add_bus); 
     
    618564 
    619565MODULE_PARM(bit_test, "i"); 
    620 MODULE_PARM(bit_scan, "i"); 
    621566MODULE_PARM(i2c_debug,"i"); 
    622567 
    623568MODULE_PARM_DESC(bit_test, "Test the lines of the bus to see if it is stuck"); 
    624 MODULE_PARM_DESC(bit_scan, "Scan for active chips on the bus"); 
    625569MODULE_PARM_DESC(i2c_debug, 
    626             "debug level - 0 off; 1 normal; 2,3 more verbose; 9 bit-protocol"); 
     570                "debug level - 0 off; 1 normal; 2,3 more verbose; 9 bit-protocol"); 
  • i2c/trunk/kernel/i2c-algo-bit.h

    r3731 r3765  
    2424/* $Id$ */ 
    2525 
    26 #ifndef I2C_ALGO_BIT_H 
    27 #define I2C_ALGO_BIT_H 1 
    28  
    29 #include "i2c.h" 
     26#ifndef _LINUX_I2C_ALGO_BIT_H 
     27#define _LINUX_I2C_ALGO_BIT_H 
    3028 
    3129/* --- Defines for bit-adapters --------------------------------------- */ 
     
    5452int i2c_bit_del_bus(struct i2c_adapter *); 
    5553 
    56 #endif /* I2C_ALGO_BIT_H */ 
     54#endif /* _LINUX_I2C_ALGO_BIT_H */ 
  • i2c/trunk/kernel/i2c-algo-biths.c

    r3759 r3765  
    2626#include <linux/delay.h> 
    2727#include <linux/slab.h> 
    28 #include <linux/version.h> 
    2928#include <linux/init.h> 
    30 #include <asm/uaccess.h> 
    31 #include <linux/ioport.h> 
    3229#include <linux/errno.h> 
    3330#include <linux/sched.h> 
     
    105102static int i2c_sda_set(struct i2c_algo_biths_data *adap, int rdcount) 
    106103{ 
    107     int sda; 
    108     /* allow some rise/fall time */ 
    109     while ( rdcount-- ) { 
    110         sda = adap->getsda(adap->hw_data); 
    111         if (adap->ctrl & _HS_SDA) { 
    112             if (sda) 
    113                 return 0; 
    114             if (!rdcount) { 
    115                 adap->errors |= _HS_SDA_ARB; 
    116                 return -1; 
    117             } 
    118         } else { /* !(adap->ctrl & _HS_SDA) */ 
    119             if (!sda) 
    120                 return 0; 
    121             if (!rdcount) { 
    122                 adap->errors |= _HS_HW_FAIL; 
    123                 return -1; 
    124             } 
    125         } 
    126     } 
    127     return 0; 
     104        int sda; 
     105        /* allow some rise/fall time */ 
     106        while ( rdcount-- ) { 
     107                sda = adap->getsda(adap->hw_data); 
     108                if (adap->ctrl & _HS_SDA) { 
     109                        if (sda) 
     110                                return 0; 
     111                        if (!rdcount) { 
     112                                adap->errors |= _HS_SDA_ARB; 
     113                                return -1; 
     114                        } 
     115                } else { /* !(adap->ctrl & _HS_SDA) */ 
     116                        if (!sda) 
     117                                return 0; 
     118                        if (!rdcount) { 
     119                                adap->errors |= _HS_HW_FAIL; 
     120                                return -1; 
     121                        } 
     122                } 
     123        } 
     124        return 0; 
    128125} 
    129126 
    130127static void i2c_setsda(struct i2c_algo_biths_data *adap) 
    131128{ 
    132     adap->setstate(adap);  
    133     adap->setsda(adap->hw_data, adap->hw_state); 
    134     if ( !(adap->ctrl & _HS_SDA_FREE) && ! i2c_sda_set(adap, 10)) { 
    135         return; 
    136     } 
    137     adap->set_timer(adap); 
    138     adap->run_timer(adap); 
     129        adap->setstate(adap);  
     130        adap->setsda(adap->hw_data, adap->hw_state); 
     131        if ( !(adap->ctrl & _HS_SDA_FREE) && ! i2c_sda_set(adap, 10)) { 
     132                return; 
     133        } 
     134        adap->set_timer(adap); 
     135        adap->run_timer(adap); 
    139136} 
    140137 
    141138static int i2c_getscl(struct i2c_algo_biths_data *adap) 
    142139{ 
    143     return adap->getscl(adap->hw_data); 
     140        return adap->getscl(adap->hw_data); 
    144141} 
    145142 
    146143static int i2c_getsda(struct i2c_algo_biths_data *adap) 
    147144{ 
    148     return adap->getsda(adap->hw_data); 
     145        return adap->getsda(adap->hw_data); 
    149146} 
    150147/* 
     
    156153{ 
    157154#ifndef HW_CANNOT_READ_SCL /* Not all adapters have scl sense line... */ 
    158     int rdcount = 10; 
    159     adap->setstate(adap); 
    160     adap->setscl(adap->hw_data, adap->hw_state); 
    161     if (adap->ctrl & _HS_SCL) { 
    162         unsigned long start; 
    163         /* allow some rise time */ 
    164         while (rdcount && !adap->getscl(adap->hw_data)) rdcount--; 
    165         /* else clock synchronisation, give more time */ 
    166         start = jiffies; 
    167         while (!rdcount && !adap->getscl(adap->hw_data)) { 
    168             if ( time_after(jiffies, start+adap->timeout) ) { 
    169                 adap->errors |= _HS_TIMEOUT; /* scl undef */ 
    170                 return; 
    171             } 
    172             cond_resched(); 
    173         } 
     155        int rdcount = 10; 
     156        adap->setstate(adap); 
     157        adap->setscl(adap->hw_data, adap->hw_state); 
     158        if (adap->ctrl & _HS_SCL) { 
     159                unsigned long start; 
     160                /* allow some rise time */ 
     161                while (rdcount && !adap->getscl(adap->hw_data)) rdcount--; 
     162                /* else clock synchronisation, give more time */ 
     163                start = jiffies; 
     164                while (!rdcount && !adap->getscl(adap->hw_data)) { 
     165                        if ( time_after(jiffies, start+adap->timeout) ) { 
     166                                adap->errors |= _HS_TIMEOUT; /* scl undef */ 
     167                                return; 
     168                        } 
     169                        cond_resched(); 
     170                } 
     171                adap->set_timer(adap); 
     172                /* test for SDA arbitration when SCL is high */ 
     173                if ( !(adap->ctrl & _HS_SDA_FREE) && ! i2c_sda_set(adap, 1)) { 
     174                        return; 
     175                } 
     176        } else { 
     177                /* allow some fall time */ 
     178                while (rdcount && adap->getscl(adap->hw_data)) rdcount--; 
     179                if ( !rdcount ) { 
     180                        adap->errors |= _HS_HW_FAIL; 
     181                        return; 
     182                } 
     183                adap->set_timer(adap); 
     184        } 
     185#else 
     186        adap->setstate(adap); 
     187        adap->setscl(adap->hw_data, adap->hw_state); 
    174188        adap->set_timer(adap); 
    175         /* test for SDA arbitration when SCL is high */ 
    176         if ( !(adap->ctrl & _HS_SDA_FREE) && ! i2c_sda_set(adap, 1)) { 
    177             return; 
    178         } 
    179     } else { 
    180         /* allow some fall time */ 
    181         while (rdcount && adap->getscl(adap->hw_data)) rdcount--; 
    182         if ( !rdcount ) { 
    183             adap->errors |= _HS_HW_FAIL; 
    184             return; 
    185         } 
    186         adap->set_timer(adap); 
    187     } 
    188 #else 
    189     adap->setstate(adap); 
    190     adap->setscl(adap->hw_data, adap->hw_state); 
    191     adap->set_timer(adap); 
    192189#endif /* HW_CANNOT_READ_SCL */ 
    193     adap->run_timer(adap); 
     190        adap->run_timer(adap); 
    194191} 
    195192 
     
    214211        adap->ctrl &= ~(_HS_SDA_FREE | _HS_DBL_DT); 
    215212        if (adap->errors) { 
    216             adap->errors = 0; 
    217             _scllo(T_hold); 
     213                adap->errors = 0; 
     214                _scllo(T_hold); 
    218215        } 
    219216        /* assert: scl low, sda undef */ 
     
    230227        PROTO_B("."); 
    231228        while  (i--) { 
    232             PROTO_B("o"); 
    233             _setsda(adap->shiftreg & 0x80, T_setup); 
    234             _sclhi(T_sclhi); 
    235             _scllo(T_hold); 
    236             adap->shiftreg<<=1; 
     229                PROTO_B("o"); 
     230                _setsda(adap->shiftreg & 0x80, T_setup); 
     231                _sclhi(T_sclhi); 
     232                _scllo(T_hold); 
     233                adap->shiftreg<<=1; 
    237234        } 
    238235        /* assert: scl is low */ 
     
    245242        PROTO_B("."); 
    246243        while  (i--) { 
    247             PROTO_B("i"); 
    248             _sdahi(T_setup);  
    249             _sclhi(T_sclhi);     
    250             adap->shiftreg<<=1; 
    251             if (_getsda()) 
    252                 adap->shiftreg |= 0x01; 
    253             _scllo(T_hold); 
     244                PROTO_B("i"); 
     245                _sdahi(T_setup);  
     246                _sclhi(T_sclhi);         
     247                adap->shiftreg<<=1; 
     248                if (_getsda()) 
     249                        adap->shiftreg |= 0x01; 
     250                _scllo(T_hold); 
    254251        } 
    255252        adap->ctrl &= ~_HS_SDA_FREE; 
     
    261258{ 
    262259        while (*count) { 
    263             adap->shiftreg = *buf; 
    264             TRY(i2c_outbits(adap, 8)); 
    265             PROTO_X(" %02X ", *buf); 
    266             buf++; 
     260                adap->shiftreg = *buf; 
     261                TRY(i2c_outbits(adap, 8)); 
     262                PROTO_X(" %02X ", *buf); 
     263                buf++; 
    267264             
    268             /* read ack: SDA should be pulled down by slave */ 
    269             TRY(i2c_inbits(adap, 1)); 
     265                /* read ack: SDA should be pulled down by slave */ 
     266                TRY(i2c_inbits(adap, 1)); 
    270267             
    271             if (! (adap->shiftreg & 0x01)) {  
    272                 PROTO_S("[A]"); 
    273             } else if (flags & I2C_M_IGNORE_NAK) { 
    274                 PROTO_S("[NA]"); 
    275             } else { 
    276                 PROTO_S("[NA]"); 
    277                 adap->errors |= _HS_NAK; 
    278             } 
    279             if (adap->errors) return; 
    280             (*count)--; 
     268                if (! (adap->shiftreg & 0x01)) {  
     269                        PROTO_S("[A]"); 
     270                } else if (flags & I2C_M_IGNORE_NAK) { 
     271                        PROTO_S("[NA]"); 
     272                } else { 
     273                        PROTO_S("[NA]"); 
     274                        adap->errors |= _HS_NAK; 
     275                } 
     276                if (adap->errors) return; 
     277                (*count)--; 
    281278        } 
    282279} 
     
    286283{ 
    287284        while (*count) { 
    288             TRY(i2c_inbits(adap, 8)); 
    289             *buf = adap->shiftreg; 
    290             PROTO_X(" [%02X] ", *buf); 
    291             buf++; 
     285                TRY(i2c_inbits(adap, 8)); 
     286                *buf = adap->shiftreg; 
     287                PROTO_X(" [%02X] ", *buf); 
     288                buf++; 
    292289             
    293             if (! (flags & I2C_M_NO_RD_ACK)) { 
    294                 if (*count == 1) /* was last */ 
    295                     adap->shiftreg = 0x80; 
    296                 else 
    297                     adap->shiftreg = 0x00; 
    298                 TRY(i2c_outbits(adap,1)); 
    299  
    300                 if (*count == 1) { 
    301                     PROTO_S("NA"); 
    302                 } else { 
    303                     PROTO_S("A"); 
     290                if (! (flags & I2C_M_NO_RD_ACK)) { 
     291                        if (*count == 1) /* was last */ 
     292                                adap->shiftreg = 0x80; 
     293                        else 
     294                                adap->shiftreg = 0x00; 
     295                        TRY(i2c_outbits(adap,1)); 
     296 
     297                        if (*count == 1) { 
     298                                PROTO_S("NA"); 
     299                        } else { 
     300                                PROTO_S("A"); 
     301                        } 
    304302                } 
    305             } 
    306             (*count)--; 
     303                (*count)--; 
    307304        } 
    308305} 
     
    311308static void debug_protocol(struct i2c_algo_biths_data *adap, int retval) 
    312309{ 
    313     if (! adap->dstr) return; 
    314  
    315     if ( ((retval<0) && (i2c_debug>=FATAL_PROTOCOL)) ||  
    316          (i2c_debug>=ALL_PROTOCOL) ) { 
    317         printk(KERN_DEBUG "i2c-algo-biths.o: %s: %s\n", adap->name, adap->dstr);  
    318     } 
    319     *adap->dstr = 0; 
     310        if (! adap->dstr) return; 
     311 
     312        if ( ((retval<0) && (i2c_debug>=FATAL_PROTOCOL)) ||  
     313             (i2c_debug>=ALL_PROTOCOL) ) { 
     314                printk(KERN_DEBUG "i2c-algo-biths.o: %s: %s\n", adap->name, adap->dstr);  
     315        } 
     316        *adap->dstr = 0; 
    320317} 
    321318 
    322319static const char * i2c_strerr(int retval) 
    323320{  
    324     switch (retval) { 
    325         case 2: 
    326             return "ack"; 
     321        switch (retval) { 
     322            case 2: 
     323                    return "ack"; 
    327324                 
    328         case 1: 
    329             return "no ack (ignored)"; 
    330  
    331         case 0: 
    332             return "not reached"; 
    333  
    334         case -EREMOTEIO: 
    335             return "no ack"; 
    336  
    337         case -ETIMEDOUT: 
    338             return "SCL rise timeout"; 
     325            case 1: 
     326                    return "no ack (ignored)"; 
     327 
     328            case 0: 
     329                    return "not reached"; 
     330 
     331            case -EREMOTEIO: 
     332                    return "no ack"; 
     333 
     334            case -ETIMEDOUT: 
     335                    return "SCL rise timeout"; 
    339336          
    340         case -ECOMM: 
    341             return "SDA arbitration"; 
    342  
    343         case -ENODEV: 
    344             return "SCL/SDA failure"; 
    345  
    346         default: 
    347             return "unknown"; 
    348     } 
     337            case -ECOMM: 
     338                    return "SDA arbitration"; 
     339 
     340            case -ENODEV: 
     341                    return "SCL/SDA failure"; 
     342 
     343            default: 
     344                    return "unknown"; 
     345        } 
    349346} 
    350347 
    351348static int errflag(int flags) 
    352349{ 
    353     if (! flags) 
    354         return 2; 
    355     if (flags & _HS_HW_FAIL) 
    356         return -ENODEV; 
    357     if (flags & _HS_SDA_ARB) 
    358         return -ECOMM; 
    359     if (flags & _HS_TIMEOUT) 
    360         return -ETIMEDOUT; 
    361     if (flags & _HS_NAK) 
    362         return -EREMOTEIO; 
    363  
    364     return -1; 
     350        if (! flags) 
     351                return 2; 
     352        if (flags & _HS_HW_FAIL) 
     353                return -ENODEV; 
     354        if (flags & _HS_SDA_ARB) 
     355                return -ECOMM; 
     356        if (flags & _HS_TIMEOUT) 
     357                return -ETIMEDOUT; 
     358        if (flags & _HS_NAK) 
     359                return -EREMOTEIO; 
     360 
     361        return -1; 
    365362} 
    366363 
    367364static void debug_printout(struct i2c_adapter *i2c_adap, int num, int retval) 
    368365{  
    369     if ( ((retval<0) && (i2c_debug>=FATAL_MSG)) || 
    370          (i2c_debug>=ALL_MSG) ) { 
    371         printk(KERN_ERR "i2c-algo-biths.o: %s: msg #%d %s\n", i2c_adap->name, num, i2c_strerr(retval)); 
    372     } 
     366        if ( ((retval<0) && (i2c_debug>=FATAL_MSG)) || 
     367             (i2c_debug>=ALL_MSG) ) { 
     368                printk(KERN_ERR "i2c-algo-biths.o: %s: msg #%d %s\n", i2c_adap->name, num, i2c_strerr(retval)); 
     369        } 
    373370} 
    374371 
     
    379376{ 
    380377 
    381     int sscl, ssda, gscl, gsda, i=0; 
    382     int errors; 
    383     int test[][2] = {{1,1}, {0,1}, {1,1}, {1,0}, {1,1}, {-1,-1}}; // SDA, SCL pair 
    384  
    385     printk(KERN_INFO "i2c-algo-biths.o: %s bus test\n", adap->name); 
    386  
    387     while ( test[i][0]!=-1 ) { 
    388         ssda = test[i][0]; 
    389         sscl = test[i][1]; 
    390  
     378        int sscl, ssda, gscl, gsda, i=0; 
     379        int errors; 
     380        int test[][2] = {{1,1}, {0,1}, {1,1}, {1,0}, {1,1}, {-1,-1}}; // SDA, SCL pair 
     381 
     382        printk(KERN_INFO "i2c-algo-biths.o: %s bus test\n", adap->name); 
     383 
     384        while ( test[i][0]!=-1 ) { 
     385                ssda = test[i][0]; 
     386                sscl = test[i][1]; 
     387 
     388                adap->errors = 0; 
     389                __setsda(ssda, T_min); 
     390                gsda = __getsda() ? 1 : 0; 
     391                errors = adap->errors & (_HS_HW_FAIL | _HS_SDA_ARB); 
     392                if (errors) 
     393                        printk(KERN_WARNING "i2c-algo-biths.o: %s %s\n", adap->name, 
     394                               i2c_strerr(errflag(errors))); 
     395             
     396                __setscl(sscl, T_min); 
     397                gscl = __getscl() ? 1 : 0; 
     398                errors = adap->errors & (_HS_HW_FAIL | _HS_TIMEOUT); 
     399                if (errors) 
     400                        printk(KERN_WARNING "i2c-algo-biths.o: %s %s\n", adap->name, 
     401                               i2c_strerr(errflag(errors))); 
     402 
     403                printk(KERN_DEBUG "i2c-algo-biths.o: %s SCL: %d  SDA: %d\n", adap->name, gscl, gsda); 
     404                if ( sscl!=gscl ) 
     405                        printk(KERN_WARNING "i2c-algo-biths.o: %s SCL set %d, got %d!\n", adap->name, sscl, gscl); 
     406                if ( ssda!=gsda ) 
     407                        printk(KERN_WARNING "i2c-algo-biths.o: %s SDA set %d, got %d!\n", adap->name, ssda, gsda); 
     408                if ( (adap->errors) || sscl!=gscl || ssda!=gsda ) 
     409                        break; 
     410                i++; 
     411        } 
     412     
     413        __setsda(1,0); 
     414        __setscl(1,0); 
    391415        adap->errors = 0; 
    392         __setsda(ssda, T_min); 
    393         gsda = __getsda() ? 1 : 0; 
    394         errors = adap->errors & (_HS_HW_FAIL | _HS_SDA_ARB); 
    395         if (errors) 
    396             printk(KERN_WARNING "i2c-algo-biths.o: %s %s\n", adap->name, 
    397                    i2c_strerr(errflag(errors))); 
    398              
    399         __setscl(sscl, T_min); 
    400         gscl = __getscl() ? 1 : 0; 
    401         errors = adap->errors & (_HS_HW_FAIL | _HS_TIMEOUT); 
    402         if (errors) 
    403             printk(KERN_WARNING "i2c-algo-biths.o: %s %s\n", adap->name, 
    404                    i2c_strerr(errflag(errors))); 
    405  
    406         printk(KERN_DEBUG "i2c-algo-biths.o: %s SCL: %d  SDA: %d\n", adap->name, gscl, gsda); 
    407         if ( sscl!=gscl ) 
    408             printk(KERN_WARNING "i2c-algo-biths.o: %s SCL set %d, got %d!\n", adap->name, sscl, gscl); 
    409         if ( ssda!=gsda ) 
    410             printk(KERN_WARNING "i2c-algo-biths.o: %s SDA set %d, got %d!\n", adap->name, ssda, gsda); 
    411         if ( (adap->errors) || sscl!=gscl || ssda!=gsda ) 
    412             break; 
    413         i++; 
    414     } 
    415      
    416     __setsda(1,0); 
    417     __setscl(1,0); 
    418     adap->errors = 0; 
    419  
    420     if (test[i][0]==-1) { 
    421         printk(KERN_INFO "i2c-algo-biths.o: %s passed bus test.\n",adap->name); 
    422         return 0; 
    423     } else { 
    424         printk(KERN_INFO "i2c-algo-biths.o: %s failed bus test.\n",adap->name); 
    425         return -ENODEV; 
    426     } 
     416 
     417        if (test[i][0]==-1) { 
     418                printk(KERN_INFO "i2c-algo-biths.o: %s passed bus test.\n",adap->name); 
     419                return 0; 
     420        } else { 
     421                printk(KERN_INFO "i2c-algo-biths.o: %s failed bus test.\n",adap->name); 
     422                return -ENODEV; 
     423        } 
    427424} 
    428425 
     
    487484        adap->dstr=NULL; 
    488485        if (i2c_debug>=FATAL_PROTOCOL) { 
    489             adap->dstr = kmalloc(PROTO_MAX_DUMP, GFP_KERNEL); 
    490             if (adap->dstr) { 
    491                 *adap->dstr = 0; 
    492             } else { 
    493                 printk(KERN_DEBUG "i2c-algo-biths.o %s: missing protocol dump (-ENOMEM)\n", adap->name); 
    494             } 
     486                adap->dstr = kmalloc(PROTO_MAX_DUMP, GFP_KERNEL); 
     487                if (adap->dstr) { 
     488                        *adap->dstr = 0; 
     489                } else { 
     490                        printk(KERN_DEBUG "i2c-algo-biths.o %s: missing protocol dump (-ENOMEM)\n", adap->name); 
     491                } 
    495492        } 
    496493 
     
    500497             
    501498            case MSG_INIT: 
    502                 msg = &msgs[mn]; 
    503                 if ((msg->flags & I2C_M_NOSTART) && (mn)) { 
    504                     state = MSG_DATA; 
    505                     break; 
    506                 } 
     499                    msg = &msgs[mn]; 
     500                    if ((msg->flags & I2C_M_NOSTART) && (mn)) { 
     501                            state = MSG_DATA; 
     502                            break; 
     503                    } 
    507504 
    508505            case MSG_START:      
    509                 i2c_start(adap); 
    510                 if (adap->errors) { 
    511                     state = MSG_STOP;    
    512                     break; 
    513                 }        
     506                    i2c_start(adap); 
     507                    if (adap->errors) { 
     508                            state = MSG_STOP;    
     509                            break; 
     510                    }    
    514511                     
    515512            case MSG_ADDRESS: 
    516                 doAddress(adap, msg); 
    517                 if (adap->errors) { 
    518                     state = MSG_STOP; 
    519                     break; 
    520                 } 
     513                    doAddress(adap, msg); 
     514                    if (adap->errors) { 
     515                            state = MSG_STOP; 
     516                            break; 
     517                    } 
    521518 
    522519            case MSG_DATA: 
    523                 j = msg->len; 
    524                 if ( msg->flags & I2C_M_RD ) { 
    525                     i2c_inb(adap, msg->flags, msg->buf, &j); 
    526                 } else { 
    527                     i2c_outb(adap, msg->flags, msg->buf, &j); 
    528                 } 
    529                 msg->done = msg->len - j; 
    530                 if (adap->errors) { 
    531                     state = MSG_STOP; 
    532                     break; 
    533                 } 
     520                    j = msg->len; 
     521                    if ( msg->flags & I2C_M_RD ) { 
     522                            i2c_inb(adap, msg->flags, msg->buf, &j); 
     523                    } else { 
     524                            i2c_outb(adap, msg->flags, msg->buf, &j); 
     525                    } 
     526                    msg->done = msg->len - j; 
     527                    if (adap->errors) { 
     528                            state = MSG_STOP; 
     529                            break; 
     530                    } 
    534531         
    535532            case MSG_READY: 
    536                 mn++; 
    537                 if (mn<num) { 
     533                    mn++; 
     534                    if (mn<num) { 
     535                            msg->err = errflag(adap->errors); 
     536                            debug_protocol(adap, msg->err); 
     537                            state = MSG_INIT; 
     538                            break; 
     539                    } 
     540 
     541            case MSG_STOP: 
    538542                    msg->err = errflag(adap->errors); 
     543                    i2c_stop(adap); 
     544                    j = 0; 
     545                    while (adap->errors) { 
     546                            if ( ++j > 10) { 
     547                                    msg->err = -ENODEV; 
     548                                    break; 
     549                            } 
     550                            i2c_stop(adap); 
     551                    } 
    539552                    debug_protocol(adap, msg->err); 
    540                     state = MSG_INIT; 
     553                    state = MSG_EXIT; 
    541554                    break; 
    542                 } 
    543  
    544             case MSG_STOP: 
    545                 msg->err = errflag(adap->errors); 
    546                 i2c_stop(adap); 
    547                 j = 0; 
    548                 while (adap->errors) { 
    549                     if ( ++j > 10) { 
    550                         msg->err = -ENODEV; 
    551                         break; 
    552                     } 
    553                     i2c_stop(adap); 
    554                 } 
    555                 debug_protocol(adap, msg->err); 
    556                 state = MSG_EXIT; 
    557                 break; 
    558555 
    559556            default: /* not reached */ 
    560                 state = MSG_EXIT; 
    561                 msg->err = -EINVAL; 
    562                 break; 
     557                    state = MSG_EXIT; 
     558                    msg->err = -EINVAL; 
     559                    break; 
    563560                                   
    564561        } while (state != MSG_EXIT); 
     
    567564 
    568565        for (j=0; j<num; j++) 
    569             debug_printout(i2c_adap, j, msgs[j].err); 
     566                debug_printout(i2c_adap, j, msgs[j].err); 
    570567 
    571568        return (msg->err < 0) ? msg->err : mn; 
    572569} 
    573570 
    574 static int algo_control(struct i2c_adapter *i2c_adap,  
    575         unsigned int cmd, unsigned long arg) 
    576 { 
    577         return 0; 
    578 } 
    579  
    580571static u32 bit_func(struct i2c_adapter *i2c_adap) 
    581572{ 
    582573        return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR |  
    583                I2C_FUNC_PROTOCOL_MANGLING; 
     574                I2C_FUNC_PROTOCOL_MANGLING; 
    584575} 
    585576 
     
    588579 
    589580static struct i2c_algorithm i2c_algo_biths = { 
     581        .owner          = THIS_MODULE, 
    590582        .name           = "Bit-shift algorithm", 
    591583        .id             = I2C_ALGO_BIT, 
    592584        .master_xfer    = bit_xfer, 
    593         .algo_control   = algo_control, 
    594585        .functionality  = bit_func, 
    595586}; 
     
    644635        adap = kmalloc(sizeof(struct i2c_algo_biths_data), GFP_KERNEL); 
    645636        if (adap==NULL) 
    646             return -ENOMEM; 
     637                return -ENOMEM; 
    647638 
    648639        memcpy(adap, &_old_template, sizeof(struct i2c_algo_biths_data)); 
     
    661652 
    662653        if ((res = i2c_biths_del_bus(i2c_adap)) < 0) 
    663             return res; 
     654                return res; 
    664655 
    665656        kfree(i2c_adap->algo_data); 
     
    677668static _HS_ATTR_ void i2c_tsc_set(struct i2c_algo_biths_data *adap) 
    678669{ 
    679     rdtscl(adap->bclock); 
     670        rdtscl(adap->bclock); 
    680671} 
    681672 
    682673static _HS_ATTR_ void i2c_tsc_run(struct i2c_algo_biths_data *adap) 
    683674{ 
    684     unsigned long now, loops, xloops; 
    685     int d0; 
    686     xloops = adap->xloops;  
    687     __asm__("mull %0" 
    688             :"=d" (xloops), "=&a" (d0) 
    689             :"1" (xloops),"0" (current_cpu_data.loops_per_jiffy)); 
    690     loops = xloops * HZ; 
    691     do 
    692     { 
    693         rep_nop(); 
    694         rdtscl(now); 
    695     } while ( (now - adap->bclock) < loops ); 
     675        unsigned long now, loops, xloops; 
     676        int d0; 
     677        xloops = adap->xloops;  
     678        __asm__("mull %0" 
     679                :"=d" (xloops), "=&a" (d0) 
     680                :"1" (xloops),"0" (current_cpu_data.loops_per_jiffy)); 
     681        loops = xloops * HZ; 
     682        do 
     683        { 
     684                rep_nop(); 
     685                rdtscl(now); 
     686        } while ( (now - adap->bclock) < loops ); 
    696687} 
    697688 
     
    702693static _HS_ATTR_ void i2c_udelay_run(struct i2c_algo_biths_data *adap) 
    703694{ 
    704     int usecs; 
    705     /* adap->xloops = usecs * 0x000010c6 / 2; */ 
    706     usecs = ((adap->xloops + 0x0863) >> 12);  
    707     if (adap->ctrl & _HS_DBL_DT) 
    708         usecs<<=1; 
    709     udelay(usecs); 
     695        int usecs; 
     696        /* adap->xloops = usecs * 0x000010c6 / 2; */ 
     697        usecs = ((adap->xloops + 0x0863) >> 12);  
     698        if (adap->ctrl & _HS_DBL_DT) 
     699                usecs<<=1; 
     700        udelay(usecs); 
    710701} 
    711702 
     
    735726 
    736727        if (bit_test) { 
    737             int ret = test_bus(adap); 
    738             if (ret<0) 
    739                 return ret; 
     728                int ret = test_bus(adap); 
     729                if (ret<0) 
     730                        return ret; 
    740731        } 
    741732 
     
    757748 
    758749        i2c_add_adapter(i2c_adap); 
    759  
    760750        return 0; 
    761751} 
     
    764754int i2c_biths_del_bus(struct i2c_adapter *i2c_adap) 
    765755{ 
    766         int res; 
    767  
    768         if ((res = i2c_del_adapter(i2c_adap)) < 0) 
    769                 return res; 
    770  
    771         DEB1(printk(KERN_DEBUG "i2c-algo-biths.o: adapter unregistered: %s\n",i2c_adap->name)); 
    772  
    773         return 0; 
     756        return i2c_del_adapter(i2c_adap); 
    774757} 
    775758 
     
    785768 
    786769MODULE_PARM_DESC(bit_test, "Test the lines of the bus to see if it is stuck"); 
    787 MODULE_PARM_DESC(i2c_debug, 
    788             "debug level - 1 use; 2 fatal, 3 +proto; 4 all, 5 +proto"); 
     770MODULE_PARM_DESC(i2c_debug, "debug level - 1 use; 2 fatal, 3 +proto; 4 all, 5 +proto"); 
  • i2c/trunk/kernel/i2c-algo-biths.h

    r3750 r3765  
    2424/* $Id$ */ 
    2525 
    26 #ifndef I2C_ALGO_BITHS_H 
    27 #define I2C_ALGO_BITHS_H 1 
    28  
    29 #include "i2c.h" 
    30 #include <linux/sched.h> 
     26#ifndef _LINUX_I2C_ALGO_BITHS_H 
     27#define _LINUX_I2C_ALGO_BITHS_H 
    3128 
    3229#if 1 
     
    9087int i2c_biths_del_bus(struct i2c_adapter *); 
    9188 
    92 #endif /* I2C_ALGO_BITHS_H */ 
     89#endif /* _LINUX_I2C_ALGO_BITHS_H */ 
  • i2c/trunk/kernel/i2c-algo-ibm_ocp.c

    r3759 r3765  
    5656#include <linux/delay.h> 
    5757#include <linux/slab.h> 
    58 #include <linux/version.h> 
    5958#include <linux/init.h> 
    60 #include <asm/uaccess.h> 
    61 #include <linux/ioport.h> 
    6259#include <linux/errno.h> 
    6360#include <linux/sched.h> 
    64  
    6561#include "i2c.h" 
    6662#include "i2c-algo-ibm_ocp.h" 
    6763#include <asm/ocp.h> 
    68  
    69 MODULE_LICENSE("GPL"); 
    7064 
    7165 
     
    7872#define DEF_TIMEOUT 5 
    7973 
    80 /* debugging - slow down transfer to have a look at the data ..         */ 
    81 /* I use this with two leds&resistors, each one connected to sda,scl    */ 
    82 /* respectively. This makes sure that the algorithm works. Some chips   */ 
    83 /* might not like this, as they have an internal timeout of some mils   */ 
    84 /* 
    85 #define SLO_IO      jif=jiffies;while(jiffies<=jif+i2c_table[minor].veryslow)\ 
    86                         if (need_resched) schedule(); 
    87 */ 
    88  
    8974 
    9075/* ----- global variables --------------------------------------------- */ 
    9176 
    92 #ifdef SLO_IO 
    93         int jif; 
    94 #endif 
    9577 
    9678/* module parameters: 
    9779 */ 
    9880static int i2c_debug=0; 
    99 static int iic_scan=0;  /* have a look at what's hanging 'round         */ 
    10081 
    10182/* --- setting states on the bus with the right timing: --------------- */ 
     
    857838 
    858839static struct i2c_algorithm iic_algo = { 
     840        .owner          = THIS_MODULE, 
    859841        .name           = "IBM on-chip IIC algorithm", 
    860842        .id             = I2C_ALGO_OCP, 
     
    889871        iic_init(iic_adap); 
    890872        i2c_add_adapter(adap); 
    891  
    892         /* scan bus */ 
    893         /* By default scanning the bus is turned off. */ 
    894         if (iic_scan) { 
    895                 printk(KERN_INFO " i2c-algo-iic.o: scanning bus %s.\n", 
    896                        adap->name); 
    897         } 
    898873        return 0; 
    899874} 
     
    905880int i2c_ocp_del_bus(struct i2c_adapter *adap) 
    906881{ 
    907         int res; 
    908         if ((res = i2c_del_adapter(adap)) < 0) 
    909                 return res; 
    910         DEB2(printk(KERN_DEBUG "i2c-algo-iic.o: adapter unregistered: %s\n",adap->name)); 
    911  
    912         return 0; 
     882        return i2c_del_adapter(adap); 
    913883} 
    914884 
     
    923893MODULE_AUTHOR("MontaVista Software <www.mvista.com>"); 
    924894MODULE_DESCRIPTION("PPC 405 iic algorithm"); 
    925  
    926 MODULE_PARM(iic_test, "i"); 
    927 MODULE_PARM(iic_scan, "i"); 
     895MODULE_LICENSE("GPL"); 
     896 
    928897MODULE_PARM(i2c_debug,"i"); 
    929898 
    930 MODULE_PARM_DESC(iic_test, "Test if the I2C bus is available"); 
    931 MODULE_PARM_DESC(iic_scan, "Scan for active chips on the bus"); 
    932899MODULE_PARM_DESC(i2c_debug, 
    933900        "debug level - 0 off; 1 normal; 2,3 more verbose; 9 iic-protocol"); 
  • i2c/trunk/kernel/i2c-algo-ibm_ocp.h

    r3759 r3765  
    2626   Changes made to support the IIC peripheral on the IBM PPC 405 */ 
    2727 
    28 #ifndef I2C_ALGO_IBM_OCP_H 
    29 #define I2C_ALGO_IBM_OCP_H 1 
    30  
    31 /* --- Defines for pcf-adapters --------------------------------------- */ 
    32 #include "i2c.h" 
     28#ifndef _LINUX_I2C_ALGO_IBM_OCP_H 
     29#define _LINUX_I2C_ALGO_IBM_OCP_H 
    3330 
    3431struct i2c_algo_iic_data { 
     
    5350int i2c_ocp_del_bus(struct i2c_adapter *); 
    5451 
    55 #endif /* I2C_ALGO_IBM_OCP_H */ 
     52#endif /* _LINUX_I2C_ALGO_IBM_OCP_H */ 
  • i2c/trunk/kernel/i2c-algo-pcf.c

    r3761 r3765  
    3232#include <linux/delay.h> 
    3333#include <linux/slab.h> 
    34 #include <linux/version.h> 
    3534#include <linux/init.h> 
    36 #include <asm/uaccess.h> 
    37 #include <linux/ioport.h> 
    3835#include <linux/errno.h> 
    39 #include <linux/sched.h> 
    40  
    4136#include "i2c.h" 
    4237#include "i2c-algo-pcf.h" 
    43 #include "i2c-pcf8584.h" 
     38 
    4439 
    4540/* ----- global defines ----------------------------------------------- */ 
     
    5449 */ 
    5550static int i2c_debug=0; 
    56 static int pcf_scan=0;  /* have a look at what's hanging 'round         */ 
    5751 
    5852/* --- setting states on the bus with the right timing: --------------- */ 
     
    428422} 
    429423 
    430 static int algo_control(struct i2c_adapter *adapter,  
    431         unsigned int cmd, unsigned long arg) 
    432 { 
    433         return 0; 
    434 } 
    435  
    436424static u32 pcf_func(struct i2c_adapter *adap) 
    437425{ 
     
    443431 
    444432static struct i2c_algorithm pcf_algo = { 
     433        .owner          = THIS_MODULE, 
    445434        .name           = "PCF8584 algorithm", 
    446435        .id             = I2C_ALGO_PCF, 
    447436        .master_xfer    = pcf_xfer, 
    448         .algo_control   = algo_control, 
    449437        .functionality  = pcf_func, 
    450438}; 
     
    474462 
    475463        i2c_add_adapter(adap); 
    476  
    477         /* scan bus */ 
    478         if (pcf_scan) { 
    479                 printk(KERN_INFO " i2c-algo-pcf.o: scanning bus %s.\n", 
    480                        adap->name); 
    481                 for (i = 0x00; i < 0xff; i+=2) { 
    482                         if (wait_for_bb(pcf_adap)) { 
    483                         printk(KERN_INFO " i2c-algo-pcf.o: scanning bus %s - TIMEOUTed.\n", 
    484                            adap->name); 
    485                             break; 
    486                         } 
    487                         i2c_outb(pcf_adap, i); 
    488                         i2c_start(pcf_adap); 
    489                         if ((wait_for_pin(pcf_adap, &status) >= 0) &&  
    490                             ((status & I2C_PCF_LRB) == 0)) {  
    491                                 printk("(%02x)",i>>1);  
    492                         } else { 
    493                                 printk(".");  
    494                         } 
    495                         i2c_stop(pcf_adap); 
    496                         udelay(pcf_adap->udelay); 
    497                 } 
    498                 printk("\n"); 
    499         } 
    500464        return 0; 
    501465} 
     
    514478MODULE_LICENSE("GPL"); 
    515479 
    516 MODULE_PARM(pcf_scan, "i"); 
    517480MODULE_PARM(i2c_debug,"i"); 
    518  
    519 MODULE_PARM_DESC(pcf_scan, "Scan for active chips on the bus"); 
    520481MODULE_PARM_DESC(i2c_debug, 
    521482        "debug level - 0 off; 1 normal; 2,3 more verbose; 9 pcf-protocol"); 
  • i2c/trunk/kernel/i2c-algo-pcf.h

    r3457 r3765  
    2525/* $Id$ */ 
    2626 
    27 #ifndef I2C_ALGO_PCF_H 
    28 #define I2C_ALGO_PCF_H 1 
     27#ifndef _LINUX_I2C_ALGO_PCF_H 
     28#define _LINUX_I2C_ALGO_PCF_H 
    2929 
    30 /* --- Defines for pcf-adapters --------------------------------------- */ 
    31 #include "i2c.h" 
     30#include "i2c-pcf8584.h" 
    3231 
    3332struct i2c_algo_pcf_data { 
     
    5049int i2c_pcf_del_bus(struct i2c_adapter *); 
    5150 
    52 #endif /* I2C_ALGO_PCF_H */ 
     51#endif /* _LINUX_I2C_ALGO_PCF_H */ 
  • i2c/trunk/kernel/i2c-core.c

    r3759 r3765  
    2929#include <linux/slab.h> 
    3030#include <linux/proc_fs.h> 
    31 #include <linux/config.h> 
     31#include <linux/init.h> 
    3232#include "i2c.h" 
    3333 
    34 /* ----- compatibility stuff ----------------------------------------------- */ 
    35  
    36 #include <linux/version.h> 
    37 #include <linux/init.h> 
    38  
    39 #include <asm/uaccess.h> 
    40  
    4134/* ----- global defines ---------------------------------------------------- */ 
    42  
    43 /* exclusive access to the bus */ 
    44 #define I2C_LOCK(adap) down(&adap->lock) 
    45 #define I2C_UNLOCK(adap) up(&adap->lock)  
    46  
    47 #define ADAP_LOCK()     down(&adap_lock) 
    48 #define ADAP_UNLOCK()   up(&adap_lock) 
    49  
    50 #define DRV_LOCK()      down(&driver_lock) 
    51 #define DRV_UNLOCK()    up(&driver_lock) 
    5235 
    5336#define DEB(x) if (i2c_debug>=1) x; 
     
    5639/* ----- global variables -------------------------------------------------- */ 
    5740 
    58 /**** lock for writing to global variables: the adapter & driver list */ 
    59 DECLARE_MUTEX(adap_lock); 
    60 DECLARE_MUTEX(driver_lock); 
    61  
    62 /**** adapter list */ 
     41DECLARE_MUTEX(core_lists); 
    6342static struct i2c_adapter *adapters[I2C_ADAP_MAX]; 
    64 static int adap_count; 
    65  
    66 /**** drivers list */ 
    6743static struct i2c_driver *drivers[I2C_DRIVER_MAX]; 
    68 static int driver_count; 
    6944 
    7045/**** debug level */ 
     
    8257                           int *eof , void *private); 
    8358 
    84 static int i2cproc_register(struct i2c_adapter *adap, int bus); 
    85 static void i2cproc_remove(int bus); 
    8659/* To implement the dynamic /proc/bus/i2c-? files, we need our own  
    8760   implementation of the read hook */ 
     
    8962        .read           = i2cproc_bus_read, 
    9063}; 
     64 
     65static int i2cproc_register(struct i2c_adapter *adap, int bus); 
     66static void i2cproc_remove(int bus); 
     67 
    9168#endif /* CONFIG_PROC_FS */ 
    9269 
     
    10481int i2c_add_adapter(struct i2c_adapter *adap) 
    10582{ 
    106         int i,j,res; 
    107  
    108         ADAP_LOCK(); 
     83        int i,j,res = 0; 
     84 
     85        down(&core_lists); 
    10986        for (i = 0; i < I2C_ADAP_MAX; i++) 
    11087                if (NULL == adapters[i]) 
     
    11794                goto ERROR0; 
    11895        } 
    119  
    120         adapters[i] = adap; 
    121         adap_count++; 
    122         ADAP_UNLOCK(); 
    123          
    124         /* init data types */ 
    125         init_MUTEX(&adap->lock); 
    126  
     96         
    12797#ifdef CONFIG_PROC_FS 
    12898        res = i2cproc_register(adap, i); 
    12999        if (res<0) 
    130             goto ERROR1; 
     100            goto ERROR0; 
    131101#endif /* def CONFIG_PROC_FS */ 
    132102 
     103        adapters[i] = adap; 
     104         
     105        /* init data types */ 
     106        init_MUTEX(&adap->bus); 
     107        init_MUTEX(&adap->list); 
     108 
    133109        /* inform drivers of new adapters */ 
    134         DRV_LOCK();      
    135110        for (j=0;j<I2C_DRIVER_MAX;j++) 
    136111                if (drivers[j]!=NULL &&  
     
    138113                        /* We ignore the return code; if it fails, too bad */ 
    139114                        drivers[j]->attach_adapter(adap); 
    140         DRV_UNLOCK(); 
    141115         
    142116        DEB(printk(KERN_DEBUG "i2c-core.o: adapter %s registered as adapter %d.\n", 
    143117                   adap->name,i)); 
    144  
    145         return 0;        
    146  
    147  
    148 ERROR1: 
    149         ADAP_LOCK(); 
    150         adapters[i] = NULL; 
    151         adap_count--; 
    152 ERROR0: 
    153         ADAP_UNLOCK(); 
     118 ERROR0: 
     119        up(&core_lists); 
    154120        return res; 
    155121} 
     
    158124int i2c_del_adapter(struct i2c_adapter *adap) 
    159125{ 
    160         int i,j,res; 
    161  
    162         ADAP_LOCK(); 
    163  
     126        int i,j, res=0; 
     127 
     128        down(&core_lists); 
    164129        for (i = 0; i < I2C_ADAP_MAX; i++) 
    165130                if (adap == adapters[i]) 
     
    177142         * this or hell will break loose... 
    178143         */ 
    179         DRV_LOCK(); 
    180144        for (j = 0; j < I2C_DRIVER_MAX; j++)  
    181145                if (drivers[j] && (drivers[j]->flags & I2C_DF_DUMMY)) 
     
    184148                                       "while detaching driver %s: driver not " 
    185149                                       "detached!",adap->name,drivers[j]->name); 
    186                                 goto ERROR1;     
     150                                goto ERROR0; 
    187151                        } 
    188         DRV_UNLOCK(); 
    189  
    190152 
    191153        /* detach any active clients. This must be done first, because 
     
    206168                        } 
    207169        } 
     170 
    208171#ifdef CONFIG_PROC_FS 
    209172        i2cproc_remove(i); 
     
    211174 
    212175        adapters[i] = NULL; 
    213         adap_count--; 
    214          
    215         ADAP_UNLOCK();   
    216         DEB(printk(KERN_DEBUG "i2c-core.o: adapter unregistered: %s\n",adap->name)); 
    217         return 0; 
    218  
    219 ERROR0: 
    220         ADAP_UNLOCK(); 
    221         return res; 
    222 ERROR1: 
    223         DRV_UNLOCK(); 
     176        DEB(printk(KERN_DEBUG "i2c-core.o: adapter unregistered: %s\n",adap->name)); 
     177 ERROR0: 
     178        up(&core_lists); 
    224179        return res; 
    225180} 
     
    235190{ 
    236191        int i; 
    237         DRV_LOCK(); 
     192 
     193        down(&core_lists); 
    238194        for (i = 0; i < I2C_DRIVER_MAX; i++) 
    239195                if (NULL == drivers[i]) 
     
    244200                       "- enlarge I2C_DRIVER_MAX.\n", 
    245201                        driver->name); 
    246                 DRV_UNLOCK(); 
     202                up(&core_lists); 
    247203                return -ENOMEM; 
    248204        } 
    249  
    250         drivers[i] = driver; 
    251         driver_count++; 
    252          
    253         DRV_UNLOCK();   /* driver was successfully added */ 
    254          
     205        drivers[i] = driver;     
    255206        DEB(printk(KERN_DEBUG "i2c-core.o: driver %s registered.\n",driver->name)); 
    256207         
    257         ADAP_LOCK(); 
    258  
    259208        /* now look for instances of driver on our adapters 
    260209         */ 
     
    265214                                driver->attach_adapter(adapters[i]); 
    266215        } 
    267         ADAP_UNLOCK(); 
     216        up(&core_lists); 
    268217        return 0; 
    269218} 
     
    271220int i2c_del_driver(struct i2c_driver *driver) 
    272221{ 
    273         int i,j,k,res; 
    274  
    275         DRV_LOCK(); 
     222        int i,j,k,res = 0; 
     223 
     224        down(&core_lists); 
    276225        for (i = 0; i < I2C_DRIVER_MAX; i++) 
    277226                if (driver == drivers[i]) 
     
    281230                                    "[%s] not found\n", 
    282231                        driver->name); 
    283                 DRV_UNLOCK(); 
     232                up(&core_lists); 
    284233                return -ENODEV; 
    285234        } 
     
    293242         * pointers. 
    294243         */ 
    295         ADAP_LOCK(); /* should be moved inside the if statement... */ 
    296244        for (k=0;k<I2C_ADAP_MAX;k++) { 
    297245                struct i2c_adapter *adap = adapters[k]; 
     
    312260                                       "not unloaded!",driver->name, 
    313261                                       adap->name); 
    314                                 ADAP_UNLOCK(); 
    315                                 return res; 
     262                                goto ERROR0; 
    316263                        } 
    317264                } else { 
     
    329276                                                       "unregistering driver " 
    330277                                                       "`%s', the client at " 
    331                                                        "address %02x of adapter `%s' could not be " 
    332                                                        "detached; driver not unloaded!", 
     278                                                       "address %02x of " 
     279                                                       "adapter `%s' could not " 
     280                                                       "be detached; driver " 
     281                                                       "not unloaded!", 
    333282                                                       driver->name, 
    334283                                                       client->addr, 
    335284                                                       adap->name); 
    336                                                 ADAP_UNLOCK(); 
    337                                                 return res; 
     285                                                goto ERROR0; 
    338286                                        } 
    339287                                } 
     
    341289                } 
    342290        } 
    343         ADAP_UNLOCK(); 
    344291        drivers[i] = NULL; 
    345         driver_count--; 
    346         DRV_UNLOCK(); 
    347          
    348292        DEB(printk(KERN_DEBUG "i2c-core.o: driver unregistered: %s\n",driver->name)); 
    349         return 0; 
     293 
     294 ERROR0: 
     295        up(&core_lists); 
     296        return res; 
    350297} 
    351298 
     
    353300{ 
    354301        int i; 
     302        down(&adapter->list); 
    355303        for (i = 0; i < I2C_CLIENT_MAX ; i++)  
    356304                if (adapter->clients[i] && (adapter->clients[i]->addr == addr)) 
    357305                        return -EBUSY; 
     306        up(&adapter->list); 
    358307        return 0; 
    359308} 
     
    367316                return -EBUSY; 
    368317 
     318        down(&adapter->list); 
    369319        for (i = 0; i < I2C_CLIENT_MAX; i++) 
    370320                if (NULL == adapter->clients[i]) 
     
    374324                       " i2c-core.o: attach_client(%s) - enlarge I2C_CLIENT_MAX.\n", 
    375325                        client->name); 
     326                up(&adapter->list); 
    376327                return -ENOMEM; 
    377328        } 
    378  
    379329        adapter->clients[i] = client; 
    380         adapter->client_count++; 
     330        up(&adapter->list); 
    381331         
    382332        if (adapter->client_register)  
     
    400350        int i,res; 
    401351 
    402         for (i = 0; i < I2C_CLIENT_MAX; i++) 
    403                 if (client == adapter->clients[i]) 
    404                         break; 
    405         if (I2C_CLIENT_MAX == i) { 
    406                 printk(KERN_WARNING " i2c-core.o: unregister_client " 
    407                                     "[%s] not found\n", 
    408                         client->name); 
    409                 return -ENODEV; 
    410         } 
    411          
    412352        if( (client->flags & I2C_CLIENT_ALLOW_USE) &&  
    413353            (client->usage_count>0)) 
     
    421361                } 
    422362 
     363        down(&adapter->list); 
     364        for (i = 0; i < I2C_CLIENT_MAX; i++) 
     365                if (client == adapter->clients[i]) 
     366                        break; 
     367        if (I2C_CLIENT_MAX == i) { 
     368                printk(KERN_WARNING " i2c-core.o: unregister_client " 
     369                                    "[%s] not found\n", 
     370                        client->name); 
     371                up(&adapter->list); 
     372                return -ENODEV; 
     373        } 
    423374        adapter->clients[i] = NULL; 
    424         adapter->client_count--; 
     375        up(&adapter->list); 
    425376 
    426377        DEB(printk(KERN_DEBUG "i2c-core.o: client [%s] unregistered.\n",client->name)); 
     
    447398} 
    448399 
     400#if 0 /* just forget about this for now --km */ 
    449401struct i2c_client *i2c_get_client(int driver_id, int adapter_id,  
    450402                                        struct i2c_client *prev) 
     
    513465        return 0; 
    514466} 
     467#endif 
    515468 
    516469int i2c_use_client(struct i2c_client *client) 
     
    559512 
    560513/* This function generates the output for /proc/bus/i2c */ 
    561 int read_bus_i2c(char *buf, char **start, off_t offset, int len, int *eof,  
     514static int read_bus_i2c(char *buf, char **start, off_t offset, int len, int *eof,  
    562515                 void *private) 
    563516{ 
     
    565518        int nr = 0; 
    566519        /* Note that it is safe to write a `little' beyond len. Yes, really. */ 
     520        down(&core_lists); 
    567521        for (i = 0; (i < I2C_ADAP_MAX) && (nr < len); i++) 
    568522                if (adapters[i]) { 
     
    581535                                      adapters[i]->algo->name); 
    582536                } 
     537        up(&core_lists); 
    583538        return nr; 
    584539} 
     
    591546        char *kbuf; 
    592547        struct i2c_client *client; 
     548        struct i2c_adapter *adap; 
    593549        int i,j,k,order_nr,len=0; 
    594550        size_t len_total; 
     
    600556                /* adjust to maximum file size */ 
    601557                len_total = (I2C_CLIENT_MAX * OUTPUT_LENGTH_PER_LINE); 
     558 
     559        down(&core_lists); 
     560        /* adap = file->private_data; ?? --km */ 
    602561        for (i = 0; i < I2C_ADAP_MAX; i++) 
    603                 if (adapters[i]->inode == inode->i_ino) { 
    604                 /* We need a bit of slack in the kernel buffer; this makes the 
    605                    sprintf safe. */ 
    606                         if (! (kbuf = kmalloc(len_total + 
    607                                               OUTPUT_LENGTH_PER_LINE, 
    608                                               GFP_KERNEL))) 
    609                                 return -ENOMEM; 
    610                         /* Order will hold the indexes of the clients 
    611                            sorted by address */ 
    612                         order_nr=0; 
    613                         for (j = 0; j < I2C_CLIENT_MAX; j++) { 
    614                                 if ((client = adapters[i]->clients[j]) &&  
    615                                     (client->driver->id != I2C_DRIVERID_I2CDEV))  { 
    616                                         for(k = order_nr;  
    617                                             (k > 0) &&  
    618                                             adapters[i]->clients[order[k-1]]-> 
    619                                                      addr > client->addr;  
    620                                             k--) 
    621                                                 order[k] = order[k-1]; 
    622                                         order[k] = j; 
    623                                         order_nr++; 
    624                                 } 
    625                         } 
    626  
    627  
    628                         for (j = 0; (j < order_nr) && (len < len_total); j++) { 
    629                                 client = adapters[i]->clients[order[j]]; 
    630                                 len += sprintf(kbuf+len,"%02x\t%-32s\t%-32s\n", 
    631                                               client->addr, 
    632                                               client->name, 
    633                                               client->driver->name); 
    634                         } 
    635                         len = len - file->f_pos; 
    636                         if (len > count) 
    637                                 len = count; 
    638                         if (len < 0)  
    639                                 len = 0; 
    640                         if (copy_to_user (buf,kbuf+file->f_pos, len)) { 
    641                                 kfree(kbuf); 
    642                                 return -EFAULT; 
    643                         } 
    644                         file->f_pos += len; 
    645                         kfree(kbuf); 
    646                         return len; 
    647                 } 
    648         return -ENOENT; 
    649 } 
    650  
     562            if (adapters[i] && (adapters[i]->inode == inode->i_ino)) { 
     563                adap = adapters[i]; 
     564                break; 
     565            } 
     566        if ( I2C_ADAP_MAX == i ) { 
     567            up(&core_lists); 
     568            return -ENOENT; 
     569        } 
     570 
     571        /* We need a bit of slack in the kernel buffer; this makes the 
     572           sprintf safe. */ 
     573        if (! (kbuf = kmalloc(len_total + 
     574                              OUTPUT_LENGTH_PER_LINE, 
     575                              GFP_KERNEL))) 
     576            return -ENOMEM; 
     577 
     578        /* Order will hold the indexes of the clients 
     579           sorted by address */ 
     580        order_nr=0; 
     581        down(&adap->list); 
     582        for (j = 0; j < I2C_CLIENT_MAX; j++) { 
     583            if ((client = adap->clients[j]) &&  
     584                (client->driver->id != I2C_DRIVERID_I2CDEV))  { 
     585                for(k = order_nr;  
     586                    (k > 0) &&  
     587                        adap->clients[order[k-1]]-> 
     588                        addr > client->addr;  
     589                    k--) 
     590                    order[k] = order[k-1]; 
     591                order[k] = j; 
     592                order_nr++; 
     593            } 
     594        } 
     595 
     596 
     597        for (j = 0; (j < order_nr) && (len < len_total); j++) { 
     598            client = adap->clients[order[j]]; 
     599            len += sprintf(kbuf+len,"%02x\t%-32s\t%-32s\n", 
     600                           client->addr, 
     601                           client->name, 
     602                           client->driver->name); 
     603        } 
     604        up(&adap->list); 
     605        up(&core_lists); 
     606         
     607        len = len - file->f_pos; 
     608        if (len > count) 
     609            len = count; 
     610        if (len < 0)  
     611            len = 0; 
     612        if (copy_to_user (buf,kbuf+file->f_pos, len)) { 
     613            kfree(kbuf); 
     614            return -EFAULT; 
     615        } 
     616        file->f_pos += len; 
     617        kfree(kbuf); 
     618        return len; 
     619} 
    651620 
    652621static int i2cproc_register(struct i2c_adapter *adap, int bus) 
     
    664633             
    665634        proc_entry->proc_fops = &i2cproc_operations; 
    666         proc_entry->owner = THIS_MODULE; 
     635        proc_entry->owner = adap->owner; 
    667636        adap->inode = proc_entry->low_ino; 
    668637        return 0; 
     
    695664        remove_proc_entry("i2c",proc_bus); 
    696665} 
     666 
    697667#endif /* def CONFIG_PROC_FS */ 
    698  
    699668 
    700669/* ---------------------------------------------------- 
     
    711680                            adap->name,num)); 
    712681 
    713                 I2C_LOCK(adap); 
     682                down(&adap->bus); 
    714683                ret = adap->algo->master_xfer(adap,msgs,num); 
    715                 I2C_UNLOCK(adap); 
     684                up(&adap->bus); 
    716685 
    717686                return ret; 
     
    738707                        count,client->adapter->name)); 
    739708         
    740                 I2C_LOCK(adap); 
     709                down(&adap->bus); 
    741710                ret = adap->algo->master_xfer(adap,&msg,1); 
    742                 I2C_UNLOCK(adap); 
     711                up(&adap->bus); 
    743712 
    744713                /* if everything went ok (i.e. 1 msg transmitted), return #bytes 
     
    768737                        count,client->adapter->name)); 
    769738         
    770                 I2C_LOCK(adap); 
     739                down(&adap->bus); 
    771740                ret = adap->algo->master_xfer(adap,&msg,1); 
    772                 I2C_UNLOCK(adap); 
     741                up(&adap->bus); 
    773742         
    774743                DEB2(printk(KERN_DEBUG "i2c-core.o: master_recv: return:%d (count:%d, addr:0x%02x)\n", 
     
    14261395        memset(adapters,0,sizeof(adapters)); 
    14271396        memset(drivers,0,sizeof(drivers)); 
    1428         adap_count=0; 
    1429         driver_count=0; 
    1430  
    1431         init_MUTEX(&adap_lock); 
    1432         init_MUTEX(&driver_lock); 
    1433          
     1397 
    14341398#ifdef CONFIG_PROC_FS 
    1435         i2cproc_init(); 
     1399        return i2cproc_init(); 
     1400#else 
     1401        return 0; 
    14361402#endif 
    14371403 
    1438         return 0; 
    14391404} 
    14401405 
     
    14521417EXPORT_SYMBOL(i2c_attach_client); 
    14531418EXPORT_SYMBOL(i2c_detach_client); 
    1454 EXPORT_SYMBOL(i2c_get_client); 
    14551419EXPORT_SYMBOL(i2c_use_client); 
    14561420EXPORT_SYMBOL(i2c_release_client); 
  • i2c/trunk/kernel/i2c-dev.c

    r3758 r3765  
    3131/* $Id$ */ 
    3232 
    33 #include <linux/config.h> 
    3433#include <linux/kernel.h> 
    3534#include <linux/module.h> 
    3635#include <linux/fs.h> 
    3736#include <linux/slab.h> 
    38 #include <linux/version.h> 
    3937#include <linux/smp_lock.h> 
    4038#include <linux/devfs_fs_kernel.h> 
    41  
     39#include <linux/init.h> 
     40#include "i2c.h" 
     41#include "i2c-dev.h" 
     42#include <asm/uaccess.h> 
    4243 
    4344/* If you want debugging uncomment: */ 
    4445/* #define DEBUG */ 
    4546 
    46 #include <linux/init.h> 
    47 #include <asm/uaccess.h> 
    48 #include "i2c.h" 
    49 #include "i2c-dev.h" 
    5047 
    5148/* struct file_operations changed too often in the 2.1 series for nice code */ 
     
    8178 
    8279static struct i2c_driver i2cdev_driver = { 
     80        .owner          = THIS_MODULE, /* not really used */ 
    8381        .name           = "i2c-dev dummy driver", 
    8482        .id             = I2C_DRIVERID_I2CDEV, 
     
    362360                return -ENOMEM; 
    363361        memcpy(client,&i2cdev_client_template,sizeof(struct i2c_client)); 
    364         client->adapter = i2cdev_adaps[minor]; 
     362 
     363        /* registered with adapter, passed as client to user */ 
     364        client->adapter = file->private_data; 
    365365        file->private_data = client; 
    366366 
    367         if (!try_module_get(i2cdev_adaps[minor]->owner)) { 
     367        /* use adapter module, i2c-dev handled with fops */ 
     368        if (!try_module_get(client->adapter->owner)) { 
    368369                kfree(client); 
    369370                return -ENODEV; 
     
    378379static int i2cdev_release (struct inode *inode, struct file *file) 
    379380{ 
     381        struct i2c_client *client; 
     382#ifdef DEBUG 
    380383        unsigned int minor = minor(inode->i_rdev); 
    381         kfree(file->private_data); 
    382         file->private_data=NULL; 
     384#endif 
     385 
     386        client = file->private_data; 
     387        file->private_data = NULL; 
     388        module_put(client->adapter->owner); 
     389        kfree(client); 
    383390#ifdef DEBUG 
    384391        printk(KERN_DEBUG "i2c-dev.o: Closed: i2c-%d\n", minor); 
    385392#endif 
    386         module_put(i2cdev_adaps[minor]->owner); 
    387393        return 0; 
    388394} 
     
    408414                        DEVFS_FL_DEFAULT, I2C_MAJOR, i, 
    409415                        S_IFCHR | S_IRUSR | S_IWUSR, 
    410                         &i2cdev_fops, NULL); 
     416                        &i2cdev_fops, adap); 
    411417                printk(KERN_DEBUG "i2c-dev.o: Registered '%s' as minor %d\n",adap->name,i); 
    412418        } else { 
  • i2c/trunk/kernel/i2c-dev.h

    r3758 r3765  
    2626 
    2727#include <linux/types.h> 
    28 #include "i2c.h" 
    2928 
    3029/* Some IOCTL commands are defined in <linux/i2c.h> */ 
     
    4544}; 
    4645 
    47 #ifndef __KERNEL__ 
    48  
    49 #include <sys/ioctl.h> 
    50  
    51 static inline __s32 i2c_smbus_access(int file, char read_write, __u8 command,  
    52                                      int size, union i2c_smbus_data *data) 
    53 { 
    54         struct i2c_smbus_ioctl_data args; 
    55  
    56         args.read_write = read_write; 
    57         args.command = command; 
    58         args.size = size; 
    59         args.data = data; 
    60         return ioctl(file,I2C_SMBUS,&args); 
    61 } 
    62  
    63  
    64 static inline __s32 i2c_smbus_write_quick(int file, __u8 value) 
    65 { 
    66         return i2c_smbus_access(file,value,0,I2C_SMBUS_QUICK,NULL); 
    67 } 
    68          
    69 static inline __s32 i2c_smbus_read_byte(int file) 
    70 { 
    71         union i2c_smbus_data data; 
    72         if (i2c_smbus_access(file,I2C_SMBUS_READ,0,I2C_SMBUS_BYTE,&data)) 
    73                 return -1; 
    74         else 
    75                 return 0x0FF & data.byte; 
    76 } 
    77  
    78 static inline __s32 i2c_smbus_write_byte(int file, __u8 value) 
    79 { 
    80         return i2c_smbus_access(file,I2C_SMBUS_WRITE,value, 
    81                                 I2C_SMBUS_BYTE,NULL); 
    82 } 
    83  
    84 static inline __s32 i2c_smbus_read_byte_data(int file, __u8 command) 
    85 { 
    86         union i2c_smbus_data data; 
    87         if (i2c_smbus_access(file,I2C_SMBUS_READ,command, 
    88                              I2C_SMBUS_BYTE_DATA,&data)) 
    89                 return -1; 
    90         else 
    91                 return 0x0FF & data.byte; 
    92 } 
    93  
    94 static inline __s32 i2c_smbus_write_byte_data(int file, __u8 command,  
    95                                               __u8 value) 
    96 { 
    97         union i2c_smbus_data data; 
    98         data.byte = value; 
    99         return i2c_smbus_access(file,I2C_SMBUS_WRITE,command, 
    100                                 I2C_SMBUS_BYTE_DATA, &data); 
    101 } 
    102  
    103 static inline __s32 i2c_smbus_read_word_data(int file, __u8 command) 
    104 { 
    105         union i2c_smbus_data data; 
    106         if (i2c_smbus_access(file,I2C_SMBUS_READ,command, 
    107                              I2C_SMBUS_WORD_DATA,&data)) 
    108                 return -1; 
    109         else 
    110                 return 0x0FFFF & data.word; 
    111 } 
    112  
    113 static inline __s32 i2c_smbus_write_word_data(int file, __u8 command,  
    114                                               __u16 value) 
    115 { 
    116         union i2c_smbus_data data; 
    117         data.word = value; 
    118         return i2c_smbus_access(file,I2C_SMBUS_WRITE,command, 
    119                                 I2C_SMBUS_WORD_DATA, &data); 
    120 } 
    121  
    122 static inline __s32 i2c_smbus_process_call(int file, __u8 command, __u16 value) 
    123 { 
    124         union i2c_smbus_data data; 
    125         data.word = value; 
    126         if (i2c_smbus_access(file,I2C_SMBUS_WRITE,command, 
    127                              I2C_SMBUS_PROC_CALL,&data)) 
    128                 return -1; 
    129         else 
    130                 return 0x0FFFF & data.word; 
    131 } 
    132  
    133  
    134 /* Returns the number of read bytes */ 
    135 static inline __s32 i2c_smbus_read_block_data(int file, __u8 command,  
    136                                               __u8 *values) 
    137 { 
    138         union i2c_smbus_data data; 
    139         int i; 
    140         if (i2c_smbus_access(file,I2C_SMBUS_READ,command, 
    141                              I2C_SMBUS_BLOCK_DATA,&data)) 
    142                 return -1; 
    143         else { 
    144                 for (i = 1; i <= data.block[0]; i++) 
    145                         values[i-1] = data.block[i]; 
    146                 return data.block[0]; 
    147         } 
    148 } 
    149  
    150 static inline __s32 i2c_smbus_write_block_data(int file, __u8 command,  
    151                                                __u8 length, __u8 *values) 
    152 { 
    153         union i2c_smbus_data data; 
    154         int i; 
    155         if (length > 32) 
    156                 length = 32; 
    157         for (i = 1; i <= length; i++) 
    158                 data.block[i] = values[i-1]; 
    159         data.block[0] = length; 
    160         return i2c_smbus_access(file,I2C_SMBUS_WRITE,command, 
    161                                 I2C_SMBUS_BLOCK_DATA, &data); 
    162 } 
    163  
    164 /* Returns the number of read bytes */ 
    165 static inline __s32 i2c_smbus_read_i2c_block_data(int file, __u8 command, 
    166                                                   __u8 *values) 
    167 { 
    168         union i2c_smbus_data data; 
    169         int i; 
    170         if (i2c_smbus_access(file,I2C_SMBUS_READ,command, 
    171                               I2C_SMBUS_I2C_BLOCK_DATA,&data)) 
    172                 return -1; 
    173         else { 
    174                 for (i = 1; i <= data.block[0]; i++) 
    175                         values[i-1] = data.block[i]; 
    176                 return data.block[0]; 
    177         } 
    178 } 
    179  
    180 static inline __s32 i2c_smbus_write_i2c_block_data(int file, __u8 command, 
    181                                                __u8 length, __u8 *values) 
    182 { 
    183         union i2c_smbus_data data; 
    184         int i; 
    185         if (length > 32) 
    186                 length = 32; 
    187         for (i = 1; i <= length; i++) 
    188                 data.block[i] = values[i-1]; 
    189         data.block[0] = length; 
    190         return i2c_smbus_access(file,I2C_SMBUS_WRITE,command, 
    191                                 I2C_SMBUS_I2C_BLOCK_DATA, &data); 
    192 } 
    193  
    194 /* Returns the number of read bytes */ 
    195 static inline __s32 i2c_smbus_block_process_call(int file, __u8 command, 
    196                                                  __u8 length, __u8 *values) 
    197 { 
    198         union i2c_smbus_data data; 
    199         int i; 
    200         if (length > 32) 
    201                 length = 32; 
    202         for (i = 1; i <= length; i++) 
    203                 data.block[i] = values[i-1]; 
    204         data.block[0] = length; 
    205         if (i2c_smbus_access(file,I2C_SMBUS_WRITE,command, 
    206                              I2C_SMBUS_BLOCK_PROC_CALL,&data)) 
    207                 return -1; 
    208         else { 
    209                 for (i = 1; i <= data.block[0]; i++) 
    210                         values[i-1] = data.block[i]; 
    211                 return data.block[0]; 
    212         } 
    213 } 
    214  
    215 #endif /* ndef __KERNEL__ */ 
    216  
    21746#endif /* _LINUX_I2C_DEV_H */ 
  • i2c/trunk/kernel/i2c-elektor.c

    r3758 r3765  
    3131#include <linux/delay.h> 
    3232#include <linux/slab.h> 
    33 #include <linux/version.h> 
    3433#include <linux/init.h> 
    3534#include <linux/interrupt.h> 
    3635#include <linux/pci.h> 
    3736#include <linux/wait.h> 
    38  
    3937#include "i2c.h" 
    4038#include "i2c-algo-pcf.h" 
    41  
    4239#include <asm/io.h> 
    4340#include <asm/irq.h> 
    44  
    45 #include "i2c-pcf8584.h" 
    4641 
    4742#define DEFAULT_BASE 0x330 
  • i2c/trunk/kernel/i2c-elv.c

    r3759 r3765  
    2828#include <linux/delay.h> 
    2929#include <linux/slab.h> 
    30 #include <linux/version.h> 
    3130#include <linux/init.h> 
    32 #include <asm/uaccess.h> 
    3331#include <linux/ioport.h> 
    34 #include <asm/io.h> 
    3532#include <linux/errno.h> 
    3633#include "i2c.h" 
    3734#include "i2c-algo-bit.h" 
     35#include <asm/io.h> 
    3836 
    3937#define DEFAULT_BASE 0x378 
  • i2c/trunk/kernel/i2c-frodo.c

    r3759 r3765  
    1313 */ 
    1414 
    15 #include <linux/config.h> 
    16 #include <linux/version.h> 
    1715#include <linux/module.h> 
    18  
    1916#include <linux/kernel.h> 
    2017#include <linux/init.h> 
    2118#include <linux/delay.h> 
    22  
     19#include "i2c.h" 
     20#include "i2c-algo-bit.h" 
    2321#include <asm/hardware.h> 
    2422 
    25 #include "i2c.h" 
    26 #include "i2c-algo-bit.h" 
    2723 
    2824static void frodo_setsda (void *data,int state) 
  • i2c/trunk/kernel/i2c-id.h

    r3751 r3765  
    2323/* $Id$ */ 
    2424 
    25 #ifndef I2C_ID_H 
    26 #define I2C_ID_H 
     25#ifndef LINUX_I2C_ID_H 
     26#define LINUX_I2C_ID_H 
     27 
    2728/* 
    2829 * This file is part of the i2c-bus package and contains the identifier 
     
    254255#define I2C_HW_IPMB 0x00 
    255256 
    256 #endif /* I2C_ID_H */ 
     257#endif /* LINUX_I2C_ID_H */ 
  • i2c/trunk/kernel/i2c-pcf-epp.c

    r3759 r3765  
    88#include <linux/delay.h> 
    99#include <linux/slab.h> 
    10 #include <linux/version.h> 
    1110#include <linux/init.h> 
    1211#include <linux/parport.h> 
     12#include "i2c.h" 
     13#include "i2c-algo-pcf.h" 
    1314#include <asm/irq.h> 
    1415#include <asm/io.h> 
    1516 
    16 #include "i2c.h" 
    17 #include "i2c-algo-pcf.h" 
    18 #include "i2c-pcf8584.h" 
    1917 
    2018struct  i2c_pcf_epp { 
  • i2c/trunk/kernel/i2c-pcf8584.h

    r3582 r3765  
    2424/* $Id$ */ 
    2525 
    26 #ifndef I2C_PCF8584_H 
    27 #define I2C_PCF8584_H 1 
     26#ifndef _LINUX_I2C_PCF8584_H 
     27#define _LINUX_I2C_PCF8584_H 
    2828 
    2929/* ----- Control register bits ---------------------------------------- */ 
     
    7676#define I2C_PCF_CLKREG  I2C_PCF_ES1 
    7777 
    78 #endif /* I2C_PCF8584_H */ 
     78#endif /* _LINUX_I2C_PCF8584_H */ 
  • i2c/trunk/kernel/i2c-philips-par.c

    r3759 r3765  
    3232#include "i2c.h" 
    3333#include "i2c-algo-bit.h" 
    34  
    35 #ifndef __exit 
    36 #define __exit __init 
    37 #endif 
    3834 
    3935static int type; 
  • i2c/trunk/kernel/i2c-pport.c

    r3759 r3765  
    3131#include <linux/delay.h> 
    3232#include <linux/slab.h> 
    33 #include <linux/version.h> 
    3433#include <linux/init.h> 
    35 #include <asm/uaccess.h> 
    3634#include <linux/ioport.h> 
    37 #include <asm/io.h> 
    3835#include <linux/errno.h> 
    3936#include "i2c.h" 
    4037#include "i2c-algo-bit.h" 
    41  
    42 MODULE_LICENSE("GPL"); 
     38#include <asm/io.h> 
     39 
    4340 
    4441#define DEFAULT_BASE 0x378 
     
    201198MODULE_AUTHOR("Daniel Smolik <marvin@sitour.cz>"); 
    202199MODULE_DESCRIPTION("I2C-Bus adapter routines for Primitive parallel port adapter"); 
     200MODULE_LICENSE("GPL"); 
     201 
    203202MODULE_PARM(base, "i"); 
    204203 
  • i2c/trunk/kernel/i2c-proc.c

    r3758 r3765  
    3030#include <linux/sysctl.h> 
    3131#include <linux/proc_fs.h> 
    32 #include <linux/ioport.h> 
     32#include <linux/init.h> 
    3333#include "i2c.h" 
    3434#include "i2c-proc.h" 
    35 #include <linux/init.h> 
    36 #include <asm/uaccess.h> 
    3735 
    3836static int i2c_create_name(char **name, const char *prefix, 
     
    7169 
    7270static ctl_table i2c_proc_dev[] = { 
    73         {DEV_SENSORS, "sensors", NULL, 0, 0555, i2c_proc_dev_sensors}, 
     71        {DEV_SENSORS, "sensors", NULL, 0, 0555, i2c_proc_dev_sensors, NULL}, 
    7472        {0}, 
    7573}; 
     
    7775 
    7876static ctl_table i2c_proc[] = { 
    79         {CTL_DEV, "dev", NULL, 0, 0555, i2c_proc_dev}, 
     77        {CTL_DEV, "dev", NULL, 0, 0555, i2c_proc_dev, NULL}, 
    8078        {0} 
    8179}; 
     
    8886   a LM75 chip on the third i2c bus at address 0x4e).   
    8987   name is allocated first. */ 
    90 int i2c_create_name(char **name, const char *prefix, 
     88static int i2c_create_name(char **name, const char *prefix, 
    9189                        struct i2c_adapter *adapter, int addr) 
    9290{ 
     
    126124   copied in memory. The extra2 field of each file is set to point to client. 
    127125   If any driver wants subdirectories within the newly created directory, 
    128    this function must be updated!  
    129    controlling_mod is the controlling module. It should usually be 
    130    THIS_MODULE when calling. Note that this symbol is not defined in 
    131    kernels before 2.3.13; define it to NULL in that case. We will not use it 
    132    for anything older than 2.3.27 anyway. */ 
     126   this function must be updated!  */ 
    133127int i2c_register_entry(struct i2c_client *client, const char *prefix, 
    134                            ctl_table * ctl_template, 
    135                            struct module *controlling_mod) 
    136 { 
    137         int i, res, len, id; 
    138         ctl_table *new_table; 
     128                           ctl_table * ctl_template) 
     129{ 
     130        int i, res, len, id, adap_id; 
     131        ctl_table *new_table, *client_tbl, *tbl; 
    139132        char *name; 
    140133        struct ctl_table_header *new_header; 
     
    151144                return -ENOMEM; 
    152145        } 
     146 
    153147        id += 256; 
    154  
     148         
    155149        len = 0; 
    156150        while (ctl_template[len].procname) 
    157151                len++; 
    158         len += 7; 
    159         if (!(new_table = kmalloc(sizeof(ctl_table) * len, GFP_KERNEL))) { 
     152        if (!(new_table = kmalloc(sizeof(sysctl_table) + sizeof(ctl_table) * (len + 1),  
     153                                  GFP_KERNEL))) { 
    160154                kfree(name); 
    161155                return -ENOMEM; 
    162156        } 
    163157 
    164         memcpy(new_table, sysctl_table, 6 * sizeof(ctl_table)); 
    165         new_table[0].child = &new_table[2]; 
    166         new_table[2].child = &new_table[4]; 
    167         new_table[4].child = &new_table[6]; 
    168         new_table[4].procname = name; 
    169         new_table[4].ctl_name = id; 
    170         memcpy(new_table + 6, ctl_template, (len - 6) * sizeof(ctl_table)); 
    171         for (i = 6; i < len; i++) 
    172                 new_table[i].extra2 = client; 
     158        memcpy(new_table, sysctl_table, sizeof(sysctl_table)); 
     159        tbl = new_table; /* sys/ */ 
     160        tbl = tbl->child = tbl + 2; /* dev/ */ 
     161        tbl = tbl->child = tbl + 2; /* sensors/ */       
     162        client_tbl = tbl->child = tbl + 2; /* XX-chip-YY-ZZ/ */ 
     163 
     164        client_tbl->procname = name; 
     165        client_tbl->ctl_name = id; 
     166        client_tbl->child = client_tbl + 2; 
     167 
     168        /* Next the client sysctls. --km */ 
     169        tbl = client_tbl->child; 
     170        memcpy(tbl, ctl_template, sizeof(ctl_table) * len); 
     171        for (i = 0; i < len; i++) 
     172                tbl[i].extra2 = client; 
    173173 
    174174        if (!(new_header = register_sysctl_table(new_table, 0))) { 
     
    179179        } 
    180180 
    181         i2c_entries[id - 256] = new_header; 
     181        i2c_entries[id - 256] = new_header; 
    182182 
    183183        i2c_clients[id - 256] = client; 
     184 
    184185#ifdef DEBUG 
    185186        if (!new_header || !new_header->ctl_table || 
    186187            !new_header->ctl_table->child || 
    187188            !new_header->ctl_table->child->child || 
    188             !new_header->ctl_table->child->child->de) { 
     189            !new_header->ctl_table->child->child->de ) { 
    189190                printk 
    190191                    (KERN_ERR "i2c-proc.o: NULL pointer when trying to install fill_inode fix!\n"); 
     
    192193        } 
    193194#endif                          /* DEBUG */ 
    194         new_header->ctl_table->child->child->de->owner = controlling_mod; 
    195  
     195        client_tbl->de->owner = client->driver->owner; 
    196196        return id; 
    197197} 
     
    201201        ctl_table *table; 
    202202        char *temp; 
    203         id -= 256; 
     203 
     204        id -= 256;       
    204205        if (i2c_entries[id]) { 
    205206                table = i2c_entries[id]->ctl_table; 
    206207                unregister_sysctl_table(i2c_entries[id]); 
    207208                /* 2-step kfree needed to keep gcc happy about const points */ 
    208                 (const char *) temp = table[4].procname; 
     209                (const char *) temp = table[6].procname; 
    209210                kfree(temp); 
    210211                kfree(table); 
     
    214215} 
    215216 
    216 int i2c_proc_chips(ctl_table * ctl, int write, struct file *filp, 
     217static int i2c_proc_chips(ctl_table * ctl, int write, struct file *filp, 
    217218                       void *buffer, size_t * lenp) 
    218219{ 
     
    252253} 
    253254 
    254 int i2c_sysctl_chips(ctl_table * table, int *name, int nlen, 
     255static int i2c_sysctl_chips(ctl_table * table, int *name, int nlen, 
    255256                         void *oldval, size_t * oldlenp, void *newval, 
    256257                         size_t newlen, void **context) 
     
    414415            hidden bugs in it, even leading to crashes and things! 
    415416*/ 
    416 int i2c_parse_reals(int *nrels, void *buffer, int bufsize, 
     417static int i2c_parse_reals(int *nrels, void *buffer, int bufsize, 
    417418                         long *results, int magnitude) 
    418419{ 
     
    515516} 
    516517 
    517 int i2c_write_reals(int nrels, void *buffer, int *bufsize, 
     518static int i2c_write_reals(int nrels, void *buffer, int *bufsize, 
    518519                         long *results, int magnitude) 
    519520{ 
     
    823824} 
    824825 
     826EXPORT_SYMBOL(i2c_register_entry); 
    825827EXPORT_SYMBOL(i2c_deregister_entry); 
     828EXPORT_SYMBOL(i2c_proc_real); 
     829EXPORT_SYMBOL(i2c_sysctl_real); 
    826830EXPORT_SYMBOL(i2c_detect); 
    827 EXPORT_SYMBOL(i2c_proc_real); 
    828 EXPORT_SYMBOL(i2c_register_entry); 
    829 EXPORT_SYMBOL(i2c_sysctl_real); 
    830831 
    831832MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"); 
  • i2c/trunk/kernel/i2c-proc.h

    r3753 r3765  
    2020*/ 
    2121 
    22 #ifndef SENSORS_SENSORS_H 
    23 #define SENSORS_SENSORS_H 
    24  
    25 #ifdef __KERNEL__ 
    26  
    27 /* Next two must be included before sysctl.h can be included, in 2.0 kernels */ 
    28 #include <linux/types.h> 
    29 #include <linux/fs.h> 
     22#ifndef _LINUX_I2C_PROC_H 
     23#define _LINUX_I2C_PROC_H 
     24 
    3025#include <linux/sysctl.h> 
    3126 
     
    7570extern int i2c_register_entry(struct i2c_client *client, 
    7671                                  const char *prefix, 
    77                                   ctl_table * ctl_template, 
    78                                   struct module *controlling_mod); 
     72                                  ctl_table * ctl_template); 
    7973 
    8074extern void i2c_deregister_entry(int id); 
     
    389383/* This macro is used to scale user-input to sensible values in almost all 
    390384   chip drivers. */ 
    391 extern inline int SENSORS_LIMIT(long value, long low, long high) 
     385static inline int SENSORS_LIMIT(long value, long low, long high) 
    392386{ 
    393387        if (value < low) 
     
    399393} 
    400394 
    401 #endif                          /* def __KERNEL__ */ 
    402  
    403395 
    404396/* The maximum length of the prefix */ 
     
    419411}; 
    420412 
    421 #endif                          /* def SENSORS_SENSORS_H */ 
    422  
     413#endif                          /* def _LINUX_I2C_PROC_H */ 
     414 
  • i2c/trunk/kernel/i2c-rpx.c

    r3759 r3765  
    1818#include <linux/stddef.h> 
    1919#include <linux/parport.h> 
    20  
     20#include "i2c.h" 
     21#include "i2c-algo-8xx.h" 
    2122#include <asm/mpc8xx.h> 
    2223#include <asm/commproc.h> 
    2324 
    24 #include "i2c.h" 
    25 #include "i2c-algo-8xx.h" 
    2625 
    2726static void 
  • i2c/trunk/kernel/i2c-velleman.c

    r3759 r3765  
    2626#include <linux/init.h> 
    2727#include <linux/delay.h> 
    28 #include <linux/string.h>  /* for 2.0 kernels to get NULL   */ 
    29 #include <asm/errno.h>     /* for 2.0 kernels to get ENODEV */ 
    30 #include <asm/io.h> 
    3128#include "i2c.h" 
    3229#include "i2c-algo-bit.h" 
     30#include <asm/io.h> 
    3331 
    3432/* ----- global defines ----------------------------------------------- */ 
  • i2c/trunk/kernel/i2c.h

    r3758 r3765  
    3232#define I2C_VERSION "2.7.0" 
    3333 
    34 #include "i2c-id.h"     /* id values of adapters et. al.        */ 
     34#include <linux/module.h> 
    3535#include <linux/types.h> 
    36  
    37  
    38 struct i2c_msg; 
    39  
    40  
    41 #ifdef __KERNEL__ 
    42  
    43 #include <linux/config.h> 
     36#include "i2c-id.h" 
    4437#include <asm/semaphore.h> 
    45  
    4638 
    4739/* --- General options ------------------------------------------------ */ 
     
    5345#define I2C_DUMMY_MAX 4 
    5446 
     47struct i2c_msg; 
    5548struct i2c_algorithm; 
    5649struct i2c_adapter; 
     
    5952struct i2c_client_address_data; 
    6053union i2c_smbus_data; 
    61  
    6254 
    6355/* 
     
    183175 */ 
    184176struct i2c_algorithm { 
     177        struct module *owner;                   /* future use --km      */ 
    185178        char name[32];                          /* textual description  */ 
    186179        unsigned int id; 
     
    207200}; 
    208201 
    209  
    210202/* 
    211203 * i2c_adapter is the structure used to identify a physical i2c bus along 
     
    230222 
    231223                        /* data fields that are valid for all devices   */ 
    232         struct semaphore lock;   
     224        struct semaphore bus; 
     225        struct semaphore list;   
    233226        unsigned int flags;/* flags specifying div. data                */ 
    234227 
    235228        struct i2c_client *clients[I2C_CLIENT_MAX]; 
    236         int client_count; 
    237229 
    238230        int timeout; 
     
    327319                i2c_client_found_addr_proc *found_proc); 
    328320 
     321static inline int i2c_client_command(struct i2c_client *client, 
     322                                     unsigned int cmd, void *arg) 
     323{ 
     324        if (client->driver && client->driver->command) 
     325                return client->driver->command(client, cmd, arg); 
     326        else 
     327                return -EINVAL; 
     328} 
     329 
    329330/* An ioctl like call to set div. parameters of the adapter. 
    330331 */ 
     
    343344/* Return 1 if adapter supports everything we need, 0 if not. */ 
    344345extern int i2c_check_functionality (struct i2c_adapter *adap, u32 func); 
    345  
    346 #endif /* __KERNEL__ */ 
    347346 
    348347/* 
     
    497496#define I2C_MAJOR       89              /* Device major number          */ 
    498497 
    499 #ifdef __KERNEL__ 
    500  
    501 #  ifndef NULL 
    502 #    define NULL ( (void *) 0 ) 
    503 #  endif 
    504  
    505 #  ifndef ENODEV 
    506 #    include <asm/errno.h> 
    507 #  endif 
    508  
    509498/* These defines are used for probing i2c client addresses */ 
    510499/* Default fill of many variables */ 
     
    568557        ((adapptr)->algo->id == I2C_ALGO_ISA) 
    569558 
    570 #endif /* def __KERNEL__ */ 
    571559#endif /* _LINUX_I2C_H */ 
  • i2c/trunk/mkpatch/Config.in

    r3695 r3765  
    4545   fi 
    4646 
    47 # This is needed for automatic patch generation: sensors code starts here 
    48 # This is needed for automatic patch generation: sensors code ends here 
    49  
    5047   dep_tristate 'I2C device interface' CONFIG_I2C_CHARDEV $CONFIG_I2C 
    5148   dep_tristate 'I2C /proc interface (required for hardware sensors)' CONFIG_I2C_PROC $CONFIG_I2C $CONFIG_SYSCTL 
  • i2c/trunk/mkpatch/FILES

    r3695 r3765  
    1 kernel/i2c-adap-ibm_ocp.c       drivers/i2c/i2c-adap-ibm_ocp.c 
     1kernel/i2c-core.c               drivers/i2c/i2c-core.c 
     2kernel/i2c-dev.c                drivers/i2c/i2c-dev.c 
     3kernel/i2c-proc.c               drivers/i2c/i2c-proc.c 
    24kernel/i2c-algo-8xx.c           drivers/i2c/i2c-algo-8xx.c 
    35kernel/i2c-algo-bit.c           drivers/i2c/i2c-algo-bit.c 
     6kernel/i2c-algo-biths.c         drivers/i2c/i2c-algo-biths.c 
    47kernel/i2c-algo-ibm_ocp.c       drivers/i2c/i2c-algo-ibm_ocp.c 
    58kernel/i2c-algo-pcf.c           drivers/i2c/i2c-algo-pcf.c 
    6 kernel/i2c-core.c               drivers/i2c/i2c-core.c 
    7 kernel/i2c-dev.c                drivers/i2c/i2c-dev.c 
    89kernel/i2c-elektor.c            drivers/i2c/i2c-elektor.c 
    910kernel/i2c-elv.c                drivers/i2c/i2c-elv.c 
     
    1213kernel/i2c-philips-par.c        drivers/i2c/i2c-philips-par.c 
    1314kernel/i2c-pport.c              drivers/i2c/i2c-pport.c 
    14 kernel/i2c-proc.c               drivers/i2c/i2c-proc.c 
    1515kernel/i2c-rpx.c                drivers/i2c/i2c-rpx.c 
    1616kernel/i2c-velleman.c           drivers/i2c/i2c-velleman.c 
    1717kernel/i2c.h                    include/linux/i2c.h 
     18kernel/i2c-id.h                 include/linux/i2c-id.h 
    1819kernel/i2c-dev.h                include/linux/i2c-dev.h 
     20kernel/i2c-proc.h               include/linux/i2c-proc.h 
    1921kernel/i2c-algo-8xx.h           include/linux/i2c-algo-8xx.h 
    2022kernel/i2c-algo-bit.h           include/linux/i2c-algo-bit.h 
     23kernel/i2c-algo-biths.h         include/linux/i2c-algo-biths.h 
    2124kernel/i2c-algo-ibm_ocp.h       include/linux/i2c-algo-ibm_ocp.h 
    2225kernel/i2c-algo-pcf.h           include/linux/i2c-algo-pcf.h 
    23 kernel/i2c-elektor.h            include/linux/i2c-elektor.h 
    24 kernel/i2c-id.h                 include/linux/i2c-id.h 
    25 kernel/i2c-pcf8584.h            drivers/i2c/i2c-pcf8584.h 
    26 kernel/i2c-proc.h               include/linux/i2c-proc.h 
    27 mkpatch/Config.in               drivers/i2c/Config.in 
     26kernel/i2c-pcf8584.h            include/linux/i2c-pcf8584.h 
    2827doc/dev-interface               Documentation/i2c/dev-interface 
    2928doc/functionality               Documentation/i2c/functionality 
  • i2c/trunk/mkpatch/INCLUDES

    r3694 r3765  
    11"i2c.h"                 <linux/i2c.h> 
     2"i2c-id.h"              <linux/i2c-id.h> 
    23"i2c-dev.h"             <linux/i2c-dev.h> 
     4"i2c-proc.h"            <linux/i2c-proc.h> 
    35"i2c-algo-bit.h"        <linux/i2c-algo-bit.h> 
     6"i2c-algo-biths.h"      <linux/i2c-algo-biths.h> 
    47"i2c-algo-pcf.h"        <linux/i2c-algo-pcf.h> 
    5 "i2c-elektor.h"         <linux/i2c-elektor.h> 
    6 "i2c-id.h"              <linux/i2c-id.h> 
    7 "i2c-proc.h"            <linux/i2c-proc.h> 
     8"i2c-pcf8584.h"         <linux/i2c-pcf8584.h> 
    89"i2c-algo-8xx.h"        <linux/i2c-algo-8xx.h> 
    910"i2c-algo-ibm_ocp.h"    <linux/i2c-algo-ibm_ocp.h> 
  • i2c/trunk/mkpatch/OLDI2C

    r3398 r3765  
    1 drivers/char/bttv.c 
    2 drivers/char/bttv.h 
    3 drivers/char/buz.c 
    4 drivers/char/msp3400.c 
    5 drivers/char/saa5249.c 
    6 drivers/char/saa7111.c 
    7 drivers/char/saa7185.c 
    8 drivers/char/tuner.c 
    9 drivers/char/i2c-parport.c 
  • i2c/trunk/mkpatch/mkpatch.pl

    r3757 r3765  
    3838  my ($diff_command,$dummy); 
    3939 
    40   $diff_command = "diff -u2"; 
    41   if ( -e "$kernel_root/$kernel_file") { 
    42     $diff_command .= " $kernel_root/$kernel_file "; 
    43   } else { 
    44     $diff_command .= " /dev/null "; 
    45   } 
    46   if ( -e "$package_root/$package_file") { 
    47     $diff_command .= " $package_root/$package_file "; 
    48   } else { 
    49     $diff_command .= " /dev/null"; 
    50   } 
     40  $diff_command = "diff -u"; 
     41  $diff_command .= " $kernel_root/$kernel_file "; 
     42  $diff_command .= " $package_root/$package_file "; 
    5143  open INPUT, "$diff_command|" or die "Can't call `$diff_command'"; 
    52   $dummy = <INPUT>; 
    53   $dummy = <INPUT>; 
    54   print "--- linux-old/$kernel_file\t".`date`; 
    55   print "+++ linux/$kernel_file\t".`date`; 
    56      
     44  if (<INPUT>) { 
     45      print "--- linux-old/$kernel_file\t".`date`; 
     46  } 
     47  if (<INPUT>) { 
     48      print "+++ linux/$kernel_file\t".`date`; 
     49  } 
    5750  while (<INPUT>) { 
    5851    print; 
     
    6154} 
    6255 
    63 # Find all the lm_sensors code in a file 
    64 # $_[0]: Linux kernel tree (like /usr/src/linux) 
    65 # $_[1]: Name of the kernel file 
    66 # Returns a list of strings with the sensors codes 
    67 sub find_sensors_code 
    68 { 
    69   my ($kernel_root,$kernel_file) = @_; 
    70   my @res; 
    71   open INPUT, "$kernel_root/$kernel_file"  
    72        or return @res; 
    73   while (<INPUT>) { 
    74     if (m@sensors code starts here@) { 
    75       push @res,""; 
    76       while (<INPUT>) { 
    77         last if m@sensors code ends here@; 
    78         $res[$#res] .= $_; 
    79       } 
    80     } 
    81   } 
    82   return @res;     
    83 }  
    84  
    85 # Here we generate diffs for all kernel files mentioned in OLDI2C  
    86 # which change the invocation # `#include <linux/i2c.h>' to  
    87 # `#include <linux/i2c-old.h>'. But first, we generate diffs to copy 
    88 # file <linux/i2c.h> to <linux/i2c-old.h>, if the kernel does not have 
    89 # this file yet. 
    90 # $_[0]: sensors package root (like /tmp/sensors) 
    91 # $_[1]: Linux kernel tree (like /usr/src/linux) 
    92 sub patch_old_i2c 
    93 { 
    94   my ($package_root,$kernel_root) = @_; 
    95   my (@files,$file,$f); 
    96   # If i2c.c does not exist, either we renamed it earlier, or there is no 
    97   # i2c support in this kernel at all. 
    98   return if not -e "$kernel_root/drivers/char/i2c.c"; 
    99  
    100   print_diff $kernel_root,$kernel_root,"include/linux/i2c-old.h",  
    101              "include/linux/i2c.h"; 
    102  
    103  
    104   open INPUT, "$package_root/mkpatch/OLDI2C"  
    105         or die "Can't open `$package_root/mkpatch/OLDI2C'"; 
    106   @files = <INPUT>; 
    107   close INPUT; 
    108  
    109   foreach $f (@files,"drivers/char/i2c-old.c") { 
    110     $file = $f; # Ugly, but seemingly needed to run on Perl 5.6. 
    111     chomp $file; 
    112     if ($file eq "drivers/char/i2c-old.c") { 
    113       open INPUT, "$kernel_root/drivers/char/i2c.c" 
    114             or next; 
    115     } else {  
    116       open INPUT, "$kernel_root/$file" 
    117            or next; 
    118     } 
    119     open OUTPUT, ">$package_root/$temp" 
    120            or die "Can't open `$package_root/$temp'"; 
    121     while (<INPUT>) { 
    122       s@(\s*#\s*include\s*)<linux/i2c.h>@\1<linux/i2c-old.h>@; 
    123       print OUTPUT; 
    124     } 
    125     close INPUT; 
    126     close OUTPUT; 
    127     print_diff $package_root,$kernel_root,$file,$temp; 
    128   } 
    129   print_diff "/dev",$kernel_root,"drivers/char/i2c.c","null"; 
    130   gen_drivers_char_Makefile $package_root, $kernel_root; 
    131 } 
    13256 
    13357# This generates diffs for kernel file Documentation/Configure.help. This 
     
    350274} 
    351275 
    352 # This generates diffs for the main Linux Makefile. 
    353 # Three lines which add drivers/i2c/i2.a to the DRIVERS list are put just 
    354 # before the place where the architecture Makefile is included. 
    355 # Of course, care is taken old lines are removed. 
    356 # $_[0]: i2c package root (like /tmp/i2c) 
    357 # $_[1]: Linux kernel tree (like /usr/src/linux) 
    358 sub gen_Makefile 
    359 { 
    360   my ($package_root,$kernel_root) = @_; 
    361   my $kernel_file = "Makefile"; 
    362   my $package_file = $temp; 
    363   my $printed = 0; 
    364   my $new_style = 0; 
    365  
    366   open INPUT,"$kernel_root/$kernel_file" 
    367         or die "Can't open `$kernel_root/$kernel_file'"; 
    368   open OUTPUT,">$package_root/$package_file" 
    369         or die "Can't open $package_root/$package_file"; 
    370   MAIN: while(<INPUT>) { 
    371     if (m@^DRIVERS :=@) { 
    372        $new_style = 1; 
    373     } 
    374     if (m@DRIVERS-\$\(CONFIG_I2C\)@) { 
    375       $_ = <INPUT>; 
    376       redo MAIN; 
    377     } elsif (m@CONFIG_I2C@) { 
    378       $_ = <INPUT> while not m@endif@; 
    379       $_ = <INPUT>; 
    380       $_ = <INPUT> if m@^$@; 
    381       redo MAIN; 
    382     } 
    383     if (not $printed and m@DRIVERS-\$\(CONFIG_PHONE\)@) { 
    384       if ($new_style) { 
    385         print OUTPUT << 'EOF'; 
    386 DRIVERS-$(CONFIG_I2C) += drivers/i2c/i2c.a 
    387 EOF 
    388       } else { 
    389         print OUTPUT << 'EOF'; 
    390 DRIVERS-$(CONFIG_I2C) += drivers/i2c/i2c.o 
    391 EOF 
    392       } 
    393       $printed = 1; 
    394     } elsif (not $printed and  
    395         (m@include arch/\$\(ARCH\)/Makefile@ or m@CONFIG_SENSORS@ or 
    396          m@CONFIG_PHONE@ )) { 
    397       print OUTPUT <<'EOF'; 
    398 ifeq ($(CONFIG_I2C),y) 
    399 DRIVERS := $(DRIVERS) drivers/i2c/i2c.a 
    400 endif 
    401  
    402 EOF 
    403       $printed = 1; 
    404     } 
    405     print OUTPUT; 
    406   } 
    407   close INPUT; 
    408   close OUTPUT; 
    409   die "Automatic patch generation for main `Makefile' failed.\n". 
    410       "See our home page http://www.lm-sensors.nu for assistance!" if $printed == 0; 
    411   print_diff $package_root,$kernel_root,$kernel_file,$package_file; 
    412 } 
    413  
    414276# This generates diffs for drivers/Makefile 
    415 # First, `i2c' is added to the ALL_SUB_DIRS list. Next, a couple of lines 
    416 # to add i2c to the SUB_DIRS and/or MOD_SUB_DIRS lists is put right before 
    417 # Rules.make is included. 
    418 # Of course, care is taken old lines are removed. 
    419277# $_[0]: i2c package root (like /tmp/i2c) 
    420278# $_[1]: Linux kernel tree (like /usr/src/linux) 
     
    427285  my $printed = 0; 
    428286  my $added = 0; 
    429   my $new_style = 0; 
    430287 
    431288  open INPUT,"$kernel_root/$kernel_file" 
     
    434291        or die "Can't open $package_root/$package_file"; 
    435292  MAIN: while(<INPUT>) { 
    436     if (m@^mod-subdirs\s*:=@) { 
    437        $new_style = 1; 
    438     } 
    439     if ((! $new_style and m@^ALL_SUB_DIRS\s*:=@) or m@^mod-subdirs\s*:=@ ) { 
    440       $added = 1; 
    441       $i2c_present = 0; 
    442       while (m@\\$@) { 
    443         $i2c_present = 1 if m@i2c@; 
    444         print OUTPUT; 
    445         $_ = <INPUT>; 
    446       } 
    447       $i2c_present = 1 if m@i2c@; 
    448       s@$@ i2c@ if (not $i2c_present); 
    449       print OUTPUT; 
    450       $_ = <INPUT>; 
    451       redo MAIN; 
    452     }  
    453293    if (m@^ifeq.*CONFIG_I2C@) { 
    454294      $_ = <INPUT> while not m@^endif@; 
     
    461301      redo MAIN; 
    462302    } 
    463 # 2.5 kernels 
    464 #   if (m@^obj.*CONFIG_I2C@) { 
    465 #   } 
    466303    if (not $printed and 
    467         (m@^include \$\(TOPDIR\)/Rules.make$@ or 
    468          m@^ifeq \(\$\(CONFIG_ACPI\),y\)$@ or 
     304        (m@^ifeq \(\$\(CONFIG_ACPI\),y\)$@ or 
    469305         m@^ifeq \(\$\(CONFIG_SENSORS\),y\)@) or 
    470306         m@^subdir-\$\(CONFIG_ACPI\)@) { 
    471       if ($new_style) { 
    472307        print OUTPUT <<'EOF'; 
    473308subdir-$(CONFIG_I2C)            += i2c 
    474309EOF 
    475       } else { 
    476         print OUTPUT <<'EOF'; 
    477 ifeq ($(CONFIG_I2C),y) 
    478 SUB_DIRS += i2c 
    479 MOD_SUB_DIRS += i2c 
    480 else 
    481   ifeq ($(CONFIG_I2C),m) 
    482   MOD_SUB_DIRS += i2c 
    483   endif 
    484 endif 
    485  
    486 EOF 
    487       } 
    488       $printed = 1; 
     310        $printed = 1; 
    489311    } 
    490312    print OUTPUT; 
     
    497319} 
    498320 
    499 # This generates diffs for drivers/char/Makefile 
    500 # It changes all occurences of `i2c.o' to `i2c-old.o'. 
    501 # $_[0]: i2c package root (like /tmp/i2c) 
    502 # $_[1]: Linux kernel tree (like /usr/src/linux) 
    503 sub gen_drivers_char_Makefile 
    504 { 
    505   my ($package_root,$kernel_root) = @_; 
    506   my $kernel_file = "drivers/char/Makefile"; 
    507   my $package_file = $temp; 
    508   open INPUT,"$kernel_root/$kernel_file" 
    509         or die "Can't open `$kernel_root/$kernel_file'"; 
    510   open OUTPUT,">$package_root/$package_file" 
    511         or die "Can't open $package_root/$package_file"; 
    512   while(<INPUT>) { 
    513     s@i2c\.o@i2c-old\.o@; 
    514     print OUTPUT; 
    515   } 
    516   close INPUT; 
    517   close OUTPUT; 
    518   print_diff $package_root,$kernel_root,$kernel_file,$package_file; 
    519 } 
    520321 
    521322# This generates diffs for drivers/i2c/Makefile 
    522 # for either 'old style' or 'new style'. 
    523 # Don't bother putting in 'old style' support for new architectures 
    524 # like 8xx, IBM405, or StrongARM since they aren't supported 
    525 # in old kernels anyway. 
    526323sub gen_drivers_i2c_Makefile 
    527324{ 
     
    530327  my $package_file = $temp; 
    531328  my $use_new_format = 0; 
    532   if (-e "$kernel_root/$kernel_file") { 
    533     `grep -q -s 'i2c\.o' "$kernel_root/$kernel_file"`; 
    534      $use_new_format = ! $?; 
    535   } 
    536329 
    537330  open OUTPUT,">$package_root/$package_file" 
    538331        or die "Can't open $package_root/$package_file"; 
    539   if ($use_new_format) { 
    540     print OUTPUT <<'EOF'; 
     332  print OUTPUT <<'EOF'; 
    541333# 
    542334# Makefile for the kernel i2c bus driver. 
     
    565357obj-$(CONFIG_I2C_FRODO)         += i2c-frodo.o 
    566358 
    567 # This is needed for automatic patch generation: sensors code starts here 
    568 # This is needed for automatic patch generation: sensors code ends here 
    569  
    570 include $(TOPDIR)/Rules.make 
    571  
    572359EOF 
    573   } else { 
    574     print OUTPUT <<'EOF'; 
    575 # 
    576 # Makefile for the kernel i2c bus driver. 
    577 # 
    578  
    579 SUB_DIRS     := 
    580 MOD_SUB_DIRS := $(SUB_DIRS) 
    581 ALL_SUB_DIRS := $(SUB_DIRS) 
    582 MOD_LIST_NAME := I2C_MODULES 
    583  
    584 L_TARGET := i2c.a 
    585 MX_OBJS :=   
    586 M_OBJS  :=  
    587 LX_OBJS := 
    588 L_OBJS  :=  
    589  
    590 # ----- 
    591 # i2c core components 
    592 # ----- 
    593  
    594 ifeq ($(CONFIG_I2C),y) 
    595   LX_OBJS += i2c-core.o 
    596 else 
    597   ifeq ($(CONFIG_I2C),m) 
    598     MX_OBJS += i2c-core.o 
    599   endif 
    600 endif 
    601  
    602 ifeq ($(CONFIG_I2C_CHARDEV),y) 
    603   L_OBJS += i2c-dev.o 
    604 else 
    605   ifeq ($(CONFIG_I2C_CHARDEV),m) 
    606     M_OBJS += i2c-dev.o 
    607   endif 
    608 endif 
    609  
    610 ifeq ($(CONFIG_I2C_PROC),y) 
    611   LX_OBJS += i2c-proc.o 
    612 else 
    613   ifeq ($(CONFIG_I2C_PROC),m) 
    614     MX_OBJS += i2c-proc.o 
    615   endif 
    616 endif 
    617  
    618 # ----- 
    619 # Bit banging adapters... 
    620 # ----- 
    621  
    622 ifeq ($(CONFIG_I2C_ALGOBIT),y) 
    623   LX_OBJS += i2c-algo-bit.o 
    624 else 
    625   ifeq ($(CONFIG_I2C_ALGOBIT),m) 
    626     MX_OBJS += i2c-algo-bit.o 
    627   endif 
    628 endif 
    629  
    630 ifeq ($(CONFIG_I2C_PHILIPSPAR),y) 
    631   L_OBJS += i2c-philips-par.o 
    632 else 
    633   ifeq ($(CONFIG_I2C_PHILIPSPAR),m) 
    634     M_OBJS += i2c-philips-par.o 
    635   endif 
    636 endif 
    637  
    638 ifeq ($(CONFIG_I2C_ELV),y) 
    639   L_OBJS += i2c-elv.o 
    640 else 
    641   ifeq ($(CONFIG_I2C_ELV),m) 
    642     M_OBJS += i2c-elv.o 
    643   endif 
    644 endif 
    645  
    646 ifeq ($(CONFIG_I2C_VELLEMAN),y) 
    647   L_OBJS += i2c-velleman.o 
    648 else 
    649   ifeq ($(CONFIG_I2C_VELLEMAN),m) 
    650     M_OBJS += i2c-velleman.o 
    651   endif 
    652 endif 
    653  
    654  
    655  
    656 # ----- 
    657 # PCF components 
    658 # ----- 
    659  
    660 ifeq ($(CONFIG_I2C_ALGOPCF),y) 
    661   LX_OBJS += i2c-algo-pcf.o 
    662 else 
    663   ifeq ($(CONFIG_I2C_ALGOPCF),m) 
    664     MX_OBJS += i2c-algo-pcf.o 
    665   endif 
    666 endif 
    667  
    668 ifeq ($(CONFIG_I2C_ELEKTOR),y) 
    669   L_OBJS += i2c-elektor.o 
    670 else 
    671   ifeq ($(CONFIG_I2C_ELEKTOR),m) 
    672     M_OBJS += i2c-elektor.o 
    673   endif 
    674 endif 
    675  
    676 # This is needed for automatic patch generation: sensors code starts here 
    677 # This is needed for automatic patch generation: sensors code ends here 
    678  
    679 include $(TOPDIR)/Rules.make 
    680  
    681 EOF 
    682   } 
     360 
    683361  close OUTPUT; 
    684362  print_diff $package_root,$kernel_root,$kernel_file,$package_file; 
    685363} 
    686364 
    687 # This generates diffs for drivers/char/Config.in 
    688 # It adds a line just before CONFIG_APM or main_menu_option lines to include 
    689 # the I2C Config.in. 
    690 # Of course, care is taken old lines are removed. 
    691 # $_[0]: i2c package root (like /tmp/i2c) 
    692 # $_[1]: Linux kernel tree (like /usr/src/linux) 
    693 sub gen_drivers_char_Config_in 
    694 { 
    695   my ($package_root,$kernel_root) = @_; 
    696   my $kernel_file = "drivers/char/Config.in"; 
    697   my $package_file = $temp; 
    698   my $ready = 0; 
    699   my $printed = 0; 
    700  
    701   open INPUT,"$kernel_root/$kernel_file" 
    702         or die "Can't open `$kernel_root/$kernel_file'"; 
    703   open OUTPUT,">$package_root/$package_file" 
    704         or die "Can't open $package_root/$package_file"; 
    705   MAIN: while(<INPUT>) { 
    706     if (m@i2c@) { 
    707       $_ = <INPUT>; 
    708       $_ = <INPUT> if (m@^$@); 
    709       redo MAIN; 
    710     } 
    711     if ($ready and not $printed and  
    712         (m@^mainmenu_option@ or m@CONFIG_APM@ or m@CONFIG_ALPHA_BOOK1@ or 
    713          m@source drivers/sensors/Config.in@)) { 
    714       $printed = 1; 
    715       print OUTPUT <<'EOF'; 
    716 source drivers/i2c/Config.in 
    717  
    718 EOF 
    719     } 
    720     $ready = 1 if (m@^mainmenu_option@); 
    721     print OUTPUT; 
    722   } 
    723   close INPUT; 
    724   close OUTPUT; 
    725   die "Automatic patch generation for `drivers/char/Config.in' failed.\n". 
    726       "See our home page http://www.lm-sensors.nu for assistance!" if $printed == 0; 
    727   print_diff $package_root,$kernel_root,$kernel_file,$package_file; 
    728 } 
    729   
    730  
    731 # This generates diffs for drivers/char/mem.c They are a bit intricate. 
    732 # Lines are generated at the beginning to declare i2c_init and i2c_init_all. 
    733 # The first is the invocation for the old I2C driver, the second for the 
    734 # new driver. At the bottom, a call to i2c_init_all is added when the 
    735 # new I2C stuff is configured in. 
    736 # Of course, care is taken old lines are removed. 
    737 # $_[0]: i2c package root (like /tmp/i2c) 
    738 # $_[1]: Linux kernel tree (like /usr/src/linux) 
    739 sub gen_drivers_char_mem_c 
    740 { 
    741   my ($package_root,$kernel_root) = @_; 
    742   my $kernel_file = "drivers/char/mem.c"; 
    743   my $package_file = $temp; 
    744   my $right_place = 0; 
    745   my $done = 0; 
    746   my $atstart = 1; 
    747   my $pr1 = 0; 
    748   my $pr2 = 0; 
    749  
    750   open INPUT,"$kernel_root/$kernel_file" 
    751         or die "Can't open `$kernel_root/$kernel_file'"; 
    752   open OUTPUT,">$package_root/$package_file" 
    753         or die "Can't open $package_root/$package_file"; 
    754   MAIN: while(<INPUT>) { 
    755     if (m@#include <linux/i2c.h>@) { 
    756        $_=<INPUT>; 
    757        redo MAIN; 
    758     } 
    759     if ($atstart and m@#ifdef@) { 
    760       print OUTPUT << 'EOF'; 
    761 #ifdef CONFIG_I2C 
    762 extern int i2c_init_all(void); 
    763 #endif 
    764 EOF 
    765       $atstart = 0; 
    766       $pr1 = 1; 
    767     } 
    768     while (not $right_place and (m@CONFIG_I2C@ or m@CONFIG_VIDEO_BT848@)) { 
    769       $_ = <INPUT> while not m@#endif@; 
    770       $_ = <INPUT>; 
    771       redo MAIN; 
    772     } 
    773     $right_place = 1 if (m@chr_dev_init@); 
    774     if ($right_place and m@CONFIG_I2C@) { 
    775       $_ = <INPUT> while not m@#endif@; 
    776       $_ = <INPUT>; 
    777       $_ = <INPUT> if m@^$@; 
    778       redo MAIN; 
    779     } 
    780     if ($right_place and not $done and 
    781         (m@CONFIG_VIDEO_BT848@ or m@return 0;@ or m@CONFIG_SENSORS@ or 
    782          m@CONFIG_FB@)) { 
    783       print OUTPUT <<'EOF'; 
    784 #ifdef CONFIG_I2C 
    785         i2c_init_all(); 
    786 #endif 
    787 EOF 
    788       $done = 1; 
    789       $pr2 = 1; 
    790     } 
    791     print OUTPUT; 
    792   } 
    793   close INPUT; 
    794   close OUTPUT; 
    795   die "Automatic patch generation for `drivers/char/mem.c' failed.\n". 
    796       "See our home page http://www.lm-sensors.nu for assistance!" if $pr1 == 0 or $pr2 == 0; 
    797   print_diff $package_root,$kernel_root,$kernel_file,$package_file; 
    798 } 
    799365  
    800366# Generate the diffs for the list of MAINTAINERS 
     
    852418        unless -d "$package_root/mkpatch"; 
    853419  $kernel_root = $ARGV[1]; 
    854 #  die "Kernel root `$kernel_root' is not found\n"  
    855 #        unless -f "$kernel_root/Rules.make"; 
    856  
    857   patch_old_i2c $package_root, $kernel_root; 
    858           
    859420 
    860421  # --> Read FILES 
     
    880441  foreach $package_file (sort keys %files) { 
    881442    $kernel_file = $files{$package_file}; 
    882     @sensors_subs = find_sensors_code "$kernel_root","$kernel_file"; 
    883443    open INPUT, "$package_root/$package_file" 
    884444         or die "Can't open `$package_root/$package_file'"; 
     
    887447    while (<INPUT>) { 
    888448      eval $sedscript; 
    889       if (m@sensors code starts here@) { 
    890         print OUTPUT; 
    891         while (<INPUT>) { 
    892            last if m@sensors code ends here@; 
    893         } 
    894         print OUTPUT $sensors_subs[0]; 
    895         shift @sensors_subs 
    896       } 
    897449      print OUTPUT; 
    898450    } 
     
    902454  } 
    903455 
    904   gen_Makefile $package_root, $kernel_root; 
    905   gen_drivers_Makefile $package_root, $kernel_root; 
    906   gen_drivers_i2c_Makefile $package_root, $kernel_root; 
    907   gen_drivers_char_Config_in $package_root, $kernel_root; 
    908   gen_drivers_char_mem_c $package_root, $kernel_root; 
    909   gen_Documentation_Configure_help $package_root, $kernel_root; 
    910   gen_MAINTAINERS $package_root, $kernel_root; 
     456#  gen_Makefile $package_root, $kernel_root; 
     457#  gen_drivers_Makefile $package_root, $kernel_root; 
     458#  gen_drivers_i2c_Makefile $package_root, $kernel_root; 
     459#  gen_Documentation_Configure_help $package_root, $kernel_root; 
    911460} 
    912461