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 | |
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 | case I2C_SMBUS_BLOCK_DATA: |
81 | buf = data->block; |
82 | len = data->block[0] + 1; |
83 | break; |
84 | case I2C_SMBUS_I2C_BLOCK_DATA: |
85 | buf = &data->block[1]; |
86 | len = data->block[0]; |
87 | break; |
88 | |
89 | default: |
90 | return -EINVAL; |
91 | } |
92 | |
93 | rc = pmac_i2c_open(bus, 0); |
94 | if (rc) { |
95 | dev_err(&adap->dev, "Failed to open I2C, err %d\n" , rc); |
96 | return rc; |
97 | } |
98 | |
99 | rc = pmac_i2c_setmode(bus, mode); |
100 | if (rc) { |
101 | dev_err(&adap->dev, "Failed to set I2C mode %d, err %d\n" , |
102 | mode, rc); |
103 | goto bail; |
104 | } |
105 | |
106 | rc = pmac_i2c_xfer(bus, addrdir, subsize, subaddr, buf, len); |
107 | if (rc) { |
108 | if (rc == -ENXIO) |
109 | dev_dbg(&adap->dev, |
110 | "I2C transfer at 0x%02x failed, size %d, " |
111 | "err %d\n" , addrdir >> 1, size, rc); |
112 | else |
113 | dev_err(&adap->dev, |
114 | "I2C transfer at 0x%02x failed, size %d, " |
115 | "err %d\n" , addrdir >> 1, size, rc); |
116 | goto bail; |
117 | } |
118 | |
119 | if (size == I2C_SMBUS_WORD_DATA && read) { |
120 | data->word = ((u16)local[1]) << 8; |
121 | data->word |= local[0]; |
122 | } |
123 | |
124 | bail: |
125 | pmac_i2c_close(bus); |
126 | return rc; |
127 | } |
128 | |
129 | /* |
130 | * Generic i2c master transfer entrypoint. This driver only support single |
131 | * messages (for "lame i2c" transfers). Anything else should use the smbus |
132 | * entry point |
133 | */ |
134 | static int i2c_powermac_master_xfer( struct i2c_adapter *adap, |
135 | struct i2c_msg *msgs, |
136 | int num) |
137 | { |
138 | struct pmac_i2c_bus *bus = i2c_get_adapdata(adap); |
139 | int rc = 0; |
140 | int addrdir; |
141 | |
142 | if (msgs->flags & I2C_M_TEN) |
143 | return -EINVAL; |
144 | addrdir = i2c_8bit_addr_from_msg(msg: msgs); |
145 | |
146 | rc = pmac_i2c_open(bus, 0); |
147 | if (rc) { |
148 | dev_err(&adap->dev, "Failed to open I2C, err %d\n" , rc); |
149 | return rc; |
150 | } |
151 | rc = pmac_i2c_setmode(bus, pmac_i2c_mode_std); |
152 | if (rc) { |
153 | dev_err(&adap->dev, "Failed to set I2C mode %d, err %d\n" , |
154 | pmac_i2c_mode_std, rc); |
155 | goto bail; |
156 | } |
157 | rc = pmac_i2c_xfer(bus, addrdir, 0, 0, msgs->buf, msgs->len); |
158 | if (rc < 0) { |
159 | if (rc == -ENXIO) |
160 | dev_dbg(&adap->dev, "I2C %s 0x%02x failed, err %d\n" , |
161 | addrdir & 1 ? "read from" : "write to" , |
162 | addrdir >> 1, rc); |
163 | else |
164 | dev_err(&adap->dev, "I2C %s 0x%02x failed, err %d\n" , |
165 | addrdir & 1 ? "read from" : "write to" , |
166 | addrdir >> 1, rc); |
167 | } |
168 | bail: |
169 | pmac_i2c_close(bus); |
170 | return rc < 0 ? rc : 1; |
171 | } |
172 | |
173 | static u32 i2c_powermac_func(struct i2c_adapter * adapter) |
174 | { |
175 | return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | |
176 | I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA | |
177 | I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_I2C; |
178 | } |
179 | |
180 | /* For now, we only handle smbus */ |
181 | static const struct i2c_algorithm i2c_powermac_algorithm = { |
182 | .smbus_xfer = i2c_powermac_smbus_xfer, |
183 | .master_xfer = i2c_powermac_master_xfer, |
184 | .functionality = i2c_powermac_func, |
185 | }; |
186 | |
187 | static const struct i2c_adapter_quirks i2c_powermac_quirks = { |
188 | .max_num_msgs = 1, |
189 | }; |
190 | |
191 | static void i2c_powermac_remove(struct platform_device *dev) |
192 | { |
193 | struct i2c_adapter *adapter = platform_get_drvdata(pdev: dev); |
194 | |
195 | i2c_del_adapter(adap: adapter); |
196 | memset(adapter, 0, sizeof(*adapter)); |
197 | } |
198 | |
199 | static u32 i2c_powermac_get_addr(struct i2c_adapter *adap, |
200 | struct pmac_i2c_bus *bus, |
201 | struct device_node *node) |
202 | { |
203 | u32 prop; |
204 | int ret; |
205 | |
206 | /* First check for valid "reg" */ |
207 | ret = of_property_read_u32(np: node, propname: "reg" , out_value: &prop); |
208 | if (ret == 0) |
209 | return (prop & 0xff) >> 1; |
210 | |
211 | /* Then check old-style "i2c-address" */ |
212 | ret = of_property_read_u32(np: node, propname: "i2c-address" , out_value: &prop); |
213 | if (ret == 0) |
214 | return (prop & 0xff) >> 1; |
215 | |
216 | /* Now handle some devices with missing "reg" properties */ |
217 | if (of_node_name_eq(np: node, name: "cereal" )) |
218 | return 0x60; |
219 | else if (of_node_name_eq(np: node, name: "deq" )) |
220 | return 0x34; |
221 | |
222 | dev_warn(&adap->dev, "No i2c address for %pOF\n" , node); |
223 | |
224 | return 0xffffffff; |
225 | } |
226 | |
227 | static void i2c_powermac_create_one(struct i2c_adapter *adap, |
228 | const char *type, |
229 | u32 addr) |
230 | { |
231 | struct i2c_board_info info = {}; |
232 | struct i2c_client *newdev; |
233 | |
234 | strscpy(p: info.type, q: type, size: sizeof(info.type)); |
235 | info.addr = addr; |
236 | newdev = i2c_new_client_device(adap, info: &info); |
237 | if (IS_ERR(ptr: newdev)) |
238 | dev_err(&adap->dev, |
239 | "i2c-powermac: Failure to register missing %s\n" , |
240 | type); |
241 | } |
242 | |
243 | static void i2c_powermac_add_missing(struct i2c_adapter *adap, |
244 | struct pmac_i2c_bus *bus, |
245 | bool found_onyx) |
246 | { |
247 | struct device_node *busnode = pmac_i2c_get_bus_node(bus); |
248 | int rc; |
249 | |
250 | /* Check for the onyx audio codec */ |
251 | #define ONYX_REG_CONTROL 67 |
252 | if (of_device_is_compatible(device: busnode, "k2-i2c" ) && !found_onyx) { |
253 | union i2c_smbus_data data; |
254 | |
255 | rc = i2c_smbus_xfer(adapter: adap, addr: 0x46, flags: 0, I2C_SMBUS_READ, |
256 | ONYX_REG_CONTROL, I2C_SMBUS_BYTE_DATA, |
257 | data: &data); |
258 | if (rc >= 0) |
259 | i2c_powermac_create_one(adap, type: "MAC,pcm3052" , addr: 0x46); |
260 | |
261 | rc = i2c_smbus_xfer(adapter: adap, addr: 0x47, flags: 0, I2C_SMBUS_READ, |
262 | ONYX_REG_CONTROL, I2C_SMBUS_BYTE_DATA, |
263 | data: &data); |
264 | if (rc >= 0) |
265 | i2c_powermac_create_one(adap, type: "MAC,pcm3052" , addr: 0x47); |
266 | } |
267 | } |
268 | |
269 | static bool i2c_powermac_get_type(struct i2c_adapter *adap, |
270 | struct device_node *node, |
271 | u32 addr, char *type, int type_size) |
272 | { |
273 | char tmp[16]; |
274 | |
275 | /* |
276 | * Note: we do _NOT_ want the standard i2c drivers to match with any of |
277 | * our powermac stuff unless they have been specifically modified to |
278 | * handle it on a case by case basis. For example, for thermal control, |
279 | * things like lm75 etc... shall match with their corresponding |
280 | * windfarm drivers, _NOT_ the generic ones, so we force a prefix of |
281 | * 'MAC', onto the modalias to make that happen |
282 | */ |
283 | |
284 | /* First try proper modalias */ |
285 | if (of_alias_from_compatible(node, alias: tmp, len: sizeof(tmp)) >= 0) { |
286 | snprintf(buf: type, size: type_size, fmt: "MAC,%s" , tmp); |
287 | return true; |
288 | } |
289 | |
290 | /* Now look for known workarounds */ |
291 | if (of_node_name_eq(np: node, name: "deq" )) { |
292 | /* Apple uses address 0x34 for TAS3001 and 0x35 for TAS3004 */ |
293 | if (addr == 0x34) { |
294 | snprintf(buf: type, size: type_size, fmt: "MAC,tas3001" ); |
295 | return true; |
296 | } else if (addr == 0x35) { |
297 | snprintf(buf: type, size: type_size, fmt: "MAC,tas3004" ); |
298 | return true; |
299 | } |
300 | } |
301 | |
302 | dev_err(&adap->dev, "i2c-powermac: modalias failure on %pOF\n" , node); |
303 | return false; |
304 | } |
305 | |
306 | static void i2c_powermac_register_devices(struct i2c_adapter *adap, |
307 | struct pmac_i2c_bus *bus) |
308 | { |
309 | struct i2c_client *newdev; |
310 | struct device_node *node; |
311 | bool found_onyx = false; |
312 | |
313 | /* |
314 | * In some cases we end up with the via-pmu node itself, in this |
315 | * case we skip this function completely as the device-tree will |
316 | * not contain anything useful. |
317 | */ |
318 | if (of_node_name_eq(np: adap->dev.of_node, name: "via-pmu" )) |
319 | return; |
320 | |
321 | for_each_child_of_node(adap->dev.of_node, node) { |
322 | struct i2c_board_info info = {}; |
323 | u32 addr; |
324 | |
325 | /* Get address & channel */ |
326 | addr = i2c_powermac_get_addr(adap, bus, node); |
327 | if (addr == 0xffffffff) |
328 | continue; |
329 | |
330 | /* Multibus setup, check channel */ |
331 | if (!pmac_i2c_match_adapter(node, adap)) |
332 | continue; |
333 | |
334 | dev_dbg(&adap->dev, "i2c-powermac: register %pOF\n" , node); |
335 | |
336 | /* |
337 | * Keep track of some device existence to handle |
338 | * workarounds later. |
339 | */ |
340 | if (of_device_is_compatible(device: node, "pcm3052" )) |
341 | found_onyx = true; |
342 | |
343 | /* Make up a modalias */ |
344 | if (!i2c_powermac_get_type(adap, node, addr, |
345 | type: info.type, type_size: sizeof(info.type))) { |
346 | continue; |
347 | } |
348 | |
349 | /* Fill out the rest of the info structure */ |
350 | info.addr = addr; |
351 | info.irq = irq_of_parse_and_map(node, index: 0); |
352 | info.of_node = of_node_get(node); |
353 | |
354 | newdev = i2c_new_client_device(adap, info: &info); |
355 | if (IS_ERR(ptr: newdev)) { |
356 | dev_err(&adap->dev, "i2c-powermac: Failure to register" |
357 | " %pOF\n" , node); |
358 | of_node_put(node); |
359 | /* We do not dispose of the interrupt mapping on |
360 | * purpose. It's not necessary (interrupt cannot be |
361 | * re-used) and somebody else might have grabbed it |
362 | * via direct DT lookup so let's not bother |
363 | */ |
364 | continue; |
365 | } |
366 | } |
367 | |
368 | /* Additional workarounds */ |
369 | i2c_powermac_add_missing(adap, bus, found_onyx); |
370 | } |
371 | |
372 | static int i2c_powermac_probe(struct platform_device *dev) |
373 | { |
374 | struct pmac_i2c_bus *bus = dev_get_platdata(dev: &dev->dev); |
375 | struct device_node *parent; |
376 | struct i2c_adapter *adapter; |
377 | int rc; |
378 | |
379 | if (bus == NULL) |
380 | return -EINVAL; |
381 | adapter = pmac_i2c_get_adapter(bus); |
382 | |
383 | /* Ok, now we need to make up a name for the interface that will |
384 | * match what we used to do in the past, that is basically the |
385 | * controller's parent device node for keywest. PMU didn't have a |
386 | * naming convention and SMU has a different one |
387 | */ |
388 | switch(pmac_i2c_get_type(bus)) { |
389 | case pmac_i2c_bus_keywest: |
390 | parent = of_get_parent(node: pmac_i2c_get_controller(bus)); |
391 | if (parent == NULL) |
392 | return -EINVAL; |
393 | snprintf(buf: adapter->name, size: sizeof(adapter->name), fmt: "%pOFn %d" , |
394 | parent, |
395 | pmac_i2c_get_channel(bus)); |
396 | of_node_put(node: parent); |
397 | break; |
398 | case pmac_i2c_bus_pmu: |
399 | snprintf(buf: adapter->name, size: sizeof(adapter->name), fmt: "pmu %d" , |
400 | pmac_i2c_get_channel(bus)); |
401 | break; |
402 | case pmac_i2c_bus_smu: |
403 | /* This is not what we used to do but I'm fixing drivers at |
404 | * the same time as this change |
405 | */ |
406 | snprintf(buf: adapter->name, size: sizeof(adapter->name), fmt: "smu %d" , |
407 | pmac_i2c_get_channel(bus)); |
408 | break; |
409 | default: |
410 | return -EINVAL; |
411 | } |
412 | |
413 | platform_set_drvdata(pdev: dev, data: adapter); |
414 | adapter->algo = &i2c_powermac_algorithm; |
415 | adapter->quirks = &i2c_powermac_quirks; |
416 | i2c_set_adapdata(adap: adapter, data: bus); |
417 | adapter->dev.parent = &dev->dev; |
418 | |
419 | /* Clear of_node to skip automatic registration of i2c child nodes */ |
420 | adapter->dev.of_node = NULL; |
421 | rc = i2c_add_adapter(adap: adapter); |
422 | if (rc) { |
423 | printk(KERN_ERR "i2c-powermac: Adapter %s registration " |
424 | "failed\n" , adapter->name); |
425 | memset(adapter, 0, sizeof(*adapter)); |
426 | return rc; |
427 | } |
428 | |
429 | printk(KERN_INFO "PowerMac i2c bus %s registered\n" , adapter->name); |
430 | |
431 | /* Use custom child registration due to Apple device-tree funkyness */ |
432 | adapter->dev.of_node = dev->dev.of_node; |
433 | i2c_powermac_register_devices(adap: adapter, bus); |
434 | |
435 | return 0; |
436 | } |
437 | |
438 | static struct platform_driver i2c_powermac_driver = { |
439 | .probe = i2c_powermac_probe, |
440 | .remove_new = i2c_powermac_remove, |
441 | .driver = { |
442 | .name = "i2c-powermac" , |
443 | .bus = &platform_bus_type, |
444 | }, |
445 | }; |
446 | |
447 | module_platform_driver(i2c_powermac_driver); |
448 | |
449 | MODULE_ALIAS("platform:i2c-powermac" ); |
450 | |