Merge master.kernel.org:/home/rmk/linux-2.6-serial
[linux-2.6] / drivers / i2c / i2c-core.c
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    SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
23    Jean Delvare <khali@linux-fr.org> */
24
25 #include <linux/module.h>
26 #include <linux/kernel.h>
27 #include <linux/errno.h>
28 #include <linux/slab.h>
29 #include <linux/i2c.h>
30 #include <linux/init.h>
31 #include <linux/idr.h>
32 #include <linux/seq_file.h>
33 #include <linux/platform_device.h>
34 #include <asm/uaccess.h>
35
36
37 static LIST_HEAD(adapters);
38 static LIST_HEAD(drivers);
39 static DECLARE_MUTEX(core_lists);
40 static DEFINE_IDR(i2c_adapter_idr);
41
42 /* match always succeeds, as we want the probe() to tell if we really accept this match */
43 static int i2c_device_match(struct device *dev, struct device_driver *drv)
44 {
45         return 1;
46 }
47
48 static int i2c_bus_suspend(struct device * dev, pm_message_t state)
49 {
50         int rc = 0;
51
52         if (dev->driver && dev->driver->suspend)
53                 rc = dev->driver->suspend(dev, state);
54         return rc;
55 }
56
57 static int i2c_bus_resume(struct device * dev)
58 {
59         int rc = 0;
60         
61         if (dev->driver && dev->driver->resume)
62                 rc = dev->driver->resume(dev);
63         return rc;
64 }
65
66 static int i2c_device_probe(struct device *dev)
67 {
68         return -ENODEV;
69 }
70
71 static int i2c_device_remove(struct device *dev)
72 {
73         return 0;
74 }
75
76 struct bus_type i2c_bus_type = {
77         .name =         "i2c",
78         .match =        i2c_device_match,
79         .probe =        i2c_device_probe,
80         .remove =       i2c_device_remove,
81         .suspend =      i2c_bus_suspend,
82         .resume =       i2c_bus_resume,
83 };
84
85 void i2c_adapter_dev_release(struct device *dev)
86 {
87         struct i2c_adapter *adap = dev_to_i2c_adapter(dev);
88         complete(&adap->dev_released);
89 }
90
91 struct device_driver i2c_adapter_driver = {
92         .owner = THIS_MODULE,
93         .name = "i2c_adapter",
94         .bus = &i2c_bus_type,
95 };
96
97 static void i2c_adapter_class_dev_release(struct class_device *dev)
98 {
99         struct i2c_adapter *adap = class_dev_to_i2c_adapter(dev);
100         complete(&adap->class_dev_released);
101 }
102
103 struct class i2c_adapter_class = {
104         .owner =        THIS_MODULE,
105         .name =         "i2c-adapter",
106         .release =      &i2c_adapter_class_dev_release,
107 };
108
109 static ssize_t show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
110 {
111         struct i2c_adapter *adap = dev_to_i2c_adapter(dev);
112         return sprintf(buf, "%s\n", adap->name);
113 }
114 static DEVICE_ATTR(name, S_IRUGO, show_adapter_name, NULL);
115
116
117 static void i2c_client_release(struct device *dev)
118 {
119         struct i2c_client *client = to_i2c_client(dev);
120         complete(&client->released);
121 }
122
123 static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
124 {
125         struct i2c_client *client = to_i2c_client(dev);
126         return sprintf(buf, "%s\n", client->name);
127 }
128
129 /* 
130  * We can't use the DEVICE_ATTR() macro here as we want the same filename for a
131  * different type of a device.  So beware if the DEVICE_ATTR() macro ever
132  * changes, this definition will also have to change.
133  */
134 static struct device_attribute dev_attr_client_name = {
135         .attr   = {.name = "name", .mode = S_IRUGO, .owner = THIS_MODULE },
136         .show   = &show_client_name,
137 };
138
139
140 /* ---------------------------------------------------
141  * registering functions 
142  * --------------------------------------------------- 
143  */
144
145 /* -----
146  * i2c_add_adapter is called from within the algorithm layer,
147  * when a new hw adapter registers. A new device is register to be
148  * available for clients.
149  */
150 int i2c_add_adapter(struct i2c_adapter *adap)
151 {
152         int id, res = 0;
153         struct list_head   *item;
154         struct i2c_driver  *driver;
155
156         down(&core_lists);
157
158         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0) {
159                 res = -ENOMEM;
160                 goto out_unlock;
161         }
162
163         res = idr_get_new(&i2c_adapter_idr, adap, &id);
164         if (res < 0) {
165                 if (res == -EAGAIN)
166                         res = -ENOMEM;
167                 goto out_unlock;
168         }
169
170         adap->nr =  id & MAX_ID_MASK;
171         init_MUTEX(&adap->bus_lock);
172         init_MUTEX(&adap->clist_lock);
173         list_add_tail(&adap->list,&adapters);
174         INIT_LIST_HEAD(&adap->clients);
175
176         /* Add the adapter to the driver core.
177          * If the parent pointer is not set up,
178          * we add this adapter to the host bus.
179          */
180         if (adap->dev.parent == NULL)
181                 adap->dev.parent = &platform_bus;
182         sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
183         adap->dev.driver = &i2c_adapter_driver;
184         adap->dev.release = &i2c_adapter_dev_release;
185         device_register(&adap->dev);
186         device_create_file(&adap->dev, &dev_attr_name);
187
188         /* Add this adapter to the i2c_adapter class */
189         memset(&adap->class_dev, 0x00, sizeof(struct class_device));
190         adap->class_dev.dev = &adap->dev;
191         adap->class_dev.class = &i2c_adapter_class;
192         strlcpy(adap->class_dev.class_id, adap->dev.bus_id, BUS_ID_SIZE);
193         class_device_register(&adap->class_dev);
194
195         dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
196
197         /* inform drivers of new adapters */
198         list_for_each(item,&drivers) {
199                 driver = list_entry(item, struct i2c_driver, list);
200                 if (driver->attach_adapter)
201                         /* We ignore the return code; if it fails, too bad */
202                         driver->attach_adapter(adap);
203         }
204
205 out_unlock:
206         up(&core_lists);
207         return res;
208 }
209
210
211 int i2c_del_adapter(struct i2c_adapter *adap)
212 {
213         struct list_head  *item, *_n;
214         struct i2c_adapter *adap_from_list;
215         struct i2c_driver *driver;
216         struct i2c_client *client;
217         int res = 0;
218
219         down(&core_lists);
220
221         /* First make sure that this adapter was ever added */
222         list_for_each_entry(adap_from_list, &adapters, list) {
223                 if (adap_from_list == adap)
224                         break;
225         }
226         if (adap_from_list != adap) {
227                 pr_debug("i2c-core: attempting to delete unregistered "
228                          "adapter [%s]\n", adap->name);
229                 res = -EINVAL;
230                 goto out_unlock;
231         }
232
233         list_for_each(item,&drivers) {
234                 driver = list_entry(item, struct i2c_driver, list);
235                 if (driver->detach_adapter)
236                         if ((res = driver->detach_adapter(adap))) {
237                                 dev_err(&adap->dev, "detach_adapter failed "
238                                         "for driver [%s]\n",
239                                         driver->driver.name);
240                                 goto out_unlock;
241                         }
242         }
243
244         /* detach any active clients. This must be done first, because
245          * it can fail; in which case we give up. */
246         list_for_each_safe(item, _n, &adap->clients) {
247                 client = list_entry(item, struct i2c_client, list);
248
249                 if ((res=client->driver->detach_client(client))) {
250                         dev_err(&adap->dev, "detach_client failed for client "
251                                 "[%s] at address 0x%02x\n", client->name,
252                                 client->addr);
253                         goto out_unlock;
254                 }
255         }
256
257         /* clean up the sysfs representation */
258         init_completion(&adap->dev_released);
259         init_completion(&adap->class_dev_released);
260         class_device_unregister(&adap->class_dev);
261         device_remove_file(&adap->dev, &dev_attr_name);
262         device_unregister(&adap->dev);
263         list_del(&adap->list);
264
265         /* wait for sysfs to drop all references */
266         wait_for_completion(&adap->dev_released);
267         wait_for_completion(&adap->class_dev_released);
268
269         /* free dynamically allocated bus id */
270         idr_remove(&i2c_adapter_idr, adap->nr);
271
272         dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
273
274  out_unlock:
275         up(&core_lists);
276         return res;
277 }
278
279
280 /* -----
281  * What follows is the "upwards" interface: commands for talking to clients,
282  * which implement the functions to access the physical information of the
283  * chips.
284  */
285
286 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
287 {
288         struct list_head   *item;
289         struct i2c_adapter *adapter;
290         int res = 0;
291
292         down(&core_lists);
293
294         /* add the driver to the list of i2c drivers in the driver core */
295         driver->driver.owner = owner;
296         driver->driver.bus = &i2c_bus_type;
297
298         res = driver_register(&driver->driver);
299         if (res)
300                 goto out_unlock;
301         
302         list_add_tail(&driver->list,&drivers);
303         pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
304
305         /* now look for instances of driver on our adapters */
306         if (driver->attach_adapter) {
307                 list_for_each(item,&adapters) {
308                         adapter = list_entry(item, struct i2c_adapter, list);
309                         driver->attach_adapter(adapter);
310                 }
311         }
312
313  out_unlock:
314         up(&core_lists);
315         return res;
316 }
317 EXPORT_SYMBOL(i2c_register_driver);
318
319 int i2c_del_driver(struct i2c_driver *driver)
320 {
321         struct list_head   *item1, *item2, *_n;
322         struct i2c_client  *client;
323         struct i2c_adapter *adap;
324         
325         int res = 0;
326
327         down(&core_lists);
328
329         /* Have a look at each adapter, if clients of this driver are still
330          * attached. If so, detach them to be able to kill the driver 
331          * afterwards.
332          */
333         list_for_each(item1,&adapters) {
334                 adap = list_entry(item1, struct i2c_adapter, list);
335                 if (driver->detach_adapter) {
336                         if ((res = driver->detach_adapter(adap))) {
337                                 dev_err(&adap->dev, "detach_adapter failed "
338                                         "for driver [%s]\n",
339                                         driver->driver.name);
340                                 goto out_unlock;
341                         }
342                 } else {
343                         list_for_each_safe(item2, _n, &adap->clients) {
344                                 client = list_entry(item2, struct i2c_client, list);
345                                 if (client->driver != driver)
346                                         continue;
347                                 dev_dbg(&adap->dev, "detaching client [%s] "
348                                         "at 0x%02x\n", client->name,
349                                         client->addr);
350                                 if ((res = driver->detach_client(client))) {
351                                         dev_err(&adap->dev, "detach_client "
352                                                 "failed for client [%s] at "
353                                                 "0x%02x\n", client->name,
354                                                 client->addr);
355                                         goto out_unlock;
356                                 }
357                         }
358                 }
359         }
360
361         driver_unregister(&driver->driver);
362         list_del(&driver->list);
363         pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
364
365  out_unlock:
366         up(&core_lists);
367         return 0;
368 }
369
370 static int __i2c_check_addr(struct i2c_adapter *adapter, unsigned int addr)
371 {
372         struct list_head   *item;
373         struct i2c_client  *client;
374
375         list_for_each(item,&adapter->clients) {
376                 client = list_entry(item, struct i2c_client, list);
377                 if (client->addr == addr)
378                         return -EBUSY;
379         }
380         return 0;
381 }
382
383 int i2c_check_addr(struct i2c_adapter *adapter, int addr)
384 {
385         int rval;
386
387         down(&adapter->clist_lock);
388         rval = __i2c_check_addr(adapter, addr);
389         up(&adapter->clist_lock);
390
391         return rval;
392 }
393
394 int i2c_attach_client(struct i2c_client *client)
395 {
396         struct i2c_adapter *adapter = client->adapter;
397
398         down(&adapter->clist_lock);
399         if (__i2c_check_addr(client->adapter, client->addr)) {
400                 up(&adapter->clist_lock);
401                 return -EBUSY;
402         }
403         list_add_tail(&client->list,&adapter->clients);
404         up(&adapter->clist_lock);
405         
406         if (adapter->client_register)  {
407                 if (adapter->client_register(client))  {
408                         dev_dbg(&adapter->dev, "client_register "
409                                 "failed for client [%s] at 0x%02x\n",
410                                 client->name, client->addr);
411                 }
412         }
413
414         client->usage_count = 0;
415
416         client->dev.parent = &client->adapter->dev;
417         client->dev.driver = &client->driver->driver;
418         client->dev.bus = &i2c_bus_type;
419         client->dev.release = &i2c_client_release;
420         
421         snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
422                 "%d-%04x", i2c_adapter_id(adapter), client->addr);
423         dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
424                 client->name, client->dev.bus_id);
425         device_register(&client->dev);
426         device_create_file(&client->dev, &dev_attr_client_name);
427         
428         return 0;
429 }
430
431
432 int i2c_detach_client(struct i2c_client *client)
433 {
434         struct i2c_adapter *adapter = client->adapter;
435         int res = 0;
436         
437         if (client->usage_count > 0) {
438                 dev_warn(&client->dev, "Client [%s] still busy, "
439                          "can't detach\n", client->name);
440                 return -EBUSY;
441         }
442
443         if (adapter->client_unregister)  {
444                 res = adapter->client_unregister(client);
445                 if (res) {
446                         dev_err(&client->dev,
447                                 "client_unregister [%s] failed, "
448                                 "client not detached\n", client->name);
449                         goto out;
450                 }
451         }
452
453         down(&adapter->clist_lock);
454         list_del(&client->list);
455         init_completion(&client->released);
456         device_remove_file(&client->dev, &dev_attr_client_name);
457         device_unregister(&client->dev);
458         up(&adapter->clist_lock);
459         wait_for_completion(&client->released);
460
461  out:
462         return res;
463 }
464
465 static int i2c_inc_use_client(struct i2c_client *client)
466 {
467
468         if (!try_module_get(client->driver->driver.owner))
469                 return -ENODEV;
470         if (!try_module_get(client->adapter->owner)) {
471                 module_put(client->driver->driver.owner);
472                 return -ENODEV;
473         }
474
475         return 0;
476 }
477
478 static void i2c_dec_use_client(struct i2c_client *client)
479 {
480         module_put(client->driver->driver.owner);
481         module_put(client->adapter->owner);
482 }
483
484 int i2c_use_client(struct i2c_client *client)
485 {
486         int ret;
487
488         ret = i2c_inc_use_client(client);
489         if (ret)
490                 return ret;
491
492         client->usage_count++;
493
494         return 0;
495 }
496
497 int i2c_release_client(struct i2c_client *client)
498 {
499         if (!client->usage_count) {
500                 pr_debug("i2c-core: %s used one too many times\n",
501                          __FUNCTION__);
502                 return -EPERM;
503         }
504         
505         client->usage_count--;
506         i2c_dec_use_client(client);
507         
508         return 0;
509 }
510
511 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
512 {
513         struct list_head  *item;
514         struct i2c_client *client;
515
516         down(&adap->clist_lock);
517         list_for_each(item,&adap->clients) {
518                 client = list_entry(item, struct i2c_client, list);
519                 if (!try_module_get(client->driver->driver.owner))
520                         continue;
521                 if (NULL != client->driver->command) {
522                         up(&adap->clist_lock);
523                         client->driver->command(client,cmd,arg);
524                         down(&adap->clist_lock);
525                 }
526                 module_put(client->driver->driver.owner);
527        }
528        up(&adap->clist_lock);
529 }
530
531 static int __init i2c_init(void)
532 {
533         int retval;
534
535         retval = bus_register(&i2c_bus_type);
536         if (retval)
537                 return retval;
538         retval = driver_register(&i2c_adapter_driver);
539         if (retval)
540                 return retval;
541         return class_register(&i2c_adapter_class);
542 }
543
544 static void __exit i2c_exit(void)
545 {
546         class_unregister(&i2c_adapter_class);
547         driver_unregister(&i2c_adapter_driver);
548         bus_unregister(&i2c_bus_type);
549 }
550
551 subsys_initcall(i2c_init);
552 module_exit(i2c_exit);
553
554 /* ----------------------------------------------------
555  * the functional interface to the i2c busses.
556  * ----------------------------------------------------
557  */
558
559 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
560 {
561         int ret;
562
563         if (adap->algo->master_xfer) {
564 #ifdef DEBUG
565                 for (ret = 0; ret < num; ret++) {
566                         dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
567                                 "len=%d\n", ret, msgs[ret].flags & I2C_M_RD ?
568                                 'R' : 'W', msgs[ret].addr, msgs[ret].len);
569                 }
570 #endif
571
572                 down(&adap->bus_lock);
573                 ret = adap->algo->master_xfer(adap,msgs,num);
574                 up(&adap->bus_lock);
575
576                 return ret;
577         } else {
578                 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
579                 return -ENOSYS;
580         }
581 }
582
583 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
584 {
585         int ret;
586         struct i2c_adapter *adap=client->adapter;
587         struct i2c_msg msg;
588
589         msg.addr = client->addr;
590         msg.flags = client->flags & I2C_M_TEN;
591         msg.len = count;
592         msg.buf = (char *)buf;
593         
594         ret = i2c_transfer(adap, &msg, 1);
595
596         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
597            transmitted, else error code. */
598         return (ret == 1) ? count : ret;
599 }
600
601 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
602 {
603         struct i2c_adapter *adap=client->adapter;
604         struct i2c_msg msg;
605         int ret;
606
607         msg.addr = client->addr;
608         msg.flags = client->flags & I2C_M_TEN;
609         msg.flags |= I2C_M_RD;
610         msg.len = count;
611         msg.buf = buf;
612
613         ret = i2c_transfer(adap, &msg, 1);
614
615         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
616            transmitted, else error code. */
617         return (ret == 1) ? count : ret;
618 }
619
620
621 int i2c_control(struct i2c_client *client,
622         unsigned int cmd, unsigned long arg)
623 {
624         int ret = 0;
625         struct i2c_adapter *adap = client->adapter;
626
627         dev_dbg(&client->adapter->dev, "i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg);
628         switch (cmd) {
629                 case I2C_RETRIES:
630                         adap->retries = arg;
631                         break;
632                 case I2C_TIMEOUT:
633                         adap->timeout = arg;
634                         break;
635                 default:
636                         if (adap->algo->algo_control!=NULL)
637                                 ret = adap->algo->algo_control(adap,cmd,arg);
638         }
639         return ret;
640 }
641
642 /* ----------------------------------------------------
643  * the i2c address scanning function
644  * Will not work for 10-bit addresses!
645  * ----------------------------------------------------
646  */
647 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
648                              int (*found_proc) (struct i2c_adapter *, int, int))
649 {
650         int err;
651
652         /* Make sure the address is valid */
653         if (addr < 0x03 || addr > 0x77) {
654                 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
655                          addr);
656                 return -EINVAL;
657         }
658
659         /* Skip if already in use */
660         if (i2c_check_addr(adapter, addr))
661                 return 0;
662
663         /* Make sure there is something at this address, unless forced */
664         if (kind < 0) {
665                 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
666                                    I2C_SMBUS_QUICK, NULL) < 0)
667                         return 0;
668
669                 /* prevent 24RF08 corruption */
670                 if ((addr & ~0x0f) == 0x50)
671                         i2c_smbus_xfer(adapter, addr, 0, 0, 0,
672                                        I2C_SMBUS_QUICK, NULL);
673         }
674
675         /* Finally call the custom detection function */
676         err = found_proc(adapter, addr, kind);
677
678         /* -ENODEV can be returned if there is a chip at the given address
679            but it isn't supported by this chip driver. We catch it here as
680            this isn't an error. */
681         return (err == -ENODEV) ? 0 : err;
682 }
683
684 int i2c_probe(struct i2c_adapter *adapter,
685               struct i2c_client_address_data *address_data,
686               int (*found_proc) (struct i2c_adapter *, int, int))
687 {
688         int i, err;
689         int adap_id = i2c_adapter_id(adapter);
690
691         /* Force entries are done first, and are not affected by ignore
692            entries */
693         if (address_data->forces) {
694                 unsigned short **forces = address_data->forces;
695                 int kind;
696
697                 for (kind = 0; forces[kind]; kind++) {
698                         for (i = 0; forces[kind][i] != I2C_CLIENT_END;
699                              i += 2) {
700                                 if (forces[kind][i] == adap_id
701                                  || forces[kind][i] == ANY_I2C_BUS) {
702                                         dev_dbg(&adapter->dev, "found force "
703                                                 "parameter for adapter %d, "
704                                                 "addr 0x%02x, kind %d\n",
705                                                 adap_id, forces[kind][i + 1],
706                                                 kind);
707                                         err = i2c_probe_address(adapter,
708                                                 forces[kind][i + 1],
709                                                 kind, found_proc);
710                                         if (err)
711                                                 return err;
712                                 }
713                         }
714                 }
715         }
716
717         /* Stop here if we can't use SMBUS_QUICK */
718         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
719                 if (address_data->probe[0] == I2C_CLIENT_END
720                  && address_data->normal_i2c[0] == I2C_CLIENT_END)
721                         return 0;
722
723                 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
724                          "can't probe for chips\n");
725                 return -1;
726         }
727
728         /* Probe entries are done second, and are not affected by ignore
729            entries either */
730         for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
731                 if (address_data->probe[i] == adap_id
732                  || address_data->probe[i] == ANY_I2C_BUS) {
733                         dev_dbg(&adapter->dev, "found probe parameter for "
734                                 "adapter %d, addr 0x%02x\n", adap_id,
735                                 address_data->probe[i + 1]);
736                         err = i2c_probe_address(adapter,
737                                                 address_data->probe[i + 1],
738                                                 -1, found_proc);
739                         if (err)
740                                 return err;
741                 }
742         }
743
744         /* Normal entries are done last, unless shadowed by an ignore entry */
745         for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
746                 int j, ignore;
747
748                 ignore = 0;
749                 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
750                      j += 2) {
751                         if ((address_data->ignore[j] == adap_id ||
752                              address_data->ignore[j] == ANY_I2C_BUS)
753                          && address_data->ignore[j + 1]
754                             == address_data->normal_i2c[i]) {
755                                 dev_dbg(&adapter->dev, "found ignore "
756                                         "parameter for adapter %d, "
757                                         "addr 0x%02x\n", adap_id,
758                                         address_data->ignore[j + 1]);
759                         }
760                         ignore = 1;
761                         break;
762                 }
763                 if (ignore)
764                         continue;
765
766                 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
767                         "addr 0x%02x\n", adap_id,
768                         address_data->normal_i2c[i]);
769                 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
770                                         -1, found_proc);
771                 if (err)
772                         return err;
773         }
774
775         return 0;
776 }
777
778 struct i2c_adapter* i2c_get_adapter(int id)
779 {
780         struct i2c_adapter *adapter;
781         
782         down(&core_lists);
783         adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
784         if (adapter && !try_module_get(adapter->owner))
785                 adapter = NULL;
786
787         up(&core_lists);
788         return adapter;
789 }
790
791 void i2c_put_adapter(struct i2c_adapter *adap)
792 {
793         module_put(adap->owner);
794 }
795
796 /* The SMBus parts */
797
798 #define POLY    (0x1070U << 3) 
799 static u8
800 crc8(u16 data)
801 {
802         int i;
803   
804         for(i = 0; i < 8; i++) {
805                 if (data & 0x8000) 
806                         data = data ^ POLY;
807                 data = data << 1;
808         }
809         return (u8)(data >> 8);
810 }
811
812 /* Incremental CRC8 over count bytes in the array pointed to by p */
813 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
814 {
815         int i;
816
817         for(i = 0; i < count; i++)
818                 crc = crc8((crc ^ p[i]) << 8);
819         return crc;
820 }
821
822 /* Assume a 7-bit address, which is reasonable for SMBus */
823 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
824 {
825         /* The address will be sent first */
826         u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
827         pec = i2c_smbus_pec(pec, &addr, 1);
828
829         /* The data buffer follows */
830         return i2c_smbus_pec(pec, msg->buf, msg->len);
831 }
832
833 /* Used for write only transactions */
834 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
835 {
836         msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
837         msg->len++;
838 }
839
840 /* Return <0 on CRC error
841    If there was a write before this read (most cases) we need to take the
842    partial CRC from the write part into account.
843    Note that this function does modify the message (we need to decrease the
844    message length to hide the CRC byte from the caller). */
845 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
846 {
847         u8 rpec = msg->buf[--msg->len];
848         cpec = i2c_smbus_msg_pec(cpec, msg);
849
850         if (rpec != cpec) {
851                 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
852                         rpec, cpec);
853                 return -1;
854         }
855         return 0;       
856 }
857
858 s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value)
859 {
860         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
861                               value,0,I2C_SMBUS_QUICK,NULL);
862 }
863
864 s32 i2c_smbus_read_byte(struct i2c_client *client)
865 {
866         union i2c_smbus_data data;
867         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
868                            I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data))
869                 return -1;
870         else
871                 return 0x0FF & data.byte;
872 }
873
874 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
875 {
876         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
877                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
878 }
879
880 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
881 {
882         union i2c_smbus_data data;
883         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
884                            I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data))
885                 return -1;
886         else
887                 return 0x0FF & data.byte;
888 }
889
890 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
891 {
892         union i2c_smbus_data data;
893         data.byte = value;
894         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
895                               I2C_SMBUS_WRITE,command,
896                               I2C_SMBUS_BYTE_DATA,&data);
897 }
898
899 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
900 {
901         union i2c_smbus_data data;
902         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
903                            I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data))
904                 return -1;
905         else
906                 return 0x0FFFF & data.word;
907 }
908
909 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
910 {
911         union i2c_smbus_data data;
912         data.word = value;
913         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
914                               I2C_SMBUS_WRITE,command,
915                               I2C_SMBUS_WORD_DATA,&data);
916 }
917
918 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
919                                u8 length, u8 *values)
920 {
921         union i2c_smbus_data data;
922         int i;
923         if (length > I2C_SMBUS_BLOCK_MAX)
924                 length = I2C_SMBUS_BLOCK_MAX;
925         for (i = 1; i <= length; i++)
926                 data.block[i] = values[i-1];
927         data.block[0] = length;
928         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
929                               I2C_SMBUS_WRITE,command,
930                               I2C_SMBUS_BLOCK_DATA,&data);
931 }
932
933 /* Returns the number of read bytes */
934 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command, u8 *values)
935 {
936         union i2c_smbus_data data;
937         int i;
938         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
939                               I2C_SMBUS_READ,command,
940                               I2C_SMBUS_I2C_BLOCK_DATA,&data))
941                 return -1;
942         else {
943                 for (i = 1; i <= data.block[0]; i++)
944                         values[i-1] = data.block[i];
945                 return data.block[0];
946         }
947 }
948
949 /* Simulate a SMBus command using the i2c protocol 
950    No checking of parameters is done!  */
951 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr, 
952                                    unsigned short flags,
953                                    char read_write, u8 command, int size, 
954                                    union i2c_smbus_data * data)
955 {
956         /* So we need to generate a series of msgs. In the case of writing, we
957           need to use only one message; when reading, we need two. We initialize
958           most things with sane defaults, to keep the code below somewhat
959           simpler. */
960         unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
961         unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
962         int num = read_write == I2C_SMBUS_READ?2:1;
963         struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 }, 
964                                   { addr, flags | I2C_M_RD, 0, msgbuf1 }
965                                 };
966         int i;
967         u8 partial_pec = 0;
968
969         msgbuf0[0] = command;
970         switch(size) {
971         case I2C_SMBUS_QUICK:
972                 msg[0].len = 0;
973                 /* Special case: The read/write field is used as data */
974                 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
975                 num = 1;
976                 break;
977         case I2C_SMBUS_BYTE:
978                 if (read_write == I2C_SMBUS_READ) {
979                         /* Special case: only a read! */
980                         msg[0].flags = I2C_M_RD | flags;
981                         num = 1;
982                 }
983                 break;
984         case I2C_SMBUS_BYTE_DATA:
985                 if (read_write == I2C_SMBUS_READ)
986                         msg[1].len = 1;
987                 else {
988                         msg[0].len = 2;
989                         msgbuf0[1] = data->byte;
990                 }
991                 break;
992         case I2C_SMBUS_WORD_DATA:
993                 if (read_write == I2C_SMBUS_READ)
994                         msg[1].len = 2;
995                 else {
996                         msg[0].len=3;
997                         msgbuf0[1] = data->word & 0xff;
998                         msgbuf0[2] = (data->word >> 8) & 0xff;
999                 }
1000                 break;
1001         case I2C_SMBUS_PROC_CALL:
1002                 num = 2; /* Special case */
1003                 read_write = I2C_SMBUS_READ;
1004                 msg[0].len = 3;
1005                 msg[1].len = 2;
1006                 msgbuf0[1] = data->word & 0xff;
1007                 msgbuf0[2] = (data->word >> 8) & 0xff;
1008                 break;
1009         case I2C_SMBUS_BLOCK_DATA:
1010                 if (read_write == I2C_SMBUS_READ) {
1011                         dev_err(&adapter->dev, "Block read not supported "
1012                                "under I2C emulation!\n");
1013                         return -1;
1014                 } else {
1015                         msg[0].len = data->block[0] + 2;
1016                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1017                                 dev_err(&adapter->dev, "smbus_access called with "
1018                                        "invalid block write size (%d)\n",
1019                                        data->block[0]);
1020                                 return -1;
1021                         }
1022                         for (i = 1; i < msg[0].len; i++)
1023                                 msgbuf0[i] = data->block[i-1];
1024                 }
1025                 break;
1026         case I2C_SMBUS_BLOCK_PROC_CALL:
1027                 dev_dbg(&adapter->dev, "Block process call not supported "
1028                        "under I2C emulation!\n");
1029                 return -1;
1030         case I2C_SMBUS_I2C_BLOCK_DATA:
1031                 if (read_write == I2C_SMBUS_READ) {
1032                         msg[1].len = I2C_SMBUS_BLOCK_MAX;
1033                 } else {
1034                         msg[0].len = data->block[0] + 1;
1035                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1036                                 dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with "
1037                                        "invalid block write size (%d)\n",
1038                                        data->block[0]);
1039                                 return -1;
1040                         }
1041                         for (i = 1; i <= data->block[0]; i++)
1042                                 msgbuf0[i] = data->block[i];
1043                 }
1044                 break;
1045         default:
1046                 dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n",
1047                        size);
1048                 return -1;
1049         }
1050
1051         i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1052                                       && size != I2C_SMBUS_I2C_BLOCK_DATA);
1053         if (i) {
1054                 /* Compute PEC if first message is a write */
1055                 if (!(msg[0].flags & I2C_M_RD)) {
1056                         if (num == 1) /* Write only */
1057                                 i2c_smbus_add_pec(&msg[0]);
1058                         else /* Write followed by read */
1059                                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1060                 }
1061                 /* Ask for PEC if last message is a read */
1062                 if (msg[num-1].flags & I2C_M_RD)
1063                         msg[num-1].len++;
1064         }
1065
1066         if (i2c_transfer(adapter, msg, num) < 0)
1067                 return -1;
1068
1069         /* Check PEC if last message is a read */
1070         if (i && (msg[num-1].flags & I2C_M_RD)) {
1071                 if (i2c_smbus_check_pec(partial_pec, &msg[num-1]) < 0)
1072                         return -1;
1073         }
1074
1075         if (read_write == I2C_SMBUS_READ)
1076                 switch(size) {
1077                         case I2C_SMBUS_BYTE:
1078                                 data->byte = msgbuf0[0];
1079                                 break;
1080                         case I2C_SMBUS_BYTE_DATA:
1081                                 data->byte = msgbuf1[0];
1082                                 break;
1083                         case I2C_SMBUS_WORD_DATA: 
1084                         case I2C_SMBUS_PROC_CALL:
1085                                 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1086                                 break;
1087                         case I2C_SMBUS_I2C_BLOCK_DATA:
1088                                 /* fixed at 32 for now */
1089                                 data->block[0] = I2C_SMBUS_BLOCK_MAX;
1090                                 for (i = 0; i < I2C_SMBUS_BLOCK_MAX; i++)
1091                                         data->block[i+1] = msgbuf1[i];
1092                                 break;
1093                 }
1094         return 0;
1095 }
1096
1097
1098 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1099                    char read_write, u8 command, int size, 
1100                    union i2c_smbus_data * data)
1101 {
1102         s32 res;
1103
1104         flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1105
1106         if (adapter->algo->smbus_xfer) {
1107                 down(&adapter->bus_lock);
1108                 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1109                                                 command,size,data);
1110                 up(&adapter->bus_lock);
1111         } else
1112                 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1113                                               command,size,data);
1114
1115         return res;
1116 }
1117
1118
1119 /* Next four are needed by i2c-isa */
1120 EXPORT_SYMBOL_GPL(i2c_adapter_dev_release);
1121 EXPORT_SYMBOL_GPL(i2c_adapter_driver);
1122 EXPORT_SYMBOL_GPL(i2c_adapter_class);
1123 EXPORT_SYMBOL_GPL(i2c_bus_type);
1124
1125 EXPORT_SYMBOL(i2c_add_adapter);
1126 EXPORT_SYMBOL(i2c_del_adapter);
1127 EXPORT_SYMBOL(i2c_del_driver);
1128 EXPORT_SYMBOL(i2c_attach_client);
1129 EXPORT_SYMBOL(i2c_detach_client);
1130 EXPORT_SYMBOL(i2c_use_client);
1131 EXPORT_SYMBOL(i2c_release_client);
1132 EXPORT_SYMBOL(i2c_clients_command);
1133 EXPORT_SYMBOL(i2c_check_addr);
1134
1135 EXPORT_SYMBOL(i2c_master_send);
1136 EXPORT_SYMBOL(i2c_master_recv);
1137 EXPORT_SYMBOL(i2c_control);
1138 EXPORT_SYMBOL(i2c_transfer);
1139 EXPORT_SYMBOL(i2c_get_adapter);
1140 EXPORT_SYMBOL(i2c_put_adapter);
1141 EXPORT_SYMBOL(i2c_probe);
1142
1143 EXPORT_SYMBOL(i2c_smbus_xfer);
1144 EXPORT_SYMBOL(i2c_smbus_write_quick);
1145 EXPORT_SYMBOL(i2c_smbus_read_byte);
1146 EXPORT_SYMBOL(i2c_smbus_write_byte);
1147 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1148 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1149 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1150 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1151 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1152 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1153
1154 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1155 MODULE_DESCRIPTION("I2C-Bus main module");
1156 MODULE_LICENSE("GPL");