Context Navigation

i2c-core.c @ 3560

Revision 3560, 36.2 KB (checked in by mds, 12 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 */
63	struct semaphore adap_lock;
64	struct semaphore driver_lock;
65
66	/**** adapter list */
67	static struct i2c_adapter *adapters[I2C_ADAP_MAX];
68	static int adap_count;
69
70	/**** drivers list */
71	static struct i2c_driver *drivers[I2C_DRIVER_MAX];
72	static int driver_count;
73
74	/**** debug level */
75	static int i2c_debug=1;
76
77	/* ---------------------------------------------------
78	* /proc entry declarations
79	*----------------------------------------------------
80	*/
81
82	#ifdef CONFIG_PROC_FS
83
84	static int i2cproc_init(void);
85	static int i2cproc_cleanup(void);
86
87	#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,3,27))
88	static void monitor_bus_i2c(struct inode *inode, int fill);
89	#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,58)) */
90
91	static ssize_t i2cproc_bus_read(struct file * file, char * buf,size_t count,
92	loff_t *ppos);
93	static 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 */
98	static struct file_operations i2cproc_operations = {
99	read: i2cproc_bus_read,
100	};
101
102	#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,48))
103	static struct inode_operations i2cproc_inode_operations = {
104	&i2cproc_operations
105	};
106	#endif
107
108	static 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	*/
128	int 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
197	ERROR1:
198	ADAP_LOCK();
199	adapters[i] = NULL;
200	adap_count--;
201	ERROR0:
202	ADAP_UNLOCK();
203	return res;
204	}
205
206
207	int 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
272	ERROR0:
273	ADAP_UNLOCK();
274	return res;
275	ERROR1:
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
287	int 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
324	int 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
407	int 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
416	int 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
452	int 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
485	void 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
495	void 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
505	struct 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
572	int 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
590	int 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 */
617	void 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 */
627	int 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-? */
653	ssize_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
715	int 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
743	int 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
761	int 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
781	int 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
811	int 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
845	int 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	*/
871	int 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	*/
995	int 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
1006	extern 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
1012	extern 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
1022	extern 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
1028	extern 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
1038	extern 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
1048	extern 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
1058	extern 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
1068	extern 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 */
1082	extern 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
1098	extern 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
1113	extern 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! */
1130	static 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
1229	s32 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. */
1249	u32 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
1257	int 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
1264	static 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
1317	int __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
1364	EXPORT_SYMBOL(i2c_add_adapter);
1365	EXPORT_SYMBOL(i2c_del_adapter);
1366	EXPORT_SYMBOL(i2c_add_driver);
1367	EXPORT_SYMBOL(i2c_del_driver);
1368	EXPORT_SYMBOL(i2c_attach_client);
1369	EXPORT_SYMBOL(i2c_detach_client);
1370	EXPORT_SYMBOL(i2c_inc_use_client);
1371	EXPORT_SYMBOL(i2c_dec_use_client);
1372	EXPORT_SYMBOL(i2c_get_client);
1373	EXPORT_SYMBOL(i2c_use_client);
1374	EXPORT_SYMBOL(i2c_release_client);
1375	EXPORT_SYMBOL(i2c_check_addr);
1376
1377
1378	EXPORT_SYMBOL(i2c_master_send);
1379	EXPORT_SYMBOL(i2c_master_recv);
1380	EXPORT_SYMBOL(i2c_control);
1381	EXPORT_SYMBOL(i2c_transfer);
1382	EXPORT_SYMBOL(i2c_adapter_id);
1383	EXPORT_SYMBOL(i2c_probe);
1384
1385	EXPORT_SYMBOL(i2c_smbus_xfer);
1386	EXPORT_SYMBOL(i2c_smbus_write_quick);
1387	EXPORT_SYMBOL(i2c_smbus_read_byte);
1388	EXPORT_SYMBOL(i2c_smbus_write_byte);
1389	EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1390	EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1391	EXPORT_SYMBOL(i2c_smbus_read_word_data);
1392	EXPORT_SYMBOL(i2c_smbus_write_word_data);
1393	EXPORT_SYMBOL(i2c_smbus_process_call);
1394	EXPORT_SYMBOL(i2c_smbus_read_block_data);
1395	EXPORT_SYMBOL(i2c_smbus_write_block_data);
1396
1397	EXPORT_SYMBOL(i2c_get_functionality);
1398	EXPORT_SYMBOL(i2c_check_functionality);
1399
1400	#ifdef MODULE
1401	MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1402	MODULE_DESCRIPTION("I2C-Bus main module");
1403	MODULE_PARM(i2c_debug, "i");
1404	MODULE_PARM_DESC(i2c_debug,"debug level");
1405
1406	int init_module(void)
1407	{
1408	return i2c_init();
1409	}
1410
1411	void cleanup_module(void)
1412	{
1413	i2cproc_cleanup();
1414	}
1415	#endif

Note: See TracBrowser for help on using the browser.

Context Navigation

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

Download in other formats: