2 i2c Support for Apple SMU Controller
4 Copyright (c) 2005 Benjamin Herrenschmidt, IBM Corp.
5 <benh@kernel.crashing.org>
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
19 #include <linux/module.h>
20 #include <linux/kernel.h>
21 #include <linux/types.h>
22 #include <linux/i2c.h>
23 #include <linux/device.h>
24 #include <linux/platform_device.h>
25 #include <linux/of_irq.h>
27 #include <asm/pmac_low_i2c.h>
29 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
30 MODULE_DESCRIPTION("I2C driver for Apple PowerMac");
31 MODULE_LICENSE("GPL");
34 * SMBUS-type transfer entrypoint
36 static s32 i2c_powermac_smbus_xfer( struct i2c_adapter* adap,
42 union i2c_smbus_data* data)
44 struct pmac_i2c_bus *bus = i2c_get_adapdata(adap);
46 int read = (read_write == I2C_SMBUS_READ);
47 int addrdir = (addr << 1) | read;
48 int mode, subsize, len;
53 if (size == I2C_SMBUS_QUICK || size == I2C_SMBUS_BYTE) {
54 mode = pmac_i2c_mode_std;
58 mode = read ? pmac_i2c_mode_combined : pmac_i2c_mode_stdsub;
69 case I2C_SMBUS_BYTE_DATA:
73 case I2C_SMBUS_WORD_DATA:
75 local[0] = data->word & 0xff;
76 local[1] = (data->word >> 8) & 0xff;
82 /* Note that these are broken vs. the expected smbus API where
83 * on reads, the length is actually returned from the function,
84 * but I think the current API makes no sense and I don't want
85 * any driver that I haven't verified for correctness to go
86 * anywhere near a pmac i2c bus anyway ...
88 * I'm also not completely sure what kind of phases to do between
89 * the actual command and the data (what I am _supposed_ to do that
90 * is). For now, I assume writes are a single stream and reads have
91 * a repeat start/addr phase (but not stop in between)
93 case I2C_SMBUS_BLOCK_DATA:
95 len = data->block[0] + 1;
97 case I2C_SMBUS_I2C_BLOCK_DATA:
98 buf = &data->block[1];
106 rc = pmac_i2c_open(bus, 0);
108 dev_err(&adap->dev, "Failed to open I2C, err %d\n", rc);
112 rc = pmac_i2c_setmode(bus, mode);
114 dev_err(&adap->dev, "Failed to set I2C mode %d, err %d\n",
119 rc = pmac_i2c_xfer(bus, addrdir, subsize, subaddr, buf, len);
123 "I2C transfer at 0x%02x failed, size %d, "
124 "err %d\n", addrdir >> 1, size, rc);
127 "I2C transfer at 0x%02x failed, size %d, "
128 "err %d\n", addrdir >> 1, size, rc);
132 if (size == I2C_SMBUS_WORD_DATA && read) {
133 data->word = ((u16)local[1]) << 8;
134 data->word |= local[0];
143 * Generic i2c master transfer entrypoint. This driver only support single
144 * messages (for "lame i2c" transfers). Anything else should use the smbus
147 static int i2c_powermac_master_xfer( struct i2c_adapter *adap,
148 struct i2c_msg *msgs,
151 struct pmac_i2c_bus *bus = i2c_get_adapdata(adap);
155 if (msgs->flags & I2C_M_TEN)
157 addrdir = i2c_8bit_addr_from_msg(msgs);
159 rc = pmac_i2c_open(bus, 0);
161 dev_err(&adap->dev, "Failed to open I2C, err %d\n", rc);
164 rc = pmac_i2c_setmode(bus, pmac_i2c_mode_std);
166 dev_err(&adap->dev, "Failed to set I2C mode %d, err %d\n",
167 pmac_i2c_mode_std, rc);
170 rc = pmac_i2c_xfer(bus, addrdir, 0, 0, msgs->buf, msgs->len);
173 dev_dbg(&adap->dev, "I2C %s 0x%02x failed, err %d\n",
174 addrdir & 1 ? "read from" : "write to",
177 dev_err(&adap->dev, "I2C %s 0x%02x failed, err %d\n",
178 addrdir & 1 ? "read from" : "write to",
183 return rc < 0 ? rc : 1;
186 static u32 i2c_powermac_func(struct i2c_adapter * adapter)
188 return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
189 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
190 I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_I2C;
193 /* For now, we only handle smbus */
194 static const struct i2c_algorithm i2c_powermac_algorithm = {
195 .smbus_xfer = i2c_powermac_smbus_xfer,
196 .master_xfer = i2c_powermac_master_xfer,
197 .functionality = i2c_powermac_func,
200 static struct i2c_adapter_quirks i2c_powermac_quirks = {
204 static int i2c_powermac_remove(struct platform_device *dev)
206 struct i2c_adapter *adapter = platform_get_drvdata(dev);
208 i2c_del_adapter(adapter);
209 memset(adapter, 0, sizeof(*adapter));
214 static u32 i2c_powermac_get_addr(struct i2c_adapter *adap,
215 struct pmac_i2c_bus *bus,
216 struct device_node *node)
221 /* First check for valid "reg" */
222 prop = of_get_property(node, "reg", &len);
223 if (prop && (len >= sizeof(int)))
224 return (be32_to_cpup(prop) & 0xff) >> 1;
226 /* Then check old-style "i2c-address" */
227 prop = of_get_property(node, "i2c-address", &len);
228 if (prop && (len >= sizeof(int)))
229 return (be32_to_cpup(prop) & 0xff) >> 1;
231 /* Now handle some devices with missing "reg" properties */
232 if (!strcmp(node->name, "cereal"))
234 else if (!strcmp(node->name, "deq"))
237 dev_warn(&adap->dev, "No i2c address for %s\n", node->full_name);
242 static void i2c_powermac_create_one(struct i2c_adapter *adap,
246 struct i2c_board_info info = {};
247 struct i2c_client *newdev;
249 strncpy(info.type, type, sizeof(info.type));
251 newdev = i2c_new_device(adap, &info);
254 "i2c-powermac: Failure to register missing %s\n",
258 static void i2c_powermac_add_missing(struct i2c_adapter *adap,
259 struct pmac_i2c_bus *bus,
262 struct device_node *busnode = pmac_i2c_get_bus_node(bus);
265 /* Check for the onyx audio codec */
266 #define ONYX_REG_CONTROL 67
267 if (of_device_is_compatible(busnode, "k2-i2c") && !found_onyx) {
268 union i2c_smbus_data data;
270 rc = i2c_smbus_xfer(adap, 0x46, 0, I2C_SMBUS_READ,
271 ONYX_REG_CONTROL, I2C_SMBUS_BYTE_DATA,
274 i2c_powermac_create_one(adap, "MAC,pcm3052", 0x46);
276 rc = i2c_smbus_xfer(adap, 0x47, 0, I2C_SMBUS_READ,
277 ONYX_REG_CONTROL, I2C_SMBUS_BYTE_DATA,
280 i2c_powermac_create_one(adap, "MAC,pcm3052", 0x47);
284 static bool i2c_powermac_get_type(struct i2c_adapter *adap,
285 struct device_node *node,
286 u32 addr, char *type, int type_size)
290 /* Note: we to _NOT_ want the standard
291 * i2c drivers to match with any of our powermac stuff
292 * unless they have been specifically modified to handle
293 * it on a case by case basis. For example, for thermal
294 * control, things like lm75 etc... shall match with their
295 * corresponding windfarm drivers, _NOT_ the generic ones,
296 * so we force a prefix of AAPL, onto the modalias to
300 /* First try proper modalias */
301 if (of_modalias_node(node, tmp, sizeof(tmp)) >= 0) {
302 snprintf(type, type_size, "MAC,%s", tmp);
306 /* Now look for known workarounds */
307 if (!strcmp(node->name, "deq")) {
308 /* Apple uses address 0x34 for TAS3001 and 0x35 for TAS3004 */
310 snprintf(type, type_size, "MAC,tas3001");
312 } else if (addr == 0x35) {
313 snprintf(type, type_size, "MAC,tas3004");
318 dev_err(&adap->dev, "i2c-powermac: modalias failure"
319 " on %s\n", node->full_name);
323 static void i2c_powermac_register_devices(struct i2c_adapter *adap,
324 struct pmac_i2c_bus *bus)
326 struct i2c_client *newdev;
327 struct device_node *node;
331 * In some cases we end up with the via-pmu node itself, in this
332 * case we skip this function completely as the device-tree will
333 * not contain anything useful.
335 if (!strcmp(adap->dev.of_node->name, "via-pmu"))
338 for_each_child_of_node(adap->dev.of_node, node) {
339 struct i2c_board_info info = {};
342 /* Get address & channel */
343 addr = i2c_powermac_get_addr(adap, bus, node);
344 if (addr == 0xffffffff)
347 /* Multibus setup, check channel */
348 if (!pmac_i2c_match_adapter(node, adap))
351 dev_dbg(&adap->dev, "i2c-powermac: register %s\n",
355 * Keep track of some device existence to handle
358 if (of_device_is_compatible(node, "pcm3052"))
361 /* Make up a modalias */
362 if (!i2c_powermac_get_type(adap, node, addr,
363 info.type, sizeof(info.type))) {
367 /* Fill out the rest of the info structure */
369 info.irq = irq_of_parse_and_map(node, 0);
370 info.of_node = of_node_get(node);
372 newdev = i2c_new_device(adap, &info);
374 dev_err(&adap->dev, "i2c-powermac: Failure to register"
375 " %s\n", node->full_name);
377 /* We do not dispose of the interrupt mapping on
378 * purpose. It's not necessary (interrupt cannot be
379 * re-used) and somebody else might have grabbed it
380 * via direct DT lookup so let's not bother
386 /* Additional workarounds */
387 i2c_powermac_add_missing(adap, bus, found_onyx);
390 static int i2c_powermac_probe(struct platform_device *dev)
392 struct pmac_i2c_bus *bus = dev_get_platdata(&dev->dev);
393 struct device_node *parent = NULL;
394 struct i2c_adapter *adapter;
395 const char *basename;
400 adapter = pmac_i2c_get_adapter(bus);
402 /* Ok, now we need to make up a name for the interface that will
403 * match what we used to do in the past, that is basically the
404 * controller's parent device node for keywest. PMU didn't have a
405 * naming convention and SMU has a different one
407 switch(pmac_i2c_get_type(bus)) {
408 case pmac_i2c_bus_keywest:
409 parent = of_get_parent(pmac_i2c_get_controller(bus));
412 basename = parent->name;
414 case pmac_i2c_bus_pmu:
417 case pmac_i2c_bus_smu:
418 /* This is not what we used to do but I'm fixing drivers at
419 * the same time as this change
426 snprintf(adapter->name, sizeof(adapter->name), "%s %d", basename,
427 pmac_i2c_get_channel(bus));
430 platform_set_drvdata(dev, adapter);
431 adapter->algo = &i2c_powermac_algorithm;
432 adapter->quirks = &i2c_powermac_quirks;
433 i2c_set_adapdata(adapter, bus);
434 adapter->dev.parent = &dev->dev;
436 /* Clear of_node to skip automatic registration of i2c child nodes */
437 adapter->dev.of_node = NULL;
438 rc = i2c_add_adapter(adapter);
440 printk(KERN_ERR "i2c-powermac: Adapter %s registration "
441 "failed\n", adapter->name);
442 memset(adapter, 0, sizeof(*adapter));
446 printk(KERN_INFO "PowerMac i2c bus %s registered\n", adapter->name);
448 /* Use custom child registration due to Apple device-tree funkyness */
449 adapter->dev.of_node = dev->dev.of_node;
450 i2c_powermac_register_devices(adapter, bus);
455 static struct platform_driver i2c_powermac_driver = {
456 .probe = i2c_powermac_probe,
457 .remove = i2c_powermac_remove,
459 .name = "i2c-powermac",
460 .bus = &platform_bus_type,
464 module_platform_driver(i2c_powermac_driver);
466 MODULE_ALIAS("platform:i2c-powermac");