Changeset 3541

Show
Ignore:
Timestamp:
05/28/01 00:40:53 (14 years ago)
Author:
mds
Message:

change sensors_* to i2c_* with the exception of sensors_init

because there's already a i2c_init().

Location:
i2c/trunk/kernel
Files:
2 modified

Legend:

Unmodified
Added
Removed
  • i2c/trunk/kernel/i2c-proc.c

    r3540 r3541  
    4747#endif 
    4848 
    49 static int sensors_create_name(char **name, const char *prefix, 
     49static int i2c_create_name(char **name, const char *prefix, 
    5050                               struct i2c_adapter *adapter, int addr); 
    51 static int sensors_parse_reals(int *nrels, void *buffer, int bufsize, 
     51static int i2c_parse_reals(int *nrels, void *buffer, int bufsize, 
    5252                               long *results, int magnitude); 
    53 static int sensors_write_reals(int nrels, void *buffer, int *bufsize, 
     53static int i2c_write_reals(int nrels, void *buffer, int *bufsize, 
    5454                               long *results, int magnitude); 
    55 static int sensors_proc_chips(ctl_table * ctl, int write, 
     55static int i2c_proc_chips(ctl_table * ctl, int write, 
    5656                              struct file *filp, void *buffer, 
    5757                              size_t * lenp); 
    58 static int sensors_sysctl_chips(ctl_table * table, int *name, int nlen, 
     58static int i2c_sysctl_chips(ctl_table * table, int *name, int nlen, 
    5959                                void *oldval, size_t * oldlenp, 
    6060                                void *newval, size_t newlen, 
     
    6464 
    6565#define SENSORS_ENTRY_MAX 20 
    66 static struct ctl_table_header *sensors_entries[SENSORS_ENTRY_MAX]; 
    67  
    68 static struct i2c_client *sensors_clients[SENSORS_ENTRY_MAX]; 
    69 static unsigned short sensors_inodes[SENSORS_ENTRY_MAX]; 
     66static struct ctl_table_header *i2c_entries[SENSORS_ENTRY_MAX]; 
     67 
     68static struct i2c_client *i2c_clients[SENSORS_ENTRY_MAX]; 
     69static unsigned short i2c_inodes[SENSORS_ENTRY_MAX]; 
    7070#if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,1) 
    71 static void sensors_fill_inode(struct inode *inode, int fill); 
    72 static void sensors_dir_fill_inode(struct inode *inode, int fill); 
     71static void i2c_fill_inode(struct inode *inode, int fill); 
     72static void i2c_dir_fill_inode(struct inode *inode, int fill); 
    7373#endif                  /* LINUX_VERSION_CODE < KERNEL_VERSION(2,3,1) */ 
    7474 
     
    8282}; 
    8383 
    84 static ctl_table sensors_proc_dev_sensors[] = { 
    85         {SENSORS_CHIPS, "chips", NULL, 0, 0644, NULL, &sensors_proc_chips, 
    86          &sensors_sysctl_chips}, 
     84static ctl_table i2c_proc_dev_sensors[] = { 
     85        {SENSORS_CHIPS, "chips", NULL, 0, 0644, NULL, &i2c_proc_chips, 
     86         &i2c_sysctl_chips}, 
    8787        {0} 
    8888}; 
    8989 
    90 static ctl_table sensors_proc_dev[] = { 
    91         {DEV_SENSORS, "sensors", NULL, 0, 0555, sensors_proc_dev_sensors}, 
     90static ctl_table i2c_proc_dev[] = { 
     91        {DEV_SENSORS, "sensors", NULL, 0, 0555, i2c_proc_dev_sensors}, 
    9292        {0}, 
    9393}; 
    9494 
    9595 
    96 static ctl_table sensors_proc[] = { 
    97         {CTL_DEV, "dev", NULL, 0, 0555, sensors_proc_dev}, 
     96static ctl_table i2c_proc[] = { 
     97        {CTL_DEV, "dev", NULL, 0, 0555, i2c_proc_dev}, 
    9898        {0} 
    9999}; 
    100100 
    101101 
    102 static struct ctl_table_header *sensors_proc_header; 
    103 static int sensors_initialized; 
     102static struct ctl_table_header *i2c_proc_header; 
     103static int i2c_initialized; 
    104104 
    105105/* This returns a nice name for a new directory; for example lm78-isa-0310 
     
    107107   a LM75 chip on the third i2c bus at address 0x4e).   
    108108   name is allocated first. */ 
    109 int sensors_create_name(char **name, const char *prefix, 
     109int i2c_create_name(char **name, const char *prefix, 
    110110                        struct i2c_adapter *adapter, int addr) 
    111111{ 
     
    135135   kernels before 2.3.13; define it to NULL in that case. We will not use it 
    136136   for anything older than 2.3.27 anyway. */ 
    137 int sensors_register_entry(struct i2c_client *client, const char *prefix, 
     137int i2c_register_entry(struct i2c_client *client, const char *prefix, 
    138138                           ctl_table * ctl_template, 
    139139                           struct module *controlling_mod) 
     
    144144        struct ctl_table_header *new_header; 
    145145 
    146         if ((res = sensors_create_name(&name, prefix, client->adapter, 
     146        if ((res = i2c_create_name(&name, prefix, client->adapter, 
    147147                                       client->addr))) return res; 
    148148 
    149149        for (id = 0; id < SENSORS_ENTRY_MAX; id++) 
    150                 if (!sensors_entries[id]) { 
     150                if (!i2c_entries[id]) { 
    151151                        break; 
    152152                } 
     
    182182        } 
    183183 
    184         sensors_entries[id - 256] = new_header; 
    185  
    186         sensors_clients[id - 256] = client; 
     184        i2c_entries[id - 256] = new_header; 
     185 
     186        i2c_clients[id - 256] = client; 
    187187#ifdef DEBUG 
    188188        if (!new_header || !new_header->ctl_table || 
     
    195195        } 
    196196#endif                          /* DEBUG */ 
    197         sensors_inodes[id - 256] = 
     197        i2c_inodes[id - 256] = 
    198198            new_header->ctl_table->child->child->de->low_ino; 
    199199#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,27)) 
     
    201201#else 
    202202        new_header->ctl_table->child->child->de->fill_inode = 
    203             &sensors_dir_fill_inode; 
     203            &i2c_dir_fill_inode; 
    204204#endif  /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,27)) */ 
    205205 
     
    207207} 
    208208 
    209 void sensors_deregister_entry(int id) 
     209void i2c_deregister_entry(int id) 
    210210{ 
    211211        ctl_table *table; 
    212212        char *temp; 
    213213        id -= 256; 
    214         if (sensors_entries[id]) { 
    215                 table = sensors_entries[id]->ctl_table; 
    216                 unregister_sysctl_table(sensors_entries[id]); 
     214        if (i2c_entries[id]) { 
     215                table = i2c_entries[id]->ctl_table; 
     216                unregister_sysctl_table(i2c_entries[id]); 
    217217                /* 2-step kfree needed to keep gcc happy about const points */ 
    218218                (const char *) temp = table[4].procname; 
    219219                kfree(temp); 
    220220                kfree(table); 
    221                 sensors_entries[id] = NULL; 
    222                 sensors_clients[id] = NULL; 
     221                i2c_entries[id] = NULL; 
     222                i2c_clients[id] = NULL; 
    223223        } 
    224224} 
     
    226226/* Monitor access for /proc/sys/dev/sensors; make unloading i2c-proc.o  
    227227   impossible if some process still uses it or some file in it */ 
    228 void sensors_fill_inode(struct inode *inode, int fill) 
     228void i2c_fill_inode(struct inode *inode, int fill) 
    229229{ 
    230230        if (fill) 
     
    237237   the corresponding module impossible if some process still uses it or 
    238238   some file in it */ 
    239 void sensors_dir_fill_inode(struct inode *inode, int fill) 
     239void i2c_dir_fill_inode(struct inode *inode, int fill) 
    240240{ 
    241241        int i; 
     
    250250 
    251251        for (i = 0; i < SENSORS_ENTRY_MAX; i++) 
    252                 if (sensors_clients[i] 
    253                     && (sensors_inodes[i] == inode->i_ino)) break; 
     252                if (i2c_clients[i] 
     253                    && (i2c_inodes[i] == inode->i_ino)) break; 
    254254#ifdef DEBUG 
    255255        if (i == SENSORS_ENTRY_MAX) { 
     
    260260        } 
    261261#endif                          /* def DEBUG */ 
    262         client = sensors_clients[i]; 
     262        client = i2c_clients[i]; 
    263263        if (fill) 
    264264                client->driver->inc_use(client); 
     
    267267} 
    268268 
    269 int sensors_proc_chips(ctl_table * ctl, int write, struct file *filp, 
     269int i2c_proc_chips(ctl_table * ctl, int write, struct file *filp, 
    270270                       void *buffer, size_t * lenp) 
    271271{ 
     
    287287        curbufsize = 0; 
    288288        for (i = 0; i < SENSORS_ENTRY_MAX; i++) 
    289                 if (sensors_entries[i]) { 
     289                if (i2c_entries[i]) { 
    290290                        client_tbl = 
    291                             sensors_entries[i]->ctl_table->child->child; 
     291                            i2c_entries[i]->ctl_table->child->child; 
    292292                        buflen = 
    293293                            sprintf(BUF, "%d\t%s\n", client_tbl->ctl_name, 
     
    305305} 
    306306 
    307 int sensors_sysctl_chips(ctl_table * table, int *name, int nlen, 
     307int i2c_sysctl_chips(ctl_table * table, int *name, int nlen, 
    308308                         void *oldval, size_t * oldlenp, void *newval, 
    309309                         size_t newlen, void **context) 
    310310{ 
    311         struct sensors_chips_data data; 
     311        struct i2c_chips_data data; 
    312312        int i, oldlen, nrels, maxels,ret=0; 
    313313        struct ctl_table *client_tbl; 
     
    315315        if (oldval && oldlenp && !((ret = get_user(oldlen, oldlenp))) &&  
    316316            oldlen) { 
    317                 maxels = oldlen / sizeof(struct sensors_chips_data); 
     317                maxels = oldlen / sizeof(struct i2c_chips_data); 
    318318                nrels = 0; 
    319319                for (i = 0; (i < SENSORS_ENTRY_MAX) && (nrels < maxels); 
    320320                     i++) 
    321                         if (sensors_entries[i]) { 
     321                        if (i2c_entries[i]) { 
    322322                                client_tbl = 
    323                                     sensors_entries[i]->ctl_table->child-> 
     323                                    i2c_entries[i]->ctl_table->child-> 
    324324                                    child; 
    325325                                data.sysctl_id = client_tbl->ctl_name; 
     
    327327                                if(copy_to_user(oldval, &data, 
    328328                                             sizeof(struct 
    329                                                     sensors_chips_data))) 
     329                                                    i2c_chips_data))) 
    330330                                        return -EFAULT; 
    331331                                (char *) oldval += 
    332                                     sizeof(struct sensors_chips_data); 
     332                                    sizeof(struct i2c_chips_data); 
    333333                                nrels++; 
    334334                        } 
    335                 oldlen = nrels * sizeof(struct sensors_chips_data); 
     335                oldlen = nrels * sizeof(struct i2c_chips_data); 
    336336                if(put_user(oldlen, oldlenp)) 
    337337                        return -EFAULT; 
     
    358358   In all cases, client points to the client we wish to interact with, 
    359359   and ctl_name is the SYSCTL id of the file we are accessing. */ 
    360 int sensors_proc_real(ctl_table * ctl, int write, struct file *filp, 
     360int i2c_proc_real(ctl_table * ctl, int write, struct file *filp, 
    361361                      void *buffer, size_t * lenp) 
    362362{ 
     
    364364        int mag, nrels = MAX_RESULTS; 
    365365        long results[MAX_RESULTS]; 
    366         sensors_real_callback callback = ctl->extra1; 
     366        i2c_real_callback callback = ctl->extra1; 
    367367        struct i2c_client *client = ctl->extra2; 
    368368        int res; 
     
    383383        if (write) { 
    384384                /* Read the complete input into results, converting to longs */ 
    385                 res = sensors_parse_reals(&nrels, buffer, *lenp, results, mag); 
     385                res = i2c_parse_reals(&nrels, buffer, *lenp, results, mag); 
    386386                if (res) 
    387387                        return res; 
     
    402402 
    403403                /* And write them to buffer, converting to reals */ 
    404                 res = sensors_write_reals(nrels, buffer, lenp, results, mag); 
     404                res = i2c_write_reals(nrels, buffer, lenp, results, mag); 
    405405                if (res) 
    406406                        return res; 
     
    410410} 
    411411 
    412 /* This function is equivalent to sensors_proc_real, only it interacts with 
     412/* This function is equivalent to i2c_proc_real, only it interacts with 
    413413   the sysctl(2) syscall, and returns no reals, but integers */ 
    414 int sensors_sysctl_real(ctl_table * table, int *name, int nlen, 
     414int i2c_sysctl_real(ctl_table * table, int *name, int nlen, 
    415415                        void *oldval, size_t * oldlenp, void *newval, 
    416416                        size_t newlen, void **context) 
     
    418418        long results[MAX_RESULTS]; 
    419419        int oldlen, nrels = MAX_RESULTS,ret=0; 
    420         sensors_real_callback callback = table->extra1; 
     420        i2c_real_callback callback = table->extra1; 
    421421        struct i2c_client *client = table->extra2; 
    422422 
     
    467467            hidden bugs in it, even leading to crashes and things! 
    468468*/ 
    469 int sensors_parse_reals(int *nrels, void *buffer, int bufsize, 
     469int i2c_parse_reals(int *nrels, void *buffer, int bufsize, 
    470470                         long *results, int magnitude) 
    471471{ 
     
    568568} 
    569569 
    570 int sensors_write_reals(int nrels, void *buffer, int *bufsize, 
     570int i2c_write_reals(int nrels, void *buffer, int *bufsize, 
    571571                         long *results, int magnitude) 
    572572{ 
     
    641641 
    642642/* Very inefficient for ISA detects, and won't work for 10-bit addresses! */ 
    643 int sensors_detect(struct i2c_adapter *adapter, 
    644                    struct sensors_address_data *address_data, 
    645                    sensors_found_addr_proc * found_proc) 
     643int i2c_detect(struct i2c_adapter *adapter, 
     644                   struct i2c_address_data *address_data, 
     645                   i2c_found_addr_proc * found_proc) 
    646646{ 
    647647        int addr, i, found, j, err; 
    648         struct sensors_force_data *this_force; 
     648        struct i2c_force_data *this_force; 
    649649        int is_isa = i2c_is_isa_adapter(adapter); 
    650650        int adapter_id = 
     
    860860{ 
    861861        printk("i2c-proc.o version %s (%s)\n", LM_VERSION, LM_DATE); 
    862         sensors_initialized = 0; 
     862        i2c_initialized = 0; 
    863863        if (! 
    864             (sensors_proc_header = 
    865              register_sysctl_table(sensors_proc, 0))) return -ENOMEM; 
     864            (i2c_proc_header = 
     865             register_sysctl_table(i2c_proc, 0))) return -ENOMEM; 
    866866#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,1)) 
    867         sensors_proc_header->ctl_table->child->de->owner = THIS_MODULE; 
     867        i2c_proc_header->ctl_table->child->de->owner = THIS_MODULE; 
    868868#else 
    869         sensors_proc_header->ctl_table->child->de->fill_inode = 
    870             &sensors_fill_inode; 
     869        i2c_proc_header->ctl_table->child->de->fill_inode = 
     870            &i2c_fill_inode; 
    871871#endif                  /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,1)) */ 
    872         sensors_initialized++; 
     872        i2c_initialized++; 
    873873        return 0; 
    874874} 
    875875 
    876 EXPORT_SYMBOL(sensors_deregister_entry); 
    877 EXPORT_SYMBOL(sensors_detect); 
    878 EXPORT_SYMBOL(sensors_proc_real); 
    879 EXPORT_SYMBOL(sensors_register_entry); 
    880 EXPORT_SYMBOL(sensors_sysctl_real); 
     876EXPORT_SYMBOL(i2c_deregister_entry); 
     877EXPORT_SYMBOL(i2c_detect); 
     878EXPORT_SYMBOL(i2c_proc_real); 
     879EXPORT_SYMBOL(i2c_register_entry); 
     880EXPORT_SYMBOL(i2c_sysctl_real); 
    881881 
    882882#ifdef MODULE 
     
    885885MODULE_DESCRIPTION("i2c-proc driver"); 
    886886 
    887 int sensors_cleanup(void) 
    888 { 
    889         if (sensors_initialized >= 1) { 
    890                 unregister_sysctl_table(sensors_proc_header); 
    891                 sensors_initialized--; 
     887int i2c_cleanup(void) 
     888{ 
     889        if (i2c_initialized >= 1) { 
     890                unregister_sysctl_table(i2c_proc_header); 
     891                i2c_initialized--; 
    892892        } 
    893893        return 0; 
     
    901901int cleanup_module(void) 
    902902{ 
    903         return sensors_cleanup(); 
     903        return i2c_cleanup(); 
    904904} 
    905905 
  • i2c/trunk/kernel/i2c-proc.h

    r3527 r3541  
    3030 
    3131/* The type of callback functions used in sensors_{proc,sysctl}_real */ 
    32 typedef void (*sensors_real_callback) (struct i2c_client * client, 
     32typedef void (*i2c_real_callback) (struct i2c_client * client, 
    3333                                       int operation, int ctl_name, 
    3434                                       int *nrels_mag, long *results); 
     
    5656   In all cases, client points to the client we wish to interact with, 
    5757   and ctl_name is the SYSCTL id of the file we are accessing. */ 
    58 extern int sensors_sysctl_real(ctl_table * table, int *name, int nlen, 
     58extern int i2c_sysctl_real(ctl_table * table, int *name, int nlen, 
    5959                               void *oldval, size_t * oldlenp, 
    6060                               void *newval, size_t newlen, 
    6161                               void **context); 
    62 extern int sensors_proc_real(ctl_table * ctl, int write, struct file *filp, 
     62extern int i2c_proc_real(ctl_table * ctl, int write, struct file *filp, 
    6363                             void *buffer, size_t * lenp); 
    6464 
     
    7272   If any driver wants subdirectories within the newly created directory, 
    7373   these functions must be updated! */ 
    74 extern int sensors_register_entry(struct i2c_client *client, 
     74extern int i2c_register_entry(struct i2c_client *client, 
    7575                                  const char *prefix, 
    7676                                  ctl_table * ctl_template, 
    7777                                  struct module *controlling_mod); 
    7878 
    79 extern void sensors_deregister_entry(int id); 
     79extern void i2c_deregister_entry(int id); 
    8080 
    8181 
     
    9292   kind: The kind of chip. 0 equals any chip. 
    9393*/ 
    94 struct sensors_force_data { 
     94struct i2c_force_data { 
    9595        unsigned short *force; 
    9696        unsigned short kind; 
     
    136136     the force field is NULL. 
    137137*/ 
    138 struct sensors_address_data { 
     138struct i2c_address_data { 
    139139        unsigned short *normal_i2c; 
    140140        unsigned short *normal_i2c_range; 
     
    145145        unsigned short *ignore; 
    146146        unsigned short *ignore_range; 
    147         struct sensors_force_data *forces; 
     147        struct i2c_force_data *forces; 
    148148}; 
    149149 
     
    210210                      "List of adapter,start-addr,end-addr triples not to " \ 
    211211                      "scan"); \ 
    212   static struct sensors_address_data addr_data = \ 
     212  static struct i2c_address_data addr_data = \ 
    213213                                       {normal_i2c, normal_i2c_range, \ 
    214214                                        normal_isa, normal_isa_range, \ 
     
    226226                      "List of adapter,address pairs to boldly assume " \ 
    227227                      "to be present"); \ 
    228   static struct sensors_force_data forces[] = {{force,any_chip},{NULL}}; \ 
     228  static struct i2c_force_data forces[] = {{force,any_chip},{NULL}}; \ 
    229229  SENSORS_INSMOD 
    230230 
     
    235235                      "to be present"); \ 
    236236  SENSORS_MODULE_PARM_FORCE(chip1); \ 
    237   static struct sensors_force_data forces[] = {{force,any_chip},\ 
     237  static struct i2c_force_data forces[] = {{force,any_chip},\ 
    238238                                                 {force_ ## chip1,chip1}, \ 
    239239                                                 {NULL}}; \ 
     
    247247  SENSORS_MODULE_PARM_FORCE(chip1); \ 
    248248  SENSORS_MODULE_PARM_FORCE(chip2); \ 
    249   static struct sensors_force_data forces[] = {{force,any_chip}, \ 
     249  static struct i2c_force_data forces[] = {{force,any_chip}, \ 
    250250                                                 {force_ ## chip1,chip1}, \ 
    251251                                                 {force_ ## chip2,chip2}, \ 
     
    261261  SENSORS_MODULE_PARM_FORCE(chip2); \ 
    262262  SENSORS_MODULE_PARM_FORCE(chip3); \ 
    263   static struct sensors_force_data forces[] = {{force,any_chip}, \ 
     263  static struct i2c_force_data forces[] = {{force,any_chip}, \ 
    264264                                                 {force_ ## chip1,chip1}, \ 
    265265                                                 {force_ ## chip2,chip2}, \ 
     
    277277  SENSORS_MODULE_PARM_FORCE(chip3); \ 
    278278  SENSORS_MODULE_PARM_FORCE(chip4); \ 
    279   static struct sensors_force_data forces[] = {{force,any_chip}, \ 
     279  static struct i2c_force_data forces[] = {{force,any_chip}, \ 
    280280                                                 {force_ ## chip1,chip1}, \ 
    281281                                                 {force_ ## chip2,chip2}, \ 
     
    295295  SENSORS_MODULE_PARM_FORCE(chip4); \ 
    296296  SENSORS_MODULE_PARM_FORCE(chip5); \ 
    297   static struct sensors_force_data forces[] = {{force,any_chip}, \ 
     297  static struct i2c_force_data forces[] = {{force,any_chip}, \ 
    298298                                                 {force_ ## chip1,chip1}, \ 
    299299                                                 {force_ ## chip2,chip2}, \ 
     
    315315  SENSORS_MODULE_PARM_FORCE(chip5); \ 
    316316  SENSORS_MODULE_PARM_FORCE(chip6); \ 
    317   static struct sensors_force_data forces[] = {{force,any_chip}, \ 
     317  static struct i2c_force_data forces[] = {{force,any_chip}, \ 
    318318                                                 {force_ ## chip1,chip1}, \ 
    319319                                                 {force_ ## chip2,chip2}, \ 
     
    337337  SENSORS_MODULE_PARM_FORCE(chip6); \ 
    338338  SENSORS_MODULE_PARM_FORCE(chip7); \ 
    339   static struct sensors_force_data forces[] = {{force,any_chip}, \ 
     339  static struct i2c_force_data forces[] = {{force,any_chip}, \ 
    340340                                                 {force_ ## chip1,chip1}, \ 
    341341                                                 {force_ ## chip2,chip2}, \ 
     
    348348  SENSORS_INSMOD 
    349349 
    350 typedef int sensors_found_addr_proc(struct i2c_adapter *adapter, 
     350typedef int i2c_found_addr_proc(struct i2c_adapter *adapter, 
    351351                                    int addr, unsigned short flags, 
    352352                                    int kind); 
    353353 
    354 /* Detect function. It itterates over all possible addresses itself. For 
     354/* Detect function. It iterates over all possible addresses itself. For 
    355355   SMBus addresses, it will only call found_proc if some client is connected 
    356356   to the SMBus (unless a 'force' matched); for ISA detections, this is not 
    357357   done. */ 
    358 extern int sensors_detect(struct i2c_adapter *adapter, 
    359                           struct sensors_address_data *address_data, 
    360                           sensors_found_addr_proc * found_proc); 
     358extern int i2c_detect(struct i2c_adapter *adapter, 
     359                          struct i2c_address_data *address_data, 
     360                          i2c_found_addr_proc * found_proc); 
    361361 
    362362 
     
    388388 
    389389#define SENSORS_CHIPS 1 
    390 struct sensors_chips_data { 
     390struct i2c_chips_data { 
    391391        int sysctl_id; 
    392392        char name[SENSORS_PREFIX_MAX + 13];