drm/radeon: switch to a finer grained reset for evergreen
[linux-3.10.git] / drivers / i2c / i2c-mux.c
1 /*
2  * Multiplexed I2C bus driver.
3  *
4  * Copyright (c) 2008-2009 Rodolfo Giometti <giometti@linux.it>
5  * Copyright (c) 2008-2009 Eurotech S.p.A. <info@eurotech.it>
6  * Copyright (c) 2009-2010 NSN GmbH & Co KG <michael.lawnick.ext@nsn.com>
7  *
8  * Simplifies access to complex multiplexed I2C bus topologies, by presenting
9  * each multiplexed bus segment as an additional I2C adapter.
10  * Supports multi-level mux'ing (mux behind a mux).
11  *
12  * Based on:
13  *      i2c-virt.c from Kumar Gala <galak@kernel.crashing.org>
14  *      i2c-virtual.c from Ken Harrenstien, Copyright (c) 2004 Google, Inc.
15  *      i2c-virtual.c from Brian Kuschak <bkuschak@yahoo.com>
16  *
17  * This file is licensed under the terms of the GNU General Public
18  * License version 2. This program is licensed "as is" without any
19  * warranty of any kind, whether express or implied.
20  */
21
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/slab.h>
25 #include <linux/i2c.h>
26 #include <linux/i2c-mux.h>
27 #include <linux/of.h>
28 #include <linux/of_i2c.h>
29
30 /* multiplexer per channel data */
31 struct i2c_mux_priv {
32         struct i2c_adapter adap;
33         struct i2c_algorithm algo;
34
35         struct i2c_adapter *parent;
36         void *mux_priv; /* the mux chip/device */
37         u32  chan_id;   /* the channel id */
38
39         int (*select)(struct i2c_adapter *, void *mux_priv, u32 chan_id);
40         int (*deselect)(struct i2c_adapter *, void *mux_priv, u32 chan_id);
41 };
42
43 static int i2c_mux_master_xfer(struct i2c_adapter *adap,
44                                struct i2c_msg msgs[], int num)
45 {
46         struct i2c_mux_priv *priv = adap->algo_data;
47         struct i2c_adapter *parent = priv->parent;
48         int ret;
49
50         /* Switch to the right mux port and perform the transfer. */
51
52         ret = priv->select(parent, priv->mux_priv, priv->chan_id);
53         if (ret >= 0)
54                 ret = parent->algo->master_xfer(parent, msgs, num);
55         if (priv->deselect)
56                 priv->deselect(parent, priv->mux_priv, priv->chan_id);
57
58         return ret;
59 }
60
61 static int i2c_mux_smbus_xfer(struct i2c_adapter *adap,
62                               u16 addr, unsigned short flags,
63                               char read_write, u8 command,
64                               int size, union i2c_smbus_data *data)
65 {
66         struct i2c_mux_priv *priv = adap->algo_data;
67         struct i2c_adapter *parent = priv->parent;
68         int ret;
69
70         /* Select the right mux port and perform the transfer. */
71
72         ret = priv->select(parent, priv->mux_priv, priv->chan_id);
73         if (ret >= 0)
74                 ret = parent->algo->smbus_xfer(parent, addr, flags,
75                                         read_write, command, size, data);
76         if (priv->deselect)
77                 priv->deselect(parent, priv->mux_priv, priv->chan_id);
78
79         return ret;
80 }
81
82 /* Return the parent's functionality */
83 static u32 i2c_mux_functionality(struct i2c_adapter *adap)
84 {
85         struct i2c_mux_priv *priv = adap->algo_data;
86         struct i2c_adapter *parent = priv->parent;
87
88         return parent->algo->functionality(parent);
89 }
90
91 /* Return all parent classes, merged */
92 static unsigned int i2c_mux_parent_classes(struct i2c_adapter *parent)
93 {
94         unsigned int class = 0;
95
96         do {
97                 class |= parent->class;
98                 parent = i2c_parent_is_i2c_adapter(parent);
99         } while (parent);
100
101         return class;
102 }
103
104 struct i2c_adapter *i2c_add_mux_adapter(struct i2c_adapter *parent,
105                                 struct device *mux_dev,
106                                 void *mux_priv, u32 force_nr, u32 chan_id,
107                                 unsigned int class,
108                                 int (*select) (struct i2c_adapter *,
109                                                void *, u32),
110                                 int (*deselect) (struct i2c_adapter *,
111                                                  void *, u32))
112 {
113         struct i2c_mux_priv *priv;
114         int ret;
115
116         priv = kzalloc(sizeof(struct i2c_mux_priv), GFP_KERNEL);
117         if (!priv)
118                 return NULL;
119
120         /* Set up private adapter data */
121         priv->parent = parent;
122         priv->mux_priv = mux_priv;
123         priv->chan_id = chan_id;
124         priv->select = select;
125         priv->deselect = deselect;
126
127         /* Need to do algo dynamically because we don't know ahead
128          * of time what sort of physical adapter we'll be dealing with.
129          */
130         if (parent->algo->master_xfer)
131                 priv->algo.master_xfer = i2c_mux_master_xfer;
132         if (parent->algo->smbus_xfer)
133                 priv->algo.smbus_xfer = i2c_mux_smbus_xfer;
134         priv->algo.functionality = i2c_mux_functionality;
135
136         /* Now fill out new adapter structure */
137         snprintf(priv->adap.name, sizeof(priv->adap.name),
138                  "i2c-%d-mux (chan_id %d)", i2c_adapter_id(parent), chan_id);
139         priv->adap.owner = THIS_MODULE;
140         priv->adap.algo = &priv->algo;
141         priv->adap.algo_data = priv;
142         priv->adap.dev.parent = &parent->dev;
143
144         /* Sanity check on class */
145         if (i2c_mux_parent_classes(parent) & class)
146                 dev_err(&parent->dev,
147                         "Segment %d behind mux can't share classes with ancestors\n",
148                         chan_id);
149         else
150                 priv->adap.class = class;
151
152         /*
153          * Try to populate the mux adapter's of_node, expands to
154          * nothing if !CONFIG_OF.
155          */
156         if (mux_dev->of_node) {
157                 struct device_node *child;
158                 u32 reg;
159
160                 for_each_child_of_node(mux_dev->of_node, child) {
161                         ret = of_property_read_u32(child, "reg", &reg);
162                         if (ret)
163                                 continue;
164                         if (chan_id == reg) {
165                                 priv->adap.dev.of_node = child;
166                                 break;
167                         }
168                 }
169         }
170
171         if (force_nr) {
172                 priv->adap.nr = force_nr;
173                 ret = i2c_add_numbered_adapter(&priv->adap);
174         } else {
175                 ret = i2c_add_adapter(&priv->adap);
176         }
177         if (ret < 0) {
178                 dev_err(&parent->dev,
179                         "failed to add mux-adapter (error=%d)\n",
180                         ret);
181                 kfree(priv);
182                 return NULL;
183         }
184
185         dev_info(&parent->dev, "Added multiplexed i2c bus %d\n",
186                  i2c_adapter_id(&priv->adap));
187
188         of_i2c_register_devices(&priv->adap);
189
190         return &priv->adap;
191 }
192 EXPORT_SYMBOL_GPL(i2c_add_mux_adapter);
193
194 int i2c_del_mux_adapter(struct i2c_adapter *adap)
195 {
196         struct i2c_mux_priv *priv = adap->algo_data;
197         int ret;
198
199         ret = i2c_del_adapter(adap);
200         if (ret < 0)
201                 return ret;
202         kfree(priv);
203
204         return 0;
205 }
206 EXPORT_SYMBOL_GPL(i2c_del_mux_adapter);
207
208 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
209 MODULE_DESCRIPTION("I2C driver for multiplexed I2C busses");
210 MODULE_LICENSE("GPL v2");