]>
Commit | Line | Data |
---|---|---|
a28d3af2 BH |
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 | ||
a28d3af2 BH |
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> | |
a28d3af2 BH |
28 | #include <linux/device.h> |
29 | #include <linux/platform_device.h> | |
5af50730 | 30 | #include <linux/of_irq.h> |
a28d3af2 BH |
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; | |
02864d58 JD |
53 | int mode, subsize, len; |
54 | u32 subaddr; | |
55 | u8 *buf; | |
a28d3af2 BH |
56 | u8 local[2]; |
57 | ||
02864d58 JD |
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 | } | |
a28d3af2 BH |
67 | |
68 | switch (size) { | |
69 | case I2C_SMBUS_QUICK: | |
02864d58 JD |
70 | buf = NULL; |
71 | len = 0; | |
a28d3af2 BH |
72 | break; |
73 | case I2C_SMBUS_BYTE: | |
a28d3af2 | 74 | case I2C_SMBUS_BYTE_DATA: |
02864d58 JD |
75 | buf = &data->byte; |
76 | len = 1; | |
a28d3af2 BH |
77 | break; |
78 | case I2C_SMBUS_WORD_DATA: | |
a28d3af2 BH |
79 | if (!read) { |
80 | local[0] = data->word & 0xff; | |
81 | local[1] = (data->word >> 8) & 0xff; | |
82 | } | |
02864d58 JD |
83 | buf = local; |
84 | len = 2; | |
a28d3af2 BH |
85 | break; |
86 | ||
87 | /* Note that these are broken vs. the expected smbus API where | |
96acafe0 | 88 | * on reads, the length is actually returned from the function, |
a28d3af2 BH |
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: | |
02864d58 JD |
99 | buf = data->block; |
100 | len = data->block[0] + 1; | |
a28d3af2 BH |
101 | break; |
102 | case I2C_SMBUS_I2C_BLOCK_DATA: | |
02864d58 JD |
103 | buf = &data->block[1]; |
104 | len = data->block[0]; | |
a28d3af2 BH |
105 | break; |
106 | ||
107 | default: | |
02864d58 | 108 | return -EINVAL; |
a28d3af2 | 109 | } |
02864d58 JD |
110 | |
111 | rc = pmac_i2c_open(bus, 0); | |
d7d838a6 JD |
112 | if (rc) { |
113 | dev_err(&adap->dev, "Failed to open I2C, err %d\n", rc); | |
02864d58 | 114 | return rc; |
d7d838a6 | 115 | } |
02864d58 JD |
116 | |
117 | rc = pmac_i2c_setmode(bus, mode); | |
d7d838a6 JD |
118 | if (rc) { |
119 | dev_err(&adap->dev, "Failed to set I2C mode %d, err %d\n", | |
120 | mode, rc); | |
02864d58 | 121 | goto bail; |
d7d838a6 | 122 | } |
02864d58 JD |
123 | |
124 | rc = pmac_i2c_xfer(bus, addrdir, subsize, subaddr, buf, len); | |
d7d838a6 | 125 | if (rc) { |
8e4b980c JD |
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); | |
02864d58 | 134 | goto bail; |
d7d838a6 | 135 | } |
02864d58 JD |
136 | |
137 | if (size == I2C_SMBUS_WORD_DATA && read) { | |
138 | data->word = ((u16)local[1]) << 8; | |
139 | data->word |= local[0]; | |
140 | } | |
141 | ||
a28d3af2 BH |
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 | ||
6f7e549f JD |
161 | if (num != 1) { |
162 | dev_err(&adap->dev, | |
163 | "Multi-message I2C transactions not supported\n"); | |
164 | return -EOPNOTSUPP; | |
165 | } | |
166 | ||
a28d3af2 BH |
167 | if (msgs->flags & I2C_M_TEN) |
168 | return -EINVAL; | |
169 | read = (msgs->flags & I2C_M_RD) != 0; | |
170 | addrdir = (msgs->addr << 1) | read; | |
a28d3af2 BH |
171 | |
172 | rc = pmac_i2c_open(bus, 0); | |
d7d838a6 JD |
173 | if (rc) { |
174 | dev_err(&adap->dev, "Failed to open I2C, err %d\n", rc); | |
a28d3af2 | 175 | return rc; |
d7d838a6 | 176 | } |
a28d3af2 | 177 | rc = pmac_i2c_setmode(bus, pmac_i2c_mode_std); |
d7d838a6 JD |
178 | if (rc) { |
179 | dev_err(&adap->dev, "Failed to set I2C mode %d, err %d\n", | |
180 | pmac_i2c_mode_std, rc); | |
a28d3af2 | 181 | goto bail; |
d7d838a6 | 182 | } |
a28d3af2 | 183 | rc = pmac_i2c_xfer(bus, addrdir, 0, 0, msgs->buf, msgs->len); |
8e4b980c JD |
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 | } | |
a28d3af2 BH |
194 | bail: |
195 | pmac_i2c_close(bus); | |
8ced8eee | 196 | return rc < 0 ? rc : 1; |
a28d3af2 BH |
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 */ | |
8f9082c5 | 207 | static const struct i2c_algorithm i2c_powermac_algorithm = { |
a28d3af2 BH |
208 | .smbus_xfer = i2c_powermac_smbus_xfer, |
209 | .master_xfer = i2c_powermac_master_xfer, | |
210 | .functionality = i2c_powermac_func, | |
211 | }; | |
212 | ||
213 | ||
0b255e92 | 214 | static int i2c_powermac_remove(struct platform_device *dev) |
a28d3af2 | 215 | { |
9f2545c1 | 216 | struct i2c_adapter *adapter = platform_get_drvdata(dev); |
bf51a8c5 LPC |
217 | |
218 | i2c_del_adapter(adapter); | |
6dfa5ca3 | 219 | memset(adapter, 0, sizeof(*adapter)); |
a28d3af2 BH |
220 | |
221 | return 0; | |
222 | } | |
223 | ||
0b255e92 | 224 | static u32 i2c_powermac_get_addr(struct i2c_adapter *adap, |
3a3dd018 BH |
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 | ||
0b255e92 | 252 | static void i2c_powermac_create_one(struct i2c_adapter *adap, |
3a3dd018 BH |
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 | ||
0b255e92 | 268 | static void i2c_powermac_add_missing(struct i2c_adapter *adap, |
3a3dd018 BH |
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 | ||
0b255e92 | 294 | static bool i2c_powermac_get_type(struct i2c_adapter *adap, |
3a3dd018 BH |
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 | ||
0b255e92 | 333 | static void i2c_powermac_register_devices(struct i2c_adapter *adap, |
81e5d864 BH |
334 | struct pmac_i2c_bus *bus) |
335 | { | |
336 | struct i2c_client *newdev; | |
337 | struct device_node *node; | |
3a3dd018 BH |
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; | |
81e5d864 BH |
347 | |
348 | for_each_child_of_node(adap->dev.of_node, node) { | |
349 | struct i2c_board_info info = {}; | |
81e5d864 | 350 | u32 addr; |
81e5d864 BH |
351 | |
352 | /* Get address & channel */ | |
3a3dd018 BH |
353 | addr = i2c_powermac_get_addr(adap, bus, node); |
354 | if (addr == 0xffffffff) | |
81e5d864 | 355 | continue; |
81e5d864 BH |
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 | ||
3a3dd018 BH |
364 | /* |
365 | * Keep track of some device existence to handle | |
366 | * workarounds later. | |
81e5d864 | 367 | */ |
3a3dd018 BH |
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))) { | |
81e5d864 BH |
374 | continue; |
375 | } | |
81e5d864 BH |
376 | |
377 | /* Fill out the rest of the info structure */ | |
3a3dd018 | 378 | info.addr = addr; |
81e5d864 BH |
379 | info.irq = irq_of_parse_and_map(node, 0); |
380 | info.of_node = of_node_get(node); | |
81e5d864 BH |
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 | } | |
3a3dd018 BH |
395 | |
396 | /* Additional workarounds */ | |
397 | i2c_powermac_add_missing(adap, bus, found_onyx); | |
81e5d864 | 398 | } |
a28d3af2 | 399 | |
0b255e92 | 400 | static int i2c_powermac_probe(struct platform_device *dev) |
a28d3af2 | 401 | { |
6d4028c6 | 402 | struct pmac_i2c_bus *bus = dev_get_platdata(&dev->dev); |
a28d3af2 BH |
403 | struct device_node *parent = NULL; |
404 | struct i2c_adapter *adapter; | |
018a3d1d | 405 | const char *basename; |
a28d3af2 BH |
406 | int rc; |
407 | ||
408 | if (bus == NULL) | |
409 | return -EINVAL; | |
bc6286e5 | 410 | adapter = pmac_i2c_get_adapter(bus); |
a28d3af2 BH |
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 | } | |
bc6286e5 JD |
436 | snprintf(adapter->name, sizeof(adapter->name), "%s %d", basename, |
437 | pmac_i2c_get_channel(bus)); | |
a28d3af2 BH |
438 | of_node_put(parent); |
439 | ||
9f2545c1 | 440 | platform_set_drvdata(dev, adapter); |
a28d3af2 BH |
441 | adapter->algo = &i2c_powermac_algorithm; |
442 | i2c_set_adapdata(adapter, bus); | |
9f2545c1 | 443 | adapter->dev.parent = &dev->dev; |
687b81d0 WS |
444 | |
445 | /* Clear of_node to skip automatic registration of i2c child nodes */ | |
446 | adapter->dev.of_node = NULL; | |
a28d3af2 BH |
447 | rc = i2c_add_adapter(adapter); |
448 | if (rc) { | |
449 | printk(KERN_ERR "i2c-powermac: Adapter %s registration " | |
bc6286e5 | 450 | "failed\n", adapter->name); |
6dfa5ca3 | 451 | memset(adapter, 0, sizeof(*adapter)); |
874e955b | 452 | return rc; |
a28d3af2 BH |
453 | } |
454 | ||
bc6286e5 | 455 | printk(KERN_INFO "PowerMac i2c bus %s registered\n", adapter->name); |
810ad7b6 | 456 | |
687b81d0 WS |
457 | /* Use custom child registration due to Apple device-tree funkyness */ |
458 | adapter->dev.of_node = dev->dev.of_node; | |
81e5d864 | 459 | i2c_powermac_register_devices(adapter, bus); |
810ad7b6 | 460 | |
874e955b | 461 | return 0; |
a28d3af2 BH |
462 | } |
463 | ||
9f2545c1 | 464 | static struct platform_driver i2c_powermac_driver = { |
a28d3af2 | 465 | .probe = i2c_powermac_probe, |
0b255e92 | 466 | .remove = i2c_powermac_remove, |
9f2545c1 BH |
467 | .driver = { |
468 | .name = "i2c-powermac", | |
469 | .bus = &platform_bus_type, | |
470 | }, | |
a28d3af2 BH |
471 | }; |
472 | ||
a3664b51 | 473 | module_platform_driver(i2c_powermac_driver); |
a28d3af2 | 474 | |
a3664b51 | 475 | MODULE_ALIAS("platform:i2c-powermac"); |