Changeset 3342

Show
Ignore:
Timestamp:
07/22/99 17:34:50 (9 years ago)
Author:
frodo
Message:

All modules report themselves now by their own name. They all print
a single line when inserted. They all use their own name for all their
messages.

To do: use the <linux/kernel.h> defines to classify all printk's by
severity.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • i2c/trunk/TODO

    r3341 r3342  
    44  variable access, especially during (de)registration activity. 
    55* Make mkpatch remove old patched lines. Make it more robust. 
    6 * Make all algorithms, adapters, clients write a small line on insertion 
    7   and deletion, all in the same way, including the driver version. 
    8   Introduce version numbers for this. 
     6* Use the defines in <linux/kernel.h> to classify printk commands  
     7  as informational, fatal, etc. Already done for some modules at some  
     8  places. 
     9* Introduce version numbers for all modules, reported on insertion 
    910* Check debugging levels in all modules are sane. 
    1011* Pretty-print everything as in the kernel code guidelines (found in  
  • i2c/trunk/kernel/i2c-algo-bit.c

    r3332 r3342  
    271271        sda=getsda(adap); 
    272272        if (adap->getscl==NULL) { 
    273                 printk("i2c(bit): Warning: Adapter can't read from clock line - skipping test.\n"); 
     273                printk("i2c-algo-bit.o: Warning: Adapter can't read from clock line - skipping test.\n"); 
    274274                return 0;                
    275275        } 
    276276        scl=getscl(adap); 
    277         printk("i2c(bit): Adapter: %s scl: %d  sda: %d -- testing...\n", 
     277        printk("i2c-algo-bit.o: Adapter: %s scl: %d  sda: %d -- testing...\n", 
    278278        name,getscl(adap),getsda(adap)); 
    279279        if (!scl || !sda ) { 
    280                 printk("i2c(bit): %s seems to be busy.\n",name); 
     280                printk("i2c-algo-bit.o: %s seems to be busy.\n",name); 
    281281                goto bailout; 
    282282        } 
    283283        sdalo(adap); 
    284         printk("i2c(bit):1 scl: %d  sda: %d \n",getscl(adap),getsda(adap)); 
     284        printk("i2c-algo-bit.o:1 scl: %d  sda: %d \n",getscl(adap),getsda(adap)); 
    285285        if ( 0 != getsda(adap) ) { 
    286                 printk("i2c(bit): %s SDA stuck high!\n",name); 
     286                printk("i2c-algo-bit.o: %s SDA stuck high!\n",name); 
    287287                sdahi(adap); 
    288288                goto bailout; 
    289289        } 
    290290        if ( 0 == getscl(adap) ) { 
    291                 printk("i2c(bit): %s SCL unexpected low while pulling SDA low!\n", 
     291                printk("i2c-algo-bit.o: %s SCL unexpected low while pulling SDA low!\n", 
    292292                        name); 
    293293                goto bailout; 
    294294        }                
    295295        sdahi(adap); 
    296         printk("i2c(bit):2 scl: %d  sda: %d \n",getscl(adap),getsda(adap)); 
     296        printk("i2c-algo-bit.o:2 scl: %d  sda: %d \n",getscl(adap),getsda(adap)); 
    297297        if ( 0 == getsda(adap) ) { 
    298                 printk("i2c(bit): %s SDA stuck low!\n",name); 
     298                printk("i2c-algo-bit.o: %s SDA stuck low!\n",name); 
    299299                sdahi(adap); 
    300300                goto bailout; 
    301301        } 
    302302        if ( 0 == getscl(adap) ) { 
    303                 printk("i2c(bit): %s SCL unexpected low while SDA high!\n",name); 
     303                printk("i2c-algo-bit.o: %s SCL unexpected low while SDA high!\n",name); 
    304304        goto bailout; 
    305305        } 
    306306        scllo(adap); 
    307         printk("i2c(bit):3 scl: %d  sda: %d \n",getscl(adap),getsda(adap)); 
     307        printk("i2c-algo-bit.o:3 scl: %d  sda: %d \n",getscl(adap),getsda(adap)); 
    308308        if ( 0 != getscl(adap) ) { 
    309                 printk("i2c(bit): %s SCL stuck high!\n",name); 
     309                printk("i2c-algo-bit.o: %s SCL stuck high!\n",name); 
    310310                sclhi(adap); 
    311311                goto bailout; 
    312312        } 
    313313        if ( 0 == getsda(adap) ) { 
    314                 printk("i2c(bit): %s SDA unexpected low while pulling SCL low!\n", 
     314                printk("i2c-algo-bit.o: %s SDA unexpected low while pulling SCL low!\n", 
    315315                        name); 
    316316                goto bailout; 
    317317        } 
    318318        sclhi(adap); 
    319         printk("i2c(bit):4 scl: %d  sda: %d \n",getscl(adap),getsda(adap)); 
     319        printk("i2c-algo-bit.o:4 scl: %d  sda: %d \n",getscl(adap),getsda(adap)); 
    320320        if ( 0 == getscl(adap) ) { 
    321                 printk("i2c(bit): %s SCL stuck low!\n",name); 
     321                printk("i2c-algo-bit.o: %s SCL stuck low!\n",name); 
    322322                sclhi(adap); 
    323323                goto bailout; 
    324324        } 
    325325        if ( 0 == getsda(adap) ) { 
    326                 printk("i2c(bit): %s SDA unexpected low while SCL high!\n", 
     326                printk("i2c-algo-bit.o: %s SDA unexpected low while SCL high!\n", 
    327327                        name); 
    328328                goto bailout; 
    329329        } 
    330         printk("i2c(bit): %s passed test.\n",name); 
     330        printk("i2c-algo-bit.o: %s passed test.\n",name); 
    331331        return 0; 
    332332bailout: 
     
    353353                udelay(adap->udelay); 
    354354        } 
    355         DEB2(if (i) printk("i2c(bit): needed %d retries for %d\n",i,addr)); 
     355        DEB2(if (i) printk("i2c-algo-bit.o: needed %d retries for %d\n",i,addr)); 
    356356        return ret; 
    357357} 
     
    367367        while (count > 0) { 
    368368                c = *temp; 
    369                 DEB2(printk("i2c(bit): %s i2c_write: writing %2.2X\n", 
     369                DEB2(printk("i2c-algo-bit.o: %s i2c_write: writing %2.2X\n", 
    370370                            i2c_adap->name, c&0xff)); 
    371371                retval = i2c_outb(i2c_adap,c); 
     
    375375                        wrcount++; 
    376376                } else { /* arbitration or no acknowledge */ 
    377                         printk("i2c(bit): %s i2c_write: error - bailout.\n", 
     377                        printk("i2c-algo-bit.o: %s i2c_write: error - bailout.\n", 
    378378                               i2c_adap->name); 
    379379                        i2c_stop(adap); 
     
    405405                        rdcount++; 
    406406                } else {   /* read timed out */ 
    407                         printk("i2c(bit): i2c_read: i2c_inb timed out.\n"); 
     407                        printk("i2c-algo-bit.o: i2c_read: i2c_inb timed out.\n"); 
    408408                        break; 
    409409                } 
     
    418418                if (sclhi(adap)<0) {    /* timeout */ 
    419419                        sdahi(adap); 
    420                         printk("i2c(bit): i2c_read: Timeout at ack\n"); 
     420                        printk("i2c-algo-bit.o: i2c_read: Timeout at ack\n"); 
    421421                        return -ETIMEDOUT; 
    422422                }; 
     
    488488                ret = bit_doAddress(i2c_adap,pmsg,i2c_adap->retries); 
    489489                if (ret != 0) { 
    490                         DEB2(printk("i2c(bit): NAK from device adr %#2x msg #%d\n" 
     490                        DEB2(printk("i2c-algo-bit.o: NAK from device adr %#2x msg #%d\n" 
    491491                               ,msgs[i].addr,i)); 
    492492                        return -EREMOTEIO; 
     
    495495                        /* read bytes into buffer*/ 
    496496                        ret = readbytes(i2c_adap,pmsg->buf,pmsg->len); 
    497                         DEB2(printk("i2c(bit): read %d bytes.\n",ret)); 
     497                        DEB2(printk("i2c-algo-bit.o: read %d bytes.\n",ret)); 
    498498                } else { 
    499499                        /* write bytes from buffer */ 
    500500                        ret = sendbytes(i2c_adap,pmsg->buf,pmsg->len); 
    501                         DEB2(printk("i2c(bit): wrote %d bytes.\n",ret)); 
     501                        DEB2(printk("i2c-algo-bit.o: wrote %d bytes.\n",ret)); 
    502502                } 
    503503                if (i<num-1) { 
     
    550550        bit_adaps[i] = adap; 
    551551        adap_count++; 
    552         DEB2(printk("i2c(bit): hw routines for %s registered.\n",adap->name)); 
     552        DEB2(printk("i2c-algo-bit.o: hw routines for %s registered.\n",adap->name)); 
    553553 
    554554        /* register new adapter to i2c module... */ 
     
    563563        if (bit_scan) { 
    564564                int ack; 
    565                 printk(KERN_INFO " i2c(bit): scanning bus %s.\n", adap->name); 
     565                printk(KERN_INFO " i2c-algo-bit.o: scanning bus %s.\n", adap->name); 
    566566                for (i = 0x00; i < 0xff; i+=2) { 
    567567                        i2c_start(bit_adap); 
     
    593593                        break; 
    594594        if ( I2C_BIT_ADAP_MAX == i) { 
    595                 printk(KERN_WARNING " i2c(bit): could not unregister bus: %s\n", 
     595                printk(KERN_WARNING " i2c-algo-bit.o: could not unregister bus: %s\n", 
    596596                        adap->name); 
    597597                return -ENODEV; 
     
    602602 
    603603        adap_count--; 
    604         DEB2(printk("i2c(bit): adapter unregistered: %s\n",adap->name)); 
     604        DEB2(printk("i2c-algo-bit.o: adapter unregistered: %s\n",adap->name)); 
    605605 
    606606#ifdef MODULE 
     
    614614        int i; 
    615615 
     616        printk("i2c-algo-bit.o: i2c bit algorithm module\n"); 
    616617        for (i=0;i<I2C_BIT_ADAP_MAX;i++) { 
    617618                bit_adaps[i]=NULL; 
  • i2c/trunk/kernel/i2c-algo-pcf.c

    r3330 r3342  
    202202        set_pcf(adap, 1, I2C_PCF_IDLE); 
    203203 
    204         DEB2(printk("algo-pcf-irq: Initialized 8584.\n")); 
     204        DEB2(printk("i2c-algo-pcf.o: irq: Initialized 8584.\n")); 
    205205        return 0; 
    206206} 
     
    216216        sda=getsda(adap); 
    217217        if (adap->getscl==NULL) { 
    218                 printk("i2c(pcf): Warning: Adapter can't read from clock line - skipping test.\n"); 
     218                printk("i2c-algo-pcf.o: Warning: Adapter can't read from clock line - skipping test.\n"); 
    219219                return 0;                
    220220        } 
    221221        scl=getscl(adap); 
    222         printk("i2c(pcf): Adapter: %s scl: %d  sda: %d -- testing...\n", 
     222        printk("i2c-algo-pcf.o: Adapter: %s scl: %d  sda: %d -- testing...\n", 
    223223        name,getscl(adap),getsda(adap)); 
    224224        if (!scl || !sda ) { 
    225                 printk("i2c(pcf): %s seems to be busy.\n",adap->name); 
     225                printk("i2c-algo-pcf.o: %s seems to be busy.\n",adap->name); 
    226226                goto bailout; 
    227227        } 
    228228        sdalo(adap); 
    229         printk("i2c(pcf):1 scl: %d  sda: %d \n",getscl(adap),getsda(adap)); 
     229        printk("i2c-algo-pcf.o:1 scl: %d  sda: %d \n",getscl(adap),getsda(adap)); 
    230230        if ( 0 != getsda(adap) ) { 
    231                 printk("i2c(pcf): %s SDA stuck high!\n",name); 
     231                printk("i2c-algo-pcf.o: %s SDA stuck high!\n",name); 
    232232                sdahi(adap); 
    233233                goto bailout; 
    234234        } 
    235235        if ( 0 == getscl(adap) ) { 
    236                 printk("i2c(pcf): %s SCL unexpected low while pulling SDA low!\n", 
     236                printk("i2c-algo-pcf.o: %s SCL unexpected low while pulling SDA low!\n", 
    237237                        name); 
    238238                goto bailout; 
    239239        }                
    240240        sdahi(adap); 
    241         printk("i2c(pcf):2 scl: %d  sda: %d \n",getscl(adap),getsda(adap)); 
     241        printk("i2c-algo-pcf.o:2 scl: %d  sda: %d \n",getscl(adap),getsda(adap)); 
    242242        if ( 0 == getsda(adap) ) { 
    243                 printk("i2c(pcf): %s SDA stuck low!\n",name); 
     243                printk("i2c-algo-pcf.o: %s SDA stuck low!\n",name); 
    244244                sdahi(adap); 
    245245                goto bailout; 
    246246        } 
    247247        if ( 0 == getscl(adap) ) { 
    248                 printk("i2c(pcf): %s SCL unexpected low while SDA high!\n",adap->name); 
     248                printk("i2c-algo-pcf.o: %s SCL unexpected low while SDA high!\n",adap->name); 
    249249        goto bailout; 
    250250        } 
    251251        scllo(adap); 
    252         printk("i2c(pcf):3 scl: %d  sda: %d \n",getscl(adap),getsda(adap)); 
     252        printk("i2c-algo-pcf.o:3 scl: %d  sda: %d \n",getscl(adap),getsda(adap)); 
    253253        if ( 0 != getscl(adap) ) { 
    254                 printk("i2c(pcf): %s SCL stuck high!\n",name); 
     254                printk("i2c-algo-pcf.o: %s SCL stuck high!\n",name); 
    255255                sclhi(adap); 
    256256                goto bailout; 
    257257        } 
    258258        if ( 0 == getsda(adap) ) { 
    259                 printk("i2c(pcf): %s SDA unexpected low while pulling SCL low!\n", 
     259                printk("i2c-algo-pcf.o: %s SDA unexpected low while pulling SCL low!\n", 
    260260                        name); 
    261261                goto bailout; 
    262262        } 
    263263        sclhi(adap); 
    264         printk("i2c(pcf):4 scl: %d  sda: %d \n",getscl(adap),getsda(adap)); 
     264        printk("i2c-algo-pcf.o:4 scl: %d  sda: %d \n",getscl(adap),getsda(adap)); 
    265265        if ( 0 == getscl(adap) ) { 
    266                 printk("i2c(pcf): %s SCL stuck low!\n",name); 
     266                printk("i2c-algo-pcf.o: %s SCL stuck low!\n",name); 
    267267                sclhi(adap); 
    268268                goto bailout; 
    269269        } 
    270270        if ( 0 == getsda(adap) ) { 
    271                 printk("i2c(pcf): %s SDA unexpected low while SCL high!\n", 
     271                printk("i2c-algo-pcf.o: %s SDA unexpected low while SCL high!\n", 
    272272                        name); 
    273273                goto bailout; 
    274274        } 
    275         printk("i2c(pcf): %s passed test.\n",name); 
     275        printk("i2c-algo-pcf.o: %s passed test.\n",name); 
    276276        return 0; 
    277277bailout: 
     
    303303      udelay(adap->udelay); 
    304304   } 
    305    DEB2(if (i) printk("i2c(pcf): needed %d retries for %d\n",i,addr)); 
     305   DEB2(if (i) printk("i2c-algo-pcf.o: needed %d retries for %d\n",i,addr)); 
    306306   return ret; 
    307307} 
     
    314314 
    315315   for (wrcount=0; wrcount<count; ++wrcount) { 
    316       DEB2(printk("i2c(pcf): %s i2c_write: writing %2.2X\n", 
     316      DEB2(printk("i2c-algo-pcf.o: %s i2c_write: writing %2.2X\n", 
    317317                  i2c_adap->name, buf[wrcount]&0xff)); 
    318318      i2c_outb(adap, buf[wrcount]); 
    319319      timeout = wait_for_pin(adap, &status); 
    320320      if (timeout) { 
    321          printk("i2c(pcf): %s i2c_write: error - timeout.\n", 
     321         printk("i2c-algo-pcf.o: %s i2c_write: error - timeout.\n", 
    322322                i2c_adap->name); 
    323323         i2c_stop(adap); 
     
    325325      } 
    326326      if (status & I2C_PCF_LRB) { 
    327          printk("i2c(pcf): %s i2c_write: error - no ack.\n", 
     327         printk("i2c-algo-pcf.o: %s i2c_write: error - no ack.\n", 
    328328                i2c_adap->name); 
    329329         i2c_stop(adap); 
     
    349349      timeout = wait_for_pin(adap, &status); 
    350350      if (timeout) { 
    351          printk("i2c(pcf): i2c_read: i2c_inb timed out.\n"); 
     351         printk("i2c-algo-pcf.o: i2c_read: i2c_inb timed out.\n"); 
    352352         return (-1); 
    353353      } 
    354354      if (status & I2C_PCF_LRB) { 
    355          printk("i2c(pcf): i2c_read: i2c_inb, No ack.\n"); 
     355         printk("i2c-algo-pcf.o: i2c_read: i2c_inb, No ack.\n"); 
    356356         return (-1); 
    357357      } 
     
    366366   timeout = wait_for_pin(adap, &status); 
    367367   if (timeout) { 
    368       printk("i2c(pcf): i2c_read: i2c_inb timed out.\n"); 
     368      printk("i2c-algo-pcf.o: i2c_read: i2c_inb timed out.\n"); 
    369369      return (-1); 
    370370   } 
     
    425425   timeout = wait_for_bb(adap); 
    426426   if (timeout) { 
    427       DEB2(printk("Timeout waiting for BB in pcf_xfer\n");) 
     427      DEB2(printk("i2c-algo-pcf.o: Timeout waiting for BB in pcf_xfer\n");) 
    428428      return -EIO; 
    429429   } 
     
    433433 
    434434   for (i=0; i<num; i++) { 
    435       DEB3(printk("Msg %d, addr=0x%x, flags=0x%x, len=%d\n", 
     435      DEB3(printk("i2c-algo-pcf.o: Msg %d, addr=0x%x, flags=0x%x, len=%d\n", 
    436436                  i, msgs[i].addr, msgs[i].flags, msgs[i].len);) 
    437437      timeout = wait_for_pin(adap, &status); 
    438438      if (timeout) { 
    439          DEB2(printk("Timeout waiting for PIN(1) in pcf_xfer\n");) 
     439         DEB2(printk("i2c-algo-pcf.o: Timeout waiting for PIN(1) in pcf_xfer\n");) 
    440440         i2c_stop(adap); 
    441441         return (-EREMOTEIO); 
     
    443443      if (status & I2C_PCF_LRB) { 
    444444         i2c_stop(adap); 
    445          DEB2(printk("i2c(pcf): NAK from device adr %#2x msg #%d\n" 
     445         DEB2(printk("i2c-algo-pcf.o: NAK from device adr %#2x msg #%d\n" 
    446446                               ,msgs[i].addr,i)); 
    447447         return -EREMOTEIO; 
     
    450450         /* read bytes into buffer*/ 
    451451         ret = pcf_readbytes(i2c_adap, pmsg->buf, pmsg->len); 
    452          DEB2(printk("i2c(pcf): read %d bytes.\n",ret)); 
     452         DEB2(printk("i2c-algo-pcf.o: read %d bytes.\n",ret)); 
    453453      } else { 
    454454         /* write bytes from buffer */ 
    455455         ret = pcf_sendbytes(i2c_adap, pmsg->buf, pmsg->len); 
    456          DEB2(printk("i2c(pcf): wrote %d bytes.\n",ret)); 
     456         DEB2(printk("i2c-algo-pcf.o: wrote %d bytes.\n",ret)); 
    457457      } 
    458458      if (i == (num-1)) { 
     
    470470         timeout = wait_for_pin(adap, &status); 
    471471         if (timeout) { 
    472             DEB2(printk("Timeout waiting for PIN(2) in pcf_xfer\n");) 
     472            DEB2(printk("i2c-algo-pcf.o: Timeout waiting for PIN(2) in pcf_xfer\n");) 
    473473            return (-EREMOTEIO); 
    474474         } 
    475475         if (status & I2C_PCF_LRB) { 
    476476            i2c_stop(adap); 
    477             DEB2(printk("No LRB(2) in pcf_xfer\n");) 
     477            DEB2(printk("i2c-algo-pcf.o: No LRB(2) in pcf_xfer\n");) 
    478478            return (-EREMOTEIO); 
    479479         } 
     
    524524        i2c_pcf_adaps[i] = adap; 
    525525        adap_count++; 
    526         DEB2(printk("i2c(pcf): hw routines for %s registered.\n",adap->name)); 
     526        DEB2(printk("i2c-algo-pcf.o: hw routines for %s registered.\n",adap->name)); 
    527527 
    528528        /* register new adapter to i2c module... */ 
     
    543543        /* scan bus */ 
    544544        if (pcf_scan) { 
    545            printk(KERN_INFO " i2c(pcf): scanning bus %s.\n", adap->name); 
     545           printk(KERN_INFO " i2c-algo-pcf.o: scanning bus %s.\n", adap->name); 
    546546           for (i = 0x00; i < 0xff; i+=2) { 
    547547              i2c_outb(pcf_adap, i); 
     
    570570                        break; 
    571571        if ( I2C_PCF_ADAP_MAX == i) { 
    572                 printk(KERN_WARNING " i2c(pcf): could not unregister bus: %s\n", 
     572                printk(KERN_WARNING " i2c-algo-pcf.o: could not unregister bus: %s\n", 
    573573                        adap->name); 
    574574                return -ENODEV; 
     
    578578        i2c_del_adapter(adap); 
    579579        adap_count--; 
    580         DEB2(printk("i2c(pcf): adapter unregistered: %s\n",adap->name)); 
     580        DEB2(printk("i2c-algo-pcf.o: adapter unregistered: %s\n",adap->name)); 
    581581 
    582582#ifdef MODULE 
     
    590590        int i; 
    591591 
     592        printk("i2c-algo-pcf.o: i2c pcf8584 algorithm module\n"); 
    592593        for (i=0;i<I2C_PCF_ADAP_MAX;i++) { 
    593594                i2c_pcf_adaps[i]=NULL; 
  • i2c/trunk/kernel/i2c-core.c

    r3341 r3342  
    184184        if (I2C_ALGO_MAX == i) { 
    185185                printk(KERN_WARNING  
    186                        " i2c: register_algorithm(%s) - enlarge I2C_ALGO_MAX.\n", 
     186                       " i2c-core.o: register_algorithm(%s) - enlarge I2C_ALGO_MAX.\n", 
    187187                        algo->name); 
    188188                return -ENOMEM; 
     
    192192        algo_count++; 
    193193 
    194         DEB(printk("i2c: algorithm %s registered.\n",algo->name)); 
     194        DEB(printk("i2-core.o: algorithm %s registered.\n",algo->name)); 
    195195        return 0;        
    196196} 
     
    206206        if (I2C_ALGO_MAX == i) { 
    207207                printk(KERN_WARNING  
    208                        " i2c: unregister_algorithm: [%s] not found.\n", 
     208                       " i2c-core.o: unregister_algorithm: [%s] not found.\n", 
    209209                        algo->name); 
    210210                return -ENODEV; 
     
    213213        algo_count--; 
    214214 
    215         DEB(printk("i2c: algorithm unregistered: %s\n",algo->name)); 
     215        DEB(printk("i2c-core.o: algorithm unregistered: %s\n",algo->name)); 
    216216        return 0;     
    217217} 
     
    232232        if (I2C_ADAP_MAX == i) { 
    233233                printk(KERN_WARNING  
    234                        " i2c: register_adapter(%s) - enlarge I2C_ADAP_MAX.\n", 
     234                       " i2c-core.o: register_adapter(%s) - enlarge I2C_ADAP_MAX.\n", 
    235235                        adap->name); 
    236236                return -ENOMEM; 
     
    255255                proc_entry = create_proc_entry(name,0,proc_bus); 
    256256                if (! proc_entry) { 
    257                         printk("i2c-core: Could not create /proc/bus/%s\n", 
     257                        printk("i2c-core.o: Could not create /proc/bus/%s\n", 
    258258                               name); 
    259259                        return -ENOENT; 
     
    267267                if (!(proc_entry = kmalloc(sizeof(struct proc_dir_entry)+ 
    268268                                           strlen(name)+1, GFP_KERNEL))) { 
    269                         printk("i2c-core: Out of memory!\n"); 
     269                        printk("i2c-core.o: Out of memory!\n"); 
    270270                        return -ENOMEM; 
    271271                } 
     
    285285         
    286286                if ((res = proc_register_dynamic(&proc_bus_dir, proc_entry))) { 
    287                         printk("i2c-core: Could not create %s.\n",name); 
     287                        printk("i2c-core.o: Could not create %s.\n",name); 
    288288                        kfree(proc_entry); 
    289289                        return res; 
     
    303303                        drivers[j]->attach_adapter(adap); 
    304304 
    305         DEB(printk("i2c: adapter %s registered as adapter %d.\n",adap->name,i)); 
     305        DEB(printk("i2c-core.o: adapter %s registered as adapter %d.\n",adap->name,i)); 
    306306 
    307307        return 0;        
     
    316316                        break; 
    317317        if (I2C_ADAP_MAX == i) { 
    318                 printk( " i2c: unregister_adapter adap [%s] not found.\n", 
     318                printk( " i2c-core.o: unregister_adapter adap [%s] not found.\n", 
    319319                        adap->name); 
    320320                return -ENODEV; 
     
    331331                        if ((res = proc_unregister(&proc_bus_dir, 
    332332                                          adapters[i]->proc_entry->low_ino))) { 
    333                                 printk("i2c-core: Deregistration of /proc " 
     333                                printk("i2c-core.o: Deregistration of /proc " 
    334334                                       "entry failed\n" 
    335335                                return res; 
     
    357357        adap_count--; 
    358358 
    359         DEB(printk("i2c: adapter unregistered: %s\n",adap->name)); 
     359        DEB(printk("i2c-core.o: adapter unregistered: %s\n",adap->name)); 
    360360        return 0;     
    361361} 
     
    376376        if (I2C_DRIVER_MAX == i) { 
    377377                printk(KERN_WARNING  
    378                        " i2c: register_driver(%s) - enlarge I2C_DRIVER_MAX.\n", 
     378                       " i2c-core.o: register_driver(%s) - enlarge I2C_DRIVER_MAX.\n", 
    379379                        driver->name); 
    380380                return -ENOMEM; 
     
    384384        driver_count++; 
    385385 
    386         DEB(printk("i2c: driver %s registered.\n",driver->name)); 
     386        DEB(printk("i2c-core.o: driver %s registered.\n",driver->name)); 
    387387 
    388388        /* now look for instances of driver on our adapters 
     
    404404                        break; 
    405405        if (I2C_DRIVER_MAX == i) { 
    406                 printk(KERN_WARNING " i2c: unregister_driver: [%s] not found\n", 
     406                printk(KERN_WARNING " i2c-core.o: unregister_driver: [%s] not found\n", 
    407407                        driver->name); 
    408408                return -ENODEV; 
     
    412412         * afterwards. 
    413413         */ 
    414         DEB2(printk("i2c: unregister_driver - looking for clients.\n")); 
     414        DEB2(printk("i2c-core.o: unregister_driver - looking for clients.\n")); 
    415415        /* removing clients does not depend on the notify flag, else  
    416416         * invalid operation might (will!) result, when using stale client 
     
    421421                if (adap == NULL) /* skip empty entries. */ 
    422422                        continue; 
    423                 DEB2(printk("i2c: examining adapter %s:\n",adap->name)); 
     423                DEB2(printk("i2c-core.o: examining adapter %s:\n",adap->name)); 
    424424                for (j=0;j<I2C_CLIENT_MAX;j++) {  
    425425                        struct i2c_client *client = adap->clients[j]; 
    426426                        if (client != NULL && client->driver == driver) { 
    427                                 DEB2(printk("i2c:   detaching client %s:\n", 
     427                                DEB2(printk("i2c-core.o:   detaching client %s:\n", 
    428428                                        client->name)); 
    429429                                /*i2c_detach_client(client);*/ 
     
    435435        driver_count--; 
    436436 
    437         DEB(printk("i2c: driver unregistered: %s\n",driver->name)); 
     437        DEB(printk("i2c-core.o: driver unregistered: %s\n",driver->name)); 
    438438        return 0; 
    439439} 
     
    450450        if (I2C_CLIENT_MAX == i) { 
    451451                printk(KERN_WARNING  
    452                        " i2c: attach_client(%s) - enlarge I2C_CLIENT_MAX.\n", 
     452                       " i2c-core.o: attach_client(%s) - enlarge I2C_CLIENT_MAX.\n", 
    453453                        client->name); 
    454454                return -ENOMEM; 
     
    459459        if (adapter->client_register != NULL)  
    460460                adapter->client_register(client); 
    461         DEB(printk("i2c: client [%s] registered to adapter [%s](pos. %d).\n", 
     461        DEB(printk("i2c-core.o: client [%s] registered to adapter [%s](pos. %d).\n", 
    462462                client->name, adapter->name,i)); 
    463463        return 0; 
     
    474474                        break; 
    475475        if (I2C_CLIENT_MAX == i) { 
    476                 printk(KERN_WARNING " i2c: unregister_client [%s] not found\n", 
     476                printk(KERN_WARNING " i2c-core.o: unregister_client [%s] not found\n", 
    477477                        client->name); 
    478478                return -ENODEV; 
     
    484484        adapter->clients[i] = NULL; 
    485485        adapter->client_count--; 
    486         DEB(printk("i2c: client [%s] unregistered.\n",client->name)); 
     486        DEB(printk("i2c-core.o: client [%s] unregistered.\n",client->name)); 
    487487        return 0;     
    488488} 
     
    613613#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,29)) 
    614614        if (! proc_bus) { 
    615                 printk("i2c-core: /proc/bus/ does not exist"); 
     615                printk("i2c-core.o: /proc/bus/ does not exist"); 
    616616                i2cproc_cleanup(); 
    617617                return -ENOENT; 
     
    619619        proc_bus_i2c = create_proc_entry("i2c",0,proc_bus); 
    620620        if (!proc_bus_i2c) { 
    621                 printk("i2c-core: Could not create /proc/bus/i2c"); 
     621                printk("i2c-core.o: Could not create /proc/bus/i2c"); 
    622622                i2cproc_cleanup(); 
    623623                return -ENOENT; 
     
    635635        proc_bus_dir.ops = proc_net.ops; 
    636636        if ((res = proc_register_dynamic(&proc_root, &proc_bus_dir))) { 
    637                 printk("i2c-core: Could not create /proc/bus/"); 
     637                printk("i2c-core.o: Could not create /proc/bus/"); 
    638638                i2cproc_cleanup(); 
    639639                return res; 
     
    641641        i2cproc_initialized ++; 
    642642        if ((res = proc_register_dynamic(&proc_bus_dir, &proc_bus_i2c_dir))) { 
    643                 printk("i2c-core: Could not create /proc/bus/i2c\n"); 
     643                printk("i2c-core.o: Could not create /proc/bus/i2c\n"); 
    644644                i2cproc_cleanup(); 
    645645                return res; 
     
    661661                        if ((res = proc_unregister(&proc_bus_dir, 
    662662                                                  proc_bus_i2c_dir.low_ino))) { 
    663                                 printk("i2c-core: could not delete " 
     663                                printk("i2c-core.o: could not delete " 
    664664                                       "/proc/bus/i2c, module not removed."); 
    665665                                return res; 
     
    668668                } 
    669669                if ((res = proc_unregister(&proc_root,proc_bus_dir.low_ino))) { 
    670                         printk("i2c-core: could not delete /proc/bus/, " 
     670                        printk("i2c-core.o: could not delete /proc/bus/, " 
    671671                               "module not removed."); 
    672672                        return res; 
     
    691691 
    692692        if (adap->algo->master_xfer) { 
    693                 DEB(printk("master_xfer: %s with %d msgs.\n",adap->name,num)); 
     693                DEB(printk("i2c-core.o: master_xfer: %s with %d msgs.\n",adap->name,num)); 
    694694 
    695695                I2C_LOCK(adap); 
     
    699699                return ret; 
    700700        } else { 
    701                 printk("I2C adapter %04x: I2C level transfers not supported\n", 
     701                printk("i2c-core.o: I2C adapter %04x: I2C level transfers not supported\n", 
    702702                       adap->id); 
    703703                return 0; 
     
    717717                (const char *)msg.buf = buf; 
    718718         
    719                 DEB(printk("master_send: writing %d bytes on %s.\n", 
     719                DEB(printk("i2c-core.o: master_send: writing %d bytes on %s.\n", 
    720720                        count,client->adapter->name)); 
    721721         
     
    729729                return (ret == 1 )? count : ret; 
    730730        } else { 
    731                 printk("I2C adapter %04x: I2C level transfers not supported\n", 
     731                printk("i2c-core.o: I2C adapter %04x: I2C level transfers not supported\n", 
    732732                       client->adapter->id); 
    733733                return 0; 
     
    756756                memcpy(&c[1], buf, sizeof(char)*count); 
    757757                 
    758                 DEB(printk("master_send_subadress: writing %d bytes on %s. (sa:0x%02x)\n", 
     758                DEB(printk("i2c-core.o: master_send_subadress: writing %d bytes on %s. (sa:0x%02x)\n", 
    759759                        count,client->adapter->name,subadress)); 
    760760         
     
    771771                return (ret == 1 )? count : ret; 
    772772        } else { 
    773                 printk("I2C adapter %04x: I2C level transfers not supported\n", 
     773                printk("i2c-core.o: I2C adapter %04x: I2C level transfers not supported\n", 
    774774                       client->adapter->id); 
    775775                return 0; 
     
    796796                (const char*)msg[1].buf = (const char*)buf; 
    797797                 
    798                 DEB(printk("master_recv_subadress: reading %d bytes from subadress %d on %s.\n", 
     798                DEB(printk("i2c-core.o: master_recv_subadress: reading %d bytes from subadress %d on %s.\n", 
    799799                        count,subadress,client->adapter->name)); 
    800800         
     
    808808                return (ret == 1 ) ? 0 : ret; 
    809809        } else { 
    810                 printk("I2C adapter %04x: I2C level transfers not supported\n", 
     810                printk("i2c-core.o: I2C adapter %04x: I2C level transfers not supported\n", 
    811811                       client->adapter->id); 
    812812                return 0; 
     
    828828                msg.buf = buf; 
    829829 
    830                 DEB(printk("master_recv: reading %d bytes on %s.\n", 
     830                DEB(printk("i2c-core.o: master_recv: reading %d bytes on %s.\n", 
    831831                        count,client->adapter->name)); 
    832832         
     
    835835                I2C_UNLOCK(adap); 
    836836         
    837                 DEB(printk("master_recv: return:%d (count:%d, addr:0x%02x)\n", 
     837                DEB(printk("i2c-core.o: master_recv: return:%d (count:%d, addr:0x%02x)\n", 
    838838                        ret, count, client->addr)); 
    839839         
     
    843843                return (ret == 1 )? count : ret; 
    844844        } else { 
    845                 printk("I2C adapter %04x: I2C level transfers not supported\n", 
     845                printk("i2c-core.o: I2C adapter %04x: I2C level transfers not supported\n", 
    846846                       client->adapter->id); 
    847847                return 0; 
     
    856856        struct i2c_adapter *adap = client->adapter; 
    857857 
    858         DEB2(printk("i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg)); 
     858        DEB2(printk("i2c-core.o: i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg)); 
    859859        switch ( cmd ) { 
    860860                case I2C_RETRIES: 
     
    893893                return (i <= hi_addr) ? (client->addr=i) : -1; 
    894894        } else { 
    895                 printk("I2C adapter %04x: I2C level transfers not supported\n", 
     895                printk("i2c-core.o: I2C adapter %04x: I2C level transfers not supported\n", 
    896896                       client->adapter->id); 
    897897                return 0; 
     
    10781078        case I2C_SMBUS_BLOCK_DATA: 
    10791079                if (read_write == I2C_SMBUS_READ) { 
    1080                         printk("smbus.o: Block read not supported under " 
     1080                        printk("i2c-core.o: Block read not supported under " 
    10811081                               "I2C emulation!\n"); 
    10821082                return -1; 
     
    10841084                        msg[1].len = data->block[0] + 1; 
    10851085                        if (msg[1].len > 32) { 
    1086                                 printk("smbus.o: smbus_access called with " 
     1086                                printk("i2c-core.o: smbus_access called with " 
    10871087                                       "invalid block write size (%d)\n", 
    10881088                                       msg[1].len); 
     
    10941094                break; 
    10951095        default: 
    1096                 printk("smbus.o: smbus_access called with invalid size (%d)\n", 
     1096                printk("i2c-core.o: smbus_access called with invalid size (%d)\n", 
    10971097                       size); 
    10981098                return -1; 
     
    11381138{ 
    11391139        /* clear algorithms */ 
     1140        printk("i2c-core.o: i2c core module\n"); 
    11401141        memset(algorithms,0,sizeof(algorithms)); 
    11411142        memset(adapters,0,sizeof(adapters)); 
     
    11471148        i2cproc_init(); 
    11481149         
    1149         printk(KERN_INFO "i2c module initialized.\n"); 
    11501150        return 0; 
    11511151} 
  • i2c/trunk/kernel/i2c-dev.c

    r3333 r3342  
    172172   struct inode *inode = file->f_dentry->d_inode; 
    173173#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,70)) */ 
    174   printk("i2c_dev,o: i2c-%d lseek to %ld bytes relative to %d.\n", 
     174  printk("i2c-dev,o: i2c-%d lseek to %ld bytes relative to %d.\n", 
    175175         MINOR(inode->i_rdev),(long) offset,origin); 
    176176#endif /* DEBUG */ 
     
    206206 
    207207#ifdef DEBUG 
    208   printk("i2c_dev,o: i2c-%d reading %d bytes.\n",MINOR(inode->i_rdev),count); 
     208  printk("i2c-dev,o: i2c-%d reading %d bytes.\n",MINOR(inode->i_rdev),count); 
    209209#endif 
    210210 
     
    243243 
    244244#ifdef DEBUG 
    245   printk("i2c_dev,o: i2c-%d writing %d bytes.\n",MINOR(inode->i_rdev),count); 
     245  printk("i2c-dev,o: i2c-%d writing %d bytes.\n",MINOR(inode->i_rdev),count); 
    246246#endif 
    247247  ret = i2c_master_send(client,tmp,count); 
     
    259259 
    260260#ifdef DEBUG 
    261   printk("i2c_dev.o: i2c-%d ioctl, cmd: 0x%x, arg: %lx.\n",  
     261  printk("i2c-dev.o: i2c-%d ioctl, cmd: 0x%x, arg: %lx.\n",  
    262262         MINOR(inode->i_rdev),cmd, arg); 
    263263#endif /* DEBUG */ 
     
    501501  int res; 
    502502 
     503  printk("i2c-dev.o: i2c /dev entries driver module\n"); 
     504 
    503505  i2cdev_initialized = 0; 
    504506  if (register_chrdev(I2C_MAJOR,"i2c",&i2cdev_fops)) { 
  • i2c/trunk/kernel/i2c-elektor.c

    r3330 r3342  
    7575   if (ctl) { 
    7676      if (gpi.pi_irq > 0) {