1 // SPDX-License-Identifier: GPL-2.0-or-later
3 i2c Support for Apple SMU Controller
5 Copyright (c) 2005 Benjamin Herrenschmidt, IBM Corp.
6 <benh@kernel.crashing.org>
11 #include <linux/module.h>
12 #include <linux/kernel.h>
13 #include <linux/types.h>
14 #include <linux/i2c.h>
15 #include <linux/device.h>
16 #include <linux/platform_device.h>
17 #include <linux/of_irq.h>
19 #include <asm/pmac_low_i2c.h>
21 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
22 MODULE_DESCRIPTION("I2C driver for Apple PowerMac");
23 MODULE_LICENSE("GPL");
26 * SMBUS-type transfer entrypoint
28 static s32 i2c_powermac_smbus_xfer( struct i2c_adapter* adap,
34 union i2c_smbus_data* data)
36 struct pmac_i2c_bus *bus = i2c_get_adapdata(adap);
38 int read = (read_write == I2C_SMBUS_READ);
39 int addrdir = (addr << 1) | read;
40 int mode, subsize, len;
45 if (size == I2C_SMBUS_QUICK || size == I2C_SMBUS_BYTE) {
46 mode = pmac_i2c_mode_std;
50 mode = read ? pmac_i2c_mode_combined : pmac_i2c_mode_stdsub;
61 case I2C_SMBUS_BYTE_DATA:
65 case I2C_SMBUS_WORD_DATA:
67 local[0] = data->word & 0xff;
68 local[1] = (data->word >> 8) & 0xff;
74 /* Note that these are broken vs. the expected smbus API where
75 * on reads, the length is actually returned from the function,
76 * but I think the current API makes no sense and I don't want
77 * any driver that I haven't verified for correctness to go
78 * anywhere near a pmac i2c bus anyway ...
80 * I'm also not completely sure what kind of phases to do between
81 * the actual command and the data (what I am _supposed_ to do that
82 * is). For now, I assume writes are a single stream and reads have
83 * a repeat start/addr phase (but not stop in between)
85 case I2C_SMBUS_BLOCK_DATA:
87 len = data->block[0] + 1;
89 case I2C_SMBUS_I2C_BLOCK_DATA:
90 buf = &data->block[1];
98 rc = pmac_i2c_open(bus, 0);
100 dev_err(&adap->dev, "Failed to open I2C, err %d\n", rc);
104 rc = pmac_i2c_setmode(bus, mode);
106 dev_err(&adap->dev, "Failed to set I2C mode %d, err %d\n",
111 rc = pmac_i2c_xfer(bus, addrdir, subsize, subaddr, buf, len);
115 "I2C transfer at 0x%02x failed, size %d, "
116 "err %d\n", addrdir >> 1, size, rc);
119 "I2C transfer at 0x%02x failed, size %d, "
120 "err %d\n", addrdir >> 1, size, rc);
124 if (size == I2C_SMBUS_WORD_DATA && read) {
125 data->word = ((u16)local[1]) << 8;
126 data->word |= local[0];
135 * Generic i2c master transfer entrypoint. This driver only support single
136 * messages (for "lame i2c" transfers). Anything else should use the smbus
139 static int i2c_powermac_master_xfer( struct i2c_adapter *adap,
140 struct i2c_msg *msgs,
143 struct pmac_i2c_bus *bus = i2c_get_adapdata(adap);
147 if (msgs->flags & I2C_M_TEN)
149 addrdir = i2c_8bit_addr_from_msg(msgs);
151 rc = pmac_i2c_open(bus, 0);
153 dev_err(&adap->dev, "Failed to open I2C, err %d\n", rc);
156 rc = pmac_i2c_setmode(bus, pmac_i2c_mode_std);
158 dev_err(&adap->dev, "Failed to set I2C mode %d, err %d\n",
159 pmac_i2c_mode_std, rc);
162 rc = pmac_i2c_xfer(bus, addrdir, 0, 0, msgs->buf, msgs->len);
165 dev_dbg(&adap->dev, "I2C %s 0x%02x failed, err %d\n",
166 addrdir & 1 ? "read from" : "write to",
169 dev_err(&adap->dev, "I2C %s 0x%02x failed, err %d\n",
170 addrdir & 1 ? "read from" : "write to",
175 return rc < 0 ? rc : 1;
178 static u32 i2c_powermac_func(struct i2c_adapter * adapter)
180 return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
181 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
182 I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_I2C;
185 /* For now, we only handle smbus */
186 static const struct i2c_algorithm i2c_powermac_algorithm = {
187 .smbus_xfer = i2c_powermac_smbus_xfer,
188 .master_xfer = i2c_powermac_master_xfer,
189 .functionality = i2c_powermac_func,
192 static const struct i2c_adapter_quirks i2c_powermac_quirks = {
196 static int i2c_powermac_remove(struct platform_device *dev)
198 struct i2c_adapter *adapter = platform_get_drvdata(dev);
200 i2c_del_adapter(adapter);
201 memset(adapter, 0, sizeof(*adapter));
206 static u32 i2c_powermac_get_addr(struct i2c_adapter *adap,
207 struct pmac_i2c_bus *bus,
208 struct device_node *node)
213 /* First check for valid "reg" */
214 prop = of_get_property(node, "reg", &len);
215 if (prop && (len >= sizeof(int)))
216 return (be32_to_cpup(prop) & 0xff) >> 1;
218 /* Then check old-style "i2c-address" */
219 prop = of_get_property(node, "i2c-address", &len);
220 if (prop && (len >= sizeof(int)))
221 return (be32_to_cpup(prop) & 0xff) >> 1;
223 /* Now handle some devices with missing "reg" properties */
224 if (of_node_name_eq(node, "cereal"))
226 else if (of_node_name_eq(node, "deq"))
229 dev_warn(&adap->dev, "No i2c address for %pOF\n", node);
234 static void i2c_powermac_create_one(struct i2c_adapter *adap,
238 struct i2c_board_info info = {};
239 struct i2c_client *newdev;
241 strncpy(info.type, type, sizeof(info.type));
243 newdev = i2c_new_device(adap, &info);
246 "i2c-powermac: Failure to register missing %s\n",
250 static void i2c_powermac_add_missing(struct i2c_adapter *adap,
251 struct pmac_i2c_bus *bus,
254 struct device_node *busnode = pmac_i2c_get_bus_node(bus);
257 /* Check for the onyx audio codec */
258 #define ONYX_REG_CONTROL 67
259 if (of_device_is_compatible(busnode, "k2-i2c") && !found_onyx) {
260 union i2c_smbus_data data;
262 rc = i2c_smbus_xfer(adap, 0x46, 0, I2C_SMBUS_READ,
263 ONYX_REG_CONTROL, I2C_SMBUS_BYTE_DATA,
266 i2c_powermac_create_one(adap, "MAC,pcm3052", 0x46);
268 rc = i2c_smbus_xfer(adap, 0x47, 0, I2C_SMBUS_READ,
269 ONYX_REG_CONTROL, I2C_SMBUS_BYTE_DATA,
272 i2c_powermac_create_one(adap, "MAC,pcm3052", 0x47);
276 static bool i2c_powermac_get_type(struct i2c_adapter *adap,
277 struct device_node *node,
278 u32 addr, char *type, int type_size)
282 /* Note: we to _NOT_ want the standard
283 * i2c drivers to match with any of our powermac stuff
284 * unless they have been specifically modified to handle
285 * it on a case by case basis. For example, for thermal
286 * control, things like lm75 etc... shall match with their
287 * corresponding windfarm drivers, _NOT_ the generic ones,
288 * so we force a prefix of AAPL, onto the modalias to
292 /* First try proper modalias */
293 if (of_modalias_node(node, tmp, sizeof(tmp)) >= 0) {
294 snprintf(type, type_size, "MAC,%s", tmp);
298 /* Now look for known workarounds */
299 if (of_node_name_eq(node, "deq")) {
300 /* Apple uses address 0x34 for TAS3001 and 0x35 for TAS3004 */
302 snprintf(type, type_size, "MAC,tas3001");
304 } else if (addr == 0x35) {
305 snprintf(type, type_size, "MAC,tas3004");
310 dev_err(&adap->dev, "i2c-powermac: modalias failure on %pOF\n", node);
314 static void i2c_powermac_register_devices(struct i2c_adapter *adap,
315 struct pmac_i2c_bus *bus)
317 struct i2c_client *newdev;
318 struct device_node *node;
322 * In some cases we end up with the via-pmu node itself, in this
323 * case we skip this function completely as the device-tree will
324 * not contain anything useful.
326 if (of_node_name_eq(adap->dev.of_node, "via-pmu"))
329 for_each_child_of_node(adap->dev.of_node, node) {
330 struct i2c_board_info info = {};
333 /* Get address & channel */
334 addr = i2c_powermac_get_addr(adap, bus, node);
335 if (addr == 0xffffffff)
338 /* Multibus setup, check channel */
339 if (!pmac_i2c_match_adapter(node, adap))
342 dev_dbg(&adap->dev, "i2c-powermac: register %pOF\n", node);
345 * Keep track of some device existence to handle
348 if (of_device_is_compatible(node, "pcm3052"))
351 /* Make up a modalias */
352 if (!i2c_powermac_get_type(adap, node, addr,
353 info.type, sizeof(info.type))) {
357 /* Fill out the rest of the info structure */
359 info.irq = irq_of_parse_and_map(node, 0);
360 info.of_node = of_node_get(node);
362 newdev = i2c_new_device(adap, &info);
364 dev_err(&adap->dev, "i2c-powermac: Failure to register"
367 /* We do not dispose of the interrupt mapping on
368 * purpose. It's not necessary (interrupt cannot be
369 * re-used) and somebody else might have grabbed it
370 * via direct DT lookup so let's not bother
376 /* Additional workarounds */
377 i2c_powermac_add_missing(adap, bus, found_onyx);
380 static int i2c_powermac_probe(struct platform_device *dev)
382 struct pmac_i2c_bus *bus = dev_get_platdata(&dev->dev);
383 struct device_node *parent;
384 struct i2c_adapter *adapter;
389 adapter = pmac_i2c_get_adapter(bus);
391 /* Ok, now we need to make up a name for the interface that will
392 * match what we used to do in the past, that is basically the
393 * controller's parent device node for keywest. PMU didn't have a
394 * naming convention and SMU has a different one
396 switch(pmac_i2c_get_type(bus)) {
397 case pmac_i2c_bus_keywest:
398 parent = of_get_parent(pmac_i2c_get_controller(bus));
401 snprintf(adapter->name, sizeof(adapter->name), "%pOFn %d",
403 pmac_i2c_get_channel(bus));
406 case pmac_i2c_bus_pmu:
407 snprintf(adapter->name, sizeof(adapter->name), "pmu %d",
408 pmac_i2c_get_channel(bus));
410 case pmac_i2c_bus_smu:
411 /* This is not what we used to do but I'm fixing drivers at
412 * the same time as this change
414 snprintf(adapter->name, sizeof(adapter->name), "smu %d",
415 pmac_i2c_get_channel(bus));
421 platform_set_drvdata(dev, adapter);
422 adapter->algo = &i2c_powermac_algorithm;
423 adapter->quirks = &i2c_powermac_quirks;
424 i2c_set_adapdata(adapter, bus);
425 adapter->dev.parent = &dev->dev;
427 /* Clear of_node to skip automatic registration of i2c child nodes */
428 adapter->dev.of_node = NULL;
429 rc = i2c_add_adapter(adapter);
431 printk(KERN_ERR "i2c-powermac: Adapter %s registration "
432 "failed\n", adapter->name);
433 memset(adapter, 0, sizeof(*adapter));
437 printk(KERN_INFO "PowerMac i2c bus %s registered\n", adapter->name);
439 /* Use custom child registration due to Apple device-tree funkyness */
440 adapter->dev.of_node = dev->dev.of_node;
441 i2c_powermac_register_devices(adapter, bus);
446 static struct platform_driver i2c_powermac_driver = {
447 .probe = i2c_powermac_probe,
448 .remove = i2c_powermac_remove,
450 .name = "i2c-powermac",
451 .bus = &platform_bus_type,
455 module_platform_driver(i2c_powermac_driver);
457 MODULE_ALIAS("platform:i2c-powermac");