1 /* bbc_i2c.c: I2C low-level driver for BBC device on UltraSPARC-III
4 * Copyright (C) 2001, 2008 David S. Miller (davem@davemloft.net)
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/init.h>
15 #include <linux/interrupt.h>
17 #include <linux/of_device.h>
23 /* Convert this driver to use i2c bus layer someday... */
24 #define I2C_PCF_PIN 0x80
25 #define I2C_PCF_ESO 0x40
26 #define I2C_PCF_ES1 0x20
27 #define I2C_PCF_ES2 0x10
28 #define I2C_PCF_ENI 0x08
29 #define I2C_PCF_STA 0x04
30 #define I2C_PCF_STO 0x02
31 #define I2C_PCF_ACK 0x01
33 #define I2C_PCF_START (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_ENI | I2C_PCF_STA | I2C_PCF_ACK)
34 #define I2C_PCF_STOP (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_STO | I2C_PCF_ACK)
35 #define I2C_PCF_REPSTART ( I2C_PCF_ESO | I2C_PCF_STA | I2C_PCF_ACK)
36 #define I2C_PCF_IDLE (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_ACK)
38 #define I2C_PCF_INI 0x40 /* 1 if not initialized */
39 #define I2C_PCF_STS 0x20
40 #define I2C_PCF_BER 0x10
41 #define I2C_PCF_AD0 0x08
42 #define I2C_PCF_LRB 0x08
43 #define I2C_PCF_AAS 0x04
44 #define I2C_PCF_LAB 0x02
45 #define I2C_PCF_BB 0x01
47 /* The BBC devices have two I2C controllers. The first I2C controller
48 * connects mainly to configuration proms (NVRAM, cpu configuration,
49 * dimm types, etc.). Whereas the second I2C controller connects to
50 * environmental control devices such as fans and temperature sensors.
51 * The second controller also connects to the smartcard reader, if present.
54 static void set_device_claimage(struct bbc_i2c_bus
*bp
, struct platform_device
*op
, int val
)
58 for (i
= 0; i
< NUM_CHILDREN
; i
++) {
59 if (bp
->devs
[i
].device
== op
) {
60 bp
->devs
[i
].client_claimed
= val
;
66 #define claim_device(BP,ECHILD) set_device_claimage(BP,ECHILD,1)
67 #define release_device(BP,ECHILD) set_device_claimage(BP,ECHILD,0)
69 struct platform_device
*bbc_i2c_getdev(struct bbc_i2c_bus
*bp
, int index
)
71 struct platform_device
*op
= NULL
;
74 for (i
= 0; i
< NUM_CHILDREN
; i
++) {
75 if (!(op
= bp
->devs
[i
].device
))
89 struct bbc_i2c_client
*bbc_i2c_attach(struct bbc_i2c_bus
*bp
, struct platform_device
*op
)
91 struct bbc_i2c_client
*client
;
94 client
= kzalloc(sizeof(*client
), GFP_KERNEL
);
100 reg
= of_get_property(op
->dev
.of_node
, "reg", NULL
);
106 client
->bus
= reg
[0];
107 client
->address
= reg
[1];
109 claim_device(bp
, op
);
114 void bbc_i2c_detach(struct bbc_i2c_client
*client
)
116 struct bbc_i2c_bus
*bp
= client
->bp
;
117 struct platform_device
*op
= client
->op
;
119 release_device(bp
, op
);
123 static int wait_for_pin(struct bbc_i2c_bus
*bp
, u8
*status
)
125 DECLARE_WAITQUEUE(wait
, current
);
130 add_wait_queue(&bp
->wq
, &wait
);
131 while (limit
-- > 0) {
134 val
= wait_event_interruptible_timeout(
136 (((*status
= readb(bp
->i2c_control_regs
+ 0))
137 & I2C_PCF_PIN
) == 0),
138 msecs_to_jiffies(250));
144 remove_wait_queue(&bp
->wq
, &wait
);
150 int bbc_i2c_writeb(struct bbc_i2c_client
*client
, unsigned char val
, int off
)
152 struct bbc_i2c_bus
*bp
= client
->bp
;
153 int address
= client
->address
;
157 if (bp
->i2c_bussel_reg
!= NULL
)
158 writeb(client
->bus
, bp
->i2c_bussel_reg
);
160 writeb(address
, bp
->i2c_control_regs
+ 0x1);
161 writeb(I2C_PCF_START
, bp
->i2c_control_regs
+ 0x0);
162 if (wait_for_pin(bp
, &status
))
165 writeb(off
, bp
->i2c_control_regs
+ 0x1);
166 if (wait_for_pin(bp
, &status
) ||
167 (status
& I2C_PCF_LRB
) != 0)
170 writeb(val
, bp
->i2c_control_regs
+ 0x1);
171 if (wait_for_pin(bp
, &status
))
177 writeb(I2C_PCF_STOP
, bp
->i2c_control_regs
+ 0x0);
181 int bbc_i2c_readb(struct bbc_i2c_client
*client
, unsigned char *byte
, int off
)
183 struct bbc_i2c_bus
*bp
= client
->bp
;
184 unsigned char address
= client
->address
, status
;
187 if (bp
->i2c_bussel_reg
!= NULL
)
188 writeb(client
->bus
, bp
->i2c_bussel_reg
);
190 writeb(address
, bp
->i2c_control_regs
+ 0x1);
191 writeb(I2C_PCF_START
, bp
->i2c_control_regs
+ 0x0);
192 if (wait_for_pin(bp
, &status
))
195 writeb(off
, bp
->i2c_control_regs
+ 0x1);
196 if (wait_for_pin(bp
, &status
) ||
197 (status
& I2C_PCF_LRB
) != 0)
200 writeb(I2C_PCF_STOP
, bp
->i2c_control_regs
+ 0x0);
202 address
|= 0x1; /* READ */
204 writeb(address
, bp
->i2c_control_regs
+ 0x1);
205 writeb(I2C_PCF_START
, bp
->i2c_control_regs
+ 0x0);
206 if (wait_for_pin(bp
, &status
))
209 /* Set PIN back to one so the device sends the first
212 (void) readb(bp
->i2c_control_regs
+ 0x1);
213 if (wait_for_pin(bp
, &status
))
216 writeb(I2C_PCF_ESO
| I2C_PCF_ENI
, bp
->i2c_control_regs
+ 0x0);
217 *byte
= readb(bp
->i2c_control_regs
+ 0x1);
218 if (wait_for_pin(bp
, &status
))
224 writeb(I2C_PCF_STOP
, bp
->i2c_control_regs
+ 0x0);
225 (void) readb(bp
->i2c_control_regs
+ 0x1);
230 int bbc_i2c_write_buf(struct bbc_i2c_client
*client
,
231 char *buf
, int len
, int off
)
236 int err
= bbc_i2c_writeb(client
, *buf
, off
);
250 int bbc_i2c_read_buf(struct bbc_i2c_client
*client
,
251 char *buf
, int len
, int off
)
256 int err
= bbc_i2c_readb(client
, buf
, off
);
269 EXPORT_SYMBOL(bbc_i2c_getdev
);
270 EXPORT_SYMBOL(bbc_i2c_attach
);
271 EXPORT_SYMBOL(bbc_i2c_detach
);
272 EXPORT_SYMBOL(bbc_i2c_writeb
);
273 EXPORT_SYMBOL(bbc_i2c_readb
);
274 EXPORT_SYMBOL(bbc_i2c_write_buf
);
275 EXPORT_SYMBOL(bbc_i2c_read_buf
);
277 static irqreturn_t
bbc_i2c_interrupt(int irq
, void *dev_id
)
279 struct bbc_i2c_bus
*bp
= dev_id
;
281 /* PIN going from set to clear is the only event which
282 * makes the i2c assert an interrupt.
285 !(readb(bp
->i2c_control_regs
+ 0x0) & I2C_PCF_PIN
))
286 wake_up_interruptible(&bp
->wq
);
291 static void __init
reset_one_i2c(struct bbc_i2c_bus
*bp
)
293 writeb(I2C_PCF_PIN
, bp
->i2c_control_regs
+ 0x0);
294 writeb(bp
->own
, bp
->i2c_control_regs
+ 0x1);
295 writeb(I2C_PCF_PIN
| I2C_PCF_ES1
, bp
->i2c_control_regs
+ 0x0);
296 writeb(bp
->clock
, bp
->i2c_control_regs
+ 0x1);
297 writeb(I2C_PCF_IDLE
, bp
->i2c_control_regs
+ 0x0);
300 static struct bbc_i2c_bus
* __init
attach_one_i2c(struct platform_device
*op
, int index
)
302 struct bbc_i2c_bus
*bp
;
303 struct device_node
*dp
;
306 bp
= kzalloc(sizeof(*bp
), GFP_KERNEL
);
310 bp
->i2c_control_regs
= of_ioremap(&op
->resource
[0], 0, 0x2, "bbc_i2c_regs");
311 if (!bp
->i2c_control_regs
)
314 bp
->i2c_bussel_reg
= of_ioremap(&op
->resource
[1], 0, 0x1, "bbc_i2c_bussel");
315 if (!bp
->i2c_bussel_reg
)
319 init_waitqueue_head(&bp
->wq
);
320 if (request_irq(op
->archdata
.irqs
[0], bbc_i2c_interrupt
,
321 IRQF_SHARED
, "bbc_i2c", bp
))
327 spin_lock_init(&bp
->lock
);
330 for (dp
= op
->dev
.of_node
->child
;
332 dp
= dp
->sibling
, entry
++) {
333 struct platform_device
*child_op
;
335 child_op
= of_find_device_by_node(dp
);
336 bp
->devs
[entry
].device
= child_op
;
337 bp
->devs
[entry
].client_claimed
= 0;
340 writeb(I2C_PCF_PIN
, bp
->i2c_control_regs
+ 0x0);
341 bp
->own
= readb(bp
->i2c_control_regs
+ 0x01);
342 writeb(I2C_PCF_PIN
| I2C_PCF_ES1
, bp
->i2c_control_regs
+ 0x0);
343 bp
->clock
= readb(bp
->i2c_control_regs
+ 0x01);
345 printk(KERN_INFO
"i2c-%d: Regs at %p, %d devices, own %02x, clock %02x.\n",
346 bp
->index
, bp
->i2c_control_regs
, entry
, bp
->own
, bp
->clock
);
353 if (bp
->i2c_bussel_reg
)
354 of_iounmap(&op
->resource
[1], bp
->i2c_bussel_reg
, 1);
355 if (bp
->i2c_control_regs
)
356 of_iounmap(&op
->resource
[0], bp
->i2c_control_regs
, 2);
361 extern int bbc_envctrl_init(struct bbc_i2c_bus
*bp
);
362 extern void bbc_envctrl_cleanup(struct bbc_i2c_bus
*bp
);
364 static int __devinit
bbc_i2c_probe(struct platform_device
*op
)
366 struct bbc_i2c_bus
*bp
;
369 bp
= attach_one_i2c(op
, index
);
373 err
= bbc_envctrl_init(bp
);
375 free_irq(op
->archdata
.irqs
[0], bp
);
376 if (bp
->i2c_bussel_reg
)
377 of_iounmap(&op
->resource
[0], bp
->i2c_bussel_reg
, 1);
378 if (bp
->i2c_control_regs
)
379 of_iounmap(&op
->resource
[1], bp
->i2c_control_regs
, 2);
382 dev_set_drvdata(&op
->dev
, bp
);
388 static int __devexit
bbc_i2c_remove(struct platform_device
*op
)
390 struct bbc_i2c_bus
*bp
= dev_get_drvdata(&op
->dev
);
392 bbc_envctrl_cleanup(bp
);
394 free_irq(op
->archdata
.irqs
[0], bp
);
396 if (bp
->i2c_bussel_reg
)
397 of_iounmap(&op
->resource
[0], bp
->i2c_bussel_reg
, 1);
398 if (bp
->i2c_control_regs
)
399 of_iounmap(&op
->resource
[1], bp
->i2c_control_regs
, 2);
406 static const struct of_device_id bbc_i2c_match
[] = {
409 .compatible
= "SUNW,bbc-i2c",
413 MODULE_DEVICE_TABLE(of
, bbc_i2c_match
);
415 static struct platform_driver bbc_i2c_driver
= {
418 .owner
= THIS_MODULE
,
419 .of_match_table
= bbc_i2c_match
,
421 .probe
= bbc_i2c_probe
,
422 .remove
= __devexit_p(bbc_i2c_remove
),
425 static int __init
bbc_i2c_init(void)
427 return platform_driver_register(&bbc_i2c_driver
);
430 static void __exit
bbc_i2c_exit(void)
432 platform_driver_unregister(&bbc_i2c_driver
);
435 module_init(bbc_i2c_init
);
436 module_exit(bbc_i2c_exit
);
438 MODULE_LICENSE("GPL");