Changeset 1080

Show
Ignore:
Timestamp:
04/23/01 01:27:23 (13 years ago)
Author:
mds
Message:

change from gl520sm_init() to gl520_init() to match

what is in driver so patched kernel will work with gl520.

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • lm-sensors/trunk/kernel/sensors.c

    r997 r1080  
    1919*/ 
    2020 
    21 #include <linux/version.h> 
    22 #include <linux/module.h> 
    23 #include <linux/kernel.h> 
    24 #include <linux/malloc.h> 
    25 #include <linux/ctype.h> 
    26 #include <linux/sysctl.h> 
    27 #include <linux/proc_fs.h> 
    28 #include <linux/ioport.h> 
    29 #include <asm/uaccess.h> 
    30  
    31 #include "version.h" 
    32 #include <linux/i2c.h> 
    33 #include "i2c-isa.h" 
    34 #include "sensors.h" 
    35  
    3621#include <linux/init.h> 
    3722 
     
    3924extern int init_module(void); 
    4025extern int cleanup_module(void); 
    41 static int sensors_cleanup(void); 
    4226#endif                          /* MODULE */ 
    43  
    44 #ifndef THIS_MODULE 
    45 #define THIS_MODULE NULL 
    46 #endif 
    47  
    48 static int sensors_create_name(char **name, const char *prefix, 
    49                                struct i2c_adapter *adapter, int addr); 
    50 static int sensors_parse_reals(int *nrels, void *buffer, int bufsize, 
    51                                long *results, int magnitude); 
    52 static int sensors_write_reals(int nrels, void *buffer, int *bufsize, 
    53                                long *results, int magnitude); 
    54 static int sensors_proc_chips(ctl_table * ctl, int write, 
    55                               struct file *filp, void *buffer, 
    56                               size_t * lenp); 
    57 static int sensors_sysctl_chips(ctl_table * table, int *name, int nlen, 
    58                                 void *oldval, size_t * oldlenp, 
    59                                 void *newval, size_t newlen, 
    60                                 void **context); 
    61  
    62 static int __init sensors_init(void); 
    63  
    64 #define SENSORS_ENTRY_MAX 20 
    65 static struct ctl_table_header *sensors_entries[SENSORS_ENTRY_MAX]; 
    66  
    67 static struct i2c_client *sensors_clients[SENSORS_ENTRY_MAX]; 
    68 static unsigned short sensors_inodes[SENSORS_ENTRY_MAX]; 
    69 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,1) 
    70 static void sensors_fill_inode(struct inode *inode, int fill); 
    71 static void sensors_dir_fill_inode(struct inode *inode, int fill); 
    72 #endif                          /* LINUX_VERSION_CODE < KERNEL_VERSION(2,3,1) */ 
    73  
    74 static ctl_table sysctl_table[] = { 
    75         {CTL_DEV, "dev", NULL, 0, 0555}, 
    76         {0}, 
    77         {DEV_SENSORS, "sensors", NULL, 0, 0555}, 
    78         {0}, 
    79         {0, NULL, NULL, 0, 0555}, 
    80         {0} 
    81 }; 
    82  
    83 static ctl_table sensors_proc_dev_sensors[] = { 
    84         {SENSORS_CHIPS, "chips", NULL, 0, 0644, NULL, &sensors_proc_chips, 
    85          &sensors_sysctl_chips}, 
    86         {0} 
    87 }; 
    88  
    89 static ctl_table sensors_proc_dev[] = { 
    90         {DEV_SENSORS, "sensors", NULL, 0, 0555, sensors_proc_dev_sensors}, 
    91         {0}, 
    92 }; 
    93  
    94  
    95 static ctl_table sensors_proc[] = { 
    96         {CTL_DEV, "dev", NULL, 0, 0555, sensors_proc_dev}, 
    97         {0} 
    98 }; 
    99  
    100  
    101 static struct ctl_table_header *sensors_proc_header; 
    102 static int sensors_initialized; 
    103  
    104 /* This returns a nice name for a new directory; for example lm78-isa-0310 
    105    (for a LM78 chip on the ISA bus at port 0x310), or lm75-i2c-3-4e (for 
    106    a LM75 chip on the third i2c bus at address 0x4e).   
    107    name is allocated first. */ 
    108 int sensors_create_name(char **name, const char *prefix, 
    109                         struct i2c_adapter *adapter, int addr) 
    110 { 
    111         char name_buffer[50]; 
    112         int id; 
    113         if (i2c_is_isa_adapter(adapter)) 
    114                 sprintf(name_buffer, "%s-isa-%04x", prefix, addr); 
    115         else { 
    116                 if ((id = i2c_adapter_id(adapter)) < 0) 
    117                         return -ENOENT; 
    118                 sprintf(name_buffer, "%s-i2c-%d-%02x", prefix, id, addr); 
    119         } 
    120         *name = kmalloc(strlen(name_buffer) + 1, GFP_KERNEL); 
    121         strcpy(*name, name_buffer); 
    122         return 0; 
    123 } 
    124  
    125 /* This rather complex function must be called when you want to add an entry 
    126    to /proc/sys/dev/sensors/chips. It also creates a new directory within  
    127    /proc/sys/dev/sensors/. 
    128    ctl_template should be a template of the newly created directory. It is 
    129    copied in memory. The extra2 field of each file is set to point to client. 
    130    If any driver wants subdirectories within the newly created directory, 
    131    this function must be updated!  
    132    controlling_mod is the controlling module. It should usually be 
    133    THIS_MODULE when calling. Note that this symbol is not defined in 
    134    kernels before 2.3.13; define it to NULL in that case. We will not use it 
    135    for anything older than 2.3.27 anyway. */ 
    136 int sensors_register_entry(struct i2c_client *client, const char *prefix, 
    137                            ctl_table * ctl_template, 
    138                            struct module *controlling_mod) 
    139 { 
    140         int i, res, len, id; 
    141         ctl_table *new_table; 
    142         char *name; 
    143         struct ctl_table_header *new_header; 
    144  
    145         if ((res = sensors_create_name(&name, prefix, client->adapter, 
    146                                        client->addr))) return res; 
    147  
    148         for (id = 0; id < SENSORS_ENTRY_MAX; id++) 
    149                 if (!sensors_entries[id]) { 
    150                         break; 
    151                 } 
    152         if (id == SENSORS_ENTRY_MAX) { 
    153                 kfree(name); 
    154                 return -ENOMEM; 
    155         } 
    156         id += 256; 
    157  
    158         len = 0; 
    159         while (ctl_template[len].procname) 
    160                 len++; 
    161         len += 7; 
    162         if (!(new_table = kmalloc(sizeof(ctl_table) * len, GFP_KERNEL))) { 
    163                 kfree(name); 
    164                 return -ENOMEM; 
    165         } 
    166  
    167         memcpy(new_table, sysctl_table, 6 * sizeof(ctl_table)); 
    168         new_table[0].child = &new_table[2]; 
    169         new_table[2].child = &new_table[4]; 
    170         new_table[4].child = &new_table[6]; 
    171         new_table[4].procname = name; 
    172         new_table[4].ctl_name = id; 
    173         memcpy(new_table + 6, ctl_template, (len - 6) * sizeof(ctl_table)); 
    174         for (i = 6; i < len; i++) 
    175                 new_table[i].extra2 = client; 
    176  
    177         if (!(new_header = register_sysctl_table(new_table, 0))) { 
    178                 kfree(new_table); 
    179                 kfree(name); 
    180                 return -ENOMEM; 
    181         } 
    182  
    183         sensors_entries[id - 256] = new_header; 
    184  
    185         sensors_clients[id - 256] = client; 
    186 #ifdef DEBUG 
    187         if (!new_header || !new_header->ctl_table || 
    188             !new_header->ctl_table->child || 
    189             !new_header->ctl_table->child->child || 
    190             !new_header->ctl_table->child->child->de) { 
    191                 printk 
    192                     ("sensors.o: NULL pointer when trying to install fill_inode fix!\n"); 
    193                 return id; 
    194         } 
    195 #endif                          /* DEBUG */ 
    196         sensors_inodes[id - 256] = 
    197             new_header->ctl_table->child->child->de->low_ino; 
    198 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,27)) 
    199         new_header->ctl_table->child->child->de->owner = controlling_mod; 
    200 #else 
    201         new_header->ctl_table->child->child->de->fill_inode = 
    202             &sensors_dir_fill_inode; 
    203 #endif  /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,27)) */ 
    204  
    205         return id; 
    206 } 
    207  
    208 void sensors_deregister_entry(int id) 
    209 { 
    210         ctl_table *table; 
    211         char *temp; 
    212         id -= 256; 
    213         if (sensors_entries[id]) { 
    214                 table = sensors_entries[id]->ctl_table; 
    215                 unregister_sysctl_table(sensors_entries[id]); 
    216                 /* Below two-step kfree is needed to keep gcc happy about const points */ 
    217                 (const char *) temp = table[4].procname; 
    218                 kfree(temp); 
    219                 kfree(table); 
    220                 sensors_entries[id] = NULL; 
    221                 sensors_clients[id] = NULL; 
    222         } 
    223 } 
    224  
    225 /* Monitor access for /proc/sys/dev/sensors; make unloading sensors.o  
    226    impossible if some process still uses it or some file in it */ 
    227 void sensors_fill_inode(struct inode *inode, int fill) 
    228 { 
    229         if (fill) 
    230                 MOD_INC_USE_COUNT; 
    231         else 
    232                 MOD_DEC_USE_COUNT; 
    233 } 
    234  
    235 /* Monitor access for /proc/sys/dev/sensors/ directories; make unloading 
    236    the corresponding module impossible if some process still uses it or 
    237    some file in it */ 
    238 void sensors_dir_fill_inode(struct inode *inode, int fill) 
    239 { 
    240         int i; 
    241         struct i2c_client *client; 
    242  
    243 #ifdef DEBUG 
    244         if (!inode) { 
    245                 printk("sensors.o: Warning: inode NULL in fill_inode()\n"); 
    246                 return; 
    247         } 
    248 #endif                          /* def DEBUG */ 
    249  
    250         for (i = 0; i < SENSORS_ENTRY_MAX; i++) 
    251                 if (sensors_clients[i] 
    252                     && (sensors_inodes[i] == inode->i_ino)) break; 
    253 #ifdef DEBUG 
    254         if (i == SENSORS_ENTRY_MAX) { 
    255                 printk 
    256                     ("sensors.o: Warning: inode (%ld) not found in fill_inode()\n", 
    257                      inode->i_ino); 
    258                 return; 
    259         } 
    260 #endif                          /* def DEBUG */ 
    261         client = sensors_clients[i]; 
    262         if (fill) 
    263                 client->driver->inc_use(client); 
    264         else 
    265                 client->driver->dec_use(client); 
    266 } 
    267  
    268 int sensors_proc_chips(ctl_table * ctl, int write, struct file *filp, 
    269                        void *buffer, size_t * lenp) 
    270 { 
    271         char BUF[SENSORS_PREFIX_MAX + 30]; 
    272         int buflen, curbufsize, i; 
    273         struct ctl_table *client_tbl; 
    274  
    275         if (write) 
    276                 return 0; 
    277  
    278         /* If buffer is size 0, or we try to read when not at the start, we 
    279            return nothing. Note that I think writing when not at the start 
    280            does not work either, but anyway, this is straight from the kernel 
    281            sources. */ 
    282         if (!*lenp || (filp->f_pos && !write)) { 
    283                 *lenp = 0; 
    284                 return 0; 
    285         } 
    286         curbufsize = 0; 
    287         for (i = 0; i < SENSORS_ENTRY_MAX; i++) 
    288                 if (sensors_entries[i]) { 
    289                         client_tbl = 
    290                             sensors_entries[i]->ctl_table->child->child; 
    291                         buflen = 
    292                             sprintf(BUF, "%d\t%s\n", client_tbl->ctl_name, 
    293                                     client_tbl->procname); 
    294                         if (buflen + curbufsize > *lenp) 
    295                                 buflen = *lenp - curbufsize; 
    296                         if(copy_to_user(buffer, BUF, buflen)) 
    297                                 return -EFAULT; 
    298                         curbufsize += buflen; 
    299                         (char *) buffer += buflen; 
    300                 } 
    301         *lenp = curbufsize; 
    302         filp->f_pos += curbufsize; 
    303         return 0; 
    304 } 
    305  
    306 int sensors_sysctl_chips(ctl_table * table, int *name, int nlen, 
    307                          void *oldval, size_t * oldlenp, void *newval, 
    308                          size_t newlen, void **context) 
    309 { 
    310         struct sensors_chips_data data; 
    311         int i, oldlen, nrels, maxels,ret=0; 
    312         struct ctl_table *client_tbl; 
    313  
    314         if (oldval && oldlenp && !((ret = get_user(oldlen, oldlenp))) &&  
    315             oldlen) { 
    316                 maxels = oldlen / sizeof(struct sensors_chips_data); 
    317                 nrels = 0; 
    318                 for (i = 0; (i < SENSORS_ENTRY_MAX) && (nrels < maxels); 
    319                      i++) 
    320                         if (sensors_entries[i]) { 
    321                                 client_tbl = 
    322                                     sensors_entries[i]->ctl_table->child-> 
    323                                     child; 
    324                                 data.sysctl_id = client_tbl->ctl_name; 
    325                                 strcpy(data.name, client_tbl->procname); 
    326                                 if(copy_to_user(oldval, &data, 
    327                                              sizeof(struct 
    328                                                     sensors_chips_data))) 
    329                                         return -EFAULT; 
    330                                 (char *) oldval += 
    331                                     sizeof(struct sensors_chips_data); 
    332                                 nrels++; 
    333                         } 
    334                 oldlen = nrels * sizeof(struct sensors_chips_data); 
    335                 if(put_user(oldlen, oldlenp)) 
    336                         return -EFAULT; 
    337         } 
    338         return ret; 
    339 } 
    340  
    341  
    342 /* This funcion reads or writes a 'real' value (encoded by the combination 
    343    of an integer and a magnitude, the last is the power of ten the value 
    344    should be divided with) to a /proc/sys directory. To use this function, 
    345    you must (before registering the ctl_table) set the extra2 field to the 
    346    client, and the extra1 field to a function of the form: 
    347       void func(struct i2c_client *client, int operation, int ctl_name, 
    348                 int *nrels_mag, long *results) 
    349    This function can be called for three values of operation. If operation 
    350    equals SENSORS_PROC_REAL_INFO, the magnitude should be returned in  
    351    nrels_mag. If operation equals SENSORS_PROC_REAL_READ, values should 
    352    be read into results. nrels_mag should return the number of elements 
    353    read; the maximum number is put in it on entry. Finally, if operation 
    354    equals SENSORS_PROC_REAL_WRITE, the values in results should be 
    355    written to the chip. nrels_mag contains on entry the number of elements 
    356    found. 
    357    In all cases, client points to the client we wish to interact with, 
    358    and ctl_name is the SYSCTL id of the file we are accessing. */ 
    359 int sensors_proc_real(ctl_table * ctl, int write, struct file *filp, 
    360                       void *buffer, size_t * lenp) 
    361 { 
    362 #define MAX_RESULTS 32 
    363         int mag, nrels = MAX_RESULTS; 
    364         long results[MAX_RESULTS]; 
    365         sensors_real_callback callback = ctl->extra1; 
    366         struct i2c_client *client = ctl->extra2; 
    367         int res; 
    368  
    369         /* If buffer is size 0, or we try to read when not at the start, we 
    370            return nothing. Note that I think writing when not at the start 
    371            does not work either, but anyway, this is straight from the kernel 
    372            sources. */ 
    373         if (!*lenp || (filp->f_pos && !write)) { 
    374                 *lenp = 0; 
    375                 return 0; 
    376         } 
    377  
    378         /* Get the magnitude */ 
    379         callback(client, SENSORS_PROC_REAL_INFO, ctl->ctl_name, &mag, 
    380                  NULL); 
    381  
    382         if (write) { 
    383                 /* Read the complete input into results, converting to longs */ 
    384                 res = sensors_parse_reals(&nrels, buffer, *lenp, results, mag); 
    385                 if (res) 
    386                         return res; 
    387  
    388                 if (!nrels) 
    389                         return 0; 
    390  
    391                 /* Now feed this information back to the client */ 
    392                 callback(client, SENSORS_PROC_REAL_WRITE, ctl->ctl_name, 
    393                          &nrels, results); 
    394  
    395                 filp->f_pos += *lenp; 
    396                 return 0; 
    397         } else {                /* read */ 
    398                 /* Get the information from the client into results */ 
    399                 callback(client, SENSORS_PROC_REAL_READ, ctl->ctl_name, 
    400                          &nrels, results); 
    401  
    402                 /* And write them to buffer, converting to reals */ 
    403                 res = sensors_write_reals(nrels, buffer, lenp, results, mag); 
    404                 if (res) 
    405                         return res; 
    406                 filp->f_pos += *lenp; 
    407                 return 0; 
    408         } 
    409 } 
    410  
    411 /* This function is equivalent to sensors_proc_real, only it interacts with 
    412    the sysctl(2) syscall, and returns no reals, but integers */ 
    413 int sensors_sysctl_real(ctl_table * table, int *name, int nlen, 
    414                         void *oldval, size_t * oldlenp, void *newval, 
    415                         size_t newlen, void **context) 
    416 { 
    417         long results[MAX_RESULTS]; 
    418         int oldlen, nrels = MAX_RESULTS,ret=0; 
    419         sensors_real_callback callback = table->extra1; 
    420         struct i2c_client *client = table->extra2; 
    421  
    422         /* Check if we need to output the old values */ 
    423         if (oldval && oldlenp && !((ret=get_user(oldlen, oldlenp))) && oldlen) { 
    424                 callback(client, SENSORS_PROC_REAL_READ, table->ctl_name, 
    425                          &nrels, results); 
    426  
    427                 /* Note the rounding factor! */ 
    428                 if (nrels * sizeof(long) < oldlen) 
    429                         oldlen = nrels * sizeof(long); 
    430                 oldlen = (oldlen / sizeof(long)) * sizeof(long); 
    431                 if(copy_to_user(oldval, results, oldlen)) 
    432                         return -EFAULT; 
    433                 if(put_user(oldlen, oldlenp)) 
    434                         return -EFAULT; 
    435         } 
    436  
    437         if (newval && newlen) { 
    438                 /* Note the rounding factor! */ 
    439                 newlen -= newlen % sizeof(long); 
    440                 nrels = newlen / sizeof(long); 
    441                 if(copy_from_user(results, newval, newlen)) 
    442                         return -EFAULT; 
    443  
    444                 /* Get the new values back to the client */ 
    445                 callback(client, SENSORS_PROC_REAL_WRITE, table->ctl_name, 
    446                          &nrels, results); 
    447         } 
    448         return ret; 
    449 } 
    450  
    451  
    452 /* nrels contains initially the maximum number of elements which can be 
    453    put in results, and finally the number of elements actually put there. 
    454    A magnitude of 1 will multiply everything with 10; etc. 
    455    buffer, bufsize is the character buffer we read from and its length. 
    456    results will finally contain the parsed integers.  
    457  
    458    Buffer should contain several reals, separated by whitespace. A real 
    459    has the following syntax: 
    460      [ Minus ] Digit* [ Dot Digit* ]  
    461    (everything between [] is optional; * means zero or more). 
    462    When the next character is unparsable, everything is skipped until the 
    463    next whitespace. 
    464  
    465    WARNING! This is tricky code. I have tested it, but there may still be 
    466             hidden bugs in it, even leading to crashes and things! 
    467 */ 
    468 int sensors_parse_reals(int *nrels, void *buffer, int bufsize, 
    469                          long *results, int magnitude) 
    470 { 
    471         int maxels, min, mag; 
    472         long res,ret=0; 
    473         char nextchar = 0; 
    474  
    475         maxels = *nrels; 
    476         *nrels = 0; 
    477  
    478         while (bufsize && (*nrels < maxels)) { 
    479  
    480                 /* Skip spaces at the start */ 
    481                 while (bufsize &&  
    482                        !((ret=get_user(nextchar, (char *) buffer))) && 
    483                        isspace((int) nextchar)) { 
    484                         bufsize--; 
    485                         ((char *) buffer)++; 
    486                 } 
    487  
    488                 if (ret) 
    489                         return -EFAULT;  
    490                 /* Well, we may be done now */ 
    491                 if (!bufsize) 
    492                         return 0; 
    493  
    494                 /* New defaults for our result */ 
    495                 min = 0; 
    496                 res = 0; 
    497                 mag = magnitude; 
    498  
    499                 /* Check for a minus */ 
    500                 if (!((ret=get_user(nextchar, (char *) buffer))) 
    501                     && (nextchar == '-')) { 
    502                         min = 1; 
    503                         bufsize--; 
    504                         ((char *) buffer)++; 
    505                 } 
    506                 if (ret) 
    507                         return -EFAULT; 
    508  
    509                 /* Digits before a decimal dot */ 
    510                 while (bufsize &&  
    511                        !((ret=get_user(nextchar, (char *) buffer))) && 
    512                        isdigit((int) nextchar)) { 
    513                         res = res * 10 + nextchar - '0'; 
    514                         bufsize--; 
    515                         ((char *) buffer)++; 
    516                 } 
    517                 if (ret) 
    518                         return -EFAULT; 
    519  
    520                 /* If mag < 0, we must actually divide here! */ 
    521                 while (mag < 0) { 
    522                         res = res / 10; 
    523                         mag++; 
    524                 } 
    525  
    526                 if (bufsize && (nextchar == '.')) { 
    527                         /* Skip the dot */ 
    528                         bufsize--; 
    529                         ((char *) buffer)++; 
    530  
    531                         /* Read digits while they are significant */ 
    532                         while (bufsize && (mag > 0) && 
    533                                !((ret=get_user(nextchar, (char *) buffer))) && 
    534                                isdigit((int) nextchar)) { 
    535                                 res = res * 10 + nextchar - '0'; 
    536                                 mag--; 
    537                                 bufsize--; 
    538                                 ((char *) buffer)++; 
    539                         } 
    540                         if (ret) 
    541                                 return -EFAULT; 
    542                 } 
    543                 /* If we are out of data, but mag > 0, we need to scale here */ 
    544                 while (mag > 0) { 
    545                         res = res * 10; 
    546                         mag--; 
    547                 } 
    548  
    549                 /* Skip everything until we hit whitespace */ 
    550                 while (bufsize &&  
    551                        !((ret=get_user(nextchar, (char *) buffer))) && 
    552                        isspace((int) nextchar)) { 
    553                         bufsize--; 
    554                         ((char *) buffer)++; 
    555                 } 
    556                 if (ret) 
    557                         return -EFAULT; 
    558  
    559                 /* Put res in results */ 
    560                 results[*nrels] = (min ? -1 : 1) * res; 
    561                 (*nrels)++; 
    562         } 
    563  
    564         /* Well, there may be more in the buffer, but we need no more data.  
    565            Ignore anything that is left. */ 
    566         return 0; 
    567 } 
    568  
    569 int sensors_write_reals(int nrels, void *buffer, int *bufsize, 
    570                          long *results, int magnitude) 
    571 { 
    572 #define BUFLEN 20 
    573         char BUF[BUFLEN + 1];   /* An individual representation should fit! */ 
    574         char printfstr[10]; 
    575         int nr = 0; 
    576         int buflen, mag, times; 
    577         int curbufsize = 0; 
    578  
    579         while ((nr < nrels) && (curbufsize < *bufsize)) { 
    580                 mag = magnitude; 
    581  
    582                 if (nr != 0) { 
    583                         if(put_user(' ', (char *) buffer)) 
    584                                 return -EFAULT; 
    585                         curbufsize++; 
    586                         ((char *) buffer)++; 
    587                 } 
    588  
    589                 /* Fill BUF with the representation of the next string */ 
    590                 if (mag <= 0) { 
    591                         buflen = sprintf(BUF, "%ld", results[nr]); 
    592                         if (buflen < 0) {       /* Oops, a sprintf error! */ 
    593                                 *bufsize = 0; 
    594                                 return -EINVAL; 
    595                         } 
    596                         while ((mag < 0) && (buflen < BUFLEN)) { 
    597                                 BUF[buflen++] = '0'; 
    598                                 mag++; 
    599                         } 
    600                         BUF[buflen] = 0; 
    601                 } else { 
    602                         times = 1; 
    603                         for (times = 1; mag-- > 0; times *= 10); 
    604                         if (results[nr] < 0) { 
    605                                 BUF[0] = '-'; 
    606                                 buflen = 1; 
    607                         } else 
    608                                 buflen = 0; 
    609                         strcpy(printfstr, "%ld.%0Xld"); 
    610                         printfstr[6] = magnitude + '0'; 
    611                         buflen += 
    612                             sprintf(BUF + buflen, printfstr, 
    613                                     abs(results[nr]) / times, 
    614                                     abs(results[nr]) % times); 
    615                         if (buflen < 0) {       /* Oops, a sprintf error! */ 
    616                                 *bufsize = 0; 
    617                                 return -EINVAL; 
    618                         } 
    619                 } 
    620  
    621                 /* Now copy it to the user-space buffer */ 
    622                 if (buflen + curbufsize > *bufsize) 
    623                         buflen = *bufsize - curbufsize; 
    624                 if(copy_to_user(buffer, BUF, buflen)) 
    625                         return -EFAULT; 
    626                 curbufsize += buflen; 
    627                 (char *) buffer += buflen; 
    628  
    629                 nr++; 
    630         } 
    631         if (curbufsize < *bufsize) { 
    632                 if(put_user('\n', (char *) buffer)) 
    633                         return -EFAULT; 
    634                 curbufsize++; 
    635         } 
    636         *bufsize = curbufsize; 
    637         return 0; 
    638 } 
    639  
    640  
    641 /* Very inefficient for ISA detects, and won't work for 10-bit addresses! */ 
    642 int sensors_detect(struct i2c_adapter *adapter, 
    643                    struct sensors_address_data *address_data, 
    644                    sensors_found_addr_proc * found_proc) 
    645 { 
    646         int addr, i, found, j, err; 
    647         struct sensors_force_data *this_force; 
    648         int is_isa = i2c_is_isa_adapter(adapter); 
    649         int adapter_id = 
    650             is_isa ? SENSORS_ISA_BUS : i2c_adapter_id(adapter); 
    651  
    652         /* Forget it if we can't probe using SMBUS_QUICK */ 
    653         if ((!is_isa) 
    654             && !i2c_check_functionality(adapter, 
    655                                         I2C_FUNC_SMBUS_QUICK)) return -1; 
    656  
    657         for (addr = 0x00; addr <= (is_isa ? 0xffff : 0x7f); addr++) { 
    658                 if ((is_isa && check_region(addr, 1)) || 
    659                     (!is_isa && i2c_check_addr(adapter, addr))) 
    660                         continue; 
    661  
    662                 /* If it is in one of the force entries, we don't do any detection 
    663                    at all */ 
    664                 found = 0; 
    665                 for (i = 0; 
    666                      !found 
    667                      && (this_force = 
    668                          address_data->forces + i, this_force->force); i++) { 
    669                         for (j = 0; 
    670                              !found 
    671                              && (this_force->force[j] != SENSORS_I2C_END); 
    672                              j += 2) { 
    673                                 if ( 
    674                                     ((adapter_id == this_force->force[j]) 
    675                                      || 
    676                                      ((this_force-> 
    677                                        force[j] == SENSORS_ANY_I2C_BUS) 
    678                                       && !is_isa)) 
    679                                     && (addr == this_force->force[j + 1])) { 
    680 #ifdef DEBUG 
    681                                         printk 
    682                                             ("sensors.o: found force parameter for adapter %d, addr %04x\n", 
    683                                              adapter_id, addr); 
    684 #endif 
    685                                         if ( 
    686                                             (err = 
    687                                              found_proc(adapter, addr, 0, 
    688                                                         this_force-> 
    689                                                         kind))) return err; 
    690                                         found = 1; 
    691                                 } 
    692                         } 
    693                 } 
    694                 if (found) 
    695                         continue; 
    696  
    697                 /* If this address is in one of the ignores, we can forget about it 
    698                    right now */ 
    699                 for (i = 0; 
    700                      !found 
    701                      && (address_data->ignore[i] != SENSORS_I2C_END); 
    702                      i += 2) { 
    703                         if ( 
    704                             ((adapter_id == address_data->ignore[i]) 
    705                              || 
    706                              ((address_data-> 
    707                                ignore[i] == SENSORS_ANY_I2C_BUS) 
    708                               && !is_isa)) 
    709                             && (addr == address_data->ignore[i + 1])) { 
    710 #ifdef DEBUG 
    711                                 printk 
    712                                     ("sensors.o: found ignore parameter for adapter %d, " 
    713                                      "addr %04x\n", adapter_id, addr); 
    714 #endif 
    715                                 found = 1; 
    716                         } 
    717                 } 
    718                 for (i = 0; 
    719                      !found 
    720                      && (address_data->ignore_range[i] != SENSORS_I2C_END); 
    721                      i += 3) { 
    722                         if ( 
    723                             ((adapter_id == address_data->ignore_range[i]) 
    724                              || 
    725                              ((address_data-> 
    726                                ignore_range[i] == 
    727                                SENSORS_ANY_I2C_BUS) & !is_isa)) 
    728                             && (addr >= address_data->ignore_range[i + 1]) 
    729                             && (addr <= address_data->ignore_range[i + 2])) { 
    730 #ifdef DEBUG 
    731                                 printk 
    732                                     ("sensors.o: found ignore_range parameter for adapter %d, " 
    733                                      "addr %04x\n", adapter_id, addr); 
    734 #endif 
    735                                 found = 1; 
    736                         } 
    737                 } 
    738                 if (found) 
    739                         continue; 
    740  
    741                 /* Now, we will do a detection, but only if it is in the normal or  
    742                    probe entries */ 
    743                 if (is_isa) { 
    744                         for (i = 0; 
    745                              !found 
    746                              && (address_data->normal_isa[i] != 
    747                                  SENSORS_ISA_END); i += 1) { 
    748                                 if (addr == address_data->normal_isa[i]) { 
    749 #ifdef DEBUG 
    750                                         printk 
    751                                             ("sensors.o: found normal isa entry for adapter %d, " 
    752                                              "addr %04x\n", adapter_id, 
    753                                              addr); 
    754 #endif 
    755                                         found = 1; 
    756                                 } 
    757                         } 
    758                         for (i = 0; 
    759                              !found 
    760                              && (address_data->normal_isa_range[i] != 
    761                                  SENSORS_ISA_END); i += 3) { 
    762                                 if ( 
    763                                     (addr >= 
    764                                      address_data->normal_isa_range[i]) 
    765                                     && (addr <= 
    766                                         address_data->normal_isa_range[i + 
    767                                                                        1]) 
    768                                     && 
    769                                     ((addr 
    770                                       - 
    771                                       address_data->normal_isa_range[i]) % 
    772                                      address_data->normal_isa_range[i + 
    773                                                                     2] == 
    774                                      0)) { 
    775 #ifdef DEBUG 
    776                                         printk 
    777                                             ("sensors.o: found normal isa_range entry for adapter %d, " 
    778                                              "addr %04x", adapter_id, 
    779                                              addr); 
    780 #endif 
    781                                         found = 1; 
    782                                 } 
    783                         } 
    784                 } else { 
    785                         for (i = 0; 
    786                              !found 
    787                              && (address_data->normal_i2c[i] != 
    788                                  SENSORS_I2C_END); i += 1) { 
    789                                 if (addr == address_data->normal_i2c[i]) { 
    790                                         found = 1; 
    791 #ifdef DEBUG 
    792                                         printk 
    793                                             ("sensors.o: found normal i2c entry for adapter %d, " 
    794                                              "addr %02x", adapter_id, 
    795                                              addr); 
    796 #endif 
    797                                 } 
    798                         } 
    799                         for (i = 0; 
    800                              !found 
    801                              && (address_data->normal_i2c_range[i] != 
    802                                  SENSORS_I2C_END); i += 2) { 
    803                                 if ( 
    804                                     (addr >= 
    805                                      address_data->normal_i2c_range[i]) 
    806                                     && (addr <= 
    807                                         address_data->normal_i2c_range[i + 
    808                                                                        1])) 
    809                                 { 
    810 #ifdef DEBUG 
    811                                         printk 
    812                                             ("sensors.o: found normal i2c_range entry for adapter %d, " 
    813                                              "addr %04x\n", adapter_id, 
    814                                              addr); 
    815 #endif 
    816                                         found = 1; 
    817                                 } 
    818                         } 
    819                 } 
    820  
    821                 for (i = 0; 
    822                      !found && (address_data->probe[i] != SENSORS_I2C_END); 
    823                      i += 2) { 
    824                         if (((adapter_id == address_data->probe[i]) || 
    825                              ((address_data-> 
    826                                probe[i] == SENSORS_ANY_I2C_BUS) & !is_isa)) 
    827                             && (addr == address_data->probe[i + 1])) { 
    828 #ifdef DEBUG 
    829                                 printk 
    830                                     ("sensors.o: found probe parameter for adapter %d, " 
    831                                      "addr %04x\n", adapter_id, addr); 
    832 #endif 
    833                                 found = 1; 
    834                         } 
    835                 } 
    836                 for (i = 0; 
    837                      !found 
    838                      && (address_data->probe_range[i] != SENSORS_I2C_END); 
    839                      i += 3) { 
    840                         if ( 
    841                             ((adapter_id == address_data->probe_range[i]) 
    842                              || 
    843                              ((address_data-> 
    844                                probe_range[i] == 
    845                                SENSORS_ANY_I2C_BUS) & !is_isa)) 
    846                             && (addr >= address_data->probe_range[i + 1]) 
    847                             && (addr <= address_data->probe_range[i + 2])) { 
    848                                 found = 1; 
    849 #ifdef DEBUG 
    850                                 printk 
    851                                     ("sensors.o: found probe_range parameter for adapter %d, " 
    852                                      "addr %04x\n", adapter_id, addr); 
    853 #endif 
    854                         } 
    855                 } 
    856                 if (!found) 
    857                         continue; 
    858  
    859                 /* OK, so we really should examine this address. First check 
    860                    whether there is some client here at all! */ 
    861                 if (is_isa || 
    862                     (i2c_smbus_xfer 
    863                      (adapter, addr, 0, 0, 0, I2C_SMBUS_QUICK, NULL) >= 0)) 
    864                         if ((err = found_proc(adapter, addr, 0, -1))) 
    865                                 return err; 
    866         } 
    867         return 0; 
    868 } 
    869  
    870 int __init sensors_init(void) 
    871 { 
    872         printk("sensors.o version %s (%s)\n", LM_VERSION, LM_DATE); 
    873         sensors_initialized = 0; 
    874         if (! 
    875             (sensors_proc_header = 
    876              register_sysctl_table(sensors_proc, 0))) return -ENOMEM; 
    877 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,1)) 
    878         sensors_proc_header->ctl_table->child->de->owner = THIS_MODULE; 
    879 #else 
    880         sensors_proc_header->ctl_table->child->de->fill_inode = 
    881             &sensors_fill_inode; 
    882 #endif                          /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,1)) */ 
    883         sensors_initialized++; 
    884         return 0; 
    885 } 
    886  
    887 EXPORT_SYMBOL(sensors_deregister_entry); 
    888 EXPORT_SYMBOL(sensors_detect); 
    889 EXPORT_SYMBOL(sensors_proc_real); 
    890 EXPORT_SYMBOL(sensors_register_entry); 
    891 EXPORT_SYMBOL(sensors_sysctl_real); 
    89227 
    89328#ifdef MODULE 
    89429 
    895 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"); 
    896 MODULE_DESCRIPTION("LM78 driver"); 
    897  
    898 int sensors_cleanup(void) 
    899 { 
    900         if (sensors_initialized >= 1) { 
    901                 unregister_sysctl_table(sensors_proc_header); 
    902                 sensors_initialized--; 
    903         } 
    904         return 0; 
    905 } 
    90630 
    90731int init_module(void) 
    90832{ 
    909         return sensors_init(); 
     33        return 0; 
    91034} 
    91135 
    91236int cleanup_module(void) 
    91337{ 
    914         return sensors_cleanup(); 
     38        return 0; 
    91539} 
    91640 
     
    93963#endif 
    94064#ifdef CONFIG_SENSORS_GL520SM 
    941 extern int sensors_gl520sm_init(void); 
     65extern int sensors_gl520_init(void); 
    94266#endif 
    94367#ifdef CONFIG_SENSORS_LM75 
     
    1000124#endif 
    1001125#ifdef CONFIG_SENSORS_GL520SM 
    1002         sensors_gl520sm_init(); 
     126        sensors_gl520_init(); 
    1003127#endif 
    1004128#ifdef CONFIG_SENSORS_LM75