Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
i2c-mux-pca954x.c
Go to the documentation of this file.
1 /*
2  * I2C multiplexer
3  *
4  * Copyright (c) 2008-2009 Rodolfo Giometti <[email protected]>
5  * Copyright (c) 2008-2009 Eurotech S.p.A. <[email protected]>
6  *
7  * This module supports the PCA954x series of I2C multiplexer/switch chips
8  * made by Philips Semiconductors.
9  * This includes the:
10  * PCA9540, PCA9542, PCA9543, PCA9544, PCA9545, PCA9546, PCA9547
11  * and PCA9548.
12  *
13  * These chips are all controlled via the I2C bus itself, and all have a
14  * single 8-bit register. The upstream "parent" bus fans out to two,
15  * four, or eight downstream busses or channels; which of these
16  * are selected is determined by the chip type and register contents. A
17  * mux can select only one sub-bus at a time; a switch can select any
18  * combination simultaneously.
19  *
20  * Based on:
21  * pca954x.c from Kumar Gala <[email protected]>
22  * Copyright (C) 2006
23  *
24  * Based on:
25  * pca954x.c from Ken Harrenstien
26  * Copyright (C) 2004 Google, Inc. (Ken Harrenstien)
27  *
28  * Based on:
29  * i2c-virtual_cb.c from Brian Kuschak <[email protected]>
30  * and
31  * pca9540.c from Jean Delvare <[email protected]>.
32  *
33  * This file is licensed under the terms of the GNU General Public
34  * License version 2. This program is licensed "as is" without any
35  * warranty of any kind, whether express or implied.
36  */
37 
38 #include <linux/module.h>
39 #include <linux/init.h>
40 #include <linux/slab.h>
41 #include <linux/device.h>
42 #include <linux/i2c.h>
43 #include <linux/i2c-mux.h>
44 
45 #include <linux/i2c/pca954x.h>
46 
47 #define PCA954X_MAX_NCHANS 8
48 
49 enum pca_type {
58 };
59 
60 struct pca954x {
61  enum pca_type type;
63 
64  u8 last_chan; /* last register value */
65 };
66 
67 struct chip_desc {
69  u8 enable; /* used for muxes only */
70  enum muxtype {
73  } muxtype;
74 };
75 
76 /* Provide specs for the PCA954x types we know about */
77 static const struct chip_desc chips[] = {
78  [pca_9540] = {
79  .nchans = 2,
80  .enable = 0x4,
81  .muxtype = pca954x_ismux,
82  },
83  [pca_9543] = {
84  .nchans = 2,
85  .muxtype = pca954x_isswi,
86  },
87  [pca_9544] = {
88  .nchans = 4,
89  .enable = 0x4,
90  .muxtype = pca954x_ismux,
91  },
92  [pca_9545] = {
93  .nchans = 4,
94  .muxtype = pca954x_isswi,
95  },
96  [pca_9547] = {
97  .nchans = 8,
98  .enable = 0x8,
99  .muxtype = pca954x_ismux,
100  },
101  [pca_9548] = {
102  .nchans = 8,
103  .muxtype = pca954x_isswi,
104  },
105 };
106 
107 static const struct i2c_device_id pca954x_id[] = {
108  { "pca9540", pca_9540 },
109  { "pca9542", pca_9540 },
110  { "pca9543", pca_9543 },
111  { "pca9544", pca_9544 },
112  { "pca9545", pca_9545 },
113  { "pca9546", pca_9545 },
114  { "pca9547", pca_9547 },
115  { "pca9548", pca_9548 },
116  { }
117 };
118 MODULE_DEVICE_TABLE(i2c, pca954x_id);
119 
120 /* Write to mux register. Don't use i2c_transfer()/i2c_smbus_xfer()
121  for this as they will try to lock adapter a second time */
122 static int pca954x_reg_write(struct i2c_adapter *adap,
123  struct i2c_client *client, u8 val)
124 {
125  int ret = -ENODEV;
126 
127  if (adap->algo->master_xfer) {
128  struct i2c_msg msg;
129  char buf[1];
130 
131  msg.addr = client->addr;
132  msg.flags = 0;
133  msg.len = 1;
134  buf[0] = val;
135  msg.buf = buf;
136  ret = adap->algo->master_xfer(adap, &msg, 1);
137  } else {
138  union i2c_smbus_data data;
139  ret = adap->algo->smbus_xfer(adap, client->addr,
140  client->flags,
142  val, I2C_SMBUS_BYTE, &data);
143  }
144 
145  return ret;
146 }
147 
148 static int pca954x_select_chan(struct i2c_adapter *adap,
149  void *client, u32 chan)
150 {
151  struct pca954x *data = i2c_get_clientdata(client);
152  const struct chip_desc *chip = &chips[data->type];
153  u8 regval;
154  int ret = 0;
155 
156  /* we make switches look like muxes, not sure how to be smarter */
157  if (chip->muxtype == pca954x_ismux)
158  regval = chan | chip->enable;
159  else
160  regval = 1 << chan;
161 
162  /* Only select the channel if its different from the last channel */
163  if (data->last_chan != regval) {
164  ret = pca954x_reg_write(adap, client, regval);
165  data->last_chan = regval;
166  }
167 
168  return ret;
169 }
170 
171 static int pca954x_deselect_mux(struct i2c_adapter *adap,
172  void *client, u32 chan)
173 {
174  struct pca954x *data = i2c_get_clientdata(client);
175 
176  /* Deselect active channel */
177  data->last_chan = 0;
178  return pca954x_reg_write(adap, client, data->last_chan);
179 }
180 
181 /*
182  * I2C init/probing/exit functions
183  */
184 static int pca954x_probe(struct i2c_client *client,
185  const struct i2c_device_id *id)
186 {
187  struct i2c_adapter *adap = to_i2c_adapter(client->dev.parent);
188  struct pca954x_platform_data *pdata = client->dev.platform_data;
189  int num, force, class;
190  struct pca954x *data;
191  int ret = -ENODEV;
192 
193  if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_BYTE))
194  goto err;
195 
196  data = kzalloc(sizeof(struct pca954x), GFP_KERNEL);
197  if (!data) {
198  ret = -ENOMEM;
199  goto err;
200  }
201 
202  i2c_set_clientdata(client, data);
203 
204  /* Write the mux register at addr to verify
205  * that the mux is in fact present. This also
206  * initializes the mux to disconnected state.
207  */
208  if (i2c_smbus_write_byte(client, 0) < 0) {
209  dev_warn(&client->dev, "probe failed\n");
210  goto exit_free;
211  }
212 
213  data->type = id->driver_data;
214  data->last_chan = 0; /* force the first selection */
215 
216  /* Now create an adapter for each channel */
217  for (num = 0; num < chips[data->type].nchans; num++) {
218  force = 0; /* dynamic adap number */
219  class = 0; /* no class by default */
220  if (pdata) {
221  if (num < pdata->num_modes) {
222  /* force static number */
223  force = pdata->modes[num].adap_id;
224  class = pdata->modes[num].class;
225  } else
226  /* discard unconfigured channels */
227  break;
228  }
229 
230  data->virt_adaps[num] =
231  i2c_add_mux_adapter(adap, &client->dev, client,
232  force, num, class, pca954x_select_chan,
233  (pdata && pdata->modes[num].deselect_on_exit)
234  ? pca954x_deselect_mux : NULL);
235 
236  if (data->virt_adaps[num] == NULL) {
237  ret = -ENODEV;
238  dev_err(&client->dev,
239  "failed to register multiplexed adapter"
240  " %d as bus %d\n", num, force);
241  goto virt_reg_failed;
242  }
243  }
244 
245  dev_info(&client->dev,
246  "registered %d multiplexed busses for I2C %s %s\n",
247  num, chips[data->type].muxtype == pca954x_ismux
248  ? "mux" : "switch", client->name);
249 
250  return 0;
251 
252 virt_reg_failed:
253  for (num--; num >= 0; num--)
254  i2c_del_mux_adapter(data->virt_adaps[num]);
255 exit_free:
256  kfree(data);
257 err:
258  return ret;
259 }
260 
261 static int pca954x_remove(struct i2c_client *client)
262 {
263  struct pca954x *data = i2c_get_clientdata(client);
264  const struct chip_desc *chip = &chips[data->type];
265  int i, err;
266 
267  for (i = 0; i < chip->nchans; ++i)
268  if (data->virt_adaps[i]) {
269  err = i2c_del_mux_adapter(data->virt_adaps[i]);
270  if (err)
271  return err;
272  data->virt_adaps[i] = NULL;
273  }
274 
275  kfree(data);
276  return 0;
277 }
278 
279 static struct i2c_driver pca954x_driver = {
280  .driver = {
281  .name = "pca954x",
282  .owner = THIS_MODULE,
283  },
284  .probe = pca954x_probe,
285  .remove = pca954x_remove,
286  .id_table = pca954x_id,
287 };
288 
289 module_i2c_driver(pca954x_driver);
290 
291 MODULE_AUTHOR("Rodolfo Giometti <[email protected]>");
292 MODULE_DESCRIPTION("PCA954x I2C mux/switch driver");
293 MODULE_LICENSE("GPL v2");