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 u32 prop; 211 int ret; 212 213 /* First check for valid "reg" */ 214 ret = of_property_read_u32(node, "reg", &prop); 215 if (ret == 0) 216 return (prop & 0xff) >> 1; 217 218 /* Then check old-style "i2c-address" */ 219 ret = of_property_read_u32(node, "i2c-address", &prop); 220 if (ret == 0) 221 return (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_client_device(adap, &info); 244 if (IS_ERR(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 /* 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 289 */ 290 291 /* First try proper modalias */ 292 if (of_modalias_node(node, tmp, sizeof(tmp)) >= 0) { 293 snprintf(type, type_size, "MAC,%s", tmp); 294 return true; 295 } 296 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 */ 300 if (addr == 0x34) { 301 snprintf(type, type_size, "MAC,tas3001"); 302 return true; 303 } else if (addr == 0x35) { 304 snprintf(type, type_size, "MAC,tas3004"); 305 return true; 306 } 307 } 308 309 dev_err(&adap->dev, "i2c-powermac: modalias failure on %pOF\n", node); 310 return false; 311 } 312 313 static void i2c_powermac_register_devices(struct i2c_adapter *adap, 314 struct pmac_i2c_bus *bus) 315 { 316 struct i2c_client *newdev; 317 struct device_node *node; 318 bool found_onyx = false; 319 320 /* 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. 324 */ 325 if (of_node_name_eq(adap->dev.of_node, "via-pmu")) 326 return; 327 328 for_each_child_of_node(adap->dev.of_node, node) { 329 struct i2c_board_info info = {}; 330 u32 addr; 331 332 /* Get address & channel */ 333 addr = i2c_powermac_get_addr(adap, bus, node); 334 if (addr == 0xffffffff) 335 continue; 336 337 /* Multibus setup, check channel */ 338 if (!pmac_i2c_match_adapter(node, adap)) 339 continue; 340 341 dev_dbg(&adap->dev, "i2c-powermac: register %pOF\n", node); 342 343 /* 344 * Keep track of some device existence to handle 345 * workarounds later. 346 */ 347 if (of_device_is_compatible(node, "pcm3052")) 348 found_onyx = true; 349 350 /* Make up a modalias */ 351 if (!i2c_powermac_get_type(adap, node, addr, 352 info.type, sizeof(info.type))) { 353 continue; 354 } 355 356 /* Fill out the rest of the info structure */ 357 info.addr = addr; 358 info.irq = irq_of_parse_and_map(node, 0); 359 info.of_node = of_node_get(node); 360 361 newdev = i2c_new_client_device(adap, &info); 362 if (IS_ERR(newdev)) { 363 dev_err(&adap->dev, "i2c-powermac: Failure to register" 364 " %pOF\n", node); 365 of_node_put(node); 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 370 */ 371 continue; 372 } 373 } 374 375 /* Additional workarounds */ 376 i2c_powermac_add_missing(adap, bus, found_onyx); 377 } 378 379 static int i2c_powermac_probe(struct platform_device *dev) 380 { 381 struct pmac_i2c_bus *bus = dev_get_platdata(&dev->dev); 382 struct device_node *parent; 383 struct i2c_adapter *adapter; 384 int rc; 385 386 if (bus == NULL) 387 return -EINVAL; 388 adapter = pmac_i2c_get_adapter(bus); 389 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 394 */ 395 switch(pmac_i2c_get_type(bus)) { 396 case pmac_i2c_bus_keywest: 397 parent = of_get_parent(pmac_i2c_get_controller(bus)); 398 if (parent == NULL) 399 return -EINVAL; 400 snprintf(adapter->name, sizeof(adapter->name), "%pOFn %d", 401 parent, 402 pmac_i2c_get_channel(bus)); 403 of_node_put(parent); 404 break; 405 case pmac_i2c_bus_pmu: 406 snprintf(adapter->name, sizeof(adapter->name), "pmu %d", 407 pmac_i2c_get_channel(bus)); 408 break; 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 412 */ 413 snprintf(adapter->name, sizeof(adapter->name), "smu %d", 414 pmac_i2c_get_channel(bus)); 415 break; 416 default: 417 return -EINVAL; 418 } 419 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; 425 426 /* Clear of_node to skip automatic registration of i2c child nodes */ 427 adapter->dev.of_node = NULL; 428 rc = i2c_add_adapter(adapter); 429 if (rc) { 430 printk(KERN_ERR "i2c-powermac: Adapter %s registration " 431 "failed\n", adapter->name); 432 memset(adapter, 0, sizeof(*adapter)); 433 return rc; 434 } 435 436 printk(KERN_INFO "PowerMac i2c bus %s registered\n", adapter->name); 437 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); 441 442 return 0; 443 } 444 445 static struct platform_driver i2c_powermac_driver = { 446 .probe = i2c_powermac_probe, 447 .remove = i2c_powermac_remove, 448 .driver = { 449 .name = "i2c-powermac", 450 .bus = &platform_bus_type, 451 }, 452 }; 453 454 module_platform_driver(i2c_powermac_driver); 455 456 MODULE_ALIAS("platform:i2c-powermac"); 457