2 * arch/powerpc/platforms/powermac/low_i2c.c
4 * Copyright (C) 2003-2005 Ben. Herrenschmidt (benh@kernel.crashing.org)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
11 * The linux i2c layer isn't completely suitable for our needs for various
12 * reasons ranging from too late initialisation to semantics not perfectly
13 * matching some requirements of the apple platform functions etc...
15 * This file thus provides a simple low level unified i2c interface for
16 * powermac that covers the various types of i2c busses used in Apple machines.
17 * For now, keywest, PMU and SMU, though we could add Cuda, or other bit
18 * banging busses found on older chipstes in earlier machines if we ever need
21 * The drivers in this file are synchronous/blocking. In addition, the
22 * keywest one is fairly slow due to the use of msleep instead of interrupts
23 * as the interrupt is currently used by i2c-keywest. In the long run, we
24 * might want to get rid of those high-level interfaces to linux i2c layer
25 * either completely (converting all drivers) or replacing them all with a
26 * single stub driver on top of this one. Once done, the interrupt will be
27 * available for our use.
33 #include <linux/types.h>
34 #include <linux/sched.h>
35 #include <linux/init.h>
36 #include <linux/module.h>
37 #include <linux/adb.h>
38 #include <linux/pmu.h>
39 #include <linux/delay.h>
40 #include <linux/completion.h>
41 #include <linux/platform_device.h>
42 #include <linux/interrupt.h>
43 #include <linux/timer.h>
44 #include <linux/mutex.h>
45 #include <linux/i2c.h>
46 #include <linux/slab.h>
47 #include <asm/keylargo.h>
48 #include <asm/uninorth.h>
51 #include <asm/machdep.h>
53 #include <asm/pmac_pfunc.h>
54 #include <asm/pmac_low_i2c.h>
57 #define DBG(x...) do {\
58 printk(KERN_DEBUG "low_i2c:" x); \
65 #define DBG_LOW(x...) do {\
66 printk(KERN_DEBUG "low_i2c:" x); \
73 static int pmac_i2c_force_poll
= 1;
76 * A bus structure. Each bus in the system has such a structure associated.
80 struct list_head link
;
81 struct device_node
*controller
;
82 struct device_node
*busnode
;
85 struct i2c_adapter adapter
;
87 int channel
; /* some hosts have multiple */
88 int mode
; /* current mode */
91 int polled
; /* open mode */
92 struct platform_device
*platform_dev
;
95 int (*open
)(struct pmac_i2c_bus
*bus
);
96 void (*close
)(struct pmac_i2c_bus
*bus
);
97 int (*xfer
)(struct pmac_i2c_bus
*bus
, u8 addrdir
, int subsize
,
98 u32 subaddr
, u8
*data
, int len
);
101 static LIST_HEAD(pmac_i2c_busses
);
104 * Keywest implementation
107 struct pmac_i2c_host_kw
109 struct mutex mutex
; /* Access mutex for use by
111 void __iomem
*base
; /* register base address */
112 int bsteps
; /* register stepping */
113 int speed
; /* speed */
121 struct completion complete
;
123 struct timer_list timeout_timer
;
126 /* Register indices */
138 /* The Tumbler audio equalizer can be really slow sometimes */
139 #define KW_POLL_TIMEOUT (2*HZ)
142 #define KW_I2C_MODE_100KHZ 0x00
143 #define KW_I2C_MODE_50KHZ 0x01
144 #define KW_I2C_MODE_25KHZ 0x02
145 #define KW_I2C_MODE_DUMB 0x00
146 #define KW_I2C_MODE_STANDARD 0x04
147 #define KW_I2C_MODE_STANDARDSUB 0x08
148 #define KW_I2C_MODE_COMBINED 0x0C
149 #define KW_I2C_MODE_MODE_MASK 0x0C
150 #define KW_I2C_MODE_CHAN_MASK 0xF0
152 /* Control register */
153 #define KW_I2C_CTL_AAK 0x01
154 #define KW_I2C_CTL_XADDR 0x02
155 #define KW_I2C_CTL_STOP 0x04
156 #define KW_I2C_CTL_START 0x08
158 /* Status register */
159 #define KW_I2C_STAT_BUSY 0x01
160 #define KW_I2C_STAT_LAST_AAK 0x02
161 #define KW_I2C_STAT_LAST_RW 0x04
162 #define KW_I2C_STAT_SDA 0x08
163 #define KW_I2C_STAT_SCL 0x10
165 /* IER & ISR registers */
166 #define KW_I2C_IRQ_DATA 0x01
167 #define KW_I2C_IRQ_ADDR 0x02
168 #define KW_I2C_IRQ_STOP 0x04
169 #define KW_I2C_IRQ_START 0x08
170 #define KW_I2C_IRQ_MASK 0x0F
172 /* State machine states */
182 #define WRONG_STATE(name) do {\
183 printk(KERN_DEBUG "KW: wrong state. Got %s, state: %s " \
185 name, __kw_state_names[host->state], isr); \
188 static const char *__kw_state_names
[] = {
197 static inline u8
__kw_read_reg(struct pmac_i2c_host_kw
*host
, reg_t reg
)
199 return readb(host
->base
+ (((unsigned int)reg
) << host
->bsteps
));
202 static inline void __kw_write_reg(struct pmac_i2c_host_kw
*host
,
205 writeb(val
, host
->base
+ (((unsigned)reg
) << host
->bsteps
));
206 (void)__kw_read_reg(host
, reg_subaddr
);
209 #define kw_write_reg(reg, val) __kw_write_reg(host, reg, val)
210 #define kw_read_reg(reg) __kw_read_reg(host, reg)
212 static u8
kw_i2c_wait_interrupt(struct pmac_i2c_host_kw
*host
)
217 for (i
= 0; i
< 1000; i
++) {
218 isr
= kw_read_reg(reg_isr
) & KW_I2C_IRQ_MASK
;
222 /* This code is used with the timebase frozen, we cannot rely
223 * on udelay nor schedule when in polled mode !
224 * For now, just use a bogus loop....
227 for (j
= 1; j
< 100000; j
++)
235 static void kw_i2c_do_stop(struct pmac_i2c_host_kw
*host
, int result
)
237 kw_write_reg(reg_control
, KW_I2C_CTL_STOP
);
238 host
->state
= state_stop
;
239 host
->result
= result
;
243 static void kw_i2c_handle_interrupt(struct pmac_i2c_host_kw
*host
, u8 isr
)
247 DBG_LOW("kw_handle_interrupt(%s, isr: %x)\n",
248 __kw_state_names
[host
->state
], isr
);
250 if (host
->state
== state_idle
) {
251 printk(KERN_WARNING
"low_i2c: Keywest got an out of state"
252 " interrupt, ignoring\n");
253 kw_write_reg(reg_isr
, isr
);
258 printk(KERN_WARNING
"low_i2c: Timeout in i2c transfer"
260 if (host
->state
!= state_stop
) {
261 kw_i2c_do_stop(host
, -EIO
);
264 ack
= kw_read_reg(reg_status
);
265 if (ack
& KW_I2C_STAT_BUSY
)
266 kw_write_reg(reg_status
, 0);
267 host
->state
= state_idle
;
268 kw_write_reg(reg_ier
, 0x00);
270 complete(&host
->complete
);
274 if (isr
& KW_I2C_IRQ_ADDR
) {
275 ack
= kw_read_reg(reg_status
);
276 if (host
->state
!= state_addr
) {
277 WRONG_STATE("KW_I2C_IRQ_ADDR");
278 kw_i2c_do_stop(host
, -EIO
);
280 if ((ack
& KW_I2C_STAT_LAST_AAK
) == 0) {
281 host
->result
= -ENXIO
;
282 host
->state
= state_stop
;
283 DBG_LOW("KW: NAK on address\n");
286 kw_i2c_do_stop(host
, 0);
288 host
->state
= state_read
;
290 kw_write_reg(reg_control
,
293 host
->state
= state_write
;
294 kw_write_reg(reg_data
, *(host
->data
++));
298 kw_write_reg(reg_isr
, KW_I2C_IRQ_ADDR
);
301 if (isr
& KW_I2C_IRQ_DATA
) {
302 if (host
->state
== state_read
) {
303 *(host
->data
++) = kw_read_reg(reg_data
);
305 kw_write_reg(reg_isr
, KW_I2C_IRQ_DATA
);
307 host
->state
= state_stop
;
308 else if (host
->len
== 1)
309 kw_write_reg(reg_control
, 0);
310 } else if (host
->state
== state_write
) {
311 ack
= kw_read_reg(reg_status
);
312 if ((ack
& KW_I2C_STAT_LAST_AAK
) == 0) {
313 DBG_LOW("KW: nack on data write\n");
314 host
->result
= -EFBIG
;
315 host
->state
= state_stop
;
316 } else if (host
->len
) {
317 kw_write_reg(reg_data
, *(host
->data
++));
320 kw_i2c_do_stop(host
, 0);
322 WRONG_STATE("KW_I2C_IRQ_DATA");
323 if (host
->state
!= state_stop
)
324 kw_i2c_do_stop(host
, -EIO
);
326 kw_write_reg(reg_isr
, KW_I2C_IRQ_DATA
);
329 if (isr
& KW_I2C_IRQ_STOP
) {
330 kw_write_reg(reg_isr
, KW_I2C_IRQ_STOP
);
331 if (host
->state
!= state_stop
) {
332 WRONG_STATE("KW_I2C_IRQ_STOP");
335 host
->state
= state_idle
;
337 complete(&host
->complete
);
340 /* Below should only happen in manual mode which we don't use ... */
341 if (isr
& KW_I2C_IRQ_START
)
342 kw_write_reg(reg_isr
, KW_I2C_IRQ_START
);
346 /* Interrupt handler */
347 static irqreturn_t
kw_i2c_irq(int irq
, void *dev_id
)
349 struct pmac_i2c_host_kw
*host
= dev_id
;
352 spin_lock_irqsave(&host
->lock
, flags
);
353 del_timer(&host
->timeout_timer
);
354 kw_i2c_handle_interrupt(host
, kw_read_reg(reg_isr
));
355 if (host
->state
!= state_idle
) {
356 host
->timeout_timer
.expires
= jiffies
+ KW_POLL_TIMEOUT
;
357 add_timer(&host
->timeout_timer
);
359 spin_unlock_irqrestore(&host
->lock
, flags
);
363 static void kw_i2c_timeout(unsigned long data
)
365 struct pmac_i2c_host_kw
*host
= (struct pmac_i2c_host_kw
*)data
;
368 spin_lock_irqsave(&host
->lock
, flags
);
369 kw_i2c_handle_interrupt(host
, kw_read_reg(reg_isr
));
370 if (host
->state
!= state_idle
) {
371 host
->timeout_timer
.expires
= jiffies
+ KW_POLL_TIMEOUT
;
372 add_timer(&host
->timeout_timer
);
374 spin_unlock_irqrestore(&host
->lock
, flags
);
377 static int kw_i2c_open(struct pmac_i2c_bus
*bus
)
379 struct pmac_i2c_host_kw
*host
= bus
->hostdata
;
380 mutex_lock(&host
->mutex
);
384 static void kw_i2c_close(struct pmac_i2c_bus
*bus
)
386 struct pmac_i2c_host_kw
*host
= bus
->hostdata
;
387 mutex_unlock(&host
->mutex
);
390 static int kw_i2c_xfer(struct pmac_i2c_bus
*bus
, u8 addrdir
, int subsize
,
391 u32 subaddr
, u8
*data
, int len
)
393 struct pmac_i2c_host_kw
*host
= bus
->hostdata
;
394 u8 mode_reg
= host
->speed
;
395 int use_irq
= host
->irq
!= NO_IRQ
&& !bus
->polled
;
397 /* Setup mode & subaddress if any */
399 case pmac_i2c_mode_dumb
:
401 case pmac_i2c_mode_std
:
402 mode_reg
|= KW_I2C_MODE_STANDARD
;
406 case pmac_i2c_mode_stdsub
:
407 mode_reg
|= KW_I2C_MODE_STANDARDSUB
;
411 case pmac_i2c_mode_combined
:
412 mode_reg
|= KW_I2C_MODE_COMBINED
;
418 /* Setup channel & clear pending irqs */
419 kw_write_reg(reg_isr
, kw_read_reg(reg_isr
));
420 kw_write_reg(reg_mode
, mode_reg
| (bus
->channel
<< 4));
421 kw_write_reg(reg_status
, 0);
423 /* Set up address and r/w bit, strip possible stale bus number from
426 kw_write_reg(reg_addr
, addrdir
& 0xff);
428 /* Set up the sub address */
429 if ((mode_reg
& KW_I2C_MODE_MODE_MASK
) == KW_I2C_MODE_STANDARDSUB
430 || (mode_reg
& KW_I2C_MODE_MODE_MASK
) == KW_I2C_MODE_COMBINED
)
431 kw_write_reg(reg_subaddr
, subaddr
);
433 /* Prepare for async operations */
436 host
->state
= state_addr
;
438 host
->rw
= (addrdir
& 1);
439 host
->polled
= bus
->polled
;
441 /* Enable interrupt if not using polled mode and interrupt is
445 /* Clear completion */
446 INIT_COMPLETION(host
->complete
);
447 /* Ack stale interrupts */
448 kw_write_reg(reg_isr
, kw_read_reg(reg_isr
));
450 host
->timeout_timer
.expires
= jiffies
+ KW_POLL_TIMEOUT
;
451 add_timer(&host
->timeout_timer
);
452 /* Enable emission */
453 kw_write_reg(reg_ier
, KW_I2C_IRQ_MASK
);
456 /* Start sending address */
457 kw_write_reg(reg_control
, KW_I2C_CTL_XADDR
);
459 /* Wait for completion */
461 wait_for_completion(&host
->complete
);
463 while(host
->state
!= state_idle
) {
466 u8 isr
= kw_i2c_wait_interrupt(host
);
467 spin_lock_irqsave(&host
->lock
, flags
);
468 kw_i2c_handle_interrupt(host
, isr
);
469 spin_unlock_irqrestore(&host
->lock
, flags
);
473 /* Disable emission */
474 kw_write_reg(reg_ier
, 0);
479 static struct pmac_i2c_host_kw
*__init
kw_i2c_host_init(struct device_node
*np
)
481 struct pmac_i2c_host_kw
*host
;
482 const u32
*psteps
, *prate
, *addrp
;
485 host
= kzalloc(sizeof(struct pmac_i2c_host_kw
), GFP_KERNEL
);
487 printk(KERN_ERR
"low_i2c: Can't allocate host for %s\n",
492 /* Apple is kind enough to provide a valid AAPL,address property
493 * on all i2c keywest nodes so far ... we would have to fallback
494 * to macio parsing if that wasn't the case
496 addrp
= of_get_property(np
, "AAPL,address", NULL
);
498 printk(KERN_ERR
"low_i2c: Can't find address for %s\n",
503 mutex_init(&host
->mutex
);
504 init_completion(&host
->complete
);
505 spin_lock_init(&host
->lock
);
506 init_timer(&host
->timeout_timer
);
507 host
->timeout_timer
.function
= kw_i2c_timeout
;
508 host
->timeout_timer
.data
= (unsigned long)host
;
510 psteps
= of_get_property(np
, "AAPL,address-step", NULL
);
511 steps
= psteps
? (*psteps
) : 0x10;
512 for (host
->bsteps
= 0; (steps
& 0x01) == 0; host
->bsteps
++)
514 /* Select interface rate */
515 host
->speed
= KW_I2C_MODE_25KHZ
;
516 prate
= of_get_property(np
, "AAPL,i2c-rate", NULL
);
517 if (prate
) switch(*prate
) {
519 host
->speed
= KW_I2C_MODE_100KHZ
;
522 host
->speed
= KW_I2C_MODE_50KHZ
;
525 host
->speed
= KW_I2C_MODE_25KHZ
;
528 host
->irq
= irq_of_parse_and_map(np
, 0);
529 if (host
->irq
== NO_IRQ
)
531 "low_i2c: Failed to map interrupt for %s\n",
534 host
->base
= ioremap((*addrp
), 0x1000);
535 if (host
->base
== NULL
) {
536 printk(KERN_ERR
"low_i2c: Can't map registers for %s\n",
542 /* Make sure IRQ is disabled */
543 kw_write_reg(reg_ier
, 0);
545 /* Request chip interrupt. We set IRQF_NO_SUSPEND because we don't
546 * want that interrupt disabled between the 2 passes of driver
547 * suspend or we'll have issues running the pfuncs
549 if (request_irq(host
->irq
, kw_i2c_irq
, IRQF_NO_SUSPEND
,
550 "keywest i2c", host
))
553 printk(KERN_INFO
"KeyWest i2c @0x%08x irq %d %s\n",
554 *addrp
, host
->irq
, np
->full_name
);
560 static void __init
kw_i2c_add(struct pmac_i2c_host_kw
*host
,
561 struct device_node
*controller
,
562 struct device_node
*busnode
,
565 struct pmac_i2c_bus
*bus
;
567 bus
= kzalloc(sizeof(struct pmac_i2c_bus
), GFP_KERNEL
);
571 bus
->controller
= of_node_get(controller
);
572 bus
->busnode
= of_node_get(busnode
);
573 bus
->type
= pmac_i2c_bus_keywest
;
574 bus
->hostdata
= host
;
575 bus
->channel
= channel
;
576 bus
->mode
= pmac_i2c_mode_std
;
577 bus
->open
= kw_i2c_open
;
578 bus
->close
= kw_i2c_close
;
579 bus
->xfer
= kw_i2c_xfer
;
580 mutex_init(&bus
->mutex
);
581 if (controller
== busnode
)
582 bus
->flags
= pmac_i2c_multibus
;
583 list_add(&bus
->link
, &pmac_i2c_busses
);
585 printk(KERN_INFO
" channel %d bus %s\n", channel
,
586 (controller
== busnode
) ? "<multibus>" : busnode
->full_name
);
589 static void __init
kw_i2c_probe(void)
591 struct device_node
*np
, *child
, *parent
;
593 /* Probe keywest-i2c busses */
594 for_each_compatible_node(np
, "i2c","keywest-i2c") {
595 struct pmac_i2c_host_kw
*host
;
598 /* Found one, init a host structure */
599 host
= kw_i2c_host_init(np
);
603 child
= of_get_next_child(np
, NULL
);
604 multibus
= !child
|| strcmp(child
->name
, "i2c-bus");
607 /* For a multibus setup, we get the bus count based on the
613 parent
= of_get_parent(np
);
616 chans
= parent
->name
[0] == 'u' ? 2 : 1;
617 for (i
= 0; i
< chans
; i
++)
618 kw_i2c_add(host
, np
, np
, i
);
621 (child
= of_get_next_child(np
, child
)) != NULL
;) {
622 const u32
*reg
= of_get_property(child
,
626 kw_i2c_add(host
, np
, child
, *reg
);
639 #ifdef CONFIG_ADB_PMU
642 * i2c command block to the PMU
655 static void pmu_i2c_complete(struct adb_request
*req
)
660 static int pmu_i2c_xfer(struct pmac_i2c_bus
*bus
, u8 addrdir
, int subsize
,
661 u32 subaddr
, u8
*data
, int len
)
663 struct adb_request
*req
= bus
->hostdata
;
664 struct pmu_i2c_hdr
*hdr
= (struct pmu_i2c_hdr
*)&req
->data
[1];
665 struct completion comp
;
666 int read
= addrdir
& 1;
670 /* For now, limit ourselves to 16 bytes transfers */
674 init_completion(&comp
);
676 for (retry
= 0; retry
< 16; retry
++) {
677 memset(req
, 0, sizeof(struct adb_request
));
678 hdr
->bus
= bus
->channel
;
682 case pmac_i2c_mode_std
:
685 hdr
->address
= addrdir
;
686 hdr
->mode
= PMU_I2C_MODE_SIMPLE
;
688 case pmac_i2c_mode_stdsub
:
689 case pmac_i2c_mode_combined
:
692 hdr
->address
= addrdir
& 0xfe;
693 hdr
->comb_addr
= addrdir
;
694 hdr
->sub_addr
= subaddr
;
695 if (bus
->mode
== pmac_i2c_mode_stdsub
)
696 hdr
->mode
= PMU_I2C_MODE_STDSUB
;
698 hdr
->mode
= PMU_I2C_MODE_COMBINED
;
704 INIT_COMPLETION(comp
);
705 req
->data
[0] = PMU_I2C_CMD
;
706 req
->reply
[0] = 0xff;
707 req
->nbytes
= sizeof(struct pmu_i2c_hdr
) + 1;
708 req
->done
= pmu_i2c_complete
;
711 memcpy(hdr
->data
, data
, len
);
714 rc
= pmu_queue_request(req
);
717 wait_for_completion(&comp
);
718 if (req
->reply
[0] == PMU_I2C_STATUS_OK
)
722 if (req
->reply
[0] != PMU_I2C_STATUS_OK
)
725 for (retry
= 0; retry
< 16; retry
++) {
726 memset(req
, 0, sizeof(struct adb_request
));
728 /* I know that looks like a lot, slow as hell, but darwin
729 * does it so let's be on the safe side for now
733 hdr
->bus
= PMU_I2C_BUS_STATUS
;
735 INIT_COMPLETION(comp
);
736 req
->data
[0] = PMU_I2C_CMD
;
737 req
->reply
[0] = 0xff;
739 req
->done
= pmu_i2c_complete
;
741 rc
= pmu_queue_request(req
);
744 wait_for_completion(&comp
);
746 if (req
->reply
[0] == PMU_I2C_STATUS_OK
&& !read
)
748 if (req
->reply
[0] == PMU_I2C_STATUS_DATAREAD
&& read
) {
749 int rlen
= req
->reply_len
- 1;
752 printk(KERN_WARNING
"low_i2c: PMU returned %d"
753 " bytes, expected %d !\n", rlen
, len
);
757 memcpy(data
, &req
->reply
[1], len
);
764 static void __init
pmu_i2c_probe(void)
766 struct pmac_i2c_bus
*bus
;
767 struct device_node
*busnode
;
773 /* There might or might not be a "pmu-i2c" node, we use that
774 * or via-pmu itself, whatever we find. I haven't seen a machine
775 * with separate bus nodes, so we assume a multibus setup
777 busnode
= of_find_node_by_name(NULL
, "pmu-i2c");
779 busnode
= of_find_node_by_name(NULL
, "via-pmu");
783 printk(KERN_INFO
"PMU i2c %s\n", busnode
->full_name
);
786 * We add bus 1 and 2 only for now, bus 0 is "special"
788 for (channel
= 1; channel
<= 2; channel
++) {
789 sz
= sizeof(struct pmac_i2c_bus
) + sizeof(struct adb_request
);
790 bus
= kzalloc(sz
, GFP_KERNEL
);
794 bus
->controller
= busnode
;
795 bus
->busnode
= busnode
;
796 bus
->type
= pmac_i2c_bus_pmu
;
797 bus
->channel
= channel
;
798 bus
->mode
= pmac_i2c_mode_std
;
799 bus
->hostdata
= bus
+ 1;
800 bus
->xfer
= pmu_i2c_xfer
;
801 mutex_init(&bus
->mutex
);
802 bus
->flags
= pmac_i2c_multibus
;
803 list_add(&bus
->link
, &pmac_i2c_busses
);
805 printk(KERN_INFO
" channel %d bus <multibus>\n", channel
);
809 #endif /* CONFIG_ADB_PMU */
818 #ifdef CONFIG_PMAC_SMU
820 static void smu_i2c_complete(struct smu_i2c_cmd
*cmd
, void *misc
)
825 static int smu_i2c_xfer(struct pmac_i2c_bus
*bus
, u8 addrdir
, int subsize
,
826 u32 subaddr
, u8
*data
, int len
)
828 struct smu_i2c_cmd
*cmd
= bus
->hostdata
;
829 struct completion comp
;
830 int read
= addrdir
& 1;
833 if ((read
&& len
> SMU_I2C_READ_MAX
) ||
834 ((!read
) && len
> SMU_I2C_WRITE_MAX
))
837 memset(cmd
, 0, sizeof(struct smu_i2c_cmd
));
838 cmd
->info
.bus
= bus
->channel
;
839 cmd
->info
.devaddr
= addrdir
;
840 cmd
->info
.datalen
= len
;
843 case pmac_i2c_mode_std
:
846 cmd
->info
.type
= SMU_I2C_TRANSFER_SIMPLE
;
848 case pmac_i2c_mode_stdsub
:
849 case pmac_i2c_mode_combined
:
850 if (subsize
> 3 || subsize
< 1)
852 cmd
->info
.sublen
= subsize
;
853 /* that's big-endian only but heh ! */
854 memcpy(&cmd
->info
.subaddr
, ((char *)&subaddr
) + (4 - subsize
),
856 if (bus
->mode
== pmac_i2c_mode_stdsub
)
857 cmd
->info
.type
= SMU_I2C_TRANSFER_STDSUB
;
859 cmd
->info
.type
= SMU_I2C_TRANSFER_COMBINED
;
865 memcpy(cmd
->info
.data
, data
, len
);
867 init_completion(&comp
);
868 cmd
->done
= smu_i2c_complete
;
870 rc
= smu_queue_i2c(cmd
);
873 wait_for_completion(&comp
);
877 memcpy(data
, cmd
->info
.data
, len
);
878 return rc
< 0 ? rc
: 0;
881 static void __init
smu_i2c_probe(void)
883 struct device_node
*controller
, *busnode
;
884 struct pmac_i2c_bus
*bus
;
891 controller
= of_find_node_by_name(NULL
, "smu-i2c-control");
892 if (controller
== NULL
)
893 controller
= of_find_node_by_name(NULL
, "smu");
894 if (controller
== NULL
)
897 printk(KERN_INFO
"SMU i2c %s\n", controller
->full_name
);
899 /* Look for childs, note that they might not be of the right
900 * type as older device trees mix i2c busses and other thigns
904 (busnode
= of_get_next_child(controller
, busnode
)) != NULL
;) {
905 if (strcmp(busnode
->type
, "i2c") &&
906 strcmp(busnode
->type
, "i2c-bus"))
908 reg
= of_get_property(busnode
, "reg", NULL
);
912 sz
= sizeof(struct pmac_i2c_bus
) + sizeof(struct smu_i2c_cmd
);
913 bus
= kzalloc(sz
, GFP_KERNEL
);
917 bus
->controller
= controller
;
918 bus
->busnode
= of_node_get(busnode
);
919 bus
->type
= pmac_i2c_bus_smu
;
921 bus
->mode
= pmac_i2c_mode_std
;
922 bus
->hostdata
= bus
+ 1;
923 bus
->xfer
= smu_i2c_xfer
;
924 mutex_init(&bus
->mutex
);
926 list_add(&bus
->link
, &pmac_i2c_busses
);
928 printk(KERN_INFO
" channel %x bus %s\n",
929 bus
->channel
, busnode
->full_name
);
933 #endif /* CONFIG_PMAC_SMU */
942 struct pmac_i2c_bus
*pmac_i2c_find_bus(struct device_node
*node
)
944 struct device_node
*p
= of_node_get(node
);
945 struct device_node
*prev
= NULL
;
946 struct pmac_i2c_bus
*bus
;
949 list_for_each_entry(bus
, &pmac_i2c_busses
, link
) {
950 if (p
== bus
->busnode
) {
951 if (prev
&& bus
->flags
& pmac_i2c_multibus
) {
953 reg
= of_get_property(prev
, "reg",
957 if (((*reg
) >> 8) != bus
->channel
)
967 p
= of_get_parent(p
);
971 EXPORT_SYMBOL_GPL(pmac_i2c_find_bus
);
973 u8
pmac_i2c_get_dev_addr(struct device_node
*device
)
975 const u32
*reg
= of_get_property(device
, "reg", NULL
);
980 return (*reg
) & 0xff;
982 EXPORT_SYMBOL_GPL(pmac_i2c_get_dev_addr
);
984 struct device_node
*pmac_i2c_get_controller(struct pmac_i2c_bus
*bus
)
986 return bus
->controller
;
988 EXPORT_SYMBOL_GPL(pmac_i2c_get_controller
);
990 struct device_node
*pmac_i2c_get_bus_node(struct pmac_i2c_bus
*bus
)
994 EXPORT_SYMBOL_GPL(pmac_i2c_get_bus_node
);
996 int pmac_i2c_get_type(struct pmac_i2c_bus
*bus
)
1000 EXPORT_SYMBOL_GPL(pmac_i2c_get_type
);
1002 int pmac_i2c_get_flags(struct pmac_i2c_bus
*bus
)
1006 EXPORT_SYMBOL_GPL(pmac_i2c_get_flags
);
1008 int pmac_i2c_get_channel(struct pmac_i2c_bus
*bus
)
1010 return bus
->channel
;
1012 EXPORT_SYMBOL_GPL(pmac_i2c_get_channel
);
1015 struct i2c_adapter
*pmac_i2c_get_adapter(struct pmac_i2c_bus
*bus
)
1017 return &bus
->adapter
;
1019 EXPORT_SYMBOL_GPL(pmac_i2c_get_adapter
);
1021 struct pmac_i2c_bus
*pmac_i2c_adapter_to_bus(struct i2c_adapter
*adapter
)
1023 struct pmac_i2c_bus
*bus
;
1025 list_for_each_entry(bus
, &pmac_i2c_busses
, link
)
1026 if (&bus
->adapter
== adapter
)
1030 EXPORT_SYMBOL_GPL(pmac_i2c_adapter_to_bus
);
1032 int pmac_i2c_match_adapter(struct device_node
*dev
, struct i2c_adapter
*adapter
)
1034 struct pmac_i2c_bus
*bus
= pmac_i2c_find_bus(dev
);
1038 return (&bus
->adapter
== adapter
);
1040 EXPORT_SYMBOL_GPL(pmac_i2c_match_adapter
);
1042 int pmac_low_i2c_lock(struct device_node
*np
)
1044 struct pmac_i2c_bus
*bus
, *found
= NULL
;
1046 list_for_each_entry(bus
, &pmac_i2c_busses
, link
) {
1047 if (np
== bus
->controller
) {
1054 return pmac_i2c_open(bus
, 0);
1056 EXPORT_SYMBOL_GPL(pmac_low_i2c_lock
);
1058 int pmac_low_i2c_unlock(struct device_node
*np
)
1060 struct pmac_i2c_bus
*bus
, *found
= NULL
;
1062 list_for_each_entry(bus
, &pmac_i2c_busses
, link
) {
1063 if (np
== bus
->controller
) {
1070 pmac_i2c_close(bus
);
1073 EXPORT_SYMBOL_GPL(pmac_low_i2c_unlock
);
1076 int pmac_i2c_open(struct pmac_i2c_bus
*bus
, int polled
)
1080 mutex_lock(&bus
->mutex
);
1081 bus
->polled
= polled
|| pmac_i2c_force_poll
;
1083 bus
->mode
= pmac_i2c_mode_std
;
1084 if (bus
->open
&& (rc
= bus
->open(bus
)) != 0) {
1086 mutex_unlock(&bus
->mutex
);
1091 EXPORT_SYMBOL_GPL(pmac_i2c_open
);
1093 void pmac_i2c_close(struct pmac_i2c_bus
*bus
)
1095 WARN_ON(!bus
->opened
);
1099 mutex_unlock(&bus
->mutex
);
1101 EXPORT_SYMBOL_GPL(pmac_i2c_close
);
1103 int pmac_i2c_setmode(struct pmac_i2c_bus
*bus
, int mode
)
1105 WARN_ON(!bus
->opened
);
1107 /* Report me if you see the error below as there might be a new
1108 * "combined4" mode that I need to implement for the SMU bus
1110 if (mode
< pmac_i2c_mode_dumb
|| mode
> pmac_i2c_mode_combined
) {
1111 printk(KERN_ERR
"low_i2c: Invalid mode %d requested on"
1112 " bus %s !\n", mode
, bus
->busnode
->full_name
);
1119 EXPORT_SYMBOL_GPL(pmac_i2c_setmode
);
1121 int pmac_i2c_xfer(struct pmac_i2c_bus
*bus
, u8 addrdir
, int subsize
,
1122 u32 subaddr
, u8
*data
, int len
)
1126 WARN_ON(!bus
->opened
);
1128 DBG("xfer() chan=%d, addrdir=0x%x, mode=%d, subsize=%d, subaddr=0x%x,"
1129 " %d bytes, bus %s\n", bus
->channel
, addrdir
, bus
->mode
, subsize
,
1130 subaddr
, len
, bus
->busnode
->full_name
);
1132 rc
= bus
->xfer(bus
, addrdir
, subsize
, subaddr
, data
, len
);
1136 DBG("xfer error %d\n", rc
);
1140 EXPORT_SYMBOL_GPL(pmac_i2c_xfer
);
1142 /* some quirks for platform function decoding */
1144 pmac_i2c_quirk_invmask
= 0x00000001u
,
1145 pmac_i2c_quirk_skip
= 0x00000002u
,
1148 static void pmac_i2c_devscan(void (*callback
)(struct device_node
*dev
,
1151 struct pmac_i2c_bus
*bus
;
1152 struct device_node
*np
;
1153 static struct whitelist_ent
{
1158 { "i2c-hwclock", "imic5002", pmac_i2c_quirk_skip
},
1159 { "i2c-hwclock", "imic5003", pmac_i2c_quirk_skip
},
1160 { "i2c-hwclock", NULL
, pmac_i2c_quirk_invmask
},
1161 { "i2c-cpu-voltage", NULL
, 0},
1162 { "temp-monitor", NULL
, 0 },
1163 { "supply-monitor", NULL
, 0 },
1167 /* Only some devices need to have platform functions instanciated
1168 * here. For now, we have a table. Others, like 9554 i2c GPIOs used
1169 * on Xserve, if we ever do a driver for them, will use their own
1170 * platform function instance
1172 list_for_each_entry(bus
, &pmac_i2c_busses
, link
) {
1174 (np
= of_get_next_child(bus
->busnode
, np
)) != NULL
;) {
1175 struct whitelist_ent
*p
;
1176 /* If multibus, check if device is on that bus */
1177 if (bus
->flags
& pmac_i2c_multibus
)
1178 if (bus
!= pmac_i2c_find_bus(np
))
1180 for (p
= whitelist
; p
->name
!= NULL
; p
++) {
1181 if (strcmp(np
->name
, p
->name
))
1183 if (p
->compatible
&&
1184 !of_device_is_compatible(np
, p
->compatible
))
1186 if (p
->quirks
& pmac_i2c_quirk_skip
)
1188 callback(np
, p
->quirks
);
1195 #define MAX_I2C_DATA 64
1197 struct pmac_i2c_pf_inst
1199 struct pmac_i2c_bus
*bus
;
1201 u8 buffer
[MAX_I2C_DATA
];
1202 u8 scratch
[MAX_I2C_DATA
];
1207 static void* pmac_i2c_do_begin(struct pmf_function
*func
, struct pmf_args
*args
)
1209 struct pmac_i2c_pf_inst
*inst
;
1210 struct pmac_i2c_bus
*bus
;
1212 bus
= pmac_i2c_find_bus(func
->node
);
1214 printk(KERN_ERR
"low_i2c: Can't find bus for %s (pfunc)\n",
1215 func
->node
->full_name
);
1218 if (pmac_i2c_open(bus
, 0)) {
1219 printk(KERN_ERR
"low_i2c: Can't open i2c bus for %s (pfunc)\n",
1220 func
->node
->full_name
);
1224 inst
= kzalloc(sizeof(struct pmac_i2c_pf_inst
), GFP_KERNEL
);
1226 pmac_i2c_close(bus
);
1230 inst
->addr
= pmac_i2c_get_dev_addr(func
->node
);
1231 inst
->quirks
= (int)(long)func
->driver_data
;
1235 static void pmac_i2c_do_end(struct pmf_function
*func
, void *instdata
)
1237 struct pmac_i2c_pf_inst
*inst
= instdata
;
1241 pmac_i2c_close(inst
->bus
);
1245 static int pmac_i2c_do_read(PMF_STD_ARGS
, u32 len
)
1247 struct pmac_i2c_pf_inst
*inst
= instdata
;
1250 return pmac_i2c_xfer(inst
->bus
, inst
->addr
| pmac_i2c_read
, 0, 0,
1254 static int pmac_i2c_do_write(PMF_STD_ARGS
, u32 len
, const u8
*data
)
1256 struct pmac_i2c_pf_inst
*inst
= instdata
;
1258 return pmac_i2c_xfer(inst
->bus
, inst
->addr
| pmac_i2c_write
, 0, 0,
1262 /* This function is used to do the masking & OR'ing for the "rmw" type
1263 * callbacks. Ze should apply the mask and OR in the values in the
1264 * buffer before writing back. The problem is that it seems that
1265 * various darwin drivers implement the mask/or differently, thus
1266 * we need to check the quirks first
1268 static void pmac_i2c_do_apply_rmw(struct pmac_i2c_pf_inst
*inst
,
1269 u32 len
, const u8
*mask
, const u8
*val
)
1273 if (inst
->quirks
& pmac_i2c_quirk_invmask
) {
1274 for (i
= 0; i
< len
; i
++)
1275 inst
->scratch
[i
] = (inst
->buffer
[i
] & mask
[i
]) | val
[i
];
1277 for (i
= 0; i
< len
; i
++)
1278 inst
->scratch
[i
] = (inst
->buffer
[i
] & ~mask
[i
])
1279 | (val
[i
] & mask
[i
]);
1283 static int pmac_i2c_do_rmw(PMF_STD_ARGS
, u32 masklen
, u32 valuelen
,
1284 u32 totallen
, const u8
*maskdata
,
1285 const u8
*valuedata
)
1287 struct pmac_i2c_pf_inst
*inst
= instdata
;
1289 if (masklen
> inst
->bytes
|| valuelen
> inst
->bytes
||
1290 totallen
> inst
->bytes
|| valuelen
> masklen
)
1293 pmac_i2c_do_apply_rmw(inst
, masklen
, maskdata
, valuedata
);
1295 return pmac_i2c_xfer(inst
->bus
, inst
->addr
| pmac_i2c_write
, 0, 0,
1296 inst
->scratch
, totallen
);
1299 static int pmac_i2c_do_read_sub(PMF_STD_ARGS
, u8 subaddr
, u32 len
)
1301 struct pmac_i2c_pf_inst
*inst
= instdata
;
1304 return pmac_i2c_xfer(inst
->bus
, inst
->addr
| pmac_i2c_read
, 1, subaddr
,
1308 static int pmac_i2c_do_write_sub(PMF_STD_ARGS
, u8 subaddr
, u32 len
,
1311 struct pmac_i2c_pf_inst
*inst
= instdata
;
1313 return pmac_i2c_xfer(inst
->bus
, inst
->addr
| pmac_i2c_write
, 1,
1314 subaddr
, (u8
*)data
, len
);
1317 static int pmac_i2c_do_set_mode(PMF_STD_ARGS
, int mode
)
1319 struct pmac_i2c_pf_inst
*inst
= instdata
;
1321 return pmac_i2c_setmode(inst
->bus
, mode
);
1324 static int pmac_i2c_do_rmw_sub(PMF_STD_ARGS
, u8 subaddr
, u32 masklen
,
1325 u32 valuelen
, u32 totallen
, const u8
*maskdata
,
1326 const u8
*valuedata
)
1328 struct pmac_i2c_pf_inst
*inst
= instdata
;
1330 if (masklen
> inst
->bytes
|| valuelen
> inst
->bytes
||
1331 totallen
> inst
->bytes
|| valuelen
> masklen
)
1334 pmac_i2c_do_apply_rmw(inst
, masklen
, maskdata
, valuedata
);
1336 return pmac_i2c_xfer(inst
->bus
, inst
->addr
| pmac_i2c_write
, 1,
1337 subaddr
, inst
->scratch
, totallen
);
1340 static int pmac_i2c_do_mask_and_comp(PMF_STD_ARGS
, u32 len
,
1342 const u8
*valuedata
)
1344 struct pmac_i2c_pf_inst
*inst
= instdata
;
1347 /* Get return value pointer, it's assumed to be a u32 */
1348 if (!args
|| !args
->count
|| !args
->u
[0].p
)
1352 if (len
> inst
->bytes
)
1355 for (i
= 0, match
= 1; match
&& i
< len
; i
++)
1356 if ((inst
->buffer
[i
] & maskdata
[i
]) != valuedata
[i
])
1358 *args
->u
[0].p
= match
;
1362 static int pmac_i2c_do_delay(PMF_STD_ARGS
, u32 duration
)
1364 msleep((duration
+ 999) / 1000);
1369 static struct pmf_handlers pmac_i2c_pfunc_handlers
= {
1370 .begin
= pmac_i2c_do_begin
,
1371 .end
= pmac_i2c_do_end
,
1372 .read_i2c
= pmac_i2c_do_read
,
1373 .write_i2c
= pmac_i2c_do_write
,
1374 .rmw_i2c
= pmac_i2c_do_rmw
,
1375 .read_i2c_sub
= pmac_i2c_do_read_sub
,
1376 .write_i2c_sub
= pmac_i2c_do_write_sub
,
1377 .rmw_i2c_sub
= pmac_i2c_do_rmw_sub
,
1378 .set_i2c_mode
= pmac_i2c_do_set_mode
,
1379 .mask_and_compare
= pmac_i2c_do_mask_and_comp
,
1380 .delay
= pmac_i2c_do_delay
,
1383 static void __init
pmac_i2c_dev_create(struct device_node
*np
, int quirks
)
1385 DBG("dev_create(%s)\n", np
->full_name
);
1387 pmf_register_driver(np
, &pmac_i2c_pfunc_handlers
,
1388 (void *)(long)quirks
);
1391 static void __init
pmac_i2c_dev_init(struct device_node
*np
, int quirks
)
1393 DBG("dev_create(%s)\n", np
->full_name
);
1395 pmf_do_functions(np
, NULL
, 0, PMF_FLAGS_ON_INIT
, NULL
);
1398 static void pmac_i2c_dev_suspend(struct device_node
*np
, int quirks
)
1400 DBG("dev_suspend(%s)\n", np
->full_name
);
1401 pmf_do_functions(np
, NULL
, 0, PMF_FLAGS_ON_SLEEP
, NULL
);
1404 static void pmac_i2c_dev_resume(struct device_node
*np
, int quirks
)
1406 DBG("dev_resume(%s)\n", np
->full_name
);
1407 pmf_do_functions(np
, NULL
, 0, PMF_FLAGS_ON_WAKE
, NULL
);
1410 void pmac_pfunc_i2c_suspend(void)
1412 pmac_i2c_devscan(pmac_i2c_dev_suspend
);
1415 void pmac_pfunc_i2c_resume(void)
1417 pmac_i2c_devscan(pmac_i2c_dev_resume
);
1421 * Initialize us: probe all i2c busses on the machine, instantiate
1422 * busses and platform functions as needed.
1424 /* This is non-static as it might be called early by smp code */
1425 int __init
pmac_i2c_init(void)
1427 static int i2c_inited
;
1433 /* Probe keywest-i2c busses */
1436 #ifdef CONFIG_ADB_PMU
1437 /* Probe PMU i2c busses */
1441 #ifdef CONFIG_PMAC_SMU
1442 /* Probe SMU i2c busses */
1446 /* Now add plaform functions for some known devices */
1447 pmac_i2c_devscan(pmac_i2c_dev_create
);
1451 machine_arch_initcall(powermac
, pmac_i2c_init
);
1453 /* Since pmac_i2c_init can be called too early for the platform device
1454 * registration, we need to do it at a later time. In our case, subsys
1455 * happens to fit well, though I agree it's a bit of a hack...
1457 static int __init
pmac_i2c_create_platform_devices(void)
1459 struct pmac_i2c_bus
*bus
;
1462 /* In the case where we are initialized from smp_init(), we must
1463 * not use the timer (and thus the irq). It's safe from now on
1466 pmac_i2c_force_poll
= 0;
1468 /* Create platform devices */
1469 list_for_each_entry(bus
, &pmac_i2c_busses
, link
) {
1471 platform_device_alloc("i2c-powermac", i
++);
1472 if (bus
->platform_dev
== NULL
)
1474 bus
->platform_dev
->dev
.platform_data
= bus
;
1475 platform_device_add(bus
->platform_dev
);
1478 /* Now call platform "init" functions */
1479 pmac_i2c_devscan(pmac_i2c_dev_init
);
1483 machine_subsys_initcall(powermac
, pmac_i2c_create_platform_devices
);