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