Changeset 3541

Timestamp:

05/28/01 00:40:53 (12 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:

• i2c-proc.c (modified) (31 diffs)
• i2c-proc.h (modified) (17 diffs)

i2c/trunk/kernel/i2c-proc.c

@@ -47 +47 @@
 #endif
 
-static int sensors_create_name(char **name, const char *prefix,
+static int i2c_create_name(char **name, const char *prefix,
                                struct i2c_adapter *adapter, int addr);
-static int sensors_parse_reals(int *nrels, void *buffer, int bufsize,
+static int i2c_parse_reals(int *nrels, void *buffer, int bufsize,
                                long *results, int magnitude);
-static int sensors_write_reals(int nrels, void *buffer, int *bufsize,
+static int i2c_write_reals(int nrels, void *buffer, int *bufsize,
                                long *results, int magnitude);
-static int sensors_proc_chips(ctl_table * ctl, int write,
+static int i2c_proc_chips(ctl_table * ctl, int write,
                               struct file *filp, void *buffer,
                               size_t * lenp);
-static int sensors_sysctl_chips(ctl_table * table, int *name, int nlen,
+static int i2c_sysctl_chips(ctl_table * table, int *name, int nlen,
                                 void *oldval, size_t * oldlenp,
                                 void *newval, size_t newlen,
@@ -64 +64 @@
 
 #define SENSORS_ENTRY_MAX 20
-static struct ctl_table_header *sensors_entries[SENSORS_ENTRY_MAX];
-
-static struct i2c_client *sensors_clients[SENSORS_ENTRY_MAX];
-static unsigned short sensors_inodes[SENSORS_ENTRY_MAX];
+static struct ctl_table_header *i2c_entries[SENSORS_ENTRY_MAX];
+
+static struct i2c_client *i2c_clients[SENSORS_ENTRY_MAX];
+static unsigned short i2c_inodes[SENSORS_ENTRY_MAX];
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,1)
-static void sensors_fill_inode(struct inode *inode, int fill);
-static void sensors_dir_fill_inode(struct inode *inode, int fill);
+static void i2c_fill_inode(struct inode *inode, int fill);
+static void i2c_dir_fill_inode(struct inode *inode, int fill);
 #endif                  /* LINUX_VERSION_CODE < KERNEL_VERSION(2,3,1) */
 
@@ -82 +82 @@
 };
 
-static ctl_table sensors_proc_dev_sensors[] = {
-        {SENSORS_CHIPS, "chips", NULL, 0, 0644, NULL, &sensors_proc_chips,
-         &sensors_sysctl_chips},
+static ctl_table i2c_proc_dev_sensors[] = {
+        {SENSORS_CHIPS, "chips", NULL, 0, 0644, NULL, &i2c_proc_chips,
+         &i2c_sysctl_chips},
         {0}
 };
 
-static ctl_table sensors_proc_dev[] = {
-        {DEV_SENSORS, "sensors", NULL, 0, 0555, sensors_proc_dev_sensors},
+static ctl_table i2c_proc_dev[] = {
+        {DEV_SENSORS, "sensors", NULL, 0, 0555, i2c_proc_dev_sensors},
         {0},
 };
 
 
-static ctl_table sensors_proc[] = {
-        {CTL_DEV, "dev", NULL, 0, 0555, sensors_proc_dev},
+static ctl_table i2c_proc[] = {
+        {CTL_DEV, "dev", NULL, 0, 0555, i2c_proc_dev},
         {0}
 };
 
 
-static struct ctl_table_header *sensors_proc_header;
-static int sensors_initialized;
+static struct ctl_table_header *i2c_proc_header;
+static int i2c_initialized;
 
 /* This returns a nice name for a new directory; for example lm78-isa-0310
@@ -107 +107 @@
    a LM75 chip on the third i2c bus at address 0x4e).  
    name is allocated first. */
-int sensors_create_name(char **name, const char *prefix,
+int i2c_create_name(char **name, const char *prefix,
                         struct i2c_adapter *adapter, int addr)
 {
@@ -135 +135 @@
    kernels before 2.3.13; define it to NULL in that case. We will not use it
    for anything older than 2.3.27 anyway. */
-int sensors_register_entry(struct i2c_client *client, const char *prefix,
+int i2c_register_entry(struct i2c_client *client, const char *prefix,
                            ctl_table * ctl_template,
                            struct module *controlling_mod)
@@ -144 +144 @@
         struct ctl_table_header *new_header;
 
-        if ((res = sensors_create_name(&name, prefix, client->adapter,
+        if ((res = i2c_create_name(&name, prefix, client->adapter,
                                        client->addr))) return res;
 
         for (id = 0; id < SENSORS_ENTRY_MAX; id++)
-                if (!sensors_entries[id]) {
+                if (!i2c_entries[id]) {
                         break;
                 }
@@ -182 +182 @@
         }
 
-        sensors_entries[id - 256] = new_header;
-
-        sensors_clients[id - 256] = client;
+        i2c_entries[id - 256] = new_header;
+
+        i2c_clients[id - 256] = client;
 #ifdef DEBUG
         if (!new_header || !new_header->ctl_table ||
@@ -195 +195 @@
         }
 #endif                          /* DEBUG */
-        sensors_inodes[id - 256] =
+        i2c_inodes[id - 256] =
             new_header->ctl_table->child->child->de->low_ino;
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,27))
@@ -201 +201 @@
 #else
         new_header->ctl_table->child->child->de->fill_inode =
-            &sensors_dir_fill_inode;
+            &i2c_dir_fill_inode;
 #endif  /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,27)) */
 
@@ -207 +207 @@
 }
 
-void sensors_deregister_entry(int id)
+void i2c_deregister_entry(int id)
 {
         ctl_table *table;
         char *temp;
         id -= 256;
-        if (sensors_entries[id]) {
-                table = sensors_entries[id]->ctl_table;
-                unregister_sysctl_table(sensors_entries[id]);
+        if (i2c_entries[id]) {
+                table = i2c_entries[id]->ctl_table;
+                unregister_sysctl_table(i2c_entries[id]);
                 /* 2-step kfree needed to keep gcc happy about const points */
                 (const char *) temp = table[4].procname;
                 kfree(temp);
                 kfree(table);
-                sensors_entries[id] = NULL;
-                sensors_clients[id] = NULL;
+                i2c_entries[id] = NULL;
+                i2c_clients[id] = NULL;
         }
 }
@@ -226 +226 @@
 /* Monitor access for /proc/sys/dev/sensors; make unloading i2c-proc.o 
    impossible if some process still uses it or some file in it */
-void sensors_fill_inode(struct inode *inode, int fill)
+void i2c_fill_inode(struct inode *inode, int fill)
 {
         if (fill)
@@ -237 +237 @@
    the corresponding module impossible if some process still uses it or
    some file in it */
-void sensors_dir_fill_inode(struct inode *inode, int fill)
+void i2c_dir_fill_inode(struct inode *inode, int fill)
 {
         int i;
@@ -250 +250 @@
 
         for (i = 0; i < SENSORS_ENTRY_MAX; i++)
-                if (sensors_clients[i]
-                    && (sensors_inodes[i] == inode->i_ino)) break;
+                if (i2c_clients[i]
+                    && (i2c_inodes[i] == inode->i_ino)) break;
 #ifdef DEBUG
         if (i == SENSORS_ENTRY_MAX) {
@@ -260 +260 @@
         }
 #endif                          /* def DEBUG */
-        client = sensors_clients[i];
+        client = i2c_clients[i];
         if (fill)
                 client->driver->inc_use(client);
@@ -267 +267 @@
 }
 
-int sensors_proc_chips(ctl_table * ctl, int write, struct file *filp,
+int i2c_proc_chips(ctl_table * ctl, int write, struct file *filp,
                        void *buffer, size_t * lenp)
 {
@@ -287 +287 @@
         curbufsize = 0;
         for (i = 0; i < SENSORS_ENTRY_MAX; i++)
-                if (sensors_entries[i]) {
+                if (i2c_entries[i]) {
                         client_tbl =
-                            sensors_entries[i]->ctl_table->child->child;
+                            i2c_entries[i]->ctl_table->child->child;
                         buflen =
                             sprintf(BUF, "%d\t%s\n", client_tbl->ctl_name,
@@ -305 +305 @@
 }
 
-int sensors_sysctl_chips(ctl_table * table, int *name, int nlen,
+int i2c_sysctl_chips(ctl_table * table, int *name, int nlen,
                          void *oldval, size_t * oldlenp, void *newval,
                          size_t newlen, void **context)
 {
-        struct sensors_chips_data data;
+        struct i2c_chips_data data;
         int i, oldlen, nrels, maxels,ret=0;
         struct ctl_table *client_tbl;
@@ -315 +315 @@
         if (oldval && oldlenp && !((ret = get_user(oldlen, oldlenp))) && 
             oldlen) {
-                maxels = oldlen / sizeof(struct sensors_chips_data);
+                maxels = oldlen / sizeof(struct i2c_chips_data);
                 nrels = 0;
                 for (i = 0; (i < SENSORS_ENTRY_MAX) && (nrels < maxels);
                      i++)
-                        if (sensors_entries[i]) {
+                        if (i2c_entries[i]) {
                                 client_tbl =
-                                    sensors_entries[i]->ctl_table->child->
+                                    i2c_entries[i]->ctl_table->child->
                                     child;
                                 data.sysctl_id = client_tbl->ctl_name;
@@ -327 +327 @@
                                 if(copy_to_user(oldval, &data,
                                              sizeof(struct
-                                                    sensors_chips_data)))
+                                                    i2c_chips_data)))
                                         return -EFAULT;
                                 (char *) oldval +=
-                                    sizeof(struct sensors_chips_data);
+                                    sizeof(struct i2c_chips_data);
                                 nrels++;
                         }
-                oldlen = nrels * sizeof(struct sensors_chips_data);
+                oldlen = nrels * sizeof(struct i2c_chips_data);
                 if(put_user(oldlen, oldlenp))
                         return -EFAULT;
@@ -358 +358 @@
    In all cases, client points to the client we wish to interact with,
    and ctl_name is the SYSCTL id of the file we are accessing. */
-int sensors_proc_real(ctl_table * ctl, int write, struct file *filp,
+int i2c_proc_real(ctl_table * ctl, int write, struct file *filp,
                       void *buffer, size_t * lenp)
 {
@@ -364 +364 @@
         int mag, nrels = MAX_RESULTS;
         long results[MAX_RESULTS];
-        sensors_real_callback callback = ctl->extra1;
+        i2c_real_callback callback = ctl->extra1;
         struct i2c_client *client = ctl->extra2;
         int res;
@@ -383 +383 @@
         if (write) {
                 /* Read the complete input into results, converting to longs */
-                res = sensors_parse_reals(&nrels, buffer, *lenp, results, mag);
+                res = i2c_parse_reals(&nrels, buffer, *lenp, results, mag);
                 if (res)
                         return res;
@@ -402 +402 @@
 
                 /* And write them to buffer, converting to reals */
-                res = sensors_write_reals(nrels, buffer, lenp, results, mag);
+                res = i2c_write_reals(nrels, buffer, lenp, results, mag);
                 if (res)
                         return res;
@@ -410 +410 @@
 }
 
-/* This function is equivalent to sensors_proc_real, only it interacts with
+/* This function is equivalent to i2c_proc_real, only it interacts with
    the sysctl(2) syscall, and returns no reals, but integers */
-int sensors_sysctl_real(ctl_table * table, int *name, int nlen,
+int i2c_sysctl_real(ctl_table * table, int *name, int nlen,
                         void *oldval, size_t * oldlenp, void *newval,
                         size_t newlen, void **context)
@@ -418 +418 @@
         long results[MAX_RESULTS];
         int oldlen, nrels = MAX_RESULTS,ret=0;
-        sensors_real_callback callback = table->extra1;
+        i2c_real_callback callback = table->extra1;
         struct i2c_client *client = table->extra2;
 
@@ -467 +467 @@
             hidden bugs in it, even leading to crashes and things!
 */
-int sensors_parse_reals(int *nrels, void *buffer, int bufsize,
+int i2c_parse_reals(int *nrels, void *buffer, int bufsize,
                          long *results, int magnitude)
 {
@@ -568 +568 @@
 }
 
-int sensors_write_reals(int nrels, void *buffer, int *bufsize,
+int i2c_write_reals(int nrels, void *buffer, int *bufsize,
                          long *results, int magnitude)
 {
@@ -641 +641 @@
 
 /* Very inefficient for ISA detects, and won't work for 10-bit addresses! */
-int sensors_detect(struct i2c_adapter *adapter,
-                   struct sensors_address_data *address_data,
-                   sensors_found_addr_proc * found_proc)
+int i2c_detect(struct i2c_adapter *adapter,
+                   struct i2c_address_data *address_data,
+                   i2c_found_addr_proc * found_proc)
 {
         int addr, i, found, j, err;
-        struct sensors_force_data *this_force;
+        struct i2c_force_data *this_force;
         int is_isa = i2c_is_isa_adapter(adapter);
         int adapter_id =
@@ -860 +860 @@
 {
         printk("i2c-proc.o version %s (%s)\n", LM_VERSION, LM_DATE);
-        sensors_initialized = 0;
+        i2c_initialized = 0;
         if (!
-            (sensors_proc_header =
-             register_sysctl_table(sensors_proc, 0))) return -ENOMEM;
+            (i2c_proc_header =
+             register_sysctl_table(i2c_proc, 0))) return -ENOMEM;
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,1))
-        sensors_proc_header->ctl_table->child->de->owner = THIS_MODULE;
+        i2c_proc_header->ctl_table->child->de->owner = THIS_MODULE;
 #else
-        sensors_proc_header->ctl_table->child->de->fill_inode =
-            &sensors_fill_inode;
+        i2c_proc_header->ctl_table->child->de->fill_inode =
+            &i2c_fill_inode;
 #endif                  /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,1)) */
-        sensors_initialized++;
+        i2c_initialized++;
         return 0;
 }
 
-EXPORT_SYMBOL(sensors_deregister_entry);
-EXPORT_SYMBOL(sensors_detect);
-EXPORT_SYMBOL(sensors_proc_real);
-EXPORT_SYMBOL(sensors_register_entry);
-EXPORT_SYMBOL(sensors_sysctl_real);
+EXPORT_SYMBOL(i2c_deregister_entry);
+EXPORT_SYMBOL(i2c_detect);
+EXPORT_SYMBOL(i2c_proc_real);
+EXPORT_SYMBOL(i2c_register_entry);
+EXPORT_SYMBOL(i2c_sysctl_real);
 
 #ifdef MODULE
@@ -885 +885 @@
 MODULE_DESCRIPTION("i2c-proc driver");
 
-int sensors_cleanup(void)
-{
-        if (sensors_initialized >= 1) {
-                unregister_sysctl_table(sensors_proc_header);
-                sensors_initialized--;
+int i2c_cleanup(void)
+{
+        if (i2c_initialized >= 1) {
+                unregister_sysctl_table(i2c_proc_header);
+                i2c_initialized--;
         }
         return 0;
@@ -901 +901 @@
 int cleanup_module(void)
 {
-        return sensors_cleanup();
+        return i2c_cleanup();
 }
 

i2c/trunk/kernel/i2c-proc.h

@@ -30 +30 @@
 
 /* The type of callback functions used in sensors_{proc,sysctl}_real */
-typedef void (*sensors_real_callback) (struct i2c_client * client,
+typedef void (*i2c_real_callback) (struct i2c_client * client,
                                        int operation, int ctl_name,
                                        int *nrels_mag, long *results);
@@ -56 +56 @@
    In all cases, client points to the client we wish to interact with,
    and ctl_name is the SYSCTL id of the file we are accessing. */
-extern int sensors_sysctl_real(ctl_table * table, int *name, int nlen,
+extern int i2c_sysctl_real(ctl_table * table, int *name, int nlen,
                                void *oldval, size_t * oldlenp,
                                void *newval, size_t newlen,
                                void **context);
-extern int sensors_proc_real(ctl_table * ctl, int write, struct file *filp,
+extern int i2c_proc_real(ctl_table * ctl, int write, struct file *filp,
                              void *buffer, size_t * lenp);
 
@@ -72 +72 @@
    If any driver wants subdirectories within the newly created directory,
    these functions must be updated! */
-extern int sensors_register_entry(struct i2c_client *client,
+extern int i2c_register_entry(struct i2c_client *client,
                                   const char *prefix,
                                   ctl_table * ctl_template,
                                   struct module *controlling_mod);
 
-extern void sensors_deregister_entry(int id);
+extern void i2c_deregister_entry(int id);
 
 
@@ -92 +92 @@
    kind: The kind of chip. 0 equals any chip.
 */
-struct sensors_force_data {
+struct i2c_force_data {
         unsigned short *force;
         unsigned short kind;
@@ -136 +136 @@
      the force field is NULL.
 */
-struct sensors_address_data {
+struct i2c_address_data {
         unsigned short *normal_i2c;
         unsigned short *normal_i2c_range;
@@ -145 +145 @@
         unsigned short *ignore;
         unsigned short *ignore_range;
-        struct sensors_force_data *forces;
+        struct i2c_force_data *forces;
 };
 
@@ -210 +210 @@
                       "List of adapter,start-addr,end-addr triples not to " \
                       "scan"); \
-  static struct sensors_address_data addr_data = \
+  static struct i2c_address_data addr_data = \
                                        {normal_i2c, normal_i2c_range, \
                                         normal_isa, normal_isa_range, \
@@ -226 +226 @@
                       "List of adapter,address pairs to boldly assume " \
                       "to be present"); \
-  static struct sensors_force_data forces[] = {{force,any_chip},{NULL}}; \
+  static struct i2c_force_data forces[] = {{force,any_chip},{NULL}}; \
   SENSORS_INSMOD
 
@@ -235 +235 @@
                       "to be present"); \
   SENSORS_MODULE_PARM_FORCE(chip1); \
-  static struct sensors_force_data forces[] = {{force,any_chip},\
+  static struct i2c_force_data forces[] = {{force,any_chip},\
                                                  {force_ ## chip1,chip1}, \
                                                  {NULL}}; \
@@ -247 +247 @@
   SENSORS_MODULE_PARM_FORCE(chip1); \
   SENSORS_MODULE_PARM_FORCE(chip2); \
-  static struct sensors_force_data forces[] = {{force,any_chip}, \
+  static struct i2c_force_data forces[] = {{force,any_chip}, \
                                                  {force_ ## chip1,chip1}, \
                                                  {force_ ## chip2,chip2}, \
@@ -261 +261 @@
   SENSORS_MODULE_PARM_FORCE(chip2); \
   SENSORS_MODULE_PARM_FORCE(chip3); \
-  static struct sensors_force_data forces[] = {{force,any_chip}, \
+  static struct i2c_force_data forces[] = {{force,any_chip}, \
                                                  {force_ ## chip1,chip1}, \
                                                  {force_ ## chip2,chip2}, \
@@ -277 +277 @@
   SENSORS_MODULE_PARM_FORCE(chip3); \
   SENSORS_MODULE_PARM_FORCE(chip4); \
-  static struct sensors_force_data forces[] = {{force,any_chip}, \
+  static struct i2c_force_data forces[] = {{force,any_chip}, \
                                                  {force_ ## chip1,chip1}, \
                                                  {force_ ## chip2,chip2}, \
@@ -295 +295 @@
   SENSORS_MODULE_PARM_FORCE(chip4); \
   SENSORS_MODULE_PARM_FORCE(chip5); \
-  static struct sensors_force_data forces[] = {{force,any_chip}, \
+  static struct i2c_force_data forces[] = {{force,any_chip}, \
                                                  {force_ ## chip1,chip1}, \
                                                  {force_ ## chip2,chip2}, \
@@ -315 +315 @@
   SENSORS_MODULE_PARM_FORCE(chip5); \
   SENSORS_MODULE_PARM_FORCE(chip6); \
-  static struct sensors_force_data forces[] = {{force,any_chip}, \
+  static struct i2c_force_data forces[] = {{force,any_chip}, \
                                                  {force_ ## chip1,chip1}, \
                                                  {force_ ## chip2,chip2}, \
@@ -337 +337 @@
   SENSORS_MODULE_PARM_FORCE(chip6); \
   SENSORS_MODULE_PARM_FORCE(chip7); \
-  static struct sensors_force_data forces[] = {{force,any_chip}, \
+  static struct i2c_force_data forces[] = {{force,any_chip}, \
                                                  {force_ ## chip1,chip1}, \
                                                  {force_ ## chip2,chip2}, \
@@ -348 +348 @@
   SENSORS_INSMOD
 
-typedef int sensors_found_addr_proc(struct i2c_adapter *adapter,
+typedef int i2c_found_addr_proc(struct i2c_adapter *adapter,
                                     int addr, unsigned short flags,
                                     int kind);
 
-/* Detect function. It itterates over all possible addresses itself. For
+/* Detect function. It iterates over all possible addresses itself. For
    SMBus addresses, it will only call found_proc if some client is connected
    to the SMBus (unless a 'force' matched); for ISA detections, this is not
    done. */
-extern int sensors_detect(struct i2c_adapter *adapter,
-                          struct sensors_address_data *address_data,
-                          sensors_found_addr_proc * found_proc);
+extern int i2c_detect(struct i2c_adapter *adapter,
+                          struct i2c_address_data *address_data,
+                          i2c_found_addr_proc * found_proc);
 
 
@@ -388 +388 @@
 
 #define SENSORS_CHIPS 1
-struct sensors_chips_data {
+struct i2c_chips_data {
         int sysctl_id;
         char name[SENSORS_PREFIX_MAX + 13];