1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 i2c Support for Apple SMU Controller 4 5 Copyright (c) 2005 Benjamin Herrenschmidt, IBM Corp. 6 <benh@kernel.crashing.org> 7 8 9 */ 10 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> 18 #include <asm/prom.h> 19 #include <asm/pmac_low_i2c.h> 20 21 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>"); 22 MODULE_DESCRIPTION("I2C driver for Apple PowerMac"); 23 MODULE_LICENSE("GPL"); 24 25 /* 26 * SMBUS-type transfer entrypoint 27 */ 28 static s32 i2c_powermac_smbus_xfer( struct i2c_adapter* adap, 29 u16 addr, 30 unsigned short flags, 31 char read_write, 32 u8 command, 33 int size, 34 union i2c_smbus_data* data) 35 { 36 struct pmac_i2c_bus *bus = i2c_get_adapdata(adap); 37 int rc = 0; 38 int read = (read_write == I2C_SMBUS_READ); 39 int addrdir = (addr << 1) | read; 40 int mode, subsize, len; 41 u32 subaddr; 42 u8 *buf; 43 u8 local[2]; 44 45 if (size == I2C_SMBUS_QUICK || size == I2C_SMBUS_BYTE) { 46 mode = pmac_i2c_mode_std; 47 subsize = 0; 48 subaddr = 0; 49 } else { 50 mode = read ? pmac_i2c_mode_combined : pmac_i2c_mode_stdsub; 51 subsize = 1; 52 subaddr = command; 53 } 54 55 switch (size) { 56 case I2C_SMBUS_QUICK: 57 buf = NULL; 58 len = 0; 59 break; 60 case I2C_SMBUS_BYTE: 61 case I2C_SMBUS_BYTE_DATA: 62 buf = &data->byte; 63 len = 1; 64 break; 65 case I2C_SMBUS_WORD_DATA: 66 if (!read) { 67 local[0] = data->word & 0xff; 68 local[1] = (data->word >> 8) & 0xff; 69 } 70 buf = local; 71 len = 2; 72 break; 73 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 ... 79 * 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) 84 */ 85 case I2C_SMBUS_BLOCK_DATA: 86 buf = data->block; 87 len = data->block[0] + 1; 88 break; 89 case I2C_SMBUS_I2C_BLOCK_DATA: 90 buf = &data->block[1]; 91 len = data->block[0]; 92 break; 93 94 default: 95 return -EINVAL; 96 } 97 98 rc = pmac_i2c_open(bus, 0); 99 if (rc) { 100 dev_err(&adap->dev, "Failed to open I2C, err %d\n", rc); 101 return rc; 102 } 103 104 rc = pmac_i2c_setmode(bus, mode); 105 if (rc) { 106 dev_err(&adap->dev, "Failed to set I2C mode %d, err %d\n", 107 mode, rc); 108 goto bail; 109 } 110 111 rc = pmac_i2c_xfer(bus, addrdir, subsize, subaddr, buf, len); 112 if (rc) { 113 if (rc == -ENXIO) 114 dev_dbg(&adap->dev, 115 "I2C transfer at 0x%02x failed, size %d, " 116 "err %d\n", addrdir >> 1, size, rc); 117 else 118 dev_err(&adap->dev, 119 "I2C transfer at 0x%02x failed, size %d, " 120 "err %d\n", addrdir >> 1, size, rc); 121 goto bail; 122 } 123 124 if (size == I2C_SMBUS_WORD_DATA && read) { 125 data->word = ((u16)local[1]) << 8; 126 data->word |= local[0]; 127 } 128 129 bail: 130 pmac_i2c_close(bus); 131 return rc; 132 } 133 134 /* 135 * Generic i2c master transfer entrypoint. This driver only support single 136 * messages (for "lame i2c" transfers). Anything else should use the smbus 137 * entry point 138 */ 139 static int i2c_powermac_master_xfer( struct i2c_adapter *adap, 140 struct i2c_msg *msgs, 141 int num) 142 { 143 struct pmac_i2c_bus *bus = i2c_get_adapdata(adap); 144 int rc = 0; 145 int addrdir; 146 147 if (msgs->flags & I2C_M_TEN) 148 return -EINVAL; 149 addrdir = i2c_8bit_addr_from_msg(msgs); 150 151 rc = pmac_i2c_open(bus, 0); 152 if (rc) { 153 dev_err(&adap->dev, "Failed to open I2C, err %d\n", rc); 154 return rc; 155 } 156 rc = pmac_i2c_setmode(bus, pmac_i2c_mode_std); 157 if (rc) { 158 dev_err(&adap->dev, "Failed to set I2C mode %d, err %d\n", 159 pmac_i2c_mode_std, rc); 160 goto bail; 161 } 162 rc = pmac_i2c_xfer(bus, addrdir, 0, 0, msgs->buf, msgs->len); 163 if (rc < 0) { 164 if (rc == -ENXIO) 165 dev_dbg(&adap->dev, "I2C %s 0x%02x failed, err %d\n", 166 addrdir & 1 ? "read from" : "write to", 167 addrdir >> 1, rc); 168 else 169 dev_err(&adap->dev, "I2C %s 0x%02x failed, err %d\n", 170 addrdir & 1 ? "read from" : "write to", 171 addrdir >> 1, rc); 172 } 173 bail: 174 pmac_i2c_close(bus); 175 return rc < 0 ? rc : 1; 176 } 177 178 static u32 i2c_powermac_func(struct i2c_adapter * adapter) 179 { 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; 183 } 184 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, 190 }; 191 192 static const struct i2c_adapter_quirks i2c_powermac_quirks = { 193 .max_num_msgs = 1, 194 }; 195 196 static int i2c_powermac_remove(struct platform_device *dev) 197 { 198 struct i2c_adapter *adapter = platform_get_drvdata(dev); 199 200 i2c_del_adapter(adapter); 201 memset(adapter, 0, sizeof(*adapter)); 202 203 return 0; 204 } 205 206 static u32 i2c_powermac_get_addr(struct i2c_adapter *adap, 207 struct pmac_i2c_bus *bus, 208 struct device_node *node) 209 { 210 const __be32 *prop; 211 int len; 212 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; 217 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; 222 223 /* Now handle some devices with missing "reg" properties */ 224 if (of_node_name_eq(node, "cereal")) 225 return 0x60; 226 else if (of_node_name_eq(node, "deq")) 227 return 0x34; 228 229 dev_warn(&adap->dev, "No i2c address for %pOF\n", node); 230 231 return 0xffffffff; 232 } 233 234 static void i2c_powermac_create_one(struct i2c_adapter *adap, 235 const char *type, 236 u32 addr) 237 { 238 struct i2c_board_info info = {}; 239 struct i2c_client *newdev; 240 241 strncpy(info.type, type, sizeof(info.type)); 242 info.addr = addr; 243 newdev = i2c_new_device(adap, &info); 244 if (!newdev) 245 dev_err(&adap->dev, 246 "i2c-powermac: Failure to register missing %s\n", 247 type); 248 } 249 250 static void i2c_powermac_add_missing(struct i2c_adapter *adap, 251 struct pmac_i2c_bus *bus, 252 bool found_onyx) 253 { 254 struct device_node *busnode = pmac_i2c_get_bus_node(bus); 255 int rc; 256 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; 261 262 rc = i2c_smbus_xfer(adap, 0x46, 0, I2C_SMBUS_READ, 263 ONYX_REG_CONTROL, I2C_SMBUS_BYTE_DATA, 264 &data); 265 if (rc >= 0) 266 i2c_powermac_create_one(adap, "MAC,pcm3052", 0x46); 267 268 rc = i2c_smbus_xfer(adap, 0x47, 0, I2C_SMBUS_READ, 269 ONYX_REG_CONTROL, I2C_SMBUS_BYTE_DATA, 270 &data); 271 if (rc >= 0) 272 i2c_powermac_create_one(adap, "MAC,pcm3052", 0x47); 273 } 274 } 275 276 static bool i2c_powermac_get_type(struct i2c_adapter *adap, 277 struct device_node *node, 278 u32 addr, char *type, int type_size) 279 { 280 char tmp[16]; 281 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 289 * make that happen 290 */ 291 292 /* First try proper modalias */ 293 if (of_modalias_node(node, tmp, sizeof(tmp)) >= 0) { 294 snprintf(type, type_size, "MAC,%s", tmp); 295 return true; 296 } 297 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 */ 301 if (addr == 0x34) { 302 snprintf(type, type_size, "MAC,tas3001"); 303 return true; 304 } else if (addr == 0x35) { 305 snprintf(type, type_size, "MAC,tas3004"); 306 return true; 307 } 308 } 309 310 dev_err(&adap->dev, "i2c-powermac: modalias failure on %pOF\n", node); 311 return false; 312 } 313 314 static void i2c_powermac_register_devices(struct i2c_adapter *adap, 315 struct pmac_i2c_bus *bus) 316 { 317 struct i2c_client *newdev; 318 struct device_node *node; 319 bool found_onyx = 0; 320 321 /* 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. 325 */ 326 if (of_node_name_eq(adap->dev.of_node, "via-pmu")) 327 return; 328 329 for_each_child_of_node(adap->dev.of_node, node) { 330 struct i2c_board_info info = {}; 331 u32 addr; 332 333 /* Get address & channel */ 334 addr = i2c_powermac_get_addr(adap, bus, node); 335 if (addr == 0xffffffff) 336 continue; 337 338 /* Multibus setup, check channel */ 339 if (!pmac_i2c_match_adapter(node, adap)) 340 continue; 341 342 dev_dbg(&adap->dev, "i2c-powermac: register %pOF\n", node); 343 344 /* 345 * Keep track of some device existence to handle 346 * workarounds later. 347 */ 348 if (of_device_is_compatible(node, "pcm3052")) 349 found_onyx = true; 350 351 /* Make up a modalias */ 352 if (!i2c_powermac_get_type(adap, node, addr, 353 info.type, sizeof(info.type))) { 354 continue; 355 } 356 357 /* Fill out the rest of the info structure */ 358 info.addr = addr; 359 info.irq = irq_of_parse_and_map(node, 0); 360 info.of_node = of_node_get(node); 361 362 newdev = i2c_new_device(adap, &info); 363 if (!newdev) { 364 dev_err(&adap->dev, "i2c-powermac: Failure to register" 365 " %pOF\n", node); 366 of_node_put(node); 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 371 */ 372 continue; 373 } 374 } 375 376 /* Additional workarounds */ 377 i2c_powermac_add_missing(adap, bus, found_onyx); 378 } 379 380 static int i2c_powermac_probe(struct platform_device *dev) 381 { 382 struct pmac_i2c_bus *bus = dev_get_platdata(&dev->dev); 383 struct device_node *parent; 384 struct i2c_adapter *adapter; 385 int rc; 386 387 if (bus == NULL) 388 return -EINVAL; 389 adapter = pmac_i2c_get_adapter(bus); 390 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 395 */ 396 switch(pmac_i2c_get_type(bus)) { 397 case pmac_i2c_bus_keywest: 398 parent = of_get_parent(pmac_i2c_get_controller(bus)); 399 if (parent == NULL) 400 return -EINVAL; 401 snprintf(adapter->name, sizeof(adapter->name), "%pOFn %d", 402 parent, 403 pmac_i2c_get_channel(bus)); 404 of_node_put(parent); 405 break; 406 case pmac_i2c_bus_pmu: 407 snprintf(adapter->name, sizeof(adapter->name), "pmu %d", 408 pmac_i2c_get_channel(bus)); 409 break; 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 413 */ 414 snprintf(adapter->name, sizeof(adapter->name), "smu %d", 415 pmac_i2c_get_channel(bus)); 416 break; 417 default: 418 return -EINVAL; 419 } 420 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; 426 427 /* Clear of_node to skip automatic registration of i2c child nodes */ 428 adapter->dev.of_node = NULL; 429 rc = i2c_add_adapter(adapter); 430 if (rc) { 431 printk(KERN_ERR "i2c-powermac: Adapter %s registration " 432 "failed\n", adapter->name); 433 memset(adapter, 0, sizeof(*adapter)); 434 return rc; 435 } 436 437 printk(KERN_INFO "PowerMac i2c bus %s registered\n", adapter->name); 438 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); 442 443 return 0; 444 } 445 446 static struct platform_driver i2c_powermac_driver = { 447 .probe = i2c_powermac_probe, 448 .remove = i2c_powermac_remove, 449 .driver = { 450 .name = "i2c-powermac", 451 .bus = &platform_bus_type, 452 }, 453 }; 454 455 module_platform_driver(i2c_powermac_driver); 456 457 MODULE_ALIAS("platform:i2c-powermac"); 458