1
2
3
4
5
6
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
21MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
22MODULE_DESCRIPTION("I2C driver for Apple PowerMac");
23MODULE_LICENSE("GPL");
24
25
26
27
28static 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
75
76
77
78
79
80
81
82
83
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
136
137
138
139static 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
178static 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
186static 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
192static const struct i2c_adapter_quirks i2c_powermac_quirks = {
193 .max_num_msgs = 1,
194};
195
196static 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
206static 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
214 prop = of_get_property(node, "reg", &len);
215 if (prop && (len >= sizeof(int)))
216 return (be32_to_cpup(prop) & 0xff) >> 1;
217
218
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
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
234static 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
250static 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
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
276static 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
284
285
286
287
288
289
290
291
292 if (of_modalias_node(node, tmp, sizeof(tmp)) >= 0) {
293 snprintf(type, type_size, "MAC,%s", tmp);
294 return true;
295 }
296
297
298 if (of_node_name_eq(node, "deq")) {
299
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
313static 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 = 0;
319
320
321
322
323
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
333 addr = i2c_powermac_get_addr(adap, bus, node);
334 if (addr == 0xffffffff)
335 continue;
336
337
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
345
346
347 if (of_device_is_compatible(node, "pcm3052"))
348 found_onyx = true;
349
350
351 if (!i2c_powermac_get_type(adap, node, addr,
352 info.type, sizeof(info.type))) {
353 continue;
354 }
355
356
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
367
368
369
370
371 continue;
372 }
373 }
374
375
376 i2c_powermac_add_missing(adap, bus, found_onyx);
377}
378
379static 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
391
392
393
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
411
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
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
439 adapter->dev.of_node = dev->dev.of_node;
440 i2c_powermac_register_devices(adapter, bus);
441
442 return 0;
443}
444
445static 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
454module_platform_driver(i2c_powermac_driver);
455
456MODULE_ALIAS("platform:i2c-powermac");
457