1 /* bbc_i2c.c: I2C low-level driver for BBC device on UltraSPARC-III
2 * platforms.
3 *
4 * Copyright (C) 2001, 2008 David S. Miller (davem@davemloft.net)
5 */
6
7 #include <linux/module.h>
8 #include <linux/kernel.h>
9 #include <linux/types.h>
10 #include <linux/slab.h>
11 #include <linux/sched.h>
12 #include <linux/wait.h>
13 #include <linux/delay.h>
14 #include <linux/interrupt.h>
15 #include <linux/of.h>
16 #include <linux/of_device.h>
17 #include <asm/bbc.h>
18 #include <asm/io.h>
19
20 #include "bbc_i2c.h"
21
22 /* Convert this driver to use i2c bus layer someday... */
23 #define I2C_PCF_PIN 0x80
24 #define I2C_PCF_ESO 0x40
25 #define I2C_PCF_ES1 0x20
26 #define I2C_PCF_ES2 0x10
27 #define I2C_PCF_ENI 0x08
28 #define I2C_PCF_STA 0x04
29 #define I2C_PCF_STO 0x02
30 #define I2C_PCF_ACK 0x01
31
32 #define I2C_PCF_START (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_ENI | I2C_PCF_STA | I2C_PCF_ACK)
33 #define I2C_PCF_STOP (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_STO | I2C_PCF_ACK)
34 #define I2C_PCF_REPSTART ( I2C_PCF_ESO | I2C_PCF_STA | I2C_PCF_ACK)
35 #define I2C_PCF_IDLE (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_ACK)
36
37 #define I2C_PCF_INI 0x40 /* 1 if not initialized */
38 #define I2C_PCF_STS 0x20
39 #define I2C_PCF_BER 0x10
40 #define I2C_PCF_AD0 0x08
41 #define I2C_PCF_LRB 0x08
42 #define I2C_PCF_AAS 0x04
43 #define I2C_PCF_LAB 0x02
44 #define I2C_PCF_BB 0x01
45
46 /* The BBC devices have two I2C controllers. The first I2C controller
47 * connects mainly to configuration proms (NVRAM, cpu configuration,
48 * dimm types, etc.). Whereas the second I2C controller connects to
49 * environmental control devices such as fans and temperature sensors.
50 * The second controller also connects to the smartcard reader, if present.
51 */
52
set_device_claimage(struct bbc_i2c_bus * bp,struct platform_device * op,int val)53 static void set_device_claimage(struct bbc_i2c_bus *bp, struct platform_device *op, int val)
54 {
55 int i;
56
57 for (i = 0; i < NUM_CHILDREN; i++) {
58 if (bp->devs[i].device == op) {
59 bp->devs[i].client_claimed = val;
60 return;
61 }
62 }
63 }
64
65 #define claim_device(BP,ECHILD) set_device_claimage(BP,ECHILD,1)
66 #define release_device(BP,ECHILD) set_device_claimage(BP,ECHILD,0)
67
bbc_i2c_getdev(struct bbc_i2c_bus * bp,int index)68 struct platform_device *bbc_i2c_getdev(struct bbc_i2c_bus *bp, int index)
69 {
70 struct platform_device *op = NULL;
71 int curidx = 0, i;
72
73 for (i = 0; i < NUM_CHILDREN; i++) {
74 if (!(op = bp->devs[i].device))
75 break;
76 if (curidx == index)
77 goto out;
78 op = NULL;
79 curidx++;
80 }
81
82 out:
83 if (curidx == index)
84 return op;
85 return NULL;
86 }
87
bbc_i2c_attach(struct bbc_i2c_bus * bp,struct platform_device * op)88 struct bbc_i2c_client *bbc_i2c_attach(struct bbc_i2c_bus *bp, struct platform_device *op)
89 {
90 struct bbc_i2c_client *client;
91 const u32 *reg;
92
93 client = kzalloc(sizeof(*client), GFP_KERNEL);
94 if (!client)
95 return NULL;
96 client->bp = bp;
97 client->op = op;
98
99 reg = of_get_property(op->dev.of_node, "reg", NULL);
100 if (!reg) {
101 kfree(client);
102 return NULL;
103 }
104
105 client->bus = reg[0];
106 client->address = reg[1];
107
108 claim_device(bp, op);
109
110 return client;
111 }
112
bbc_i2c_detach(struct bbc_i2c_client * client)113 void bbc_i2c_detach(struct bbc_i2c_client *client)
114 {
115 struct bbc_i2c_bus *bp = client->bp;
116 struct platform_device *op = client->op;
117
118 release_device(bp, op);
119 kfree(client);
120 }
121
wait_for_pin(struct bbc_i2c_bus * bp,u8 * status)122 static int wait_for_pin(struct bbc_i2c_bus *bp, u8 *status)
123 {
124 DECLARE_WAITQUEUE(wait, current);
125 int limit = 32;
126 int ret = 1;
127
128 bp->waiting = 1;
129 add_wait_queue(&bp->wq, &wait);
130 while (limit-- > 0) {
131 long val;
132
133 val = wait_event_interruptible_timeout(
134 bp->wq,
135 (((*status = readb(bp->i2c_control_regs + 0))
136 & I2C_PCF_PIN) == 0),
137 msecs_to_jiffies(250));
138 if (val > 0) {
139 ret = 0;
140 break;
141 }
142 }
143 remove_wait_queue(&bp->wq, &wait);
144 bp->waiting = 0;
145
146 return ret;
147 }
148
bbc_i2c_writeb(struct bbc_i2c_client * client,unsigned char val,int off)149 int bbc_i2c_writeb(struct bbc_i2c_client *client, unsigned char val, int off)
150 {
151 struct bbc_i2c_bus *bp = client->bp;
152 int address = client->address;
153 u8 status;
154 int ret = -1;
155
156 if (bp->i2c_bussel_reg != NULL)
157 writeb(client->bus, bp->i2c_bussel_reg);
158
159 writeb(address, bp->i2c_control_regs + 0x1);
160 writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0);
161 if (wait_for_pin(bp, &status))
162 goto out;
163
164 writeb(off, bp->i2c_control_regs + 0x1);
165 if (wait_for_pin(bp, &status) ||
166 (status & I2C_PCF_LRB) != 0)
167 goto out;
168
169 writeb(val, bp->i2c_control_regs + 0x1);
170 if (wait_for_pin(bp, &status))
171 goto out;
172
173 ret = 0;
174
175 out:
176 writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0);
177 return ret;
178 }
179
bbc_i2c_readb(struct bbc_i2c_client * client,unsigned char * byte,int off)180 int bbc_i2c_readb(struct bbc_i2c_client *client, unsigned char *byte, int off)
181 {
182 struct bbc_i2c_bus *bp = client->bp;
183 unsigned char address = client->address, status;
184 int ret = -1;
185
186 if (bp->i2c_bussel_reg != NULL)
187 writeb(client->bus, bp->i2c_bussel_reg);
188
189 writeb(address, bp->i2c_control_regs + 0x1);
190 writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0);
191 if (wait_for_pin(bp, &status))
192 goto out;
193
194 writeb(off, bp->i2c_control_regs + 0x1);
195 if (wait_for_pin(bp, &status) ||
196 (status & I2C_PCF_LRB) != 0)
197 goto out;
198
199 writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0);
200
201 address |= 0x1; /* READ */
202
203 writeb(address, bp->i2c_control_regs + 0x1);
204 writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0);
205 if (wait_for_pin(bp, &status))
206 goto out;
207
208 /* Set PIN back to one so the device sends the first
209 * byte.
210 */
211 (void) readb(bp->i2c_control_regs + 0x1);
212 if (wait_for_pin(bp, &status))
213 goto out;
214
215 writeb(I2C_PCF_ESO | I2C_PCF_ENI, bp->i2c_control_regs + 0x0);
216 *byte = readb(bp->i2c_control_regs + 0x1);
217 if (wait_for_pin(bp, &status))
218 goto out;
219
220 ret = 0;
221
222 out:
223 writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0);
224 (void) readb(bp->i2c_control_regs + 0x1);
225
226 return ret;
227 }
228
bbc_i2c_write_buf(struct bbc_i2c_client * client,char * buf,int len,int off)229 int bbc_i2c_write_buf(struct bbc_i2c_client *client,
230 char *buf, int len, int off)
231 {
232 int ret = 0;
233
234 while (len > 0) {
235 ret = bbc_i2c_writeb(client, *buf, off);
236 if (ret < 0)
237 break;
238 len--;
239 buf++;
240 off++;
241 }
242 return ret;
243 }
244
bbc_i2c_read_buf(struct bbc_i2c_client * client,char * buf,int len,int off)245 int bbc_i2c_read_buf(struct bbc_i2c_client *client,
246 char *buf, int len, int off)
247 {
248 int ret = 0;
249
250 while (len > 0) {
251 ret = bbc_i2c_readb(client, buf, off);
252 if (ret < 0)
253 break;
254 len--;
255 buf++;
256 off++;
257 }
258
259 return ret;
260 }
261
262 EXPORT_SYMBOL(bbc_i2c_getdev);
263 EXPORT_SYMBOL(bbc_i2c_attach);
264 EXPORT_SYMBOL(bbc_i2c_detach);
265 EXPORT_SYMBOL(bbc_i2c_writeb);
266 EXPORT_SYMBOL(bbc_i2c_readb);
267 EXPORT_SYMBOL(bbc_i2c_write_buf);
268 EXPORT_SYMBOL(bbc_i2c_read_buf);
269
bbc_i2c_interrupt(int irq,void * dev_id)270 static irqreturn_t bbc_i2c_interrupt(int irq, void *dev_id)
271 {
272 struct bbc_i2c_bus *bp = dev_id;
273
274 /* PIN going from set to clear is the only event which
275 * makes the i2c assert an interrupt.
276 */
277 if (bp->waiting &&
278 !(readb(bp->i2c_control_regs + 0x0) & I2C_PCF_PIN))
279 wake_up_interruptible(&bp->wq);
280
281 return IRQ_HANDLED;
282 }
283
reset_one_i2c(struct bbc_i2c_bus * bp)284 static void reset_one_i2c(struct bbc_i2c_bus *bp)
285 {
286 writeb(I2C_PCF_PIN, bp->i2c_control_regs + 0x0);
287 writeb(bp->own, bp->i2c_control_regs + 0x1);
288 writeb(I2C_PCF_PIN | I2C_PCF_ES1, bp->i2c_control_regs + 0x0);
289 writeb(bp->clock, bp->i2c_control_regs + 0x1);
290 writeb(I2C_PCF_IDLE, bp->i2c_control_regs + 0x0);
291 }
292
attach_one_i2c(struct platform_device * op,int index)293 static struct bbc_i2c_bus * attach_one_i2c(struct platform_device *op, int index)
294 {
295 struct bbc_i2c_bus *bp;
296 struct device_node *dp;
297 int entry;
298
299 bp = kzalloc(sizeof(*bp), GFP_KERNEL);
300 if (!bp)
301 return NULL;
302
303 INIT_LIST_HEAD(&bp->temps);
304 INIT_LIST_HEAD(&bp->fans);
305
306 bp->i2c_control_regs = of_ioremap(&op->resource[0], 0, 0x2, "bbc_i2c_regs");
307 if (!bp->i2c_control_regs)
308 goto fail;
309
310 if (op->num_resources == 2) {
311 bp->i2c_bussel_reg = of_ioremap(&op->resource[1], 0, 0x1, "bbc_i2c_bussel");
312 if (!bp->i2c_bussel_reg)
313 goto fail;
314 }
315
316 bp->waiting = 0;
317 init_waitqueue_head(&bp->wq);
318 if (request_irq(op->archdata.irqs[0], bbc_i2c_interrupt,
319 IRQF_SHARED, "bbc_i2c", bp))
320 goto fail;
321
322 bp->index = index;
323 bp->op = op;
324
325 spin_lock_init(&bp->lock);
326
327 entry = 0;
328 for (dp = op->dev.of_node->child;
329 dp && entry < 8;
330 dp = dp->sibling, entry++) {
331 struct platform_device *child_op;
332
333 child_op = of_find_device_by_node(dp);
334 bp->devs[entry].device = child_op;
335 bp->devs[entry].client_claimed = 0;
336 }
337
338 writeb(I2C_PCF_PIN, bp->i2c_control_regs + 0x0);
339 bp->own = readb(bp->i2c_control_regs + 0x01);
340 writeb(I2C_PCF_PIN | I2C_PCF_ES1, bp->i2c_control_regs + 0x0);
341 bp->clock = readb(bp->i2c_control_regs + 0x01);
342
343 printk(KERN_INFO "i2c-%d: Regs at %p, %d devices, own %02x, clock %02x.\n",
344 bp->index, bp->i2c_control_regs, entry, bp->own, bp->clock);
345
346 reset_one_i2c(bp);
347
348 return bp;
349
350 fail:
351 if (bp->i2c_bussel_reg)
352 of_iounmap(&op->resource[1], bp->i2c_bussel_reg, 1);
353 if (bp->i2c_control_regs)
354 of_iounmap(&op->resource[0], bp->i2c_control_regs, 2);
355 kfree(bp);
356 return NULL;
357 }
358
359 extern int bbc_envctrl_init(struct bbc_i2c_bus *bp);
360 extern void bbc_envctrl_cleanup(struct bbc_i2c_bus *bp);
361
bbc_i2c_probe(struct platform_device * op)362 static int bbc_i2c_probe(struct platform_device *op)
363 {
364 struct bbc_i2c_bus *bp;
365 int err, index = 0;
366
367 bp = attach_one_i2c(op, index);
368 if (!bp)
369 return -EINVAL;
370
371 err = bbc_envctrl_init(bp);
372 if (err) {
373 free_irq(op->archdata.irqs[0], bp);
374 if (bp->i2c_bussel_reg)
375 of_iounmap(&op->resource[0], bp->i2c_bussel_reg, 1);
376 if (bp->i2c_control_regs)
377 of_iounmap(&op->resource[1], bp->i2c_control_regs, 2);
378 kfree(bp);
379 } else {
380 dev_set_drvdata(&op->dev, bp);
381 }
382
383 return err;
384 }
385
bbc_i2c_remove(struct platform_device * op)386 static int bbc_i2c_remove(struct platform_device *op)
387 {
388 struct bbc_i2c_bus *bp = dev_get_drvdata(&op->dev);
389
390 bbc_envctrl_cleanup(bp);
391
392 free_irq(op->archdata.irqs[0], bp);
393
394 if (bp->i2c_bussel_reg)
395 of_iounmap(&op->resource[0], bp->i2c_bussel_reg, 1);
396 if (bp->i2c_control_regs)
397 of_iounmap(&op->resource[1], bp->i2c_control_regs, 2);
398
399 kfree(bp);
400
401 return 0;
402 }
403
404 static const struct of_device_id bbc_i2c_match[] = {
405 {
406 .name = "i2c",
407 .compatible = "SUNW,bbc-i2c",
408 },
409 {},
410 };
411 MODULE_DEVICE_TABLE(of, bbc_i2c_match);
412
413 static struct platform_driver bbc_i2c_driver = {
414 .driver = {
415 .name = "bbc_i2c",
416 .of_match_table = bbc_i2c_match,
417 },
418 .probe = bbc_i2c_probe,
419 .remove = bbc_i2c_remove,
420 };
421
422 module_platform_driver(bbc_i2c_driver);
423
424 MODULE_LICENSE("GPL");
425
