drivers/i2c/i2c-proc.c

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