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 ret = of_property_read_u32(node, "reg", &prop);
216 return (prop & 0xff) >> 1;
218 /* Then check old-style "i2c-address" */
219 ret = of_property_read_u32(node, "i2c-address", &prop);
221 return (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_client_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)
283 * Note: we do _NOT_ want the standard i2c drivers to match with any of
284 * our powermac stuff unless they have been specifically modified to
285 * handle it on a case by case basis. For example, for thermal control,
286 * things like lm75 etc... shall match with their corresponding
287 * windfarm drivers, _NOT_ the generic ones, so we force a prefix of
288 * 'MAC', onto the modalias to make that happen
291 /* First try proper modalias */
292 if (of_modalias_node(node, tmp, sizeof(tmp)) >= 0) {
293 snprintf(type, type_size, "MAC,%s", tmp);
297 /* Now look for known workarounds */
298 if (of_node_name_eq(node, "deq")) {
299 /* Apple uses address 0x34 for TAS3001 and 0x35 for TAS3004 */
301 snprintf(type, type_size, "MAC,tas3001");
303 } else if (addr == 0x35) {
304 snprintf(type, type_size, "MAC,tas3004");
309 dev_err(&adap->dev, "i2c-powermac: modalias failure on %pOF\n", node);
313 static void i2c_powermac_register_devices(struct i2c_adapter *adap,
314 struct pmac_i2c_bus *bus)
316 struct i2c_client *newdev;
317 struct device_node *node;
318 bool found_onyx = false;
321 * In some cases we end up with the via-pmu node itself, in this
322 * case we skip this function completely as the device-tree will
323 * not contain anything useful.
325 if (of_node_name_eq(adap->dev.of_node, "via-pmu"))
328 for_each_child_of_node(adap->dev.of_node, node) {
329 struct i2c_board_info info = {};
332 /* Get address & channel */
333 addr = i2c_powermac_get_addr(adap, bus, node);
334 if (addr == 0xffffffff)
337 /* Multibus setup, check channel */
338 if (!pmac_i2c_match_adapter(node, adap))
341 dev_dbg(&adap->dev, "i2c-powermac: register %pOF\n", node);
344 * Keep track of some device existence to handle
347 if (of_device_is_compatible(node, "pcm3052"))
350 /* Make up a modalias */
351 if (!i2c_powermac_get_type(adap, node, addr,
352 info.type, sizeof(info.type))) {
356 /* Fill out the rest of the info structure */
358 info.irq = irq_of_parse_and_map(node, 0);
359 info.of_node = of_node_get(node);
361 newdev = i2c_new_client_device(adap, &info);
362 if (IS_ERR(newdev)) {
363 dev_err(&adap->dev, "i2c-powermac: Failure to register"
366 /* We do not dispose of the interrupt mapping on
367 * purpose. It's not necessary (interrupt cannot be
368 * re-used) and somebody else might have grabbed it
369 * via direct DT lookup so let's not bother
375 /* Additional workarounds */
376 i2c_powermac_add_missing(adap, bus, found_onyx);
379 static int i2c_powermac_probe(struct platform_device *dev)
381 struct pmac_i2c_bus *bus = dev_get_platdata(&dev->dev);
382 struct device_node *parent;
383 struct i2c_adapter *adapter;
388 adapter = pmac_i2c_get_adapter(bus);
390 /* Ok, now we need to make up a name for the interface that will
391 * match what we used to do in the past, that is basically the
392 * controller's parent device node for keywest. PMU didn't have a
393 * naming convention and SMU has a different one
395 switch(pmac_i2c_get_type(bus)) {
396 case pmac_i2c_bus_keywest:
397 parent = of_get_parent(pmac_i2c_get_controller(bus));
400 snprintf(adapter->name, sizeof(adapter->name), "%pOFn %d",
402 pmac_i2c_get_channel(bus));
405 case pmac_i2c_bus_pmu:
406 snprintf(adapter->name, sizeof(adapter->name), "pmu %d",
407 pmac_i2c_get_channel(bus));
409 case pmac_i2c_bus_smu:
410 /* This is not what we used to do but I'm fixing drivers at
411 * the same time as this change
413 snprintf(adapter->name, sizeof(adapter->name), "smu %d",
414 pmac_i2c_get_channel(bus));
420 platform_set_drvdata(dev, adapter);
421 adapter->algo = &i2c_powermac_algorithm;
422 adapter->quirks = &i2c_powermac_quirks;
423 i2c_set_adapdata(adapter, bus);
424 adapter->dev.parent = &dev->dev;
426 /* Clear of_node to skip automatic registration of i2c child nodes */
427 adapter->dev.of_node = NULL;
428 rc = i2c_add_adapter(adapter);
430 printk(KERN_ERR "i2c-powermac: Adapter %s registration "
431 "failed\n", adapter->name);
432 memset(adapter, 0, sizeof(*adapter));
436 printk(KERN_INFO "PowerMac i2c bus %s registered\n", adapter->name);
438 /* Use custom child registration due to Apple device-tree funkyness */
439 adapter->dev.of_node = dev->dev.of_node;
440 i2c_powermac_register_devices(adapter, bus);
445 static struct platform_driver i2c_powermac_driver = {
446 .probe = i2c_powermac_probe,
447 .remove = i2c_powermac_remove,
449 .name = "i2c-powermac",
450 .bus = &platform_bus_type,
454 module_platform_driver(i2c_powermac_driver);
456 MODULE_ALIAS("platform:i2c-powermac");