root/i2c/trunk/kernel/i2c-core.c @ 3560

Revision 3560, 36.2 KB (checked in by mds, 13 years ago)

Belatedly sync with kernel 2.4.2 (malloc.h -> slab.h)

Should be ok for 2.2 kernels also.
Thanks J . A . Magallon <jamagallon@…>

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* i2c-core.c - a device driver for the iic-bus interface                    */
2/* ------------------------------------------------------------------------- */
3/*   Copyright (C) 1995-99 Simon G. Vogl
4
5    This program is free software; you can redistribute it and/or modify
6    it under the terms of the GNU General Public License as published by
7    the Free Software Foundation; either version 2 of the License, or
8    (at your option) any later version.
9
10    This program is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13    GNU General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with this program; if not, write to the Free Software
17    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
18/* ------------------------------------------------------------------------- */
19
20/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
21   All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl> */
22
23/* $Id$ */
24
25#include <linux/module.h>
26#include <linux/kernel.h>
27#include <linux/errno.h>
28#include <linux/slab.h>
29#include <linux/proc_fs.h>
30#include <linux/config.h>
31
32#include "i2c.h"
33
34/* ----- compatibility stuff ----------------------------------------------- */
35
36#include <linux/version.h>
37#include <linux/init.h>
38
39#if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,1)
40#define init_MUTEX(s) do { *(s) = MUTEX; } while(0)
41#endif
42
43#include <asm/uaccess.h>
44
45/* ----- global defines ---------------------------------------------------- */
46
47/* exclusive access to the bus */
48#define I2C_LOCK(adap) down(&adap->lock)
49#define I2C_UNLOCK(adap) up(&adap->lock)
50
51#define ADAP_LOCK()     down(&adap_lock)
52#define ADAP_UNLOCK()   up(&adap_lock)
53
54#define DRV_LOCK()      down(&driver_lock)
55#define DRV_UNLOCK()    up(&driver_lock)
56
57#define DEB(x) if (i2c_debug>=1) x;
58#define DEB2(x) if (i2c_debug>=2) x;
59
60/* ----- global variables -------------------------------------------------- */
61
62/**** lock for writing to global variables: the adapter & driver list */
63struct semaphore adap_lock;
64struct semaphore driver_lock;
65
66/**** adapter list */
67static struct i2c_adapter *adapters[I2C_ADAP_MAX];
68static int adap_count;
69
70/**** drivers list */
71static struct i2c_driver *drivers[I2C_DRIVER_MAX];
72static int driver_count;
73
74/**** debug level */
75static int i2c_debug=1;
76
77/* ---------------------------------------------------
78 * /proc entry declarations
79 *----------------------------------------------------
80 */
81
82#ifdef CONFIG_PROC_FS
83
84static int i2cproc_init(void);
85static int i2cproc_cleanup(void);
86
87#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,3,27))
88static void monitor_bus_i2c(struct inode *inode, int fill);
89#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,58)) */
90
91static ssize_t i2cproc_bus_read(struct file * file, char * buf,size_t count, 
92                                loff_t *ppos);
93static int read_bus_i2c(char *buf, char **start, off_t offset, int len,
94                           int *eof , void *private);
95
96/* To implement the dynamic /proc/bus/i2c-? files, we need our own
97   implementation of the read hook */
98static struct file_operations i2cproc_operations = {
99        read:           i2cproc_bus_read,
100};
101
102#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,48))
103static struct inode_operations i2cproc_inode_operations = {
104        &i2cproc_operations
105};
106#endif
107
108static int i2cproc_initialized = 0;
109
110#else /* undef CONFIG_PROC_FS */
111
112#define i2cproc_init() 0
113#define i2cproc_cleanup() 0
114
115#endif /* CONFIG_PROC_FS */
116
117
118/* ---------------------------------------------------
119 * registering functions
120 * ---------------------------------------------------
121 */
122
123/* -----
124 * i2c_add_adapter is called from within the algorithm layer,
125 * when a new hw adapter registers. A new device is register to be
126 * available for clients.
127 */
128int i2c_add_adapter(struct i2c_adapter *adap)
129{
130        int i,j,res;
131
132        ADAP_LOCK();
133        for (i = 0; i < I2C_ADAP_MAX; i++)
134                if (NULL == adapters[i])
135                        break;
136        if (I2C_ADAP_MAX == i) {
137                printk(KERN_WARNING
138                       " i2c-core.o: register_adapter(%s) - enlarge I2C_ADAP_MAX.\n",
139                        adap->name);
140                res = -ENOMEM;
141                goto ERROR0;
142        }
143
144        adapters[i] = adap;
145        adap_count++;
146        ADAP_UNLOCK();
147       
148        /* init data types */
149        init_MUTEX(&adap->lock);
150
151#ifdef CONFIG_PROC_FS
152
153        if (i2cproc_initialized) {
154                char name[8];
155                struct proc_dir_entry *proc_entry;
156
157                sprintf(name,"i2c-%d", i);
158
159                proc_entry = create_proc_entry(name,0,proc_bus);
160                if (! proc_entry) {
161                        printk("i2c-core.o: Could not create /proc/bus/%s\n",
162                               name);
163                        res = -ENOENT;
164                        goto ERROR1;
165                }
166
167#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,48))
168                proc_entry->proc_fops = &i2cproc_operations;
169#else
170                proc_entry->ops = &i2cproc_inode_operations;
171#endif
172#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,27))
173                proc_entry->owner = THIS_MODULE;
174#else
175                proc_entry->fill_inode = &monitor_bus_i2c;
176#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,58)) */
177                adap->inode = proc_entry->low_ino;
178        }
179
180#endif /* def CONFIG_PROC_FS */
181
182        /* inform drivers of new adapters */
183        DRV_LOCK();     
184        for (j=0;j<I2C_DRIVER_MAX;j++)
185                if (drivers[j]!=NULL && 
186                    (drivers[j]->flags&(I2C_DF_NOTIFY|I2C_DF_DUMMY)))
187                        /* We ignore the return code; if it fails, too bad */
188                        drivers[j]->attach_adapter(adap);
189        DRV_UNLOCK();
190       
191        DEB(printk("i2c-core.o: adapter %s registered as adapter %d.\n",
192                   adap->name,i));
193
194        return 0;       
195
196
197ERROR1:
198        ADAP_LOCK();
199        adapters[i] = NULL;
200        adap_count--;
201ERROR0:
202        ADAP_UNLOCK();
203        return res;
204}
205
206
207int i2c_del_adapter(struct i2c_adapter *adap)
208{
209        int i,j,res;
210
211        ADAP_LOCK();
212
213        for (i = 0; i < I2C_ADAP_MAX; i++)
214                if (adap == adapters[i])
215                        break;
216        if (I2C_ADAP_MAX == i) {
217                printk( "i2c-core.o: unregister_adapter adap [%s] not found.\n",
218                        adap->name);
219                res = -ENODEV;
220                goto ERROR0;
221        }
222
223        /* DUMMY drivers do not register their clients, so we have to
224         * use a trick here: we call driver->attach_adapter to
225         * *detach* it! Of course, each dummy driver should know about
226         * this or hell will break loose...
227         */
228        DRV_LOCK();
229        for (j = 0; j < I2C_DRIVER_MAX; j++) 
230                if (drivers[j] && (drivers[j]->flags & I2C_DF_DUMMY))
231                        if ((res = drivers[j]->attach_adapter(adap))) {
232                                printk("i2c-core.o: can't detach adapter %s "
233                                       "while detaching driver %s: driver not "
234                                       "detached!",adap->name,drivers[j]->name);
235                                goto ERROR1;   
236                        }
237        DRV_UNLOCK();
238
239
240        /* detach any active clients. This must be done first, because
241         * it can fail; in which case we give upp. */
242        for (j=0;j<I2C_CLIENT_MAX;j++) {
243                struct i2c_client *client = adap->clients[j];
244                if (client!=NULL)
245                    /* detaching devices is unconditional of the set notify
246                     * flag, as _all_ clients that reside on the adapter
247                     * must be deleted, as this would cause invalid states.
248                     */
249                        if ((res=client->driver->detach_client(client))) {
250                                printk("i2c-core.o: adapter %s not "
251                                        "unregistered, because client at "
252                                        "address %02x can't be detached. ",
253                                        adap->name, client->addr);
254                                goto ERROR0;
255                        }
256        }
257#ifdef CONFIG_PROC_FS
258        if (i2cproc_initialized) {
259                char name[8];
260                sprintf(name,"i2c-%d", i);
261                remove_proc_entry(name,proc_bus);
262        }
263#endif /* def CONFIG_PROC_FS */
264
265        adapters[i] = NULL;
266        adap_count--;
267       
268        ADAP_UNLOCK(); 
269        DEB(printk("i2c-core.o: adapter unregistered: %s\n",adap->name));
270        return 0;
271
272ERROR0:
273        ADAP_UNLOCK();
274        return res;
275ERROR1:
276        DRV_UNLOCK();
277        return res;
278}
279
280
281/* -----
282 * What follows is the "upwards" interface: commands for talking to clients,
283 * which implement the functions to access the physical information of the
284 * chips.
285 */
286
287int i2c_add_driver(struct i2c_driver *driver)
288{
289        int i;
290        DRV_LOCK();
291        for (i = 0; i < I2C_DRIVER_MAX; i++)
292                if (NULL == drivers[i])
293                        break;
294        if (I2C_DRIVER_MAX == i) {
295                printk(KERN_WARNING
296                       " i2c-core.o: register_driver(%s) "
297                       "- enlarge I2C_DRIVER_MAX.\n",
298                        driver->name);
299                DRV_UNLOCK();
300                return -ENOMEM;
301        }
302
303        drivers[i] = driver;
304        driver_count++;
305       
306        DRV_UNLOCK();   /* driver was successfully added */
307       
308        DEB(printk("i2c-core.o: driver %s registered.\n",driver->name));
309       
310        ADAP_LOCK();
311
312        /* now look for instances of driver on our adapters
313         */
314        if (driver->flags& (I2C_DF_NOTIFY|I2C_DF_DUMMY)) {
315                for (i=0;i<I2C_ADAP_MAX;i++)
316                        if (adapters[i]!=NULL)
317                                /* Ignore errors */
318                                driver->attach_adapter(adapters[i]);
319        }
320        ADAP_UNLOCK();
321        return 0;
322}
323
324int i2c_del_driver(struct i2c_driver *driver)
325{
326        int i,j,k,res;
327
328        DRV_LOCK();
329        for (i = 0; i < I2C_DRIVER_MAX; i++)
330                if (driver == drivers[i])
331                        break;
332        if (I2C_DRIVER_MAX == i) {
333                printk(KERN_WARNING " i2c-core.o: unregister_driver: "
334                                    "[%s] not found\n",
335                        driver->name);
336                DRV_UNLOCK();
337                return -ENODEV;
338        }
339        /* Have a look at each adapter, if clients of this driver are still
340         * attached. If so, detach them to be able to kill the driver
341         * afterwards.
342         */
343        DEB2(printk("i2c-core.o: unregister_driver - looking for clients.\n"));
344        /* removing clients does not depend on the notify flag, else
345         * invalid operation might (will!) result, when using stale client
346         * pointers.
347         */
348        ADAP_LOCK(); /* should be moved inside the if statement... */
349        for (k=0;k<I2C_ADAP_MAX;k++) {
350                struct i2c_adapter *adap = adapters[k];
351                if (adap == NULL) /* skip empty entries. */
352                        continue;
353                DEB2(printk("i2c-core.o: examining adapter %s:\n",
354                            adap->name));
355                if (driver->flags & I2C_DF_DUMMY) {
356                /* DUMMY drivers do not register their clients, so we have to
357                 * use a trick here: we call driver->attach_adapter to
358                 * *detach* it! Of course, each dummy driver should know about
359                 * this or hell will break loose... 
360                 */
361                        if ((res = driver->attach_adapter(adap))) {
362                                printk("i2c-core.o: while unregistering "
363                                       "dummy driver %s, adapter %s could "
364                                       "not be detached properly; driver "
365                                       "not unloaded!",driver->name,
366                                       adap->name);
367                                ADAP_UNLOCK();
368                                return res;
369                        }
370                } else {
371                        for (j=0;j<I2C_CLIENT_MAX;j++) { 
372                                struct i2c_client *client = adap->clients[j];
373                                if (client != NULL && 
374                                    client->driver == driver) {
375                                        DEB2(printk("i2c-core.o: "
376                                                    "detaching client %s:\n",
377                                                    client->name));
378                                        if ((res = driver->
379                                                        detach_client(client)))
380                                        {
381                                                printk("i2c-core.o: while "
382                                                       "unregistering driver "
383                                                       "`%s', the client at "
384                                                       "address %02x of
385                                                       adapter `%s' could not
386                                                       be detached; driver
387                                                       not unloaded!",
388                                                       driver->name,
389                                                       client->addr,
390                                                       adap->name);
391                                                ADAP_UNLOCK();
392                                                return res;
393                                        }
394                                }
395                        }
396                }
397        }
398        ADAP_UNLOCK();
399        drivers[i] = NULL;
400        driver_count--;
401        DRV_UNLOCK();
402       
403        DEB(printk("i2c-core.o: driver unregistered: %s\n",driver->name));
404        return 0;
405}
406
407int i2c_check_addr (struct i2c_adapter *adapter, int addr)
408{
409        int i;
410        for (i = 0; i < I2C_CLIENT_MAX ; i++) 
411                if (adapter->clients[i] && (adapter->clients[i]->addr == addr))
412                        return -EBUSY;
413        return 0;
414}
415
416int i2c_attach_client(struct i2c_client *client)
417{
418        struct i2c_adapter *adapter = client->adapter;
419        int i;
420
421        if (i2c_check_addr(client->adapter,client->addr))
422                return -EBUSY;
423
424        for (i = 0; i < I2C_CLIENT_MAX; i++)
425                if (NULL == adapter->clients[i])
426                        break;
427        if (I2C_CLIENT_MAX == i) {
428                printk(KERN_WARNING
429                       " i2c-core.o: attach_client(%s) - enlarge I2C_CLIENT_MAX.\n",
430                        client->name);
431                return -ENOMEM;
432        }
433
434        adapter->clients[i] = client;
435        adapter->client_count++;
436       
437        if (adapter->client_register) 
438                if (adapter->client_register(client)) 
439                        printk("i2c-core.o: warning: client_register seems "
440                               "to have failed for client %02x at adapter %s\n",
441                               client->addr,adapter->name);
442        DEB(printk("i2c-core.o: client [%s] registered to adapter [%s](pos. %d).\n",
443                client->name, adapter->name,i));
444
445        if(client->flags & I2C_CLIENT_ALLOW_USE)
446                client->usage_count = 0;
447       
448        return 0;
449}
450
451
452int i2c_detach_client(struct i2c_client *client)
453{
454        struct i2c_adapter *adapter = client->adapter;
455        int i,res;
456
457        for (i = 0; i < I2C_CLIENT_MAX; i++)
458                if (client == adapter->clients[i])
459                        break;
460        if (I2C_CLIENT_MAX == i) {
461                printk(KERN_WARNING " i2c-core.o: unregister_client "
462                                    "[%s] not found\n",
463                        client->name);
464                return -ENODEV;
465        }
466       
467        if( (client->flags & I2C_CLIENT_ALLOW_USE) && 
468            (client->usage_count>0))
469                return -EBUSY;
470       
471        if (adapter->client_unregister != NULL) 
472                if ((res = adapter->client_unregister(client))) {
473                        printk("i2c-core.o: client_unregister [%s] failed, "
474                               "client not detached",client->name);
475                        return res;
476                }
477
478        adapter->clients[i] = NULL;
479        adapter->client_count--;
480
481        DEB(printk("i2c-core.o: client [%s] unregistered.\n",client->name));
482        return 0;
483}
484
485void i2c_inc_use_client(struct i2c_client *client)
486{
487
488        if (client->driver->inc_use != NULL)
489                client->driver->inc_use(client);
490
491        if (client->adapter->inc_use != NULL)
492                client->adapter->inc_use(client->adapter);
493}
494
495void i2c_dec_use_client(struct i2c_client *client)
496{
497       
498        if (client->driver->dec_use != NULL)
499                client->driver->dec_use(client);
500
501        if (client->adapter->dec_use != NULL)
502                client->adapter->dec_use(client->adapter);
503}
504
505struct i2c_client *i2c_get_client(int driver_id, int adapter_id, 
506                                        struct i2c_client *prev)
507{
508        int i,j;
509       
510        /* Will iterate through the list of clients in each adapter of adapters-list
511           in search for a client that matches the search criteria. driver_id or
512           adapter_id are ignored if set to 0. If both are ignored this returns
513           first client found. */
514       
515        i = j = 0; 
516       
517        /* set starting point */ 
518        if(prev)
519        {
520                if(!(prev->adapter))
521                        return (struct i2c_client *) -EINVAL;
522               
523                for(j=0; j < I2C_ADAP_MAX; j++)
524                        if(prev->adapter == adapters[j])
525                                break;
526               
527                /* invalid starting point? */
528                if (I2C_ADAP_MAX == j) {
529                        printk(KERN_WARNING " i2c-core.o: get_client adapter for client:[%s] not found\n",
530                                prev->name);
531                        return (struct i2c_client *) -ENODEV;
532                }       
533               
534                for(i=0; i < I2C_CLIENT_MAX; i++)
535                        if(prev == adapters[j]->clients[i])
536                                break;
537               
538                /* invalid starting point? */
539                if (I2C_CLIENT_MAX == i) {
540                        printk(KERN_WARNING " i2c-core.o: get_client client:[%s] not found\n",
541                                prev->name);
542                        return (struct i2c_client *) -ENODEV;
543                }       
544               
545                i++; /* start from one after prev */
546        }
547       
548        for(; j < I2C_ADAP_MAX; j++)
549        {
550                if(!adapters[j])
551                        continue;
552                       
553                if(adapter_id && (adapters[j]->id != adapter_id))
554                        continue;
555               
556                for(; i < I2C_CLIENT_MAX; i++)
557                {
558                        if(!adapters[j]->clients[i])
559                                continue;
560                               
561                        if(driver_id && (adapters[j]->clients[i]->driver->id != driver_id))
562                                continue;
563                        if(adapters[j]->clients[i]->flags & I2C_CLIENT_ALLOW_USE)       
564                                return adapters[j]->clients[i];
565                }
566                i = 0;
567        }
568
569        return 0;
570}
571
572int i2c_use_client(struct i2c_client *client)
573{
574        if(client->flags & I2C_CLIENT_ALLOW_USE) {
575                if (client->flags & I2C_CLIENT_ALLOW_MULTIPLE_USE) 
576                        client->usage_count++;
577                else {
578                        if(client->usage_count > 0) 
579                                return -EBUSY;
580                         else 
581                                client->usage_count++;
582                }
583        }
584
585        i2c_inc_use_client(client);
586
587        return 0;
588}
589
590int i2c_release_client(struct i2c_client *client)
591{
592        if(client->flags & I2C_CLIENT_ALLOW_USE) {
593                if(client->usage_count>0)
594                        client->usage_count--;
595                else
596                {
597                        printk(KERN_WARNING " i2c-core.o: dec_use_client used one too many times\n");
598                        return -EPERM;
599                }
600        }
601       
602        i2c_dec_use_client(client);
603       
604        return 0;
605}
606
607/* ----------------------------------------------------
608 * The /proc functions
609 * ----------------------------------------------------
610 */
611
612#ifdef CONFIG_PROC_FS
613
614#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,3,27))
615/* Monitor access to /proc/bus/i2c*; make unloading i2c-proc impossible
616   if some process still uses it or some file in it */
617void monitor_bus_i2c(struct inode *inode, int fill)
618{
619        if (fill)
620                MOD_INC_USE_COUNT;
621        else
622                MOD_DEC_USE_COUNT;
623}
624#endif /* (LINUX_VERSION_CODE <= KERNEL_VERSION(2,3,37)) */
625
626/* This function generates the output for /proc/bus/i2c */
627int read_bus_i2c(char *buf, char **start, off_t offset, int len, int *eof, 
628                 void *private)
629{
630        int i;
631        int nr = 0;
632        /* Note that it is safe to write a `little' beyond len. Yes, really. */
633        for (i = 0; (i < I2C_ADAP_MAX) && (nr < len); i++)
634                if (adapters[i]) {
635                        nr += sprintf(buf+nr, "i2c-%d\t", i);
636                        if (adapters[i]->algo->smbus_xfer) {
637                                if (adapters[i]->algo->master_xfer)
638                                        nr += sprintf(buf+nr,"smbus/i2c");
639                                else
640                                        nr += sprintf(buf+nr,"smbus    ");
641                        } else if (adapters[i]->algo->master_xfer)
642                                nr += sprintf(buf+nr,"i2c       ");
643                        else
644                                nr += sprintf(buf+nr,"dummy     ");
645                        nr += sprintf(buf+nr,"\t%-32s\t%-32s\n",
646                                      adapters[i]->name,
647                                      adapters[i]->algo->name);
648                }
649        return nr;
650}
651
652/* This function generates the output for /proc/bus/i2c-? */
653ssize_t i2cproc_bus_read(struct file * file, char * buf,size_t count, 
654                         loff_t *ppos)
655{
656        struct inode * inode = file->f_dentry->d_inode;
657        char *kbuf;
658        struct i2c_client *client;
659        int i,j,k,order_nr,len=0,len_total;
660        int order[I2C_CLIENT_MAX];
661
662        if (count > 4000)
663                return -EINVAL; 
664        len_total = file->f_pos + count;
665        /* Too bad if this gets longer (unlikely) */
666        if (len_total > 4000)
667                len_total = 4000;
668        for (i = 0; i < I2C_ADAP_MAX; i++)
669                if (adapters[i]->inode == inode->i_ino) {
670                /* We need a bit of slack in the kernel buffer; this makes the
671                   sprintf safe. */
672                        if (! (kbuf = kmalloc(count + 80,GFP_KERNEL)))
673                                return -ENOMEM;
674                        /* Order will hold the indexes of the clients
675                           sorted by address */
676                        order_nr=0;
677                        for (j = 0; j < I2C_CLIENT_MAX; j++) {
678                                if ((client = adapters[i]->clients[j]) && 
679                                    (client->driver->id != I2C_DRIVERID_I2CDEV))  {
680                                        for(k = order_nr; 
681                                            (k > 0) && 
682                                            adapters[i]->clients[order[k-1]]->
683                                                     addr > client->addr; 
684                                            k--)
685                                                order[k] = order[k-1];
686                                        order[k] = j;
687                                        order_nr++;
688                                }
689                        }
690
691
692                        for (j = 0; (j < order_nr) && (len < len_total); j++) {
693                                client = adapters[i]->clients[order[j]];
694                                len += sprintf(kbuf+len,"%02x\t%-32s\t%-32s\n",
695                                              client->addr,
696                                              client->name,
697                                              client->driver->name);
698                        }
699                        len = len - file->f_pos;
700                        if (len > count)
701                                len = count;
702                        if (len < 0) 
703                                len = 0;
704                        if (copy_to_user (buf,kbuf+file->f_pos, len)) {
705                                kfree(kbuf);
706                                return -EFAULT;
707                        }
708                        file->f_pos += len;
709                        kfree(kbuf);
710                        return len;
711                }
712        return -ENOENT;
713}
714
715int i2cproc_init(void)
716{
717
718        struct proc_dir_entry *proc_bus_i2c;
719
720        i2cproc_initialized = 0;
721
722        if (! proc_bus) {
723                printk("i2c-core.o: /proc/bus/ does not exist");
724                i2cproc_cleanup();
725                return -ENOENT;
726        } 
727        proc_bus_i2c = create_proc_entry("i2c",0,proc_bus);
728        if (!proc_bus_i2c) {
729                printk("i2c-core.o: Could not create /proc/bus/i2c");
730                i2cproc_cleanup();
731                return -ENOENT;
732        }
733        proc_bus_i2c->read_proc = &read_bus_i2c;
734#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,27))
735        proc_bus_i2c->owner = THIS_MODULE;
736#else
737        proc_bus_i2c->fill_inode = &monitor_bus_i2c;
738#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,27)) */
739        i2cproc_initialized += 2;
740        return 0;
741}
742
743int i2cproc_cleanup(void)
744{
745
746        if (i2cproc_initialized >= 1) {
747                remove_proc_entry("i2c",proc_bus);
748                i2cproc_initialized -= 2;
749        }
750        return 0;
751}
752
753
754#endif /* def CONFIG_PROC_FS */
755
756/* ----------------------------------------------------
757 * the functional interface to the i2c busses.
758 * ----------------------------------------------------
759 */
760
761int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg msgs[],int num)
762{
763        int ret;
764
765        if (adap->algo->master_xfer) {
766                DEB2(printk("i2c-core.o: master_xfer: %s with %d msgs.\n",
767                            adap->name,num));
768
769                I2C_LOCK(adap);
770                ret = adap->algo->master_xfer(adap,msgs,num);
771                I2C_UNLOCK(adap);
772
773                return ret;
774        } else {
775                printk("i2c-core.o: I2C adapter %04x: I2C level transfers not supported\n",
776                       adap->id);
777                return -ENOSYS;
778        }
779}
780
781int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
782{
783        int ret;
784        struct i2c_adapter *adap=client->adapter;
785        struct i2c_msg msg;
786
787        if (client->adapter->algo->master_xfer) {
788                msg.addr   = client->addr;
789                msg.flags = client->flags & I2C_M_TEN;
790                msg.len = count;
791                (const char *)msg.buf = buf;
792       
793                DEB2(printk("i2c-core.o: master_send: writing %d bytes on %s.\n",
794                        count,client->adapter->name));
795       
796                I2C_LOCK(adap);
797                ret = adap->algo->master_xfer(adap,&msg,1);
798                I2C_UNLOCK(adap);
799
800                /* if everything went ok (i.e. 1 msg transmitted), return #bytes
801                 * transmitted, else error code.
802                 */
803                return (ret == 1 )? count : ret;
804        } else {
805                printk("i2c-core.o: I2C adapter %04x: I2C level transfers not supported\n",
806                       client->adapter->id);
807                return -ENOSYS;
808        }
809}
810
811int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
812{
813        struct i2c_adapter *adap=client->adapter;
814        struct i2c_msg msg;
815        int ret;
816        if (client->adapter->algo->master_xfer) {
817                msg.addr   = client->addr;
818                msg.flags = client->flags & I2C_M_TEN;
819                msg.flags |= I2C_M_RD;
820                msg.len = count;
821                msg.buf = buf;
822
823                DEB2(printk("i2c-core.o: master_recv: reading %d bytes on %s.\n",
824                        count,client->adapter->name));
825       
826                I2C_LOCK(adap);
827                ret = adap->algo->master_xfer(adap,&msg,1);
828                I2C_UNLOCK(adap);
829       
830                DEB2(printk("i2c-core.o: master_recv: return:%d (count:%d, addr:0x%02x)\n",
831                        ret, count, client->addr));
832       
833                /* if everything went ok (i.e. 1 msg transmitted), return #bytes
834                * transmitted, else error code.
835                */
836                return (ret == 1 )? count : ret;
837        } else {
838                printk("i2c-core.o: I2C adapter %04x: I2C level transfers not supported\n",
839                       client->adapter->id);
840                return -ENOSYS;
841        }
842}
843
844
845int i2c_control(struct i2c_client *client,
846        unsigned int cmd, unsigned long arg)
847{
848        int ret = 0;
849        struct i2c_adapter *adap = client->adapter;
850
851        DEB2(printk("i2c-core.o: i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg));
852        switch ( cmd ) {
853                case I2C_RETRIES:
854                        adap->retries = arg;
855                        break;
856                case I2C_TIMEOUT:
857                        adap->timeout = arg;
858                        break;
859                default:
860                        if (adap->algo->algo_control!=NULL)
861                                ret = adap->algo->algo_control(adap,cmd,arg);
862        }
863        return ret;
864}
865
866/* ----------------------------------------------------
867 * the i2c address scanning function
868 * Will not work for 10-bit addresses!
869 * ----------------------------------------------------
870 */
871int i2c_probe(struct i2c_adapter *adapter,
872                   struct i2c_client_address_data *address_data,
873                   i2c_client_found_addr_proc *found_proc)
874{
875        int addr,i,found,err;
876        int adap_id = i2c_adapter_id(adapter);
877
878        /* Forget it if we can't probe using SMBUS_QUICK */
879        if (! i2c_check_functionality(adapter,I2C_FUNC_SMBUS_QUICK))
880                return -1;
881
882        for (addr = 0x00; addr <= 0x7f; addr++) {
883
884                /* Skip if already in use */
885                if (i2c_check_addr(adapter,addr))
886                        continue;
887
888                /* If it is in one of the force entries, we don't do any detection
889                   at all */
890                found = 0;
891
892                for (i = 0; !found && (address_data->force[i] != I2C_CLIENT_END); i += 3) {
893                        if (((adap_id == address_data->force[i]) || 
894                             (address_data->force[i] == ANY_I2C_BUS)) &&
895                             (addr == address_data->force[i+1])) {
896                                DEB2(printk("i2c-core.o: found force parameter for adapter %d, addr %04x\n",
897                                            adap_id,addr));
898                                if ((err = found_proc(adapter,addr,0,0)))
899                                        return err;
900                                found = 1;
901                        }
902                }
903                if (found) 
904                        continue;
905
906                /* If this address is in one of the ignores, we can forget about
907                   it right now */
908                for (i = 0;
909                     !found && (address_data->ignore[i] != I2C_CLIENT_END);
910                     i += 2) {
911                        if (((adap_id == address_data->ignore[i]) || 
912                            ((address_data->ignore[i] == ANY_I2C_BUS))) &&
913                            (addr == address_data->ignore[i+1])) {
914                                DEB2(printk("i2c-core.o: found ignore parameter for adapter %d, "
915                                     "addr %04x\n", adap_id ,addr));
916                                found = 1;
917                        }
918                }
919                for (i = 0;
920                     !found && (address_data->ignore_range[i] != I2C_CLIENT_END);
921                     i += 3) {
922                        if (((adap_id == address_data->ignore_range[i]) ||
923                            ((address_data->ignore_range[i]==ANY_I2C_BUS))) &&
924                            (addr >= address_data->ignore_range[i+1]) &&
925                            (addr <= address_data->ignore_range[i+2])) {
926                                DEB2(printk("i2c-core.o: found ignore_range parameter for adapter %d, "
927                                            "addr %04x\n", adap_id,addr));
928                                found = 1;
929                        }
930                }
931                if (found) 
932                        continue;
933
934                /* Now, we will do a detection, but only if it is in the normal or
935                   probe entries */ 
936                for (i = 0;
937                     !found && (address_data->normal_i2c[i] != I2C_CLIENT_END);
938                     i += 1) {
939                        if (addr == address_data->normal_i2c[i]) {
940                                found = 1;
941                                DEB2(printk("i2c-core.o: found normal i2c entry for adapter %d, "
942                                            "addr %02x", adap_id,addr));
943                        }
944                }
945
946                for (i = 0;
947                     !found && (address_data->normal_i2c_range[i] != I2C_CLIENT_END);
948                     i += 2) {
949                        if ((addr >= address_data->normal_i2c_range[i]) &&
950                            (addr <= address_data->normal_i2c_range[i+1])) {
951                                found = 1;
952                                DEB2(printk("i2c-core.o: found normal i2c_range entry for adapter %d, "
953                                            "addr %04x\n", adap_id,addr));
954                        }
955                }
956
957                for (i = 0;
958                     !found && (address_data->probe[i] != I2C_CLIENT_END);
959                     i += 2) {
960                        if (((adap_id == address_data->probe[i]) ||
961                            ((address_data->probe[i] == ANY_I2C_BUS))) &&
962                            (addr == address_data->probe[i+1])) {
963                                found = 1;
964                                DEB2(printk("i2c-core.o: found probe parameter for adapter %d, "
965                                            "addr %04x\n", adap_id,addr));
966                        }
967                }
968                for (i = 0;
969                     !found && (address_data->probe_range[i] != I2C_CLIENT_END);
970                     i += 3) {
971                        if (((adap_id == address_data->probe_range[i]) ||
972                           (address_data->probe_range[i] == ANY_I2C_BUS)) &&
973                           (addr >= address_data->probe_range[i+1]) &&
974                           (addr <= address_data->probe_range[i+2])) {
975                                found = 1;
976                                DEB2(printk("i2c-core.o: found probe_range parameter for adapter %d, "
977                                            "addr %04x\n", adap_id,addr));
978                        }
979                }
980                if (!found) 
981                        continue;
982
983                /* OK, so we really should examine this address. First check
984                   whether there is some client here at all! */
985                if (i2c_smbus_xfer(adapter,addr,0,0,0,I2C_SMBUS_QUICK,NULL) >= 0)
986                        if ((err = found_proc(adapter,addr,0,-1)))
987                                return err;
988        }
989        return 0;
990}
991
992/*
993 * return id number for a specific adapter
994 */
995int i2c_adapter_id(struct i2c_adapter *adap)
996{
997        int i;
998        for (i = 0; i < I2C_ADAP_MAX; i++)
999                if (adap == adapters[i])
1000                        return i;
1001        return -1;
1002}
1003
1004/* The SMBus parts */
1005
1006extern s32 i2c_smbus_write_quick(struct i2c_client * client, u8 value)
1007{
1008        return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1009                              value,0,I2C_SMBUS_QUICK,NULL);
1010}
1011
1012extern s32 i2c_smbus_read_byte(struct i2c_client * client)
1013{
1014        union i2c_smbus_data data;
1015        if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1016                           I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data))
1017                return -1;
1018        else
1019                return 0x0FF & data.byte;
1020}
1021
1022extern s32 i2c_smbus_write_byte(struct i2c_client * client, u8 value)
1023{
1024        return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1025                              I2C_SMBUS_WRITE,value, I2C_SMBUS_BYTE,NULL);
1026}
1027
1028extern s32 i2c_smbus_read_byte_data(struct i2c_client * client, u8 command)
1029{
1030        union i2c_smbus_data data;
1031        if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1032                           I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data))
1033                return -1;
1034        else
1035                return 0x0FF & data.byte;
1036}
1037
1038extern s32 i2c_smbus_write_byte_data(struct i2c_client * client, u8 command,
1039                                     u8 value)
1040{
1041        union i2c_smbus_data data;
1042        data.byte = value;
1043        return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1044                              I2C_SMBUS_WRITE,command,
1045                              I2C_SMBUS_BYTE_DATA,&data);
1046}
1047
1048extern s32 i2c_smbus_read_word_data(struct i2c_client * client, u8 command)
1049{
1050        union i2c_smbus_data data;
1051        if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1052                           I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data))
1053                return -1;
1054        else
1055                return 0x0FFFF & data.word;
1056}
1057
1058extern s32 i2c_smbus_write_word_data(struct i2c_client * client,
1059                                     u8 command, u16 value)
1060{
1061        union i2c_smbus_data data;
1062        data.word = value;
1063        return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1064                              I2C_SMBUS_WRITE,command,
1065                              I2C_SMBUS_WORD_DATA,&data);
1066}
1067
1068extern s32 i2c_smbus_process_call(struct i2c_client * client,
1069                                  u8 command, u16 value)
1070{
1071        union i2c_smbus_data data;
1072        data.word = value;
1073        if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1074                           I2C_SMBUS_WRITE,command,
1075                           I2C_SMBUS_PROC_CALL, &data))
1076                return -1;
1077        else
1078                return 0x0FFFF & data.word;
1079}
1080
1081/* Returns the number of read bytes */
1082extern s32 i2c_smbus_read_block_data(struct i2c_client * client,
1083                                     u8 command, u8 *values)
1084{
1085        union i2c_smbus_data data;
1086        int i;
1087        if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1088                           I2C_SMBUS_READ,command,
1089                           I2C_SMBUS_BLOCK_DATA,&data))
1090                return -1;
1091        else {
1092                for (i = 1; i <= data.block[0]; i++)
1093                        values[i-1] = data.block[i];
1094                return data.block[0];
1095        }
1096}
1097
1098extern s32 i2c_smbus_write_block_data(struct i2c_client * client,
1099                                      u8 command, u8 length, u8 *values)
1100{
1101        union i2c_smbus_data data;
1102        int i;
1103        if (length > 32)
1104                length = 32;
1105        for (i = 1; i <= length; i++)
1106                data.block[i] = values[i-1];
1107        data.block[0] = length;
1108        return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1109                              I2C_SMBUS_WRITE,command,
1110                              I2C_SMBUS_BLOCK_DATA,&data);
1111}
1112
1113extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client * client,
1114                                          u8 command, u8 length, u8 *values)
1115{
1116        union i2c_smbus_data data;
1117        int i;
1118        if (length > 32)
1119                length = 32;
1120        for (i = 1; i <= length; i++)
1121                data.block[i] = values[i-1];
1122        data.block[0] = length;
1123        return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1124                              I2C_SMBUS_WRITE,command,
1125                              I2C_SMBUS_I2C_BLOCK_DATA,&data);
1126}
1127
1128/* Simulate a SMBus command using the i2c protocol
1129   No checking of parameters is done!  */
1130static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr, 
1131                                   unsigned short flags,
1132                                   char read_write, u8 command, int size, 
1133                                   union i2c_smbus_data * data)
1134{
1135        /* So we need to generate a series of msgs. In the case of writing, we
1136          need to use only one message; when reading, we need two. We initialize
1137          most things with sane defaults, to keep the code below somewhat
1138          simpler. */
1139        unsigned char msgbuf0[34];
1140        unsigned char msgbuf1[34];
1141        int num = read_write == I2C_SMBUS_READ?2:1;
1142        struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 }, 
1143                                  { addr, flags | I2C_M_RD, 0, msgbuf1 }
1144                                };
1145        int i;
1146
1147        msgbuf0[0] = command;
1148        switch(size) {
1149        case I2C_SMBUS_QUICK:
1150                msg[0].len = 0;
1151                /* Special case: The read/write field is used as data */
1152                msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
1153                num = 1;
1154                break;
1155        case I2C_SMBUS_BYTE:
1156                if (read_write == I2C_SMBUS_READ) {
1157                        /* Special case: only a read! */
1158                        msg[0].flags = I2C_M_RD | flags;
1159                        num = 1;
1160                }
1161                break;
1162        case I2C_SMBUS_BYTE_DATA:
1163                if (read_write == I2C_SMBUS_READ)
1164                        msg[1].len = 1;
1165                else {
1166                        msg[0].len = 2;
1167                        msgbuf0[1] = data->byte;
1168                }
1169                break;
1170        case I2C_SMBUS_WORD_DATA:
1171                if (read_write == I2C_SMBUS_READ)
1172                        msg[1].len = 2;
1173                else {
1174                        msg[0].len=3;
1175                        msgbuf0[1] = data->word & 0xff;
1176                        msgbuf0[2] = (data->word >> 8) & 0xff;
1177                }
1178                break;
1179        case I2C_SMBUS_PROC_CALL:
1180                num = 2; /* Special case */
1181                msg[0].len = 3;
1182                msg[1].len = 2;
1183                msgbuf0[1] = data->word & 0xff;
1184                msgbuf0[2] = (data->word >> 8) & 0xff;
1185                break;
1186        case I2C_SMBUS_BLOCK_DATA:
1187                if (read_write == I2C_SMBUS_READ) {
1188                        printk("i2c-core.o: Block read not supported under "
1189                               "I2C emulation!\n");
1190                return -1;
1191                } else {
1192                        msg[0].len = data->block[0] + 2;
1193                        if (msg[0].len > 34) {
1194                                printk("i2c-core.o: smbus_access called with "
1195                                       "invalid block write size (%d)\n",
1196                                       msg[0].len);
1197                                return -1;
1198                        }
1199                        for (i = 1; i <= msg[0].len; i++)
1200                                msgbuf0[i] = data->block[i-1];
1201                }
1202                break;
1203        default:
1204                printk("i2c-core.o: smbus_access called with invalid size (%d)\n",
1205                       size);
1206                return -1;
1207        }
1208
1209        if (i2c_transfer(adapter, msg, num) < 0)
1210                return -1;
1211
1212        if (read_write == I2C_SMBUS_READ)
1213                switch(size) {
1214                        case I2C_SMBUS_BYTE:
1215                                data->byte = msgbuf0[0];
1216                                break;
1217                        case I2C_SMBUS_BYTE_DATA:
1218                                data->byte = msgbuf1[0];
1219                                break;
1220                        case I2C_SMBUS_WORD_DATA:
1221                        case I2C_SMBUS_PROC_CALL:
1222                                data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1223                                break;
1224                }
1225        return 0;
1226}
1227
1228
1229s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1230                   char read_write, u8 command, int size, 
1231                   union i2c_smbus_data * data)
1232{
1233        s32 res;
1234        flags = flags & I2C_M_TEN;
1235        if (adapter->algo->smbus_xfer) {
1236                I2C_LOCK(adapter);
1237                res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1238                                                command,size,data);
1239                I2C_UNLOCK(adapter);
1240        } else
1241                res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1242                                              command,size,data);
1243        return res;
1244}
1245
1246
1247/* You should always define `functionality'; the 'else' is just for
1248   backward compatibility. */ 
1249u32 i2c_get_functionality (struct i2c_adapter *adap)
1250{
1251        if (adap->algo->functionality)
1252                return adap->algo->functionality(adap);
1253        else
1254                return 0xffffffff;
1255}
1256
1257int i2c_check_functionality (struct i2c_adapter *adap, u32 func)
1258{
1259        u32 adap_func = i2c_get_functionality (adap);
1260        return (func & adap_func) == func;
1261}
1262
1263
1264static int __init i2c_init(void)
1265{
1266        printk("i2c-core.o: i2c core module\n");
1267        memset(adapters,0,sizeof(adapters));
1268        memset(drivers,0,sizeof(drivers));
1269        adap_count=0;
1270        driver_count=0;
1271
1272        init_MUTEX(&adap_lock);
1273        init_MUTEX(&driver_lock);
1274       
1275        i2cproc_init();
1276       
1277        return 0;
1278}
1279
1280#ifndef MODULE
1281#ifdef CONFIG_I2C_CHARDEV
1282        extern int i2c_dev_init(void);
1283#endif
1284#ifdef CONFIG_I2C_ALGOBIT
1285        extern int i2c_algo_bit_init(void);
1286#endif
1287#ifdef CONFIG_I2C_BITLP
1288        extern int i2c_bitlp_init(void);
1289#endif
1290#ifdef CONFIG_I2C_BITELV
1291        extern int i2c_bitelv_init(void);
1292#endif
1293#ifdef CONFIG_I2C_BITVELLE
1294        extern int i2c_bitvelle_init(void);
1295#endif
1296#ifdef CONFIG_I2C_BITVIA
1297        extern int i2c_bitvia_init(void);
1298#endif
1299
1300#ifdef CONFIG_I2C_ALGOPCF
1301        extern int i2c_algo_pcf_init(void);     
1302#endif
1303#ifdef CONFIG_I2C_PCFISA
1304        extern int i2c_pcfisa_init(void);
1305#endif
1306
1307#ifdef CONFIG_I2C_ALGO8XX
1308        extern int i2c_algo_8xx_init(void);
1309#endif
1310#ifdef CONFIG_I2C_RPXLITE
1311        extern int i2c_rpx_init(void);
1312#endif
1313
1314/* This is needed for automatic patch generation: sensors code starts here */
1315/* This is needed for automatic patch generation: sensors code ends here   */
1316
1317int __init i2c_init_all(void)
1318{
1319        /* --------------------- global ----- */
1320        i2c_init();
1321
1322#ifdef CONFIG_I2C_CHARDEV
1323        i2c_dev_init();
1324#endif
1325        /* --------------------- bit -------- */
1326#ifdef CONFIG_I2C_ALGOBIT
1327        i2c_algo_bit_init();
1328#endif
1329#ifdef CONFIG_I2C_PHILIPSPAR
1330        i2c_bitlp_init();
1331#endif
1332#ifdef CONFIG_I2C_ELV
1333        i2c_bitelv_init();
1334#endif
1335#ifdef CONFIG_I2C_VELLEMAN
1336        i2c_bitvelle_init();
1337#endif
1338
1339        /* --------------------- pcf -------- */
1340#ifdef CONFIG_I2C_ALGOPCF
1341        i2c_algo_pcf_init();   
1342#endif
1343#ifdef CONFIG_I2C_ELEKTOR
1344        i2c_pcfisa_init();
1345#endif
1346
1347        /* --------------------- 8xx -------- */
1348#ifdef CONFIG_I2C_ALGO8XX
1349        i2c_algo_8xx_init();
1350#endif
1351#ifdef CONFIG_I2C_RPXLITE
1352        i2c_rpx_init();
1353#endif
1354/* This is needed for automatic patch generation: sensors code starts here */
1355/* This is needed for automatic patch generation: sensors code ends here */
1356
1357        return 0;
1358}
1359
1360#endif
1361
1362
1363
1364EXPORT_SYMBOL(i2c_add_adapter);
1365EXPORT_SYMBOL(i2c_del_adapter);
1366EXPORT_SYMBOL(i2c_add_driver);
1367EXPORT_SYMBOL(i2c_del_driver);
1368EXPORT_SYMBOL(i2c_attach_client);
1369EXPORT_SYMBOL(i2c_detach_client);
1370EXPORT_SYMBOL(i2c_inc_use_client);
1371EXPORT_SYMBOL(i2c_dec_use_client);
1372EXPORT_SYMBOL(i2c_get_client);
1373EXPORT_SYMBOL(i2c_use_client);
1374EXPORT_SYMBOL(i2c_release_client);
1375EXPORT_SYMBOL(i2c_check_addr);
1376
1377
1378EXPORT_SYMBOL(i2c_master_send);
1379EXPORT_SYMBOL(i2c_master_recv);
1380EXPORT_SYMBOL(i2c_control);
1381EXPORT_SYMBOL(i2c_transfer);
1382EXPORT_SYMBOL(i2c_adapter_id);
1383EXPORT_SYMBOL(i2c_probe);
1384
1385EXPORT_SYMBOL(i2c_smbus_xfer);
1386EXPORT_SYMBOL(i2c_smbus_write_quick);
1387EXPORT_SYMBOL(i2c_smbus_read_byte);
1388EXPORT_SYMBOL(i2c_smbus_write_byte);
1389EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1390EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1391EXPORT_SYMBOL(i2c_smbus_read_word_data);
1392EXPORT_SYMBOL(i2c_smbus_write_word_data);
1393EXPORT_SYMBOL(i2c_smbus_process_call);
1394EXPORT_SYMBOL(i2c_smbus_read_block_data);
1395EXPORT_SYMBOL(i2c_smbus_write_block_data);
1396
1397EXPORT_SYMBOL(i2c_get_functionality);
1398EXPORT_SYMBOL(i2c_check_functionality);
1399
1400#ifdef MODULE
1401MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1402MODULE_DESCRIPTION("I2C-Bus main module");
1403MODULE_PARM(i2c_debug, "i");
1404MODULE_PARM_DESC(i2c_debug,"debug level");
1405
1406int init_module(void) 
1407{
1408        return i2c_init();
1409}
1410
1411void cleanup_module(void) 
1412{
1413        i2cproc_cleanup();
1414}
1415#endif
Note: See TracBrowser for help on using the browser.