API tools faq
paste
Advertisement
lehjr

i2c-core.c (camera debugging)

lehjr
Sep 10th, 2013
146
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 63.83 KB | None | 0 0
raw download clone embed print report
  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.    Mux support by Rodolfo Giometti <giometti@enneenne.com> and
  25.    Michael Lawnick <michael.lawnick.ext@nsn.com> */
  26.  
  27. #include <linux/module.h>
  28. #include <linux/kernel.h>
  29. #include <linux/errno.h>
  30. #include <linux/slab.h>
  31. #include <linux/i2c.h>
  32. #include <linux/init.h>
  33. #include <linux/idr.h>
  34. #include <linux/mutex.h>
  35. #include <linux/of_device.h>
  36. #include <linux/completion.h>
  37. #include <linux/hardirq.h>
  38. #include <linux/irqflags.h>
  39. #include <linux/rwsem.h>
  40. #include <linux/pm_runtime.h>
  41. #include <asm/uaccess.h>
  42.  
  43. #include "i2c-core.h"
  44.  
  45.  
  46. /* core_lock protects i2c_adapter_idr, and guarantees
  47.    that device detection, deletion of detected devices, and attach_adapter
  48.    and detach_adapter calls are serialized */
  49. static DEFINE_MUTEX(core_lock);
  50. static DEFINE_IDR(i2c_adapter_idr);
  51.  
  52. static struct device_type i2c_client_type;
  53. static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
  54.  
  55. bool flash_read = 0;// for debugging
  56.  
  57. /* ------------------------------------------------------------------------- */
  58.  
  59. static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
  60.                         const struct i2c_client *client)
  61. {
  62.     while (id->name[0]) {
  63.         if (strcmp(client->name, id->name) == 0)
  64.             return id;
  65.         id++;
  66.     }
  67.     return NULL;
  68. }
  69.  
  70. static int i2c_device_match(struct device *dev, struct device_driver *drv)
  71. {
  72.     struct i2c_client   *client = i2c_verify_client(dev);
  73.     struct i2c_driver   *driver;
  74.  
  75.     if (!client)
  76.         return 0;
  77.  
  78.     /* Attempt an OF style match */
  79.     if (of_driver_match_device(dev, drv))
  80.         return 1;
  81.  
  82.     driver = to_i2c_driver(drv);
  83.     /* match on an id table if there is one */
  84.     if (driver->id_table)
  85.         return i2c_match_id(driver->id_table, client) != NULL;
  86.  
  87.     return 0;
  88. }
  89.  
  90. #ifdef  CONFIG_HOTPLUG
  91.  
  92. /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
  93. static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
  94. {
  95.     struct i2c_client   *client = to_i2c_client(dev);
  96.  
  97.     if (add_uevent_var(env, "MODALIAS=%s%s",
  98.                I2C_MODULE_PREFIX, client->name))
  99.         return -ENOMEM;
  100.     dev_dbg(dev, "uevent\n");
  101.     return 0;
  102. }
  103.  
  104. #else
  105. #define i2c_device_uevent   NULL
  106. #endif  /* CONFIG_HOTPLUG */
  107.  
  108. static int i2c_device_probe(struct device *dev)
  109. {
  110.     struct i2c_client   *client = i2c_verify_client(dev);
  111.     struct i2c_driver   *driver;
  112.     int status;
  113.  
  114.     if (!client)
  115.         return 0;
  116.  
  117.     driver = to_i2c_driver(dev->driver);
  118.     if (!driver->probe || !driver->id_table)
  119.         return -ENODEV;
  120.     client->driver = driver;
  121.     if (!device_can_wakeup(&client->dev))
  122.         device_init_wakeup(&client->dev,
  123.                     client->flags & I2C_CLIENT_WAKE);
  124.     dev_dbg(dev, "probe\n");
  125.  
  126.     status = driver->probe(client, i2c_match_id(driver->id_table, client));
  127.     if (status) {
  128.         client->driver = NULL;
  129.         i2c_set_clientdata(client, NULL);
  130.     }
  131.     return status;
  132. }
  133.  
  134. static int i2c_device_remove(struct device *dev)
  135. {
  136.     struct i2c_client   *client = i2c_verify_client(dev);
  137.     struct i2c_driver   *driver;
  138.     int         status;
  139.  
  140.     if (!client || !dev->driver)
  141.         return 0;
  142.  
  143.     driver = to_i2c_driver(dev->driver);
  144.     if (driver->remove) {
  145.         dev_dbg(dev, "remove\n");
  146.         status = driver->remove(client);
  147.     } else {
  148.         dev->driver = NULL;
  149.         status = 0;
  150.     }
  151.     if (status == 0) {
  152.         client->driver = NULL;
  153.         i2c_set_clientdata(client, NULL);
  154.     }
  155.     return status;
  156. }
  157.  
  158. static void i2c_device_shutdown(struct device *dev)
  159. {
  160.     struct i2c_client *client = i2c_verify_client(dev);
  161.     struct i2c_driver *driver;
  162.  
  163.     if (!client || !dev->driver)
  164.         return;
  165.     driver = to_i2c_driver(dev->driver);
  166.     if (driver->shutdown)
  167.         driver->shutdown(client);
  168. }
  169.  
  170. #ifdef CONFIG_PM_SLEEP
  171. static int i2c_legacy_suspend(struct device *dev, pm_message_t mesg)
  172. {
  173.     struct i2c_client *client = i2c_verify_client(dev);
  174.     struct i2c_driver *driver;
  175.  
  176.     if (!client || !dev->driver)
  177.         return 0;
  178.     driver = to_i2c_driver(dev->driver);
  179.     if (!driver->suspend)
  180.         return 0;
  181.     return driver->suspend(client, mesg);
  182. }
  183.  
  184. static int i2c_legacy_resume(struct device *dev)
  185. {
  186.     struct i2c_client *client = i2c_verify_client(dev);
  187.     struct i2c_driver *driver;
  188.  
  189.     if (!client || !dev->driver)
  190.         return 0;
  191.     driver = to_i2c_driver(dev->driver);
  192.     if (!driver->resume)
  193.         return 0;
  194.     return driver->resume(client);
  195. }
  196.  
  197. static int i2c_device_pm_suspend(struct device *dev)
  198. {
  199.     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
  200.  
  201.     if (pm)
  202.         return pm_generic_suspend(dev);
  203.     else
  204.         return i2c_legacy_suspend(dev, PMSG_SUSPEND);
  205. }
  206.  
  207. static int i2c_device_pm_resume(struct device *dev)
  208. {
  209.     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
  210.  
  211.     if (pm)
  212.         return pm_generic_resume(dev);
  213.     else
  214.         return i2c_legacy_resume(dev);
  215. }
  216.  
  217. static int i2c_device_pm_freeze(struct device *dev)
  218. {
  219.     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
  220.  
  221.     if (pm)
  222.         return pm_generic_freeze(dev);
  223.     else
  224.         return i2c_legacy_suspend(dev, PMSG_FREEZE);
  225. }
  226.  
  227. static int i2c_device_pm_thaw(struct device *dev)
  228. {
  229.     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
  230.  
  231.     if (pm)
  232.         return pm_generic_thaw(dev);
  233.     else
  234.         return i2c_legacy_resume(dev);
  235. }
  236.  
  237. static int i2c_device_pm_poweroff(struct device *dev)
  238. {
  239.     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
  240.  
  241.     if (pm)
  242.         return pm_generic_poweroff(dev);
  243.     else
  244.         return i2c_legacy_suspend(dev, PMSG_HIBERNATE);
  245. }
  246.  
  247. static int i2c_device_pm_restore(struct device *dev)
  248. {
  249.     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
  250.  
  251.     if (pm)
  252.         return pm_generic_restore(dev);
  253.     else
  254.         return i2c_legacy_resume(dev);
  255. }
  256. #else /* !CONFIG_PM_SLEEP */
  257. #define i2c_device_pm_suspend   NULL
  258. #define i2c_device_pm_resume    NULL
  259. #define i2c_device_pm_freeze    NULL
  260. #define i2c_device_pm_thaw  NULL
  261. #define i2c_device_pm_poweroff  NULL
  262. #define i2c_device_pm_restore   NULL
  263. #endif /* !CONFIG_PM_SLEEP */
  264.  
  265. static void i2c_client_dev_release(struct device *dev)
  266. {
  267.     kfree(to_i2c_client(dev));
  268. }
  269.  
  270. static ssize_t
  271. show_name(struct device *dev, struct device_attribute *attr, char *buf)
  272. {
  273.     return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
  274.                to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
  275. }
  276.  
  277. static ssize_t
  278. show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
  279. {
  280.     struct i2c_client *client = to_i2c_client(dev);
  281.     return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
  282. }
  283.  
  284. static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
  285. static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
  286.  
  287. static struct attribute *i2c_dev_attrs[] = {
  288.     &dev_attr_name.attr,
  289.     /* modalias helps coldplug:  modprobe $(cat .../modalias) */
  290.     &dev_attr_modalias.attr,
  291.     NULL
  292. };
  293.  
  294. static struct attribute_group i2c_dev_attr_group = {
  295.     .attrs      = i2c_dev_attrs,
  296. };
  297.  
  298. static const struct attribute_group *i2c_dev_attr_groups[] = {
  299.     &i2c_dev_attr_group,
  300.     NULL
  301. };
  302.  
  303. static const struct dev_pm_ops i2c_device_pm_ops = {
  304.     .suspend = i2c_device_pm_suspend,
  305.     .resume = i2c_device_pm_resume,
  306.     .freeze = i2c_device_pm_freeze,
  307.     .thaw = i2c_device_pm_thaw,
  308.     .poweroff = i2c_device_pm_poweroff,
  309.     .restore = i2c_device_pm_restore,
  310.     SET_RUNTIME_PM_OPS(
  311.         pm_generic_runtime_suspend,
  312.         pm_generic_runtime_resume,
  313.         pm_generic_runtime_idle
  314.     )
  315. };
  316.  
  317. struct bus_type i2c_bus_type = {
  318.     .name       = "i2c",
  319.     .match      = i2c_device_match,
  320.     .probe      = i2c_device_probe,
  321.     .remove     = i2c_device_remove,
  322.     .shutdown   = i2c_device_shutdown,
  323.     .pm     = &i2c_device_pm_ops,
  324. };
  325. EXPORT_SYMBOL_GPL(i2c_bus_type);
  326.  
  327. static struct device_type i2c_client_type = {
  328.     .groups     = i2c_dev_attr_groups,
  329.     .uevent     = i2c_device_uevent,
  330.     .release    = i2c_client_dev_release,
  331. };
  332.  
  333.  
  334. /**
  335.  * i2c_verify_client - return parameter as i2c_client, or NULL
  336.  * @dev: device, probably from some driver model iterator
  337.  *
  338.  * When traversing the driver model tree, perhaps using driver model
  339.  * iterators like @device_for_each_child(), you can't assume very much
  340.  * about the nodes you find.  Use this function to avoid oopses caused
  341.  * by wrongly treating some non-I2C device as an i2c_client.
  342.  */
  343. struct i2c_client *i2c_verify_client(struct device *dev)
  344. {
  345.     return (dev->type == &i2c_client_type)
  346.             ? to_i2c_client(dev)
  347.             : NULL;
  348. }
  349. EXPORT_SYMBOL(i2c_verify_client);
  350.  
  351.  
  352. /* This is a permissive address validity check, I2C address map constraints
  353.  * are purposely not enforced, except for the general call address. */
  354. static int i2c_check_client_addr_validity(const struct i2c_client *client)
  355. {
  356.     if (client->flags & I2C_CLIENT_TEN) {
  357.         /* 10-bit address, all values are valid */
  358.         if (client->addr > 0x3ff)
  359.             return -EINVAL;
  360.     } else {
  361.         /* 7-bit address, reject the general call address */
  362.         if (client->addr == 0x00 || client->addr > 0x7f)
  363.             return -EINVAL;
  364.     }
  365.     return 0;
  366. }
  367.  
  368. /* And this is a strict address validity check, used when probing. If a
  369.  * device uses a reserved address, then it shouldn't be probed. 7-bit
  370.  * addressing is assumed, 10-bit address devices are rare and should be
  371.  * explicitly enumerated. */
  372. static int i2c_check_addr_validity(unsigned short addr)
  373. {
  374.     /*
  375.      * Reserved addresses per I2C specification:
  376.      *  0x00       General call address / START byte
  377.      *  0x01       CBUS address
  378.      *  0x02       Reserved for different bus format
  379.      *  0x03       Reserved for future purposes
  380.      *  0x04-0x07  Hs-mode master code
  381.      *  0x78-0x7b  10-bit slave addressing
  382.      *  0x7c-0x7f  Reserved for future purposes
  383.      */
  384.     if (addr < 0x08 || addr > 0x77)
  385.         return -EINVAL;
  386.     return 0;
  387. }
  388.  
  389. static int __i2c_check_addr_busy(struct device *dev, void *addrp)
  390. {
  391.     struct i2c_client   *client = i2c_verify_client(dev);
  392.     int         addr = *(int *)addrp;
  393.  
  394.     if (client && client->addr == addr)
  395.         return -EBUSY;
  396.     return 0;
  397. }
  398.  
  399. /* walk up mux tree */
  400. static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
  401. {
  402.     struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
  403.     int result;
  404.  
  405.     result = device_for_each_child(&adapter->dev, &addr,
  406.                     __i2c_check_addr_busy);
  407.  
  408.     if (!result && parent)
  409.         result = i2c_check_mux_parents(parent, addr);
  410.  
  411.     return result;
  412. }
  413.  
  414. /* recurse down mux tree */
  415. static int i2c_check_mux_children(struct device *dev, void *addrp)
  416. {
  417.     int result;
  418.  
  419.     if (dev->type == &i2c_adapter_type)
  420.         result = device_for_each_child(dev, addrp,
  421.                         i2c_check_mux_children);
  422.     else
  423.         result = __i2c_check_addr_busy(dev, addrp);
  424.  
  425.     return result;
  426. }
  427.  
  428. static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
  429. {
  430.     struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
  431.     int result = 0;
  432.  
  433.     if (parent)
  434.         result = i2c_check_mux_parents(parent, addr);
  435.  
  436.     if (!result)
  437.         result = device_for_each_child(&adapter->dev, &addr,
  438.                         i2c_check_mux_children);
  439.  
  440.     return result;
  441. }
  442.  
  443. /**
  444.  * i2c_lock_adapter - Get exclusive access to an I2C bus segment
  445.  * @adapter: Target I2C bus segment
  446.  */
  447. void i2c_lock_adapter(struct i2c_adapter *adapter)
  448. {
  449.     struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
  450.  
  451.     if (parent)
  452.         i2c_lock_adapter(parent);
  453.     else
  454.         rt_mutex_lock(&adapter->bus_lock);
  455. }
  456. EXPORT_SYMBOL_GPL(i2c_lock_adapter);
  457.  
  458. /**
  459.  * i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment
  460.  * @adapter: Target I2C bus segment
  461.  */
  462. static int i2c_trylock_adapter(struct i2c_adapter *adapter)
  463. {
  464.     struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
  465.  
  466.     if (parent)
  467.         return i2c_trylock_adapter(parent);
  468.     else
  469.         return rt_mutex_trylock(&adapter->bus_lock);
  470. }
  471.  
  472. /**
  473.  * i2c_unlock_adapter - Release exclusive access to an I2C bus segment
  474.  * @adapter: Target I2C bus segment
  475.  */
  476. void i2c_unlock_adapter(struct i2c_adapter *adapter)
  477. {
  478.     struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
  479.  
  480.     if (parent)
  481.         i2c_unlock_adapter(parent);
  482.     else
  483.         rt_mutex_unlock(&adapter->bus_lock);
  484. }
  485. EXPORT_SYMBOL_GPL(i2c_unlock_adapter);
  486.  
  487. /**
  488.  * i2c_new_device - instantiate an i2c device
  489.  * @adap: the adapter managing the device
  490.  * @info: describes one I2C device; bus_num is ignored
  491.  * Context: can sleep
  492.  *
  493.  * Create an i2c device. Binding is handled through driver model
  494.  * probe()/remove() methods.  A driver may be bound to this device when we
  495.  * return from this function, or any later moment (e.g. maybe hotplugging will
  496.  * load the driver module).  This call is not appropriate for use by mainboard
  497.  * initialization logic, which usually runs during an arch_initcall() long
  498.  * before any i2c_adapter could exist.
  499.  *
  500.  * This returns the new i2c client, which may be saved for later use with
  501.  * i2c_unregister_device(); or NULL to indicate an error.
  502.  */
  503. struct i2c_client *
  504. i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
  505. {
  506.     struct i2c_client   *client;
  507.     int         status;
  508.  
  509.     client = kzalloc(sizeof *client, GFP_KERNEL);
  510.     if (!client)
  511.         return NULL;
  512.  
  513.     client->adapter = adap;
  514.  
  515.     client->dev.platform_data = info->platform_data;
  516.  
  517.     if (info->archdata)
  518.         client->dev.archdata = *info->archdata;
  519.  
  520.     client->flags = info->flags;
  521.     client->addr = info->addr;
  522.     client->irq = info->irq;
  523.  
  524.     strlcpy(client->name, info->type, sizeof(client->name));
  525.  
  526.     /* Check for address validity */
  527.     status = i2c_check_client_addr_validity(client);
  528.     if (status) {
  529.         dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
  530.             client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
  531.         goto out_err_silent;
  532.     }
  533.  
  534.     /* Check for address business */
  535.     status = i2c_check_addr_busy(adap, client->addr);
  536.     if (status)
  537.         goto out_err;
  538.  
  539.     client->dev.parent = &client->adapter->dev;
  540.     client->dev.bus = &i2c_bus_type;
  541.     client->dev.type = &i2c_client_type;
  542.     client->dev.of_node = info->of_node;
  543.  
  544.     dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
  545.              client->addr);
  546.     status = device_register(&client->dev);
  547.     if (status)
  548.         goto out_err;
  549.  
  550.     dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
  551.         client->name, dev_name(&client->dev));
  552.  
  553.     return client;
  554.  
  555. out_err:
  556.     dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
  557.         "(%d)\n", client->name, client->addr, status);
  558. out_err_silent:
  559.     kfree(client);
  560.     return NULL;
  561. }
  562. EXPORT_SYMBOL_GPL(i2c_new_device);
  563.  
  564.  
  565. /**
  566.  * i2c_unregister_device - reverse effect of i2c_new_device()
  567.  * @client: value returned from i2c_new_device()
  568.  * Context: can sleep
  569.  */
  570. void i2c_unregister_device(struct i2c_client *client)
  571. {
  572.     device_unregister(&client->dev);
  573. }
  574. EXPORT_SYMBOL_GPL(i2c_unregister_device);
  575.  
  576.  
  577. static const struct i2c_device_id dummy_id[] = {
  578.     { "dummy", 0 },
  579.     { },
  580. };
  581.  
  582. static int dummy_probe(struct i2c_client *client,
  583.                const struct i2c_device_id *id)
  584. {
  585.     return 0;
  586. }
  587.  
  588. static int dummy_remove(struct i2c_client *client)
  589. {
  590.     return 0;
  591. }
  592.  
  593. static struct i2c_driver dummy_driver = {
  594.     .driver.name    = "dummy",
  595.     .probe      = dummy_probe,
  596.     .remove     = dummy_remove,
  597.     .id_table   = dummy_id,
  598. };
  599.  
  600. /**
  601.  * i2c_new_dummy - return a new i2c device bound to a dummy driver
  602.  * @adapter: the adapter managing the device
  603.  * @address: seven bit address to be used
  604.  * Context: can sleep
  605.  *
  606.  * This returns an I2C client bound to the "dummy" driver, intended for use
  607.  * with devices that consume multiple addresses.  Examples of such chips
  608.  * include various EEPROMS (like 24c04 and 24c08 models).
  609.  *
  610.  * These dummy devices have two main uses.  First, most I2C and SMBus calls
  611.  * except i2c_transfer() need a client handle; the dummy will be that handle.
  612.  * And second, this prevents the specified address from being bound to a
  613.  * different driver.
  614.  *
  615.  * This returns the new i2c client, which should be saved for later use with
  616.  * i2c_unregister_device(); or NULL to indicate an error.
  617.  */
  618. struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
  619. {
  620.     struct i2c_board_info info = {
  621.         I2C_BOARD_INFO("dummy", address),
  622.     };
  623.  
  624.     return i2c_new_device(adapter, &info);
  625. }
  626. EXPORT_SYMBOL_GPL(i2c_new_dummy);
  627.  
  628. /* ------------------------------------------------------------------------- */
  629.  
  630. /* I2C bus adapters -- one roots each I2C or SMBUS segment */
  631.  
  632. static void i2c_adapter_dev_release(struct device *dev)
  633. {
  634.     struct i2c_adapter *adap = to_i2c_adapter(dev);
  635.     complete(&adap->dev_released);
  636. }
  637.  
  638. /*
  639.  * Let users instantiate I2C devices through sysfs. This can be used when
  640.  * platform initialization code doesn't contain the proper data for
  641.  * whatever reason. Also useful for drivers that do device detection and
  642.  * detection fails, either because the device uses an unexpected address,
  643.  * or this is a compatible device with different ID register values.
  644.  *
  645.  * Parameter checking may look overzealous, but we really don't want
  646.  * the user to provide incorrect parameters.
  647.  */
  648. static ssize_t
  649. i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
  650.              const char *buf, size_t count)
  651. {
  652.     struct i2c_adapter *adap = to_i2c_adapter(dev);
  653.     struct i2c_board_info info;
  654.     struct i2c_client *client;
  655.     char *blank, end;
  656.     int res;
  657.  
  658.     memset(&info, 0, sizeof(struct i2c_board_info));
  659.  
  660.     blank = strchr(buf, ' ');
  661.     if (!blank) {
  662.         dev_err(dev, "%s: Missing parameters\n", "new_device");
  663.         return -EINVAL;
  664.     }
  665.     if (blank - buf > I2C_NAME_SIZE - 1) {
  666.         dev_err(dev, "%s: Invalid device name\n", "new_device");
  667.         return -EINVAL;
  668.     }
  669.     memcpy(info.type, buf, blank - buf);
  670.  
  671.     /* Parse remaining parameters, reject extra parameters */
  672.     res = sscanf(++blank, "%hi%c", &info.addr, &end);
  673.     if (res < 1) {
  674.         dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
  675.         return -EINVAL;
  676.     }
  677.     if (res > 1  && end != '\n') {
  678.         dev_err(dev, "%s: Extra parameters\n", "new_device");
  679.         return -EINVAL;
  680.     }
  681.  
  682.     client = i2c_new_device(adap, &info);
  683.     if (!client)
  684.         return -EINVAL;
  685.  
  686.     /* Keep track of the added device */
  687.     mutex_lock(&adap->userspace_clients_lock);
  688.     list_add_tail(&client->detected, &adap->userspace_clients);
  689.     mutex_unlock(&adap->userspace_clients_lock);
  690.     dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
  691.          info.type, info.addr);
  692.  
  693.     return count;
  694. }
  695.  
  696. /*
  697.  * And of course let the users delete the devices they instantiated, if
  698.  * they got it wrong. This interface can only be used to delete devices
  699.  * instantiated by i2c_sysfs_new_device above. This guarantees that we
  700.  * don't delete devices to which some kernel code still has references.
  701.  *
  702.  * Parameter checking may look overzealous, but we really don't want
  703.  * the user to delete the wrong device.
  704.  */
  705. static ssize_t
  706. i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
  707.             const char *buf, size_t count)
  708. {
  709.     struct i2c_adapter *adap = to_i2c_adapter(dev);
  710.     struct i2c_client *client, *next;
  711.     unsigned short addr;
  712.     char end;
  713.     int res;
  714.  
  715.     /* Parse parameters, reject extra parameters */
  716.     res = sscanf(buf, "%hi%c", &addr, &end);
  717.     if (res < 1) {
  718.         dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
  719.         return -EINVAL;
  720.     }
  721.     if (res > 1  && end != '\n') {
  722.         dev_err(dev, "%s: Extra parameters\n", "delete_device");
  723.         return -EINVAL;
  724.     }
  725.  
  726.     /* Make sure the device was added through sysfs */
  727.     res = -ENOENT;
  728.     mutex_lock(&adap->userspace_clients_lock);
  729.     list_for_each_entry_safe(client, next, &adap->userspace_clients,
  730.                  detected) {
  731.         if (client->addr == addr) {
  732.             dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
  733.                  "delete_device", client->name, client->addr);
  734.  
  735.             list_del(&client->detected);
  736.             i2c_unregister_device(client);
  737.             res = count;
  738.             break;
  739.         }
  740.     }
  741.     mutex_unlock(&adap->userspace_clients_lock);
  742.  
  743.     if (res < 0)
  744.         dev_err(dev, "%s: Can't find device in list\n",
  745.             "delete_device");
  746.     return res;
  747. }
  748.  
  749. static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
  750. static DEVICE_ATTR(delete_device, S_IWUSR, NULL, i2c_sysfs_delete_device);
  751.  
  752. static struct attribute *i2c_adapter_attrs[] = {
  753.     &dev_attr_name.attr,
  754.     &dev_attr_new_device.attr,
  755.     &dev_attr_delete_device.attr,
  756.     NULL
  757. };
  758.  
  759. static struct attribute_group i2c_adapter_attr_group = {
  760.     .attrs      = i2c_adapter_attrs,
  761. };
  762.  
  763. static const struct attribute_group *i2c_adapter_attr_groups[] = {
  764.     &i2c_adapter_attr_group,
  765.     NULL
  766. };
  767.  
  768. struct device_type i2c_adapter_type = {
  769.     .groups     = i2c_adapter_attr_groups,
  770.     .release    = i2c_adapter_dev_release,
  771. };
  772. EXPORT_SYMBOL_GPL(i2c_adapter_type);
  773.  
  774. #ifdef CONFIG_I2C_COMPAT
  775. static struct class_compat *i2c_adapter_compat_class;
  776. #endif
  777.  
  778. static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
  779. {
  780.     struct i2c_devinfo  *devinfo;
  781.  
  782.     down_read(&__i2c_board_lock);
  783.     list_for_each_entry(devinfo, &__i2c_board_list, list) {
  784.         if (devinfo->busnum == adapter->nr
  785.                 && !i2c_new_device(adapter,
  786.                         &devinfo->board_info))
  787.             dev_err(&adapter->dev,
  788.                 "Can't create device at 0x%02x\n",
  789.                 devinfo->board_info.addr);
  790.     }
  791.     up_read(&__i2c_board_lock);
  792. }
  793.  
  794. static int i2c_do_add_adapter(struct i2c_driver *driver,
  795.                   struct i2c_adapter *adap)
  796. {
  797.     /* Detect supported devices on that bus, and instantiate them */
  798.     i2c_detect(adap, driver);
  799.  
  800.     /* Let legacy drivers scan this bus for matching devices */
  801.     if (driver->attach_adapter) {
  802.         dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
  803.              driver->driver.name);
  804.         dev_warn(&adap->dev, "Please use another way to instantiate "
  805.              "your i2c_client\n");
  806.         /* We ignore the return code; if it fails, too bad */
  807.         driver->attach_adapter(adap);
  808.     }
  809.     return 0;
  810. }
  811.  
  812. static int __process_new_adapter(struct device_driver *d, void *data)
  813. {
  814.     return i2c_do_add_adapter(to_i2c_driver(d), data);
  815. }
  816.  
  817. static int i2c_register_adapter(struct i2c_adapter *adap)
  818. {
  819.     int res = 0;
  820.  
  821.     /* Can't register until after driver model init */
  822.     if (unlikely(WARN_ON(!i2c_bus_type.p))) {
  823.         res = -EAGAIN;
  824.         goto out_list;
  825.     }
  826.  
  827.     /* Sanity checks */
  828.     if (unlikely(adap->name[0] == '\0')) {
  829.         pr_err("i2c-core: Attempt to register an adapter with "
  830.                "no name!\n");
  831.         return -EINVAL;
  832.     }
  833.     if (unlikely(!adap->algo)) {
  834.         pr_err("i2c-core: Attempt to register adapter '%s' with "
  835.                "no algo!\n", adap->name);
  836.         return -EINVAL;
  837.     }
  838.  
  839.     rt_mutex_init(&adap->bus_lock);
  840.     mutex_init(&adap->userspace_clients_lock);
  841.     INIT_LIST_HEAD(&adap->userspace_clients);
  842.  
  843.     /* Set default timeout to 1 second if not already set */
  844.     if (adap->timeout == 0)
  845.         adap->timeout = HZ;
  846.  
  847.     dev_set_name(&adap->dev, "i2c-%d", adap->nr);
  848.     adap->dev.bus = &i2c_bus_type;
  849.     adap->dev.type = &i2c_adapter_type;
  850.     res = device_register(&adap->dev);
  851.     if (res)
  852.         goto out_list;
  853.  
  854.     dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
  855.  
  856. #ifdef CONFIG_I2C_COMPAT
  857.     res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
  858.                        adap->dev.parent);
  859.     if (res)
  860.         dev_warn(&adap->dev,
  861.              "Failed to create compatibility class link\n");
  862. #endif
  863.  
  864.     /* create pre-declared device nodes */
  865.     if (adap->nr < __i2c_first_dynamic_bus_num)
  866.         i2c_scan_static_board_info(adap);
  867.  
  868.     /* Notify drivers */
  869.     mutex_lock(&core_lock);
  870.     bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
  871.     mutex_unlock(&core_lock);
  872.  
  873.     return 0;
  874.  
  875. out_list:
  876.     mutex_lock(&core_lock);
  877.     idr_remove(&i2c_adapter_idr, adap->nr);
  878.     mutex_unlock(&core_lock);
  879.     return res;
  880. }
  881.  
  882. /**
  883.  * i2c_add_adapter - declare i2c adapter, use dynamic bus number
  884.  * @adapter: the adapter to add
  885.  * Context: can sleep
  886.  *
  887.  * This routine is used to declare an I2C adapter when its bus number
  888.  * doesn't matter.  Examples: for I2C adapters dynamically added by
  889.  * USB links or PCI plugin cards.
  890.  *
  891.  * When this returns zero, a new bus number was allocated and stored
  892.  * in adap->nr, and the specified adapter became available for clients.
  893.  * Otherwise, a negative errno value is returned.
  894.  */
  895. int i2c_add_adapter(struct i2c_adapter *adapter)
  896. {
  897.     int id, res = 0;
  898.  
  899. retry:
  900.     if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
  901.         return -ENOMEM;
  902.  
  903.     mutex_lock(&core_lock);
  904.     /* "above" here means "above or equal to", sigh */
  905.     res = idr_get_new_above(&i2c_adapter_idr, adapter,
  906.                 __i2c_first_dynamic_bus_num, &id);
  907.     mutex_unlock(&core_lock);
  908.  
  909.     if (res < 0) {
  910.         if (res == -EAGAIN)
  911.             goto retry;
  912.         return res;
  913.     }
  914.  
  915.     adapter->nr = id;
  916.     return i2c_register_adapter(adapter);
  917. }
  918. EXPORT_SYMBOL(i2c_add_adapter);
  919.  
  920. /**
  921.  * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
  922.  * @adap: the adapter to register (with adap->nr initialized)
  923.  * Context: can sleep
  924.  *
  925.  * This routine is used to declare an I2C adapter when its bus number
  926.  * matters.  For example, use it for I2C adapters from system-on-chip CPUs,
  927.  * or otherwise built in to the system's mainboard, and where i2c_board_info
  928.  * is used to properly configure I2C devices.
  929.  *
  930.  * If the requested bus number is set to -1, then this function will behave
  931.  * identically to i2c_add_adapter, and will dynamically assign a bus number.
  932.  *
  933.  * If no devices have pre-been declared for this bus, then be sure to
  934.  * register the adapter before any dynamically allocated ones.  Otherwise
  935.  * the required bus ID may not be available.
  936.  *
  937.  * When this returns zero, the specified adapter became available for
  938.  * clients using the bus number provided in adap->nr.  Also, the table
  939.  * of I2C devices pre-declared using i2c_register_board_info() is scanned,
  940.  * and the appropriate driver model device nodes are created.  Otherwise, a
  941.  * negative errno value is returned.
  942.  */
  943. int i2c_add_numbered_adapter(struct i2c_adapter *adap)
  944. {
  945.     int id;
  946.     int status;
  947.  
  948.     if (adap->nr == -1) /* -1 means dynamically assign bus id */
  949.         return i2c_add_adapter(adap);
  950.     if (adap->nr & ~MAX_ID_MASK)
  951.         return -EINVAL;
  952.  
  953. retry:
  954.     if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
  955.         return -ENOMEM;
  956.  
  957.     mutex_lock(&core_lock);
  958.     /* "above" here means "above or equal to", sigh;
  959.      * we need the "equal to" result to force the result
  960.      */
  961.     status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
  962.     if (status == 0 && id != adap->nr) {
  963.         status = -EBUSY;
  964.         idr_remove(&i2c_adapter_idr, id);
  965.     }
  966.     mutex_unlock(&core_lock);
  967.     if (status == -EAGAIN)
  968.         goto retry;
  969.  
  970.     if (status == 0)
  971.         status = i2c_register_adapter(adap);
  972.     return status;
  973. }
  974. EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
  975.  
  976. static int i2c_do_del_adapter(struct i2c_driver *driver,
  977.                   struct i2c_adapter *adapter)
  978. {
  979.     struct i2c_client *client, *_n;
  980.     int res;
  981.  
  982.     /* Remove the devices we created ourselves as the result of hardware
  983.      * probing (using a driver's detect method) */
  984.     list_for_each_entry_safe(client, _n, &driver->clients, detected) {
  985.         if (client->adapter == adapter) {
  986.             dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
  987.                 client->name, client->addr);
  988.             list_del(&client->detected);
  989.             i2c_unregister_device(client);
  990.         }
  991.     }
  992.  
  993.     if (!driver->detach_adapter)
  994.         return 0;
  995.     dev_warn(&adapter->dev, "%s: detach_adapter method is deprecated\n",
  996.          driver->driver.name);
  997.     res = driver->detach_adapter(adapter);
  998.     if (res)
  999.         dev_err(&adapter->dev, "detach_adapter failed (%d) "
  1000.             "for driver [%s]\n", res, driver->driver.name);
  1001.     return res;
  1002. }
  1003.  
  1004. static int __unregister_client(struct device *dev, void *dummy)
  1005. {
  1006.     struct i2c_client *client = i2c_verify_client(dev);
  1007.     if (client && strcmp(client->name, "dummy"))
  1008.         i2c_unregister_device(client);
  1009.     return 0;
  1010. }
  1011.  
  1012. static int __unregister_dummy(struct device *dev, void *dummy)
  1013. {
  1014.     struct i2c_client *client = i2c_verify_client(dev);
  1015.     if (client)
  1016.         i2c_unregister_device(client);
  1017.     return 0;
  1018. }
  1019.  
  1020. static int __process_removed_adapter(struct device_driver *d, void *data)
  1021. {
  1022.     return i2c_do_del_adapter(to_i2c_driver(d), data);
  1023. }
  1024.  
  1025. /**
  1026.  * i2c_del_adapter - unregister I2C adapter
  1027.  * @adap: the adapter being unregistered
  1028.  * Context: can sleep
  1029.  *
  1030.  * This unregisters an I2C adapter which was previously registered
  1031.  * by @i2c_add_adapter or @i2c_add_numbered_adapter.
  1032.  */
  1033. int i2c_del_adapter(struct i2c_adapter *adap)
  1034. {
  1035.     int res = 0;
  1036.     struct i2c_adapter *found;
  1037.     struct i2c_client *client, *next;
  1038.  
  1039.     /* First make sure that this adapter was ever added */
  1040.     mutex_lock(&core_lock);
  1041.     found = idr_find(&i2c_adapter_idr, adap->nr);
  1042.     mutex_unlock(&core_lock);
  1043.     if (found != adap) {
  1044.         pr_debug("i2c-core: attempting to delete unregistered "
  1045.              "adapter [%s]\n", adap->name);
  1046.         return -EINVAL;
  1047.     }
  1048.  
  1049.     /* Tell drivers about this removal */
  1050.     mutex_lock(&core_lock);
  1051.     res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
  1052.                    __process_removed_adapter);
  1053.     mutex_unlock(&core_lock);
  1054.     if (res)
  1055.         return res;
  1056.  
  1057.     /* Remove devices instantiated from sysfs */
  1058.     mutex_lock(&adap->userspace_clients_lock);
  1059.     list_for_each_entry_safe(client, next, &adap->userspace_clients,
  1060.                  detected) {
  1061.         dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
  1062.             client->addr);
  1063.         list_del(&client->detected);
  1064.         i2c_unregister_device(client);
  1065.     }
  1066.     mutex_unlock(&adap->userspace_clients_lock);
  1067.  
  1068.     /* Detach any active clients. This can't fail, thus we do not
  1069.      * check the returned value. This is a two-pass process, because
  1070.      * we can't remove the dummy devices during the first pass: they
  1071.      * could have been instantiated by real devices wishing to clean
  1072.      * them up properly, so we give them a chance to do that first. */
  1073.     res = device_for_each_child(&adap->dev, NULL, __unregister_client);
  1074.     res = device_for_each_child(&adap->dev, NULL, __unregister_dummy);
  1075.  
  1076. #ifdef CONFIG_I2C_COMPAT
  1077.     class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
  1078.                  adap->dev.parent);
  1079. #endif
  1080.  
  1081.     /* device name is gone after device_unregister */
  1082.     dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
  1083.  
  1084.     /* clean up the sysfs representation */
  1085.     init_completion(&adap->dev_released);
  1086.     device_unregister(&adap->dev);
  1087.  
  1088.     /* wait for sysfs to drop all references */
  1089.     wait_for_completion(&adap->dev_released);
  1090.  
  1091.     /* free bus id */
  1092.     mutex_lock(&core_lock);
  1093.     idr_remove(&i2c_adapter_idr, adap->nr);
  1094.     mutex_unlock(&core_lock);
  1095.  
  1096.     /* Clear the device structure in case this adapter is ever going to be
  1097.        added again */
  1098.     memset(&adap->dev, 0, sizeof(adap->dev));
  1099.  
  1100.     return 0;
  1101. }
  1102. EXPORT_SYMBOL(i2c_del_adapter);
  1103.  
  1104.  
  1105. /* ------------------------------------------------------------------------- */
  1106.  
  1107. int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
  1108. {
  1109.     int res;
  1110.  
  1111.     mutex_lock(&core_lock);
  1112.     res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
  1113.     mutex_unlock(&core_lock);
  1114.  
  1115.     return res;
  1116. }
  1117. EXPORT_SYMBOL_GPL(i2c_for_each_dev);
  1118.  
  1119. static int __process_new_driver(struct device *dev, void *data)
  1120. {
  1121.     if (dev->type != &i2c_adapter_type)
  1122.         return 0;
  1123.     return i2c_do_add_adapter(data, to_i2c_adapter(dev));
  1124. }
  1125.  
  1126. /*
  1127.  * An i2c_driver is used with one or more i2c_client (device) nodes to access
  1128.  * i2c slave chips, on a bus instance associated with some i2c_adapter.
  1129.  */
  1130.  
  1131. int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
  1132. {
  1133.     int res;
  1134.  
  1135.     /* Can't register until after driver model init */
  1136.     if (unlikely(WARN_ON(!i2c_bus_type.p)))
  1137.         return -EAGAIN;
  1138.  
  1139.     /* add the driver to the list of i2c drivers in the driver core */
  1140.     driver->driver.owner = owner;
  1141.     driver->driver.bus = &i2c_bus_type;
  1142.  
  1143.     /* When registration returns, the driver core
  1144.      * will have called probe() for all matching-but-unbound devices.
  1145.      */
  1146.     res = driver_register(&driver->driver);
  1147.     if (res)
  1148.         return res;
  1149.  
  1150.     /* Drivers should switch to dev_pm_ops instead. */
  1151.     if (driver->suspend)
  1152.         pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
  1153.             driver->driver.name);
  1154.     if (driver->resume)
  1155.         pr_warn("i2c-core: driver [%s] using legacy resume method\n",
  1156.             driver->driver.name);
  1157.  
  1158.     pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
  1159.  
  1160.     INIT_LIST_HEAD(&driver->clients);
  1161.     /* Walk the adapters that are already present */
  1162.     i2c_for_each_dev(driver, __process_new_driver);
  1163.  
  1164.     return 0;
  1165. }
  1166. EXPORT_SYMBOL(i2c_register_driver);
  1167.  
  1168. static int __process_removed_driver(struct device *dev, void *data)
  1169. {
  1170.     if (dev->type != &i2c_adapter_type)
  1171.         return 0;
  1172.     return i2c_do_del_adapter(data, to_i2c_adapter(dev));
  1173. }
  1174.  
  1175. /**
  1176.  * i2c_del_driver - unregister I2C driver
  1177.  * @driver: the driver being unregistered
  1178.  * Context: can sleep
  1179.  */
  1180. void i2c_del_driver(struct i2c_driver *driver)
  1181. {
  1182.     i2c_for_each_dev(driver, __process_removed_driver);
  1183.  
  1184.     driver_unregister(&driver->driver);
  1185.     pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
  1186. }
  1187. EXPORT_SYMBOL(i2c_del_driver);
  1188.  
  1189. /* ------------------------------------------------------------------------- */
  1190.  
  1191. /**
  1192.  * i2c_use_client - increments the reference count of the i2c client structure
  1193.  * @client: the client being referenced
  1194.  *
  1195.  * Each live reference to a client should be refcounted. The driver model does
  1196.  * that automatically as part of driver binding, so that most drivers don't
  1197.  * need to do this explicitly: they hold a reference until they're unbound
  1198.  * from the device.
  1199.  *
  1200.  * A pointer to the client with the incremented reference counter is returned.
  1201.  */
  1202. struct i2c_client *i2c_use_client(struct i2c_client *client)
  1203. {
  1204.     if (client && get_device(&client->dev))
  1205.         return client;
  1206.     return NULL;
  1207. }
  1208. EXPORT_SYMBOL(i2c_use_client);
  1209.  
  1210. /**
  1211.  * i2c_release_client - release a use of the i2c client structure
  1212.  * @client: the client being no longer referenced
  1213.  *
  1214.  * Must be called when a user of a client is finished with it.
  1215.  */
  1216. void i2c_release_client(struct i2c_client *client)
  1217. {
  1218.     if (client)
  1219.         put_device(&client->dev);
  1220. }
  1221. EXPORT_SYMBOL(i2c_release_client);
  1222.  
  1223. struct i2c_cmd_arg {
  1224.     unsigned    cmd;
  1225.     void        *arg;
  1226. };
  1227.  
  1228. static int i2c_cmd(struct device *dev, void *_arg)
  1229. {
  1230.     struct i2c_client   *client = i2c_verify_client(dev);
  1231.     struct i2c_cmd_arg  *arg = _arg;
  1232.  
  1233.     if (client && client->driver && client->driver->command)
  1234.         client->driver->command(client, arg->cmd, arg->arg);
  1235.     return 0;
  1236. }
  1237.  
  1238. void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
  1239. {
  1240.     struct i2c_cmd_arg  cmd_arg;
  1241.  
  1242.     cmd_arg.cmd = cmd;
  1243.     cmd_arg.arg = arg;
  1244.     device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
  1245. }
  1246. EXPORT_SYMBOL(i2c_clients_command);
  1247.  
  1248. static int __init i2c_init(void)
  1249. {
  1250.     int retval;
  1251.  
  1252.     retval = bus_register(&i2c_bus_type);
  1253.     if (retval)
  1254.         return retval;
  1255. #ifdef CONFIG_I2C_COMPAT
  1256.     i2c_adapter_compat_class = class_compat_register("i2c-adapter");
  1257.     if (!i2c_adapter_compat_class) {
  1258.         retval = -ENOMEM;
  1259.         goto bus_err;
  1260.     }
  1261. #endif
  1262.     retval = i2c_add_driver(&dummy_driver);
  1263.     if (retval)
  1264.         goto class_err;
  1265.     return 0;
  1266.  
  1267. class_err:
  1268. #ifdef CONFIG_I2C_COMPAT
  1269.     class_compat_unregister(i2c_adapter_compat_class);
  1270. bus_err:
  1271. #endif
  1272.     bus_unregister(&i2c_bus_type);
  1273.     return retval;
  1274. }
  1275.  
  1276. static void __exit i2c_exit(void)
  1277. {
  1278.     i2c_del_driver(&dummy_driver);
  1279. #ifdef CONFIG_I2C_COMPAT
  1280.     class_compat_unregister(i2c_adapter_compat_class);
  1281. #endif
  1282.     bus_unregister(&i2c_bus_type);
  1283. }
  1284.  
  1285. /* We must initialize early, because some subsystems register i2c drivers
  1286.  * in subsys_initcall() code, but are linked (and initialized) before i2c.
  1287.  */
  1288. postcore_initcall(i2c_init);
  1289. module_exit(i2c_exit);
  1290.  
  1291. /* ----------------------------------------------------
  1292.  * the functional interface to the i2c busses.
  1293.  * ----------------------------------------------------
  1294.  */
  1295.  
  1296. /**
  1297.  * i2c_transfer - execute a single or combined I2C message
  1298.  * @adap: Handle to I2C bus
  1299.  * @msgs: One or more messages to execute before STOP is issued to
  1300.  *  terminate the operation; each message begins with a START.
  1301.  * @num: Number of messages to be executed.
  1302.  *
  1303.  * Returns negative errno, else the number of messages executed.
  1304.  *
  1305.  * Note that there is no requirement that each message be sent to
  1306.  * the same slave address, although that is the most common model.
  1307.  */
  1308. int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
  1309. {
  1310.     unsigned long orig_jiffies;
  1311.     int ret, try;
  1312.    
  1313.     u16 reg_addr;
  1314.         int i, i2c_address;
  1315.     bool print_data=0, print_read=0;
  1316.  
  1317.  
  1318.     /* REVISIT the fault reporting model here is weak:
  1319.      *
  1320.      *  - When we get an error after receiving N bytes from a slave,
  1321.      *    there is no way to report "N".
  1322.      *
  1323.      *  - When we get a NAK after transmitting N bytes to a slave,
  1324.      *    there is no way to report "N" ... or to let the master
  1325.      *    continue executing the rest of this combined message, if
  1326.      *    that's the appropriate response.
  1327.      *
  1328.      *  - When for example "num" is two and we successfully complete
  1329.      *    the first message but get an error part way through the
  1330.      *    second, it's unclear whether that should be reported as
  1331.      *    one (discarding status on the second message) or errno
  1332.      *    (discarding status on the first one).
  1333.      */
  1334.  
  1335.     if (adap->algo->master_xfer) {
  1336. #ifdef DEBUG
  1337.         for (ret = 0; ret < num; ret++) {
  1338.             dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
  1339.                 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
  1340.                 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
  1341.                 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
  1342.         }
  1343. #endif
  1344.         /*
  1345.             Data looks like this:          
  1346.             for (thingie = 0; thingie < msgs[ret].len; thingie++)
  1347.             {
  1348.                 printk (KERN_INFO "data[%d]=0x%02x",thingie ,msgs[ret].buf[thingie] ); 
  1349.             }
  1350.         */
  1351.         // we just want the camera bus
  1352.                 if (adap->nr == 2){
  1353.             // if num == 1 then msgs is not an array
  1354.             i2c_address = msgs[0].addr;
  1355.             /*
  1356.             if (num == 1){
  1357.                 i2c_address = msgs.addr;
  1358.             }
  1359.             else
  1360.             {
  1361.                 i2c_address = msgs[0].addr;
  1362.             }
  1363.             */
  1364.                        
  1365.  
  1366.             // device i2c address
  1367.             switch(i2c_address) {
  1368.                     /* front camera */
  1369.                     case 0x3d:
  1370.                             printk (KERN_INFO "Thingie: front cam: 0x%x",i2c_address);
  1371.                         print_data = 1;
  1372.                             break;
  1373.  
  1374.                     /* rear camera */
  1375.                         case 0x36:
  1376.                         // this should indicate a read request 
  1377.                         if (num == 2){
  1378.                             printk (KERN_INFO "Thingie: OV5650 read request at 0x%04x", (int)msgs[0].buf[0] << 8 | msgs[0].buf[1]);                                            
  1379.                             print_read = 1;                    
  1380.                         }
  1381.                                 // The camera regisers are 16 bit addresses
  1382.                                 if (msgs[0].len == 3){
  1383.                             // script format
  1384.                                     //printk (KERN_INFO "Thingie: i2cset -y 2 0x36 0x%x 0x%x 0x%x i", Data[0], Data[1], Data[2]);
  1385.                                     // Driver format
  1386.                             printk (KERN_INFO "Thingie: OV5650  {0x%04x, 0x%02x}", (int)msgs[0].buf[0] << 8 | msgs[0].buf[1], msgs[0].buf[2]);
  1387.                                 }
  1388.                         /* bulk transfers: observations!
  1389.                          * bulk transfers through i2c-core are much smaller than the setup in GB
  1390.                          * first 2 bytes are an address, the next byte is the data
  1391.                          *   after that, each byte goes to the next address but the address itself is not there in the data
  1392.                          */
  1393.                         else if (num !=2) {
  1394.                             reg_addr = (int)msgs[0].buf[0] << 8 | msgs[0].buf[1];
  1395.                             // script format
  1396.                                     //printk (KERN_INFO "Thingie: i2cset -y 2 0x36 0x%x 0x%x 0x%x i", Data[0], Data[1], Data[2]);
  1397.                                     // Driver format
  1398.                             printk (KERN_INFO "Thingie: OV5650  {0x%04x, 0x%02x}", (int)msgs[0].buf[0] << 8 | msgs[0].buf[1], msgs[0].buf[2]);
  1399.  
  1400.                             for (i = 1; i < msgs[0].len -2; i++) {
  1401.                                 printk (KERN_INFO "Thingie: OV5650  {0x%04x, 0x%02x}", reg_addr + i, msgs[0].buf[i+2]);                        
  1402.                             }                              
  1403.                         }
  1404.                         break;
  1405.                         /* camera flash */
  1406.                         case 0x53:
  1407.                                 if (msgs[0].len == 2){
  1408.                                     printk (KERN_INFO "Thingie: i2cset -y 2 0x53 0x%02x 0x%02x", msgs[0].buf[0], msgs[0].buf[1]);
  1409.                                     print_data = 0;
  1410.                                 }
  1411.                         // setting up a read transaction
  1412.                                 else if (!flash_read) {
  1413.                                     printk (KERN_INFO "# Thingie: Sending read request to camera flash");
  1414.                                     printk (KERN_INFO "Thingie: i2cset -y 2 0x53 0x%02x", msgs[0].buf[0]);
  1415.                                 //print_data = 1;
  1416.                                     flash_read = 1;
  1417.                                 }
  1418.                                 break;
  1419.  
  1420.  
  1421.                     /* focuser */
  1422.                         case 0x0c:
  1423.                                 //printk (KERN_INFO "Thingie focuser: 0x%x",i2c_address);
  1424.                             print_data = 0; // too spammy right now
  1425.                                 break;
  1426.  
  1427.  
  1428.  
  1429.  
  1430.  
  1431.                     /* only happens during probing on power up */
  1432.                         default:
  1433.                                 // not much to see here            
  1434.                                 printk (KERN_INFO "Thingie: probing i2c address: 0x%02x",i2c_address);
  1435.                         print_data = 0;
  1436.                                 break;
  1437.             }
  1438.         }
  1439.  
  1440.                    
  1441.  
  1442.  
  1443.  
  1444.  
  1445.         if (in_atomic() || irqs_disabled()) {
  1446.             ret = i2c_trylock_adapter(adap);
  1447.             if (!ret)
  1448.                 /* I2C activity is ongoing. */
  1449.                 return -EAGAIN;
  1450.         } else {
  1451.             i2c_lock_adapter(adap);
  1452.         }
  1453.  
  1454.         /* Retry automatically on arbitration loss */
  1455.         orig_jiffies = jiffies;
  1456.         for (ret = 0, try = 0; try <= adap->retries; try++) {
  1457.             ret = adap->algo->master_xfer(adap, msgs, num);
  1458.             if (ret != -EAGAIN)
  1459.                 break;
  1460.             if (time_after(jiffies, orig_jiffies + adap->timeout))
  1461.                 break;
  1462.         }
  1463.         i2c_unlock_adapter(adap);
  1464.         /* Grab read values here */
  1465.         if (flash_read){
  1466.  
  1467.             flash_read = 0;
  1468.         }
  1469.         else if (print_read){
  1470.             printk (KERN_INFO "Thingie: OV5650  read value: 0x%02x", msgs[0].buf[2]);
  1471.             print_read = 0;    
  1472.         }
  1473.  
  1474.  
  1475.         return ret;
  1476.     } else {
  1477.         dev_dbg(&adap->dev, "I2C level transfers not supported\n");
  1478.         return -EOPNOTSUPP;
  1479.     }
  1480. }
  1481. EXPORT_SYMBOL(i2c_transfer);
  1482.  
  1483. /**
  1484.  * i2c_master_send - issue a single I2C message in master transmit mode
  1485.  * @client: Handle to slave device
  1486.  * @buf: Data that will be written to the slave
  1487.  * @count: How many bytes to write, must be less than 64k since msg.len is u16
  1488.  *
  1489.  * Returns negative errno, or else the number of bytes written.
  1490.  */
  1491. int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
  1492. {
  1493.     int ret;
  1494.     struct i2c_adapter *adap = client->adapter;
  1495.     struct i2c_msg msg;
  1496.  
  1497.     msg.addr = client->addr;
  1498.     msg.flags = client->flags & I2C_M_TEN;
  1499.     msg.len = count;
  1500.     msg.buf = (char *)buf;
  1501.  
  1502.     ret = i2c_transfer(adap, &msg, 1);
  1503.  
  1504.     /* If everything went ok (i.e. 1 msg transmitted), return #bytes
  1505.        transmitted, else error code. */
  1506.     return (ret == 1) ? count : ret;
  1507. }
  1508. EXPORT_SYMBOL(i2c_master_send);
  1509.  
  1510. /**
  1511.  * i2c_master_recv - issue a single I2C message in master receive mode
  1512.  * @client: Handle to slave device
  1513.  * @buf: Where to store data read from slave
  1514.  * @count: How many bytes to read, must be less than 64k since msg.len is u16
  1515.  *
  1516.  * Returns negative errno, or else the number of bytes read.
  1517.  */
  1518. int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
  1519. {
  1520.     struct i2c_adapter *adap = client->adapter;
  1521.     struct i2c_msg msg;
  1522.     int ret;
  1523.  
  1524.     msg.addr = client->addr;
  1525.     msg.flags = client->flags & I2C_M_TEN;
  1526.     msg.flags |= I2C_M_RD;
  1527.     msg.len = count;
  1528.     msg.buf = buf;
  1529.  
  1530.     ret = i2c_transfer(adap, &msg, 1);
  1531.  
  1532.     /* If everything went ok (i.e. 1 msg transmitted), return #bytes
  1533.        transmitted, else error code. */
  1534.     return (ret == 1) ? count : ret;
  1535. }
  1536. EXPORT_SYMBOL(i2c_master_recv);
  1537.  
  1538. /* ----------------------------------------------------
  1539.  * the i2c address scanning function
  1540.  * Will not work for 10-bit addresses!
  1541.  * ----------------------------------------------------
  1542.  */
  1543.  
  1544. /*
  1545.  * Legacy default probe function, mostly relevant for SMBus. The default
  1546.  * probe method is a quick write, but it is known to corrupt the 24RF08
  1547.  * EEPROMs due to a state machine bug, and could also irreversibly
  1548.  * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
  1549.  * we use a short byte read instead. Also, some bus drivers don't implement
  1550.  * quick write, so we fallback to a byte read in that case too.
  1551.  * On x86, there is another special case for FSC hardware monitoring chips,
  1552.  * which want regular byte reads (address 0x73.) Fortunately, these are the
  1553.  * only known chips using this I2C address on PC hardware.
  1554.  * Returns 1 if probe succeeded, 0 if not.
  1555.  */
  1556. static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
  1557. {
  1558.     int err;
  1559.     union i2c_smbus_data dummy;
  1560.  
  1561. #ifdef CONFIG_X86
  1562.     if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
  1563.      && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
  1564.         err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
  1565.                      I2C_SMBUS_BYTE_DATA, &dummy);
  1566.     else
  1567. #endif
  1568.     if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
  1569.      && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
  1570.         err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
  1571.                      I2C_SMBUS_QUICK, NULL);
  1572.     else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
  1573.         err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
  1574.                      I2C_SMBUS_BYTE, &dummy);
  1575.     else {
  1576.         dev_warn(&adap->dev, "No suitable probing method supported\n");
  1577.         err = -EOPNOTSUPP;
  1578.     }
  1579.  
  1580.     return err >= 0;
  1581. }
  1582.  
  1583. static int i2c_detect_address(struct i2c_client *temp_client,
  1584.                   struct i2c_driver *driver)
  1585. {
  1586.     struct i2c_board_info info;
  1587.     struct i2c_adapter *adapter = temp_client->adapter;
  1588.     int addr = temp_client->addr;
  1589.     int err;
  1590.  
  1591.     /* Make sure the address is valid */
  1592.     err = i2c_check_addr_validity(addr);
  1593.     if (err) {
  1594.         dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
  1595.              addr);
  1596.         return err;
  1597.     }
  1598.  
  1599.     /* Skip if already in use */
  1600.     if (i2c_check_addr_busy(adapter, addr))
  1601.         return 0;
  1602.  
  1603.     /* Make sure there is something at this address */
  1604.     if (!i2c_default_probe(adapter, addr))
  1605.         return 0;
  1606.  
  1607.     /* Finally call the custom detection function */
  1608.     memset(&info, 0, sizeof(struct i2c_board_info));
  1609.     info.addr = addr;
  1610.     err = driver->detect(temp_client, &info);
  1611.     if (err) {
  1612.         /* -ENODEV is returned if the detection fails. We catch it
  1613.            here as this isn't an error. */
  1614.         return err == -ENODEV ? 0 : err;
  1615.     }
  1616.  
  1617.     /* Consistency check */
  1618.     if (info.type[0] == '\0') {
  1619.         dev_err(&adapter->dev, "%s detection function provided "
  1620.             "no name for 0x%x\n", driver->driver.name,
  1621.             addr);
  1622.     } else {
  1623.         struct i2c_client *client;
  1624.  
  1625.         /* Detection succeeded, instantiate the device */
  1626.         dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
  1627.             info.type, info.addr);
  1628.         client = i2c_new_device(adapter, &info);
  1629.         if (client)
  1630.             list_add_tail(&client->detected, &driver->clients);
  1631.         else
  1632.             dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
  1633.                 info.type, info.addr);
  1634.     }
  1635.     return 0;
  1636. }
  1637.  
  1638. static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
  1639. {
  1640.     const unsigned short *address_list;
  1641.     struct i2c_client *temp_client;
  1642.     int i, err = 0;
  1643.     int adap_id = i2c_adapter_id(adapter);
  1644.  
  1645.     address_list = driver->address_list;
  1646.     if (!driver->detect || !address_list)
  1647.         return 0;
  1648.  
  1649.     /* Stop here if the classes do not match */
  1650.     if (!(adapter->class & driver->class))
  1651.         return 0;
  1652.  
  1653.     /* Set up a temporary client to help detect callback */
  1654.     temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
  1655.     if (!temp_client)
  1656.         return -ENOMEM;
  1657.     temp_client->adapter = adapter;
  1658.  
  1659.     for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
  1660.         dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
  1661.             "addr 0x%02x\n", adap_id, address_list[i]);
  1662.         temp_client->addr = address_list[i];
  1663.         err = i2c_detect_address(temp_client, driver);
  1664.         if (unlikely(err))
  1665.             break;
  1666.     }
  1667.  
  1668.     kfree(temp_client);
  1669.     return err;
  1670. }
  1671.  
  1672. int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
  1673. {
  1674.     return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
  1675.                   I2C_SMBUS_QUICK, NULL) >= 0;
  1676. }
  1677. EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
  1678.  
  1679. struct i2c_client *
  1680. i2c_new_probed_device(struct i2c_adapter *adap,
  1681.               struct i2c_board_info *info,
  1682.               unsigned short const *addr_list,
  1683.               int (*probe)(struct i2c_adapter *, unsigned short addr))
  1684. {
  1685.     int i;
  1686.  
  1687.     if (!probe)
  1688.         probe = i2c_default_probe;
  1689.  
  1690.     for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
  1691.         /* Check address validity */
  1692.         if (i2c_check_addr_validity(addr_list[i]) < 0) {
  1693.             dev_warn(&adap->dev, "Invalid 7-bit address "
  1694.                  "0x%02x\n", addr_list[i]);
  1695.             continue;
  1696.         }
  1697.  
  1698.         /* Check address availability */
  1699.         if (i2c_check_addr_busy(adap, addr_list[i])) {
  1700.             dev_dbg(&adap->dev, "Address 0x%02x already in "
  1701.                 "use, not probing\n", addr_list[i]);
  1702.             continue;
  1703.         }
  1704.  
  1705.         /* Test address responsiveness */
  1706.         if (probe(adap, addr_list[i]))
  1707.             break;
  1708.     }
  1709.  
  1710.     if (addr_list[i] == I2C_CLIENT_END) {
  1711.         dev_dbg(&adap->dev, "Probing failed, no device found\n");
  1712.         return NULL;
  1713.     }
  1714.  
  1715.     info->addr = addr_list[i];
  1716.     return i2c_new_device(adap, info);
  1717. }
  1718. EXPORT_SYMBOL_GPL(i2c_new_probed_device);
  1719.  
  1720. struct i2c_adapter *i2c_get_adapter(int nr)
  1721. {
  1722.     struct i2c_adapter *adapter;
  1723.  
  1724.     mutex_lock(&core_lock);
  1725.     adapter = idr_find(&i2c_adapter_idr, nr);
  1726.     if (adapter && !try_module_get(adapter->owner))
  1727.         adapter = NULL;
  1728.  
  1729.     mutex_unlock(&core_lock);
  1730.     return adapter;
  1731. }
  1732. EXPORT_SYMBOL(i2c_get_adapter);
  1733.  
  1734. void i2c_put_adapter(struct i2c_adapter *adap)
  1735. {
  1736.     module_put(adap->owner);
  1737. }
  1738. EXPORT_SYMBOL(i2c_put_adapter);
  1739.  
  1740. /* The SMBus parts */
  1741.  
  1742. #define POLY    (0x1070U << 3)
  1743. static u8 crc8(u16 data)
  1744. {
  1745.     int i;
  1746.  
  1747.     for (i = 0; i < 8; i++) {
  1748.         if (data & 0x8000)
  1749.             data = data ^ POLY;
  1750.         data = data << 1;
  1751.     }
  1752.     return (u8)(data >> 8);
  1753. }
  1754.  
  1755. /* Incremental CRC8 over count bytes in the array pointed to by p */
  1756. static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
  1757. {
  1758.     int i;
  1759.  
  1760.     for (i = 0; i < count; i++)
  1761.         crc = crc8((crc ^ p[i]) << 8);
  1762.     return crc;
  1763. }
  1764.  
  1765. /* Assume a 7-bit address, which is reasonable for SMBus */
  1766. static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
  1767. {
  1768.     /* The address will be sent first */
  1769.     u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
  1770.     pec = i2c_smbus_pec(pec, &addr, 1);
  1771.  
  1772.     /* The data buffer follows */
  1773.     return i2c_smbus_pec(pec, msg->buf, msg->len);
  1774. }
  1775.  
  1776. /* Used for write only transactions */
  1777. static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
  1778. {
  1779.     msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
  1780.     msg->len++;
  1781. }
  1782.  
  1783. /* Return <0 on CRC error
  1784.    If there was a write before this read (most cases) we need to take the
  1785.    partial CRC from the write part into account.
  1786.    Note that this function does modify the message (we need to decrease the
  1787.    message length to hide the CRC byte from the caller). */
  1788. static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
  1789. {
  1790.     u8 rpec = msg->buf[--msg->len];
  1791.     cpec = i2c_smbus_msg_pec(cpec, msg);
  1792.  
  1793.     if (rpec != cpec) {
  1794.         pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
  1795.             rpec, cpec);
  1796.         return -EBADMSG;
  1797.     }
  1798.     return 0;
  1799. }
  1800.  
  1801. /**
  1802.  * i2c_smbus_read_byte - SMBus "receive byte" protocol
  1803.  * @client: Handle to slave device
  1804.  *
  1805.  * This executes the SMBus "receive byte" protocol, returning negative errno
  1806.  * else the byte received from the device.
  1807.  */
  1808. s32 i2c_smbus_read_byte(const struct i2c_client *client)
  1809. {
  1810.     union i2c_smbus_data data;
  1811.     int status;
  1812.  
  1813.     status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
  1814.                 I2C_SMBUS_READ, 0,
  1815.                 I2C_SMBUS_BYTE, &data);
  1816.     return (status < 0) ? status : data.byte;
  1817. }
  1818. EXPORT_SYMBOL(i2c_smbus_read_byte);
  1819.  
  1820. /**
  1821.  * i2c_smbus_write_byte - SMBus "send byte" protocol
  1822.  * @client: Handle to slave device
  1823.  * @value: Byte to be sent
  1824.  *
  1825.  * This executes the SMBus "send byte" protocol, returning negative errno
  1826.  * else zero on success.
  1827.  */
  1828. s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
  1829. {
  1830.     return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
  1831.                           I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
  1832. }
  1833. EXPORT_SYMBOL(i2c_smbus_write_byte);
  1834.  
  1835. /**
  1836.  * i2c_smbus_read_byte_data - SMBus "read byte" protocol
  1837.  * @client: Handle to slave device
  1838.  * @command: Byte interpreted by slave
  1839.  *
  1840.  * This executes the SMBus "read byte" protocol, returning negative errno
  1841.  * else a data byte received from the device.
  1842.  */
  1843. s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
  1844. {
  1845.     union i2c_smbus_data data;
  1846.     int status;
  1847.  
  1848.     status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
  1849.                 I2C_SMBUS_READ, command,
  1850.                 I2C_SMBUS_BYTE_DATA, &data);
  1851.     return (status < 0) ? status : data.byte;
  1852. }
  1853. EXPORT_SYMBOL(i2c_smbus_read_byte_data);
  1854.  
  1855. /**
  1856.  * i2c_smbus_write_byte_data - SMBus "write byte" protocol
  1857.  * @client: Handle to slave device
  1858.  * @command: Byte interpreted by slave
  1859.  * @value: Byte being written
  1860.  *
  1861.  * This executes the SMBus "write byte" protocol, returning negative errno
  1862.  * else zero on success.
  1863.  */
  1864. s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
  1865.                   u8 value)
  1866. {
  1867.     union i2c_smbus_data data;
  1868.     data.byte = value;
  1869.     return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
  1870.                   I2C_SMBUS_WRITE, command,
  1871.                   I2C_SMBUS_BYTE_DATA, &data);
  1872. }
  1873. EXPORT_SYMBOL(i2c_smbus_write_byte_data);
  1874.  
  1875. /**
  1876.  * i2c_smbus_read_word_data - SMBus "read word" protocol
  1877.  * @client: Handle to slave device
  1878.  * @command: Byte interpreted by slave
  1879.  *
  1880.  * This executes the SMBus "read word" protocol, returning negative errno
  1881.  * else a 16-bit unsigned "word" received from the device.
  1882.  */
  1883. s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
  1884. {
  1885.     union i2c_smbus_data data;
  1886.     int status;
  1887.  
  1888.     status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
  1889.                 I2C_SMBUS_READ, command,
  1890.                 I2C_SMBUS_WORD_DATA, &data);
  1891.     return (status < 0) ? status : data.word;
  1892. }
  1893. EXPORT_SYMBOL(i2c_smbus_read_word_data);
  1894.  
  1895. /**
  1896.  * i2c_smbus_write_word_data - SMBus "write word" protocol
  1897.  * @client: Handle to slave device
  1898.  * @command: Byte interpreted by slave
  1899.  * @value: 16-bit "word" being written
  1900.  *
  1901.  * This executes the SMBus "write word" protocol, returning negative errno
  1902.  * else zero on success.
  1903.  */
  1904. s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
  1905.                   u16 value)
  1906. {
  1907.     union i2c_smbus_data data;
  1908.     data.word = value;
  1909.     return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
  1910.                   I2C_SMBUS_WRITE, command,
  1911.                   I2C_SMBUS_WORD_DATA, &data);
  1912. }
  1913. EXPORT_SYMBOL(i2c_smbus_write_word_data);
  1914.  
  1915. /**
  1916.  * i2c_smbus_process_call - SMBus "process call" protocol
  1917.  * @client: Handle to slave device
  1918.  * @command: Byte interpreted by slave
  1919.  * @value: 16-bit "word" being written
  1920.  *
  1921.  * This executes the SMBus "process call" protocol, returning negative errno
  1922.  * else a 16-bit unsigned "word" received from the device.
  1923.  */
  1924. s32 i2c_smbus_process_call(const struct i2c_client *client, u8 command,
  1925.                u16 value)
  1926. {
  1927.     union i2c_smbus_data data;
  1928.     int status;
  1929.     data.word = value;
  1930.  
  1931.     status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
  1932.                 I2C_SMBUS_WRITE, command,
  1933.                 I2C_SMBUS_PROC_CALL, &data);
  1934.     return (status < 0) ? status : data.word;
  1935. }
  1936. EXPORT_SYMBOL(i2c_smbus_process_call);
  1937.  
  1938. /**
  1939.  * i2c_smbus_read_block_data - SMBus "block read" protocol
  1940.  * @client: Handle to slave device
  1941.  * @command: Byte interpreted by slave
  1942.  * @values: Byte array into which data will be read; big enough to hold
  1943.  *  the data returned by the slave.  SMBus allows at most 32 bytes.
  1944.  *
  1945.  * This executes the SMBus "block read" protocol, returning negative errno
  1946.  * else the number of data bytes in the slave's response.
  1947.  *
  1948.  * Note that using this function requires that the client's adapter support
  1949.  * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality.  Not all adapter drivers
  1950.  * support this; its emulation through I2C messaging relies on a specific
  1951.  * mechanism (I2C_M_RECV_LEN) which may not be implemented.
  1952.  */
  1953. s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
  1954.                   u8 *values)
  1955. {
  1956.     union i2c_smbus_data data;
  1957.     int status;
  1958.  
  1959.     status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
  1960.                 I2C_SMBUS_READ, command,
  1961.                 I2C_SMBUS_BLOCK_DATA, &data);
  1962.     if (status)
  1963.         return status;
  1964.  
  1965.     memcpy(values, &data.block[1], data.block[0]);
  1966.     return data.block[0];
  1967. }
  1968. EXPORT_SYMBOL(i2c_smbus_read_block_data);
  1969.  
  1970. /**
  1971.  * i2c_smbus_write_block_data - SMBus "block write" protocol
  1972.  * @client: Handle to slave device
  1973.  * @command: Byte interpreted by slave
  1974.  * @length: Size of data block; SMBus allows at most 32 bytes
  1975.  * @values: Byte array which will be written.
  1976.  *
  1977.  * This executes the SMBus "block write" protocol, returning negative errno
  1978.  * else zero on success.
  1979.  */
  1980. s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
  1981.                    u8 length, const u8 *values)
  1982. {
  1983.     union i2c_smbus_data data;
  1984.  
  1985.     if (length > I2C_SMBUS_BLOCK_MAX)
  1986.         length = I2C_SMBUS_BLOCK_MAX;
  1987.     data.block[0] = length;
  1988.     memcpy(&data.block[1], values, length);
  1989.     return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
  1990.                   I2C_SMBUS_WRITE, command,
  1991.                   I2C_SMBUS_BLOCK_DATA, &data);
  1992. }
  1993. EXPORT_SYMBOL(i2c_smbus_write_block_data);
  1994.  
  1995. /* Returns the number of read bytes */
  1996. s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
  1997.                   u8 length, u8 *values)
  1998. {
  1999.     union i2c_smbus_data data;
  2000.     int status;
  2001.  
  2002.     if (length > I2C_SMBUS_BLOCK_MAX)
  2003.         length = I2C_SMBUS_BLOCK_MAX;
  2004.     data.block[0] = length;
  2005.     status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
  2006.                 I2C_SMBUS_READ, command,
  2007.                 I2C_SMBUS_I2C_BLOCK_DATA, &data);
  2008.     if (status < 0)
  2009.         return status;
  2010.  
  2011.     memcpy(values, &data.block[1], data.block[0]);
  2012.     return data.block[0];
  2013. }
  2014. EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
  2015.  
  2016. s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
  2017.                    u8 length, const u8 *values)
  2018. {
  2019.     union i2c_smbus_data data;
  2020.  
  2021.     if (length > I2C_SMBUS_BLOCK_MAX)
  2022.         length = I2C_SMBUS_BLOCK_MAX;
  2023.     data.block[0] = length;
  2024.     memcpy(data.block + 1, values, length);
  2025.     return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
  2026.                   I2C_SMBUS_WRITE, command,
  2027.                   I2C_SMBUS_I2C_BLOCK_DATA, &data);
  2028. }
  2029. EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
  2030.  
  2031. /* Simulate a SMBus command using the i2c protocol
  2032.    No checking of parameters is done!  */
  2033. static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
  2034.                    unsigned short flags,
  2035.                    char read_write, u8 command, int size,
  2036.                    union i2c_smbus_data *data)
  2037. {
  2038.     /* So we need to generate a series of msgs. In the case of writing, we
  2039.       need to use only one message; when reading, we need two. We initialize
  2040.       most things with sane defaults, to keep the code below somewhat
  2041.       simpler. */
  2042.     unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
  2043.     unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
  2044.     int num = read_write == I2C_SMBUS_READ ? 2 : 1;
  2045.     struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
  2046.                               { addr, flags | I2C_M_RD, 0, msgbuf1 }
  2047.                             };
  2048.     int i;
  2049.     u8 partial_pec = 0;
  2050.     int status;
  2051.  
  2052.     msgbuf0[0] = command;
  2053.     switch (size) {
  2054.     case I2C_SMBUS_QUICK:
  2055.         msg[0].len = 0;
  2056.         /* Special case: The read/write field is used as data */
  2057.         msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
  2058.                     I2C_M_RD : 0);
  2059.         num = 1;
  2060.         break;
  2061.     case I2C_SMBUS_BYTE:
  2062.         if (read_write == I2C_SMBUS_READ) {
  2063.             /* Special case: only a read! */
  2064.             msg[0].flags = I2C_M_RD | flags;
  2065.             num = 1;
  2066.         }
  2067.         break;
  2068.     case I2C_SMBUS_BYTE_DATA:
  2069.         if (read_write == I2C_SMBUS_READ)
  2070.             msg[1].len = 1;
  2071.         else {
  2072.             msg[0].len = 2;
  2073.             msgbuf0[1] = data->byte;
  2074.         }
  2075.         break;
  2076.     case I2C_SMBUS_WORD_DATA:
  2077.         if (read_write == I2C_SMBUS_READ)
  2078.             msg[1].len = 2;
  2079.         else {
  2080.             msg[0].len = 3;
  2081.             msgbuf0[1] = data->word & 0xff;
  2082.             msgbuf0[2] = data->word >> 8;
  2083.         }
  2084.         break;
  2085.     case I2C_SMBUS_PROC_CALL:
  2086.         num = 2; /* Special case */
  2087.         read_write = I2C_SMBUS_READ;
  2088.         msg[0].len = 3;
  2089.         msg[1].len = 2;
  2090.         msgbuf0[1] = data->word & 0xff;
  2091.         msgbuf0[2] = data->word >> 8;
  2092.         break;
  2093.     case I2C_SMBUS_BLOCK_DATA:
  2094.         if (read_write == I2C_SMBUS_READ) {
  2095.             msg[1].flags |= I2C_M_RECV_LEN;
  2096.             msg[1].len = 1; /* block length will be added by
  2097.                        the underlying bus driver */
  2098.         } else {
  2099.             msg[0].len = data->block[0] + 2;
  2100.             if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
  2101.                 dev_err(&adapter->dev,
  2102.                     "Invalid block write size %d\n",
  2103.                     data->block[0]);
  2104.                 return -EINVAL;
  2105.             }
  2106.             for (i = 1; i < msg[0].len; i++)
  2107.                 msgbuf0[i] = data->block[i-1];
  2108.         }
  2109.         break;
  2110.     case I2C_SMBUS_BLOCK_PROC_CALL:
  2111.         num = 2; /* Another special case */
  2112.         read_write = I2C_SMBUS_READ;
  2113.         if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
  2114.             dev_err(&adapter->dev,
  2115.                 "Invalid block write size %d\n",
  2116.                 data->block[0]);
  2117.             return -EINVAL;
  2118.         }
  2119.         msg[0].len = data->block[0] + 2;
  2120.         for (i = 1; i < msg[0].len; i++)
  2121.             msgbuf0[i] = data->block[i-1];
  2122.         msg[1].flags |= I2C_M_RECV_LEN;
  2123.         msg[1].len = 1; /* block length will be added by
  2124.                    the underlying bus driver */
  2125.         break;
  2126.     case I2C_SMBUS_I2C_BLOCK_DATA:
  2127.         if (read_write == I2C_SMBUS_READ) {
  2128.             msg[1].len = data->block[0];
  2129.         } else {
  2130.             msg[0].len = data->block[0] + 1;
  2131.             if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
  2132.                 dev_err(&adapter->dev,
  2133.                     "Invalid block write size %d\n",
  2134.                     data->block[0]);
  2135.                 return -EINVAL;
  2136.             }
  2137.             for (i = 1; i <= data->block[0]; i++)
  2138.                 msgbuf0[i] = data->block[i];
  2139.         }
  2140.         break;
  2141.     default:
  2142.         dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
  2143.         return -EOPNOTSUPP;
  2144.     }
  2145.  
  2146.     i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
  2147.                       && size != I2C_SMBUS_I2C_BLOCK_DATA);
  2148.     if (i) {
  2149.         /* Compute PEC if first message is a write */
  2150.         if (!(msg[0].flags & I2C_M_RD)) {
  2151.             if (num == 1) /* Write only */
  2152.                 i2c_smbus_add_pec(&msg[0]);
  2153.             else /* Write followed by read */
  2154.                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
  2155.         }
  2156.         /* Ask for PEC if last message is a read */
  2157.         if (msg[num-1].flags & I2C_M_RD)
  2158.             msg[num-1].len++;
  2159.     }
  2160.  
  2161.     status = i2c_transfer(adapter, msg, num);
  2162.     if (status < 0)
  2163.         return status;
  2164.  
  2165.     /* Check PEC if last message is a read */
  2166.     if (i && (msg[num-1].flags & I2C_M_RD)) {
  2167.         status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
  2168.         if (status < 0)
  2169.             return status;
  2170.     }
  2171.  
  2172.     if (read_write == I2C_SMBUS_READ)
  2173.         switch (size) {
  2174.         case I2C_SMBUS_BYTE:
  2175.             data->byte = msgbuf0[0];
  2176.             break;
  2177.         case I2C_SMBUS_BYTE_DATA:
  2178.             data->byte = msgbuf1[0];
  2179.             break;
  2180.         case I2C_SMBUS_WORD_DATA:
  2181.         case I2C_SMBUS_PROC_CALL:
  2182.             data->word = msgbuf1[0] | (msgbuf1[1] << 8);
  2183.             break;
  2184.         case I2C_SMBUS_I2C_BLOCK_DATA:
  2185.             for (i = 0; i < data->block[0]; i++)
  2186.                 data->block[i+1] = msgbuf1[i];
  2187.             break;
  2188.         case I2C_SMBUS_BLOCK_DATA:
  2189.         case I2C_SMBUS_BLOCK_PROC_CALL:
  2190.             for (i = 0; i < msgbuf1[0] + 1; i++)
  2191.                 data->block[i] = msgbuf1[i];
  2192.             break;
  2193.         }
  2194.     return 0;
  2195. }
  2196.  
  2197. /**
  2198.  * i2c_smbus_xfer - execute SMBus protocol operations
  2199.  * @adapter: Handle to I2C bus
  2200.  * @addr: Address of SMBus slave on that bus
  2201.  * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
  2202.  * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
  2203.  * @command: Byte interpreted by slave, for protocols which use such bytes
  2204.  * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
  2205.  * @data: Data to be read or written
  2206.  *
  2207.  * This executes an SMBus protocol operation, and returns a negative
  2208.  * errno code else zero on success.
  2209.  */
  2210. s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
  2211.            char read_write, u8 command, int protocol,
  2212.            union i2c_smbus_data *data)
  2213. {
  2214.     unsigned long orig_jiffies;
  2215.     int try;
  2216.     s32 res;
  2217.  
  2218.     flags &= I2C_M_TEN | I2C_CLIENT_PEC;
  2219.  
  2220.     if (adapter->algo->smbus_xfer) {
  2221.         i2c_lock_adapter(adapter);
  2222.  
  2223.         /* Retry automatically on arbitration loss */
  2224.         orig_jiffies = jiffies;
  2225.         for (res = 0, try = 0; try <= adapter->retries; try++) {
  2226.             res = adapter->algo->smbus_xfer(adapter, addr, flags,
  2227.                             read_write, command,
  2228.                             protocol, data);
  2229.             if (res != -EAGAIN)
  2230.                 break;
  2231.             if (time_after(jiffies,
  2232.                        orig_jiffies + adapter->timeout))
  2233.                 break;
  2234.         }
  2235.         i2c_unlock_adapter(adapter);
  2236.     } else
  2237.         res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
  2238.                           command, protocol, data);
  2239.  
  2240.     return res;
  2241. }
  2242. EXPORT_SYMBOL(i2c_smbus_xfer);
  2243.  
  2244. MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
  2245. MODULE_DESCRIPTION("I2C-Bus main module");
  2246. MODULE_LICENSE("GPL");
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!