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