1 /* 2 i2c Support for Apple SMU Controller 3 4 Copyright (c) 2005 Benjamin Herrenschmidt, IBM Corp. 5 <benh@kernel.crashing.org> 6 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. 11 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. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 21 */ 22 23 #include <linux/module.h> 24 #include <linux/kernel.h> 25 #include <linux/types.h> 26 #include <linux/i2c.h> 27 #include <linux/init.h> 28 #include <linux/device.h> 29 #include <linux/platform_device.h> 30 #include <linux/of_irq.h> 31 #include <asm/prom.h> 32 #include <asm/pmac_low_i2c.h> 33 34 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>"); 35 MODULE_DESCRIPTION("I2C driver for Apple PowerMac"); 36 MODULE_LICENSE("GPL"); 37 38 /* 39 * SMBUS-type transfer entrypoint 40 */ 41 static s32 i2c_powermac_smbus_xfer( struct i2c_adapter* adap, 42 u16 addr, 43 unsigned short flags, 44 char read_write, 45 u8 command, 46 int size, 47 union i2c_smbus_data* data) 48 { 49 struct pmac_i2c_bus *bus = i2c_get_adapdata(adap); 50 int rc = 0; 51 int read = (read_write == I2C_SMBUS_READ); 52 int addrdir = (addr << 1) | read; 53 int mode, subsize, len; 54 u32 subaddr; 55 u8 *buf; 56 u8 local[2]; 57 58 if (size == I2C_SMBUS_QUICK || size == I2C_SMBUS_BYTE) { 59 mode = pmac_i2c_mode_std; 60 subsize = 0; 61 subaddr = 0; 62 } else { 63 mode = read ? pmac_i2c_mode_combined : pmac_i2c_mode_stdsub; 64 subsize = 1; 65 subaddr = command; 66 } 67 68 switch (size) { 69 case I2C_SMBUS_QUICK: 70 buf = NULL; 71 len = 0; 72 break; 73 case I2C_SMBUS_BYTE: 74 case I2C_SMBUS_BYTE_DATA: 75 buf = &data->byte; 76 len = 1; 77 break; 78 case I2C_SMBUS_WORD_DATA: 79 if (!read) { 80 local[0] = data->word & 0xff; 81 local[1] = (data->word >> 8) & 0xff; 82 } 83 buf = local; 84 len = 2; 85 break; 86 87 /* Note that these are broken vs. the expected smbus API where 88 * on reads, the length is actually returned from the function, 89 * but I think the current API makes no sense and I don't want 90 * any driver that I haven't verified for correctness to go 91 * anywhere near a pmac i2c bus anyway ... 92 * 93 * I'm also not completely sure what kind of phases to do between 94 * the actual command and the data (what I am _supposed_ to do that 95 * is). For now, I assume writes are a single stream and reads have 96 * a repeat start/addr phase (but not stop in between) 97 */ 98 case I2C_SMBUS_BLOCK_DATA: 99 buf = data->block; 100 len = data->block[0] + 1; 101 break; 102 case I2C_SMBUS_I2C_BLOCK_DATA: 103 buf = &data->block[1]; 104 len = data->block[0]; 105 break; 106 107 default: 108 return -EINVAL; 109 } 110 111 rc = pmac_i2c_open(bus, 0); 112 if (rc) { 113 dev_err(&adap->dev, "Failed to open I2C, err %d\n", rc); 114 return rc; 115 } 116 117 rc = pmac_i2c_setmode(bus, mode); 118 if (rc) { 119 dev_err(&adap->dev, "Failed to set I2C mode %d, err %d\n", 120 mode, rc); 121 goto bail; 122 } 123 124 rc = pmac_i2c_xfer(bus, addrdir, subsize, subaddr, buf, len); 125 if (rc) { 126 if (rc == -ENXIO) 127 dev_dbg(&adap->dev, 128 "I2C transfer at 0x%02x failed, size %d, " 129 "err %d\n", addrdir >> 1, size, rc); 130 else 131 dev_err(&adap->dev, 132 "I2C transfer at 0x%02x failed, size %d, " 133 "err %d\n", addrdir >> 1, size, rc); 134 goto bail; 135 } 136 137 if (size == I2C_SMBUS_WORD_DATA && read) { 138 data->word = ((u16)local[1]) << 8; 139 data->word |= local[0]; 140 } 141 142 bail: 143 pmac_i2c_close(bus); 144 return rc; 145 } 146 147 /* 148 * Generic i2c master transfer entrypoint. This driver only support single 149 * messages (for "lame i2c" transfers). Anything else should use the smbus 150 * entry point 151 */ 152 static int i2c_powermac_master_xfer( struct i2c_adapter *adap, 153 struct i2c_msg *msgs, 154 int num) 155 { 156 struct pmac_i2c_bus *bus = i2c_get_adapdata(adap); 157 int rc = 0; 158 int read; 159 int addrdir; 160 161 if (num != 1) { 162 dev_err(&adap->dev, 163 "Multi-message I2C transactions not supported\n"); 164 return -EOPNOTSUPP; 165 } 166 167 if (msgs->flags & I2C_M_TEN) 168 return -EINVAL; 169 read = (msgs->flags & I2C_M_RD) != 0; 170 addrdir = (msgs->addr << 1) | read; 171 172 rc = pmac_i2c_open(bus, 0); 173 if (rc) { 174 dev_err(&adap->dev, "Failed to open I2C, err %d\n", rc); 175 return rc; 176 } 177 rc = pmac_i2c_setmode(bus, pmac_i2c_mode_std); 178 if (rc) { 179 dev_err(&adap->dev, "Failed to set I2C mode %d, err %d\n", 180 pmac_i2c_mode_std, rc); 181 goto bail; 182 } 183 rc = pmac_i2c_xfer(bus, addrdir, 0, 0, msgs->buf, msgs->len); 184 if (rc < 0) { 185 if (rc == -ENXIO) 186 dev_dbg(&adap->dev, "I2C %s 0x%02x failed, err %d\n", 187 addrdir & 1 ? "read from" : "write to", 188 addrdir >> 1, rc); 189 else 190 dev_err(&adap->dev, "I2C %s 0x%02x failed, err %d\n", 191 addrdir & 1 ? "read from" : "write to", 192 addrdir >> 1, rc); 193 } 194 bail: 195 pmac_i2c_close(bus); 196 return rc < 0 ? rc : 1; 197 } 198 199 static u32 i2c_powermac_func(struct i2c_adapter * adapter) 200 { 201 return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | 202 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA | 203 I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_I2C; 204 } 205 206 /* For now, we only handle smbus */ 207 static const struct i2c_algorithm i2c_powermac_algorithm = { 208 .smbus_xfer = i2c_powermac_smbus_xfer, 209 .master_xfer = i2c_powermac_master_xfer, 210 .functionality = i2c_powermac_func, 211 }; 212 213 214 static int i2c_powermac_remove(struct platform_device *dev) 215 { 216 struct i2c_adapter *adapter = platform_get_drvdata(dev); 217 218 i2c_del_adapter(adapter); 219 memset(adapter, 0, sizeof(*adapter)); 220 221 return 0; 222 } 223 224 static u32 i2c_powermac_get_addr(struct i2c_adapter *adap, 225 struct pmac_i2c_bus *bus, 226 struct device_node *node) 227 { 228 const __be32 *prop; 229 int len; 230 231 /* First check for valid "reg" */ 232 prop = of_get_property(node, "reg", &len); 233 if (prop && (len >= sizeof(int))) 234 return (be32_to_cpup(prop) & 0xff) >> 1; 235 236 /* Then check old-style "i2c-address" */ 237 prop = of_get_property(node, "i2c-address", &len); 238 if (prop && (len >= sizeof(int))) 239 return (be32_to_cpup(prop) & 0xff) >> 1; 240 241 /* Now handle some devices with missing "reg" properties */ 242 if (!strcmp(node->name, "cereal")) 243 return 0x60; 244 else if (!strcmp(node->name, "deq")) 245 return 0x34; 246 247 dev_warn(&adap->dev, "No i2c address for %s\n", node->full_name); 248 249 return 0xffffffff; 250 } 251 252 static void i2c_powermac_create_one(struct i2c_adapter *adap, 253 const char *type, 254 u32 addr) 255 { 256 struct i2c_board_info info = {}; 257 struct i2c_client *newdev; 258 259 strncpy(info.type, type, sizeof(info.type)); 260 info.addr = addr; 261 newdev = i2c_new_device(adap, &info); 262 if (!newdev) 263 dev_err(&adap->dev, 264 "i2c-powermac: Failure to register missing %s\n", 265 type); 266 } 267 268 static void i2c_powermac_add_missing(struct i2c_adapter *adap, 269 struct pmac_i2c_bus *bus, 270 bool found_onyx) 271 { 272 struct device_node *busnode = pmac_i2c_get_bus_node(bus); 273 int rc; 274 275 /* Check for the onyx audio codec */ 276 #define ONYX_REG_CONTROL 67 277 if (of_device_is_compatible(busnode, "k2-i2c") && !found_onyx) { 278 union i2c_smbus_data data; 279 280 rc = i2c_smbus_xfer(adap, 0x46, 0, I2C_SMBUS_READ, 281 ONYX_REG_CONTROL, I2C_SMBUS_BYTE_DATA, 282 &data); 283 if (rc >= 0) 284 i2c_powermac_create_one(adap, "MAC,pcm3052", 0x46); 285 286 rc = i2c_smbus_xfer(adap, 0x47, 0, I2C_SMBUS_READ, 287 ONYX_REG_CONTROL, I2C_SMBUS_BYTE_DATA, 288 &data); 289 if (rc >= 0) 290 i2c_powermac_create_one(adap, "MAC,pcm3052", 0x47); 291 } 292 } 293 294 static bool i2c_powermac_get_type(struct i2c_adapter *adap, 295 struct device_node *node, 296 u32 addr, char *type, int type_size) 297 { 298 char tmp[16]; 299 300 /* Note: we to _NOT_ want the standard 301 * i2c drivers to match with any of our powermac stuff 302 * unless they have been specifically modified to handle 303 * it on a case by case basis. For example, for thermal 304 * control, things like lm75 etc... shall match with their 305 * corresponding windfarm drivers, _NOT_ the generic ones, 306 * so we force a prefix of AAPL, onto the modalias to 307 * make that happen 308 */ 309 310 /* First try proper modalias */ 311 if (of_modalias_node(node, tmp, sizeof(tmp)) >= 0) { 312 snprintf(type, type_size, "MAC,%s", tmp); 313 return true; 314 } 315 316 /* Now look for known workarounds */ 317 if (!strcmp(node->name, "deq")) { 318 /* Apple uses address 0x34 for TAS3001 and 0x35 for TAS3004 */ 319 if (addr == 0x34) { 320 snprintf(type, type_size, "MAC,tas3001"); 321 return true; 322 } else if (addr == 0x35) { 323 snprintf(type, type_size, "MAC,tas3004"); 324 return true; 325 } 326 } 327 328 dev_err(&adap->dev, "i2c-powermac: modalias failure" 329 " on %s\n", node->full_name); 330 return false; 331 } 332 333 static void i2c_powermac_register_devices(struct i2c_adapter *adap, 334 struct pmac_i2c_bus *bus) 335 { 336 struct i2c_client *newdev; 337 struct device_node *node; 338 bool found_onyx = 0; 339 340 /* 341 * In some cases we end up with the via-pmu node itself, in this 342 * case we skip this function completely as the device-tree will 343 * not contain anything useful. 344 */ 345 if (!strcmp(adap->dev.of_node->name, "via-pmu")) 346 return; 347 348 for_each_child_of_node(adap->dev.of_node, node) { 349 struct i2c_board_info info = {}; 350 u32 addr; 351 352 /* Get address & channel */ 353 addr = i2c_powermac_get_addr(adap, bus, node); 354 if (addr == 0xffffffff) 355 continue; 356 357 /* Multibus setup, check channel */ 358 if (!pmac_i2c_match_adapter(node, adap)) 359 continue; 360 361 dev_dbg(&adap->dev, "i2c-powermac: register %s\n", 362 node->full_name); 363 364 /* 365 * Keep track of some device existence to handle 366 * workarounds later. 367 */ 368 if (of_device_is_compatible(node, "pcm3052")) 369 found_onyx = true; 370 371 /* Make up a modalias */ 372 if (!i2c_powermac_get_type(adap, node, addr, 373 info.type, sizeof(info.type))) { 374 continue; 375 } 376 377 /* Fill out the rest of the info structure */ 378 info.addr = addr; 379 info.irq = irq_of_parse_and_map(node, 0); 380 info.of_node = of_node_get(node); 381 382 newdev = i2c_new_device(adap, &info); 383 if (!newdev) { 384 dev_err(&adap->dev, "i2c-powermac: Failure to register" 385 " %s\n", node->full_name); 386 of_node_put(node); 387 /* We do not dispose of the interrupt mapping on 388 * purpose. It's not necessary (interrupt cannot be 389 * re-used) and somebody else might have grabbed it 390 * via direct DT lookup so let's not bother 391 */ 392 continue; 393 } 394 } 395 396 /* Additional workarounds */ 397 i2c_powermac_add_missing(adap, bus, found_onyx); 398 } 399 400 static int i2c_powermac_probe(struct platform_device *dev) 401 { 402 struct pmac_i2c_bus *bus = dev_get_platdata(&dev->dev); 403 struct device_node *parent = NULL; 404 struct i2c_adapter *adapter; 405 const char *basename; 406 int rc; 407 408 if (bus == NULL) 409 return -EINVAL; 410 adapter = pmac_i2c_get_adapter(bus); 411 412 /* Ok, now we need to make up a name for the interface that will 413 * match what we used to do in the past, that is basically the 414 * controller's parent device node for keywest. PMU didn't have a 415 * naming convention and SMU has a different one 416 */ 417 switch(pmac_i2c_get_type(bus)) { 418 case pmac_i2c_bus_keywest: 419 parent = of_get_parent(pmac_i2c_get_controller(bus)); 420 if (parent == NULL) 421 return -EINVAL; 422 basename = parent->name; 423 break; 424 case pmac_i2c_bus_pmu: 425 basename = "pmu"; 426 break; 427 case pmac_i2c_bus_smu: 428 /* This is not what we used to do but I'm fixing drivers at 429 * the same time as this change 430 */ 431 basename = "smu"; 432 break; 433 default: 434 return -EINVAL; 435 } 436 snprintf(adapter->name, sizeof(adapter->name), "%s %d", basename, 437 pmac_i2c_get_channel(bus)); 438 of_node_put(parent); 439 440 platform_set_drvdata(dev, adapter); 441 adapter->algo = &i2c_powermac_algorithm; 442 i2c_set_adapdata(adapter, bus); 443 adapter->dev.parent = &dev->dev; 444 445 /* Clear of_node to skip automatic registration of i2c child nodes */ 446 adapter->dev.of_node = NULL; 447 rc = i2c_add_adapter(adapter); 448 if (rc) { 449 printk(KERN_ERR "i2c-powermac: Adapter %s registration " 450 "failed\n", adapter->name); 451 memset(adapter, 0, sizeof(*adapter)); 452 return rc; 453 } 454 455 printk(KERN_INFO "PowerMac i2c bus %s registered\n", adapter->name); 456 457 /* Use custom child registration due to Apple device-tree funkyness */ 458 adapter->dev.of_node = dev->dev.of_node; 459 i2c_powermac_register_devices(adapter, bus); 460 461 return 0; 462 } 463 464 static struct platform_driver i2c_powermac_driver = { 465 .probe = i2c_powermac_probe, 466 .remove = i2c_powermac_remove, 467 .driver = { 468 .name = "i2c-powermac", 469 .bus = &platform_bus_type, 470 }, 471 }; 472 473 module_platform_driver(i2c_powermac_driver); 474 475 MODULE_ALIAS("platform:i2c-powermac"); 476