aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--arch/powerpc/platforms/powermac/feature.c127
-rw-r--r--arch/powerpc/platforms/powermac/low_i2c.c853
-rw-r--r--arch/powerpc/platforms/powermac/setup.c23
-rw-r--r--arch/powerpc/platforms/powermac/smp.c75
-rw-r--r--drivers/i2c/busses/i2c-pmac-smu.c17
-rw-r--r--drivers/macintosh/smu.c58
-rw-r--r--drivers/macintosh/via-pmu.c264
-rw-r--r--include/asm-powerpc/pmac_feature.h4
-rw-r--r--include/asm-powerpc/pmac_low_i2c.h85
-rw-r--r--include/asm-powerpc/smu.h12
-rw-r--r--include/linux/pmu.h8
11 files changed, 859 insertions, 667 deletions
diff --git a/arch/powerpc/platforms/powermac/feature.c b/arch/powerpc/platforms/powermac/feature.c
index d2915d64d45e..b271b11583ac 100644
--- a/arch/powerpc/platforms/powermac/feature.c
+++ b/arch/powerpc/platforms/powermac/feature.c
@@ -1677,124 +1677,6 @@ intrepid_shutdown(struct macio_chip *macio, int sleep_mode)
1677} 1677}
1678 1678
1679 1679
1680void pmac_tweak_clock_spreading(int enable)
1681{
1682 struct macio_chip *macio = &macio_chips[0];
1683
1684 /* Hack for doing clock spreading on some machines PowerBooks and
1685 * iBooks. This implements the "platform-do-clockspreading" OF
1686 * property as decoded manually on various models. For safety, we also
1687 * check the product ID in the device-tree in cases we'll whack the i2c
1688 * chip to make reasonably sure we won't set wrong values in there
1689 *
1690 * Of course, ultimately, we have to implement a real parser for
1691 * the platform-do-* stuff...
1692 */
1693
1694 if (macio->type == macio_intrepid) {
1695 struct device_node *clock =
1696 of_find_node_by_path("/uni-n@f8000000/hw-clock");
1697 if (clock && get_property(clock, "platform-do-clockspreading",
1698 NULL)) {
1699 printk(KERN_INFO "%sabling clock spreading on Intrepid"
1700 " ASIC\n", enable ? "En" : "Dis");
1701 if (enable)
1702 UN_OUT(UNI_N_CLOCK_SPREADING, 2);
1703 else
1704 UN_OUT(UNI_N_CLOCK_SPREADING, 0);
1705 mdelay(40);
1706 }
1707 of_node_put(clock);
1708 }
1709
1710 while (machine_is_compatible("PowerBook5,2") ||
1711 machine_is_compatible("PowerBook5,3") ||
1712 machine_is_compatible("PowerBook6,2") ||
1713 machine_is_compatible("PowerBook6,3")) {
1714 struct device_node *ui2c = of_find_node_by_type(NULL, "i2c");
1715 struct device_node *dt = of_find_node_by_name(NULL, "device-tree");
1716 u8 buffer[9];
1717 u32 *productID;
1718 int i, rc, changed = 0;
1719
1720 if (dt == NULL)
1721 break;
1722 productID = (u32 *)get_property(dt, "pid#", NULL);
1723 if (productID == NULL)
1724 break;
1725 while(ui2c) {
1726 struct device_node *p = of_get_parent(ui2c);
1727 if (p && !strcmp(p->name, "uni-n"))
1728 break;
1729 ui2c = of_find_node_by_type(ui2c, "i2c");
1730 }
1731 if (ui2c == NULL)
1732 break;
1733 DBG("Trying to bump clock speed for PID: %08x...\n", *productID);
1734 rc = pmac_low_i2c_open(ui2c, 1);
1735 if (rc != 0)
1736 break;
1737 pmac_low_i2c_setmode(ui2c, pmac_low_i2c_mode_combined);
1738 rc = pmac_low_i2c_xfer(ui2c, 0xd2 | pmac_low_i2c_read, 0x80, buffer, 9);
1739 DBG("read result: %d,", rc);
1740 if (rc != 0) {
1741 pmac_low_i2c_close(ui2c);
1742 break;
1743 }
1744 for (i=0; i<9; i++)
1745 DBG(" %02x", buffer[i]);
1746 DBG("\n");
1747
1748 switch(*productID) {
1749 case 0x1182: /* AlBook 12" rev 2 */
1750 case 0x1183: /* iBook G4 12" */
1751 buffer[0] = (buffer[0] & 0x8f) | 0x70;
1752 buffer[2] = (buffer[2] & 0x7f) | 0x00;
1753 buffer[5] = (buffer[5] & 0x80) | 0x31;
1754 buffer[6] = (buffer[6] & 0x40) | 0xb0;
1755 buffer[7] = (buffer[7] & 0x00) | (enable ? 0xc0 : 0xba);
1756 buffer[8] = (buffer[8] & 0x00) | 0x30;
1757 changed = 1;
1758 break;
1759 case 0x3142: /* AlBook 15" (ATI M10) */
1760 case 0x3143: /* AlBook 17" (ATI M10) */
1761 buffer[0] = (buffer[0] & 0xaf) | 0x50;
1762 buffer[2] = (buffer[2] & 0x7f) | 0x00;
1763 buffer[5] = (buffer[5] & 0x80) | 0x31;
1764 buffer[6] = (buffer[6] & 0x40) | 0xb0;
1765 buffer[7] = (buffer[7] & 0x00) | (enable ? 0xd0 : 0xc0);
1766 buffer[8] = (buffer[8] & 0x00) | 0x30;
1767 changed = 1;
1768 break;
1769 default:
1770 DBG("i2c-hwclock: Machine model not handled\n");
1771 break;
1772 }
1773 if (!changed) {
1774 pmac_low_i2c_close(ui2c);
1775 break;
1776 }
1777 printk(KERN_INFO "%sabling clock spreading on i2c clock chip\n",
1778 enable ? "En" : "Dis");
1779
1780 pmac_low_i2c_setmode(ui2c, pmac_low_i2c_mode_stdsub);
1781 rc = pmac_low_i2c_xfer(ui2c, 0xd2 | pmac_low_i2c_write, 0x80, buffer, 9);
1782 DBG("write result: %d,", rc);
1783 pmac_low_i2c_setmode(ui2c, pmac_low_i2c_mode_combined);
1784 rc = pmac_low_i2c_xfer(ui2c, 0xd2 | pmac_low_i2c_read, 0x80, buffer, 9);
1785 DBG("read result: %d,", rc);
1786 if (rc != 0) {
1787 pmac_low_i2c_close(ui2c);
1788 break;
1789 }
1790 for (i=0; i<9; i++)
1791 DBG(" %02x", buffer[i]);
1792 pmac_low_i2c_close(ui2c);
1793 break;
1794 }
1795}
1796
1797
1798static int 1680static int
1799core99_sleep(void) 1681core99_sleep(void)
1800{ 1682{
@@ -2980,12 +2862,6 @@ set_initial_features(void)
2980 MACIO_BIC(HEATHROW_FCR, HRW_SOUND_POWER_N); 2862 MACIO_BIC(HEATHROW_FCR, HRW_SOUND_POWER_N);
2981 } 2863 }
2982 2864
2983 /* Some machine models need the clock chip to be properly setup for
2984 * clock spreading now. This should be a platform function but we
2985 * don't do these at the moment
2986 */
2987 pmac_tweak_clock_spreading(1);
2988
2989#endif /* CONFIG_POWER4 */ 2865#endif /* CONFIG_POWER4 */
2990 2866
2991 /* On all machines, switch modem & serial ports off */ 2867 /* On all machines, switch modem & serial ports off */
@@ -3013,9 +2889,6 @@ pmac_feature_init(void)
3013 return; 2889 return;
3014 } 2890 }
3015 2891
3016 /* Setup low-level i2c stuffs */
3017 pmac_init_low_i2c();
3018
3019 /* Probe machine type */ 2892 /* Probe machine type */
3020 if (probe_motherboard()) 2893 if (probe_motherboard())
3021 printk(KERN_WARNING "Unknown PowerMac !\n"); 2894 printk(KERN_WARNING "Unknown PowerMac !\n");
diff --git a/arch/powerpc/platforms/powermac/low_i2c.c b/arch/powerpc/platforms/powermac/low_i2c.c
index 606e0ed13731..f31d6a678b9e 100644
--- a/arch/powerpc/platforms/powermac/low_i2c.c
+++ b/arch/powerpc/platforms/powermac/low_i2c.c
@@ -1,22 +1,34 @@
1/* 1/*
2 * arch/ppc/platforms/pmac_low_i2c.c 2 * arch/powerpc/platforms/powermac/low_i2c.c
3 * 3 *
4 * Copyright (C) 2003 Ben. Herrenschmidt (benh@kernel.crashing.org) 4 * Copyright (C) 2003-2005 Ben. Herrenschmidt (benh@kernel.crashing.org)
5 * 5 *
6 * This program is free software; you can redistribute it and/or 6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License 7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version. 9 * 2 of the License, or (at your option) any later version.
10 * 10 *
11 * This file contains some low-level i2c access routines that 11 * The linux i2c layer isn't completely suitable for our needs for various
12 * need to be used by various bits of the PowerMac platform code 12 * reasons ranging from too late initialisation to semantics not perfectly
13 * at times where the real asynchronous & interrupt driven driver 13 * matching some requirements of the apple platform functions etc...
14 * cannot be used. The API borrows some semantics from the darwin 14 *
15 * driver in order to ease the implementation of the platform 15 * This file thus provides a simple low level unified i2c interface for
16 * properties parser 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
19 * one of them.
20 *
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.
17 */ 28 */
18 29
19#undef DEBUG 30#undef DEBUG
31#undef DEBUG_LOW
20 32
21#include <linux/config.h> 33#include <linux/config.h>
22#include <linux/types.h> 34#include <linux/types.h>
@@ -25,15 +37,16 @@
25#include <linux/module.h> 37#include <linux/module.h>
26#include <linux/adb.h> 38#include <linux/adb.h>
27#include <linux/pmu.h> 39#include <linux/pmu.h>
40#include <linux/delay.h>
41#include <linux/completion.h>
28#include <asm/keylargo.h> 42#include <asm/keylargo.h>
29#include <asm/uninorth.h> 43#include <asm/uninorth.h>
30#include <asm/io.h> 44#include <asm/io.h>
31#include <asm/prom.h> 45#include <asm/prom.h>
32#include <asm/machdep.h> 46#include <asm/machdep.h>
47#include <asm/smu.h>
33#include <asm/pmac_low_i2c.h> 48#include <asm/pmac_low_i2c.h>
34 49
35#define MAX_LOW_I2C_HOST 4
36
37#ifdef DEBUG 50#ifdef DEBUG
38#define DBG(x...) do {\ 51#define DBG(x...) do {\
39 printk(KERN_DEBUG "low_i2c:" x); \ 52 printk(KERN_DEBUG "low_i2c:" x); \
@@ -42,49 +55,54 @@
42#define DBG(x...) 55#define DBG(x...)
43#endif 56#endif
44 57
45struct low_i2c_host; 58#ifdef DEBUG_LOW
46 59#define DBG_LOW(x...) do {\
47typedef int (*low_i2c_func_t)(struct low_i2c_host *host, u8 addr, u8 sub, u8 *data, int len); 60 printk(KERN_DEBUG "low_i2c:" x); \
48 61 } while(0)
49struct low_i2c_host 62#else
50{ 63#define DBG_LOW(x...)
51 struct device_node *np; /* OF device node */ 64#endif
52 struct semaphore mutex; /* Access mutex for use by i2c-keywest */
53 low_i2c_func_t func; /* Access function */
54 unsigned int is_open : 1; /* Poor man's access control */
55 int mode; /* Current mode */
56 int channel; /* Current channel */
57 int num_channels; /* Number of channels */
58 void __iomem *base; /* For keywest-i2c, base address */
59 int bsteps; /* And register stepping */
60 int speed; /* And speed */
61};
62
63static struct low_i2c_host low_i2c_hosts[MAX_LOW_I2C_HOST];
64 65
65/* No locking is necessary on allocation, we are running way before 66/*
66 * anything can race with us 67 * A bus structure. Each bus in the system has such a structure associated.
67 */ 68 */
68static struct low_i2c_host *find_low_i2c_host(struct device_node *np) 69struct pmac_i2c_bus
69{ 70{
70 int i; 71 struct list_head link;
72 struct device_node *controller;
73 struct device_node *busnode;
74 int type;
75 int flags;
76 struct i2c_adapter *adapter;
77 void *hostdata;
78 int channel; /* some hosts have multiple */
79 int mode; /* current mode */
80 struct semaphore sem;
81 int opened;
82 int polled; /* open mode */
83
84 /* ops */
85 int (*open)(struct pmac_i2c_bus *bus);
86 void (*close)(struct pmac_i2c_bus *bus);
87 int (*xfer)(struct pmac_i2c_bus *bus, u8 addrdir, int subsize,
88 u32 subaddr, u8 *data, int len);
89};
71 90
72 for (i = 0; i < MAX_LOW_I2C_HOST; i++) 91static LIST_HEAD(pmac_i2c_busses);
73 if (low_i2c_hosts[i].np == np)
74 return &low_i2c_hosts[i];
75 return NULL;
76}
77 92
78/* 93/*
79 * 94 * Keywest implementation
80 * i2c-keywest implementation (UniNorth, U2, U3, Keylargo's)
81 *
82 */ 95 */
83 96
84/* 97struct pmac_i2c_host_kw
85 * Keywest i2c definitions borrowed from drivers/i2c/i2c-keywest.h, 98{
86 * should be moved somewhere in include/asm-ppc/ 99 struct semaphore mutex; /* Access mutex for use by
87 */ 100 * i2c-keywest */
101 void __iomem *base; /* register base address */
102 int bsteps; /* register stepping */
103 int speed; /* speed */
104};
105
88/* Register indices */ 106/* Register indices */
89typedef enum { 107typedef enum {
90 reg_mode = 0, 108 reg_mode = 0,
@@ -153,52 +171,56 @@ static const char *__kw_state_names[] = {
153 "state_dead" 171 "state_dead"
154}; 172};
155 173
156static inline u8 __kw_read_reg(struct low_i2c_host *host, reg_t reg) 174static inline u8 __kw_read_reg(struct pmac_i2c_bus *bus, reg_t reg)
157{ 175{
176 struct pmac_i2c_host_kw *host = bus->hostdata;
158 return readb(host->base + (((unsigned int)reg) << host->bsteps)); 177 return readb(host->base + (((unsigned int)reg) << host->bsteps));
159} 178}
160 179
161static inline void __kw_write_reg(struct low_i2c_host *host, reg_t reg, u8 val) 180static inline void __kw_write_reg(struct pmac_i2c_bus *bus, reg_t reg, u8 val)
162{ 181{
182 struct pmac_i2c_host_kw *host = bus->hostdata;
163 writeb(val, host->base + (((unsigned)reg) << host->bsteps)); 183 writeb(val, host->base + (((unsigned)reg) << host->bsteps));
164 (void)__kw_read_reg(host, reg_subaddr); 184 (void)__kw_read_reg(bus, reg_subaddr);
165} 185}
166 186
167#define kw_write_reg(reg, val) __kw_write_reg(host, reg, val) 187#define kw_write_reg(reg, val) __kw_write_reg(bus, reg, val)
168#define kw_read_reg(reg) __kw_read_reg(host, reg) 188#define kw_read_reg(reg) __kw_read_reg(bus, reg)
169 189
170 190static u8 kw_i2c_wait_interrupt(struct pmac_i2c_bus* bus)
171/* Don't schedule, the g5 fan controller is too
172 * timing sensitive
173 */
174static u8 kw_wait_interrupt(struct low_i2c_host* host)
175{ 191{
176 int i, j; 192 int i, j;
177 u8 isr; 193 u8 isr;
178 194
179 for (i = 0; i < 100000; i++) { 195 for (i = 0; i < 1000; i++) {
180 isr = kw_read_reg(reg_isr) & KW_I2C_IRQ_MASK; 196 isr = kw_read_reg(reg_isr) & KW_I2C_IRQ_MASK;
181 if (isr != 0) 197 if (isr != 0)
182 return isr; 198 return isr;
183 199
184 /* This code is used with the timebase frozen, we cannot rely 200 /* This code is used with the timebase frozen, we cannot rely
185 * on udelay ! For now, just use a bogus loop 201 * on udelay nor schedule when in polled mode !
202 * For now, just use a bogus loop....
186 */ 203 */
187 for (j = 1; j < 10000; j++) 204 if (bus->polled) {
188 mb(); 205 for (j = 1; j < 1000000; j++)
206 mb();
207 } else
208 msleep(1);
189 } 209 }
190 return isr; 210 return isr;
191} 211}
192 212
193static int kw_handle_interrupt(struct low_i2c_host *host, int state, int rw, int *rc, u8 **data, int *len, u8 isr) 213static int kw_i2c_handle_interrupt(struct pmac_i2c_bus *bus, int state, int rw,
214 int *rc, u8 **data, int *len, u8 isr)
194{ 215{
195 u8 ack; 216 u8 ack;
196 217
197 DBG("kw_handle_interrupt(%s, isr: %x)\n", __kw_state_names[state], isr); 218 DBG_LOW("kw_handle_interrupt(%s, isr: %x)\n",
219 __kw_state_names[state], isr);
198 220
199 if (isr == 0) { 221 if (isr == 0) {
200 if (state != state_stop) { 222 if (state != state_stop) {
201 DBG("KW: Timeout !\n"); 223 DBG_LOW("KW: Timeout !\n");
202 *rc = -EIO; 224 *rc = -EIO;
203 goto stop; 225 goto stop;
204 } 226 }
@@ -220,15 +242,16 @@ static int kw_handle_interrupt(struct low_i2c_host *host, int state, int rw, int
220 *rc = -EIO; 242 *rc = -EIO;
221 goto stop; 243 goto stop;
222 } 244 }
223 if ((ack & KW_I2C_STAT_LAST_AAK) == 0) { 245 if ((ack & KW_I2C_STAT_LAST_AAK) == 0) {
224 *rc = -ENODEV; 246 *rc = -ENODEV;
225 DBG("KW: NAK on address\n"); 247 DBG_LOW("KW: NAK on address\n");
226 return state_stop; 248 return state_stop;
227 } else { 249 } else {
228 if (rw) { 250 if (rw) {
229 state = state_read; 251 state = state_read;
230 if (*len > 1) 252 if (*len > 1)
231 kw_write_reg(reg_control, KW_I2C_CTL_AAK); 253 kw_write_reg(reg_control,
254 KW_I2C_CTL_AAK);
232 } else { 255 } else {
233 state = state_write; 256 state = state_write;
234 kw_write_reg(reg_data, **data); 257 kw_write_reg(reg_data, **data);
@@ -250,7 +273,7 @@ static int kw_handle_interrupt(struct low_i2c_host *host, int state, int rw, int
250 } else if (state == state_write) { 273 } else if (state == state_write) {
251 ack = kw_read_reg(reg_status); 274 ack = kw_read_reg(reg_status);
252 if ((ack & KW_I2C_STAT_LAST_AAK) == 0) { 275 if ((ack & KW_I2C_STAT_LAST_AAK) == 0) {
253 DBG("KW: nack on data write\n"); 276 DBG_LOW("KW: nack on data write\n");
254 *rc = -EIO; 277 *rc = -EIO;
255 goto stop; 278 goto stop;
256 } else if (*len) { 279 } else if (*len) {
@@ -291,35 +314,57 @@ static int kw_handle_interrupt(struct low_i2c_host *host, int state, int rw, int
291 return state_stop; 314 return state_stop;
292} 315}
293 316
294static int keywest_low_i2c_func(struct low_i2c_host *host, u8 addr, u8 subaddr, u8 *data, int len) 317static int kw_i2c_open(struct pmac_i2c_bus *bus)
295{ 318{
319 struct pmac_i2c_host_kw *host = bus->hostdata;
320 down(&host->mutex);
321 return 0;
322}
323
324static void kw_i2c_close(struct pmac_i2c_bus *bus)
325{
326 struct pmac_i2c_host_kw *host = bus->hostdata;
327 up(&host->mutex);
328}
329
330static int kw_i2c_xfer(struct pmac_i2c_bus *bus, u8 addrdir, int subsize,
331 u32 subaddr, u8 *data, int len)
332{
333 struct pmac_i2c_host_kw *host = bus->hostdata;
296 u8 mode_reg = host->speed; 334 u8 mode_reg = host->speed;
297 int state = state_addr; 335 int state = state_addr;
298 int rc = 0; 336 int rc = 0;
299 337
300 /* Setup mode & subaddress if any */ 338 /* Setup mode & subaddress if any */
301 switch(host->mode) { 339 switch(bus->mode) {
302 case pmac_low_i2c_mode_dumb: 340 case pmac_i2c_mode_dumb:
303 printk(KERN_ERR "low_i2c: Dumb mode not supported !\n");
304 return -EINVAL; 341 return -EINVAL;
305 case pmac_low_i2c_mode_std: 342 case pmac_i2c_mode_std:
306 mode_reg |= KW_I2C_MODE_STANDARD; 343 mode_reg |= KW_I2C_MODE_STANDARD;
344 if (subsize != 0)
345 return -EINVAL;
307 break; 346 break;
308 case pmac_low_i2c_mode_stdsub: 347 case pmac_i2c_mode_stdsub:
309 mode_reg |= KW_I2C_MODE_STANDARDSUB; 348 mode_reg |= KW_I2C_MODE_STANDARDSUB;
349 if (subsize != 1)
350 return -EINVAL;
310 break; 351 break;
311 case pmac_low_i2c_mode_combined: 352 case pmac_i2c_mode_combined:
312 mode_reg |= KW_I2C_MODE_COMBINED; 353 mode_reg |= KW_I2C_MODE_COMBINED;
354 if (subsize != 1)
355 return -EINVAL;
313 break; 356 break;
314 } 357 }
315 358
316 /* Setup channel & clear pending irqs */ 359 /* Setup channel & clear pending irqs */
317 kw_write_reg(reg_isr, kw_read_reg(reg_isr)); 360 kw_write_reg(reg_isr, kw_read_reg(reg_isr));
318 kw_write_reg(reg_mode, mode_reg | (host->channel << 4)); 361 kw_write_reg(reg_mode, mode_reg | (bus->channel << 4));
319 kw_write_reg(reg_status, 0); 362 kw_write_reg(reg_status, 0);
320 363
321 /* Set up address and r/w bit */ 364 /* Set up address and r/w bit, strip possible stale bus number from
322 kw_write_reg(reg_addr, addr); 365 * address top bits
366 */
367 kw_write_reg(reg_addr, addrdir & 0xff);
323 368
324 /* Set up the sub address */ 369 /* Set up the sub address */
325 if ((mode_reg & KW_I2C_MODE_MODE_MASK) == KW_I2C_MODE_STANDARDSUB 370 if ((mode_reg & KW_I2C_MODE_MODE_MASK) == KW_I2C_MODE_STANDARDSUB
@@ -330,27 +375,27 @@ static int keywest_low_i2c_func(struct low_i2c_host *host, u8 addr, u8 subaddr,
330 kw_write_reg(reg_ier, 0 /*KW_I2C_IRQ_MASK*/); 375 kw_write_reg(reg_ier, 0 /*KW_I2C_IRQ_MASK*/);
331 kw_write_reg(reg_control, KW_I2C_CTL_XADDR); 376 kw_write_reg(reg_control, KW_I2C_CTL_XADDR);
332 377
333 /* State machine, to turn into an interrupt handler */ 378 /* State machine, to turn into an interrupt handler in the future */
334 while(state != state_idle) { 379 while(state != state_idle) {
335 u8 isr = kw_wait_interrupt(host); 380 u8 isr = kw_i2c_wait_interrupt(bus);
336 state = kw_handle_interrupt(host, state, addr & 1, &rc, &data, &len, isr); 381 state = kw_i2c_handle_interrupt(bus, state, addrdir & 1, &rc,
382 &data, &len, isr);
337 } 383 }
338 384
339 return rc; 385 return rc;
340} 386}
341 387
342static void keywest_low_i2c_add(struct device_node *np) 388static struct pmac_i2c_host_kw *__init kw_i2c_host_init(struct device_node *np)
343{ 389{
344 struct low_i2c_host *host = find_low_i2c_host(NULL); 390 struct pmac_i2c_host_kw *host;
345 u32 *psteps, *prate, *addrp, steps; 391 u32 *psteps, *prate, *addrp, steps;
346 struct device_node *parent;
347 392
393 host = kzalloc(sizeof(struct pmac_i2c_host_kw), GFP_KERNEL);
348 if (host == NULL) { 394 if (host == NULL) {
349 printk(KERN_ERR "low_i2c: Can't allocate host for %s\n", 395 printk(KERN_ERR "low_i2c: Can't allocate host for %s\n",
350 np->full_name); 396 np->full_name);
351 return; 397 return NULL;
352 } 398 }
353 memset(host, 0, sizeof(*host));
354 399
355 /* Apple is kind enough to provide a valid AAPL,address property 400 /* Apple is kind enough to provide a valid AAPL,address property
356 * on all i2c keywest nodes so far ... we would have to fallback 401 * on all i2c keywest nodes so far ... we would have to fallback
@@ -360,18 +405,14 @@ static void keywest_low_i2c_add(struct device_node *np)
360 if (addrp == NULL) { 405 if (addrp == NULL) {
361 printk(KERN_ERR "low_i2c: Can't find address for %s\n", 406 printk(KERN_ERR "low_i2c: Can't find address for %s\n",
362 np->full_name); 407 np->full_name);
363 return; 408 kfree(host);
409 return NULL;
364 } 410 }
365 init_MUTEX(&host->mutex); 411 init_MUTEX(&host->mutex);
366 host->np = of_node_get(np);
367 psteps = (u32 *)get_property(np, "AAPL,address-step", NULL); 412 psteps = (u32 *)get_property(np, "AAPL,address-step", NULL);
368 steps = psteps ? (*psteps) : 0x10; 413 steps = psteps ? (*psteps) : 0x10;
369 for (host->bsteps = 0; (steps & 0x01) == 0; host->bsteps++) 414 for (host->bsteps = 0; (steps & 0x01) == 0; host->bsteps++)
370 steps >>= 1; 415 steps >>= 1;
371 parent = of_get_parent(np);
372 host->num_channels = 1;
373 if (parent && parent->name[0] == 'u')
374 host->num_channels = 2;
375 /* Select interface rate */ 416 /* Select interface rate */
376 host->speed = KW_I2C_MODE_25KHZ; 417 host->speed = KW_I2C_MODE_25KHZ;
377 prate = (u32 *)get_property(np, "AAPL,i2c-rate", NULL); 418 prate = (u32 *)get_property(np, "AAPL,i2c-rate", NULL);
@@ -387,148 +428,620 @@ static void keywest_low_i2c_add(struct device_node *np)
387 break; 428 break;
388 } 429 }
389 430
390 printk(KERN_INFO "low_i2c: Bus %s found at 0x%08x, %d channels," 431 printk(KERN_INFO "KeyWest i2c @0x%08x %s\n", *addrp, np->full_name);
391 " speed = %d KHz\n",
392 np->full_name, *addrp, host->num_channels, prate ? *prate : 25);
393
394 host->mode = pmac_low_i2c_mode_std;
395 host->base = ioremap((*addrp), 0x1000); 432 host->base = ioremap((*addrp), 0x1000);
396 host->func = keywest_low_i2c_func; 433
434 return host;
397} 435}
398 436
437
438static void __init kw_i2c_add(struct pmac_i2c_host_kw *host,
439 struct device_node *controller,
440 struct device_node *busnode,
441 int channel)
442{
443 struct pmac_i2c_bus *bus;
444
445 bus = kzalloc(sizeof(struct pmac_i2c_bus), GFP_KERNEL);
446 if (bus == NULL)
447 return;
448
449 bus->controller = of_node_get(controller);
450 bus->busnode = of_node_get(busnode);
451 bus->type = pmac_i2c_bus_keywest;
452 bus->hostdata = host;
453 bus->channel = channel;
454 bus->mode = pmac_i2c_mode_std;
455 bus->open = kw_i2c_open;
456 bus->close = kw_i2c_close;
457 bus->xfer = kw_i2c_xfer;
458 init_MUTEX(&bus->sem);
459 if (controller == busnode)
460 bus->flags = pmac_i2c_multibus;
461 list_add(&bus->link, &pmac_i2c_busses);
462
463 printk(KERN_INFO " channel %d bus %s\n", channel,
464 (controller == busnode) ? "<multibus>" : busnode->full_name);
465}
466
467static void __init kw_i2c_probe(void)
468{
469 struct device_node *np, *child, *parent;
470
471 /* Probe keywest-i2c busses */
472 for (np = NULL;
473 (np = of_find_compatible_node(np, "i2c","keywest-i2c")) != NULL;){
474 struct pmac_i2c_host_kw *host;
475 int multibus, chans, i;
476
477 /* Found one, init a host structure */
478 host = kw_i2c_host_init(np);
479 if (host == NULL)
480 continue;
481
482 /* Now check if we have a multibus setup (old style) or if we
483 * have proper bus nodes. Note that the "new" way (proper bus
484 * nodes) might cause us to not create some busses that are
485 * kept hidden in the device-tree. In the future, we might
486 * want to work around that by creating busses without a node
487 * but not for now
488 */
489 child = of_get_next_child(np, NULL);
490 multibus = !child || strcmp(child->name, "i2c-bus");
491 of_node_put(child);
492
493 /* For a multibus setup, we get the bus count based on the
494 * parent type
495 */
496 if (multibus) {
497 parent = of_get_parent(np);
498 if (parent == NULL)
499 continue;
500 chans = parent->name[0] == 'u' ? 2 : 1;
501 for (i = 0; i < chans; i++)
502 kw_i2c_add(host, np, np, i);
503 } else {
504 for (child = NULL;
505 (child = of_get_next_child(np, child)) != NULL;) {
506 u32 *reg =
507 (u32 *)get_property(child, "reg", NULL);
508 if (reg == NULL)
509 continue;
510 kw_i2c_add(host, np, child, *reg);
511 }
512 }
513 }
514}
515
516
399/* 517/*
400 * 518 *
401 * PMU implementation 519 * PMU implementation
402 * 520 *
403 */ 521 */
404 522
405
406#ifdef CONFIG_ADB_PMU 523#ifdef CONFIG_ADB_PMU
407 524
408static int pmu_low_i2c_func(struct low_i2c_host *host, u8 addr, u8 sub, u8 *data, int len) 525/*
526 * i2c command block to the PMU
527 */
528struct pmu_i2c_hdr {
529 u8 bus;
530 u8 mode;
531 u8 bus2;
532 u8 address;
533 u8 sub_addr;
534 u8 comb_addr;
535 u8 count;
536 u8 data[];
537};
538
539static void pmu_i2c_complete(struct adb_request *req)
409{ 540{
410 // TODO 541 complete(req->arg);
411 return -ENODEV;
412} 542}
413 543
414static void pmu_low_i2c_add(struct device_node *np) 544static int pmu_i2c_xfer(struct pmac_i2c_bus *bus, u8 addrdir, int subsize,
545 u32 subaddr, u8 *data, int len)
415{ 546{
416 struct low_i2c_host *host = find_low_i2c_host(NULL); 547 struct adb_request *req = bus->hostdata;
548 struct pmu_i2c_hdr *hdr = (struct pmu_i2c_hdr *)&req->data[1];
549 struct completion comp;
550 int read = addrdir & 1;
551 int retry;
552 int rc = 0;
417 553
418 if (host == NULL) { 554 /* For now, limit ourselves to 16 bytes transfers */
419 printk(KERN_ERR "low_i2c: Can't allocate host for %s\n", 555 if (len > 16)
420 np->full_name); 556 return -EINVAL;
421 return; 557
558 init_completion(&comp);
559
560 for (retry = 0; retry < 16; retry++) {
561 memset(req, 0, sizeof(struct adb_request));
562 hdr->bus = bus->channel;
563 hdr->count = len;
564
565 switch(bus->mode) {
566 case pmac_i2c_mode_std:
567 if (subsize != 0)
568 return -EINVAL;
569 hdr->address = addrdir;
570 hdr->mode = PMU_I2C_MODE_SIMPLE;
571 break;
572 case pmac_i2c_mode_stdsub:
573 case pmac_i2c_mode_combined:
574 if (subsize != 1)
575 return -EINVAL;
576 hdr->address = addrdir & 0xfe;
577 hdr->comb_addr = addrdir;
578 hdr->sub_addr = subaddr;
579 if (bus->mode == pmac_i2c_mode_stdsub)
580 hdr->mode = PMU_I2C_MODE_STDSUB;
581 else
582 hdr->mode = PMU_I2C_MODE_COMBINED;
583 break;
584 default:
585 return -EINVAL;
586 }
587
588 INIT_COMPLETION(comp);
589 req->data[0] = PMU_I2C_CMD;
590 req->reply[0] = 0xff;
591 req->nbytes = sizeof(struct pmu_i2c_hdr) + 1;
592 req->done = pmu_i2c_complete;
593 req->arg = &comp;
594 if (!read) {
595 memcpy(hdr->data, data, len);
596 req->nbytes += len;
597 }
598 rc = pmu_queue_request(req);
599 if (rc)
600 return rc;
601 wait_for_completion(&comp);
602 if (req->reply[0] == PMU_I2C_STATUS_OK)
603 break;
604 msleep(15);
422 } 605 }
423 memset(host, 0, sizeof(*host)); 606 if (req->reply[0] != PMU_I2C_STATUS_OK)
607 return -EIO;
424 608
425 init_MUTEX(&host->mutex); 609 for (retry = 0; retry < 16; retry++) {
426 host->np = of_node_get(np); 610 memset(req, 0, sizeof(struct adb_request));
427 host->num_channels = 3; 611
428 host->mode = pmac_low_i2c_mode_std; 612 /* I know that looks like a lot, slow as hell, but darwin
429 host->func = pmu_low_i2c_func; 613 * does it so let's be on the safe side for now
614 */
615 msleep(15);
616
617 hdr->bus = PMU_I2C_BUS_STATUS;
618
619 INIT_COMPLETION(comp);
620 req->data[0] = PMU_I2C_CMD;
621 req->reply[0] = 0xff;
622 req->nbytes = 2;
623 req->done = pmu_i2c_complete;
624 req->arg = &comp;
625 rc = pmu_queue_request(req);
626 if (rc)
627 return rc;
628 wait_for_completion(&comp);
629
630 if (req->reply[0] == PMU_I2C_STATUS_OK && !read)
631 return 0;
632 if (req->reply[0] == PMU_I2C_STATUS_DATAREAD && read) {
633 int rlen = req->reply_len - 1;
634
635 if (rlen != len) {
636 printk(KERN_WARNING "low_i2c: PMU returned %d"
637 " bytes, expected %d !\n", rlen, len);
638 return -EIO;
639 }
640 memcpy(data, &req->reply[1], len);
641 return 0;
642 }
643 }
644 return -EIO;
645}
646
647static void __init pmu_i2c_probe(void)
648{
649 struct pmac_i2c_bus *bus;
650 struct device_node *busnode;
651 int channel, sz;
652
653 if (!pmu_present())
654 return;
655
656 /* There might or might not be a "pmu-i2c" node, we use that
657 * or via-pmu itself, whatever we find. I haven't seen a machine
658 * with separate bus nodes, so we assume a multibus setup
659 */
660 busnode = of_find_node_by_name(NULL, "pmu-i2c");
661 if (busnode == NULL)
662 busnode = of_find_node_by_name(NULL, "via-pmu");
663 if (busnode == NULL)
664 return;
665
666 printk(KERN_INFO "PMU i2c %s\n", busnode->full_name);
667
668 /*
669 * We add bus 1 and 2 only for now, bus 0 is "special"
670 */
671 for (channel = 1; channel <= 2; channel++) {
672 sz = sizeof(struct pmac_i2c_bus) + sizeof(struct adb_request);
673 bus = kzalloc(sz, GFP_KERNEL);
674 if (bus == NULL)
675 return;
676
677 bus->controller = busnode;
678 bus->busnode = busnode;
679 bus->type = pmac_i2c_bus_pmu;
680 bus->channel = channel;
681 bus->mode = pmac_i2c_mode_std;
682 bus->hostdata = bus + 1;
683 bus->xfer = pmu_i2c_xfer;
684 init_MUTEX(&bus->sem);
685 bus->flags = pmac_i2c_multibus;
686 list_add(&bus->link, &pmac_i2c_busses);
687
688 printk(KERN_INFO " channel %d bus <multibus>\n", channel);
689 }
430} 690}
431 691
432#endif /* CONFIG_ADB_PMU */ 692#endif /* CONFIG_ADB_PMU */
433 693
434void __init pmac_init_low_i2c(void) 694
695/*
696 *
697 * SMU implementation
698 *
699 */
700
701#ifdef CONFIG_PMAC_SMU
702
703static void smu_i2c_complete(struct smu_i2c_cmd *cmd, void *misc)
435{ 704{
436 struct device_node *np; 705 complete(misc);
706}
437 707
438 /* Probe keywest-i2c busses */ 708static int smu_i2c_xfer(struct pmac_i2c_bus *bus, u8 addrdir, int subsize,
439 np = of_find_compatible_node(NULL, "i2c", "keywest-i2c"); 709 u32 subaddr, u8 *data, int len)
440 while(np) { 710{
441 keywest_low_i2c_add(np); 711 struct smu_i2c_cmd *cmd = bus->hostdata;
442 np = of_find_compatible_node(np, "i2c", "keywest-i2c"); 712 struct completion comp;
713 int read = addrdir & 1;
714 int rc = 0;
715
716 memset(cmd, 0, sizeof(struct smu_i2c_cmd));
717 cmd->info.bus = bus->channel;
718 cmd->info.devaddr = addrdir;
719 cmd->info.datalen = len;
720
721 switch(bus->mode) {
722 case pmac_i2c_mode_std:
723 if (subsize != 0)
724 return -EINVAL;
725 cmd->info.type = SMU_I2C_TRANSFER_SIMPLE;
726 break;
727 case pmac_i2c_mode_stdsub:
728 case pmac_i2c_mode_combined:
729 if (subsize > 3 || subsize < 1)
730 return -EINVAL;
731 cmd->info.sublen = subsize;
732 /* that's big-endian only but heh ! */
733 memcpy(&cmd->info.subaddr, ((char *)&subaddr) + (4 - subsize),
734 subsize);
735 if (bus->mode == pmac_i2c_mode_stdsub)
736 cmd->info.type = SMU_I2C_TRANSFER_STDSUB;
737 else
738 cmd->info.type = SMU_I2C_TRANSFER_COMBINED;
739 break;
740 default:
741 return -EINVAL;
443 } 742 }
743 if (!read)
744 memcpy(cmd->info.data, data, len);
745
746 init_completion(&comp);
747 cmd->done = smu_i2c_complete;
748 cmd->misc = &comp;
749 rc = smu_queue_i2c(cmd);
750 if (rc < 0)
751 return rc;
752 wait_for_completion(&comp);
753 rc = cmd->status;
754
755 if (read)
756 memcpy(data, cmd->info.data, len);
757 return rc < 0 ? rc : 0;
758}
444 759
445#ifdef CONFIG_ADB_PMU 760static void __init smu_i2c_probe(void)
446 /* Probe PMU busses */ 761{
447 np = of_find_node_by_name(NULL, "via-pmu"); 762 struct device_node *controller, *busnode;
448 if (np) 763 struct pmac_i2c_bus *bus;
449 pmu_low_i2c_add(np); 764 u32 *reg;
450#endif /* CONFIG_ADB_PMU */ 765 int sz;
766
767 if (!smu_present())
768 return;
769
770 controller = of_find_node_by_name(NULL, "smu_i2c_control");
771 if (controller == NULL)
772 controller = of_find_node_by_name(NULL, "smu");
773 if (controller == NULL)
774 return;
775
776 printk(KERN_INFO "SMU i2c %s\n", controller->full_name);
777
778 /* Look for childs, note that they might not be of the right
779 * type as older device trees mix i2c busses and other thigns
780 * at the same level
781 */
782 for (busnode = NULL;
783 (busnode = of_get_next_child(controller, busnode)) != NULL;) {
784 if (strcmp(busnode->type, "i2c") &&
785 strcmp(busnode->type, "i2c-bus"))
786 continue;
787 reg = (u32 *)get_property(busnode, "reg", NULL);
788 if (reg == NULL)
789 continue;
790
791 sz = sizeof(struct pmac_i2c_bus) + sizeof(struct smu_i2c_cmd);
792 bus = kzalloc(sz, GFP_KERNEL);
793 if (bus == NULL)
794 return;
795
796 bus->controller = controller;
797 bus->busnode = of_node_get(busnode);
798 bus->type = pmac_i2c_bus_smu;
799 bus->channel = *reg;
800 bus->mode = pmac_i2c_mode_std;
801 bus->hostdata = bus + 1;
802 bus->xfer = smu_i2c_xfer;
803 init_MUTEX(&bus->sem);
804 bus->flags = 0;
805 list_add(&bus->link, &pmac_i2c_busses);
806
807 printk(KERN_INFO " channel %x bus %s\n",
808 bus->channel, busnode->full_name);
809 }
810}
811
812#endif /* CONFIG_PMAC_SMU */
813
814/*
815 *
816 * Core code
817 *
818 */
819
820
821struct pmac_i2c_bus *pmac_i2c_find_bus(struct device_node *node)
822{
823 struct device_node *p = of_node_get(node);
824 struct device_node *prev = NULL;
825 struct pmac_i2c_bus *bus;
826
827 while(p) {
828 list_for_each_entry(bus, &pmac_i2c_busses, link) {
829 if (p == bus->busnode) {
830 if (prev && bus->flags & pmac_i2c_multibus) {
831 u32 *reg;
832 reg = (u32 *)get_property(prev, "reg",
833 NULL);
834 if (!reg)
835 continue;
836 if (((*reg) >> 8) != bus->channel)
837 continue;
838 }
839 of_node_put(p);
840 of_node_put(prev);
841 return bus;
842 }
843 }
844 of_node_put(prev);
845 prev = p;
846 p = of_get_parent(p);
847 }
848 return NULL;
849}
850EXPORT_SYMBOL_GPL(pmac_i2c_find_bus);
851
852u8 pmac_i2c_get_dev_addr(struct device_node *device)
853{
854 u32 *reg = (u32 *)get_property(device, "reg", NULL);
855
856 if (reg == NULL)
857 return 0;
858
859 return (*reg) & 0xff;
860}
861EXPORT_SYMBOL_GPL(pmac_i2c_get_dev_addr);
862
863struct device_node *pmac_i2c_get_controller(struct pmac_i2c_bus *bus)
864{
865 return bus->controller;
866}
867EXPORT_SYMBOL_GPL(pmac_i2c_get_controller);
868
869struct device_node *pmac_i2c_get_bus_node(struct pmac_i2c_bus *bus)
870{
871 return bus->busnode;
872}
873EXPORT_SYMBOL_GPL(pmac_i2c_get_bus_node);
874
875int pmac_i2c_get_type(struct pmac_i2c_bus *bus)
876{
877 return bus->type;
878}
879EXPORT_SYMBOL_GPL(pmac_i2c_get_type);
880
881int pmac_i2c_get_flags(struct pmac_i2c_bus *bus)
882{
883 return bus->flags;
884}
885EXPORT_SYMBOL_GPL(pmac_i2c_get_flags);
451 886
452 /* TODO: Add CUDA support as well */ 887void pmac_i2c_attach_adapter(struct pmac_i2c_bus *bus,
888 struct i2c_adapter *adapter)
889{
890 WARN_ON(bus->adapter != NULL);
891 bus->adapter = adapter;
453} 892}
893EXPORT_SYMBOL_GPL(pmac_i2c_attach_adapter);
894
895void pmac_i2c_detach_adapter(struct pmac_i2c_bus *bus,
896 struct i2c_adapter *adapter)
897{
898 WARN_ON(bus->adapter != adapter);
899 bus->adapter = NULL;
900}
901EXPORT_SYMBOL_GPL(pmac_i2c_detach_adapter);
902
903struct i2c_adapter *pmac_i2c_get_adapter(struct pmac_i2c_bus *bus)
904{
905 return bus->adapter;
906}
907EXPORT_SYMBOL_GPL(pmac_i2c_get_adapter);
908
909extern int pmac_i2c_match_adapter(struct device_node *dev,
910 struct i2c_adapter *adapter)
911{
912 struct pmac_i2c_bus *bus = pmac_i2c_find_bus(dev);
913
914 if (bus == NULL)
915 return 0;
916 return (bus->adapter == adapter);
917}
918EXPORT_SYMBOL_GPL(pmac_i2c_match_adapter);
454 919
455int pmac_low_i2c_lock(struct device_node *np) 920int pmac_low_i2c_lock(struct device_node *np)
456{ 921{
457 struct low_i2c_host *host = find_low_i2c_host(np); 922 struct pmac_i2c_bus *bus, *found = NULL;
458 923
459 if (!host) 924 list_for_each_entry(bus, &pmac_i2c_busses, link) {
925 if (np == bus->controller) {
926 found = bus;
927 break;
928 }
929 }
930 if (!found)
460 return -ENODEV; 931 return -ENODEV;
461 down(&host->mutex); 932 return pmac_i2c_open(bus, 0);
462 return 0;
463} 933}
464EXPORT_SYMBOL(pmac_low_i2c_lock); 934EXPORT_SYMBOL_GPL(pmac_low_i2c_lock);
465 935
466int pmac_low_i2c_unlock(struct device_node *np) 936int pmac_low_i2c_unlock(struct device_node *np)
467{ 937{
468 struct low_i2c_host *host = find_low_i2c_host(np); 938 struct pmac_i2c_bus *bus, *found = NULL;
469 939
470 if (!host) 940 list_for_each_entry(bus, &pmac_i2c_busses, link) {
941 if (np == bus->controller) {
942 found = bus;
943 break;
944 }
945 }
946 if (!found)
471 return -ENODEV; 947 return -ENODEV;
472 up(&host->mutex); 948 pmac_i2c_close(bus);
473 return 0; 949 return 0;
474} 950}
475EXPORT_SYMBOL(pmac_low_i2c_unlock); 951EXPORT_SYMBOL_GPL(pmac_low_i2c_unlock);
476 952
477 953
478int pmac_low_i2c_open(struct device_node *np, int channel) 954int pmac_i2c_open(struct pmac_i2c_bus *bus, int polled)
479{ 955{
480 struct low_i2c_host *host = find_low_i2c_host(np); 956 int rc;
957
958 down(&bus->sem);
959 bus->polled = polled;
960 bus->opened = 1;
961 bus->mode = pmac_i2c_mode_std;
962 if (bus->open && (rc = bus->open(bus)) != 0) {
963 bus->opened = 0;
964 up(&bus->sem);
965 return rc;
966 }
967 return 0;
968}
969EXPORT_SYMBOL_GPL(pmac_i2c_open);
481 970
482 if (!host) 971void pmac_i2c_close(struct pmac_i2c_bus *bus)
483 return -ENODEV; 972{
973 WARN_ON(!bus->opened);
974 if (bus->close)
975 bus->close(bus);
976 bus->opened = 0;
977 up(&bus->sem);
978}
979EXPORT_SYMBOL_GPL(pmac_i2c_close);
484 980
485 if (channel >= host->num_channels) 981int pmac_i2c_setmode(struct pmac_i2c_bus *bus, int mode)
486 return -EINVAL; 982{
983 WARN_ON(!bus->opened);
487 984
488 down(&host->mutex); 985 /* Report me if you see the error below as there might be a new
489 host->is_open = 1; 986 * "combined4" mode that I need to implement for the SMU bus
490 host->channel = channel; 987 */
988 if (mode < pmac_i2c_mode_dumb || mode > pmac_i2c_mode_combined) {
989 printk(KERN_ERR "low_i2c: Invalid mode %d requested on"
990 " bus %s !\n", mode, bus->busnode->full_name);
991 return -EINVAL;
992 }
993 bus->mode = mode;
491 994
492 return 0; 995 return 0;
493} 996}
494EXPORT_SYMBOL(pmac_low_i2c_open); 997EXPORT_SYMBOL_GPL(pmac_i2c_setmode);
495 998
496int pmac_low_i2c_close(struct device_node *np) 999int pmac_i2c_xfer(struct pmac_i2c_bus *bus, u8 addrdir, int subsize,
1000 u32 subaddr, u8 *data, int len)
497{ 1001{
498 struct low_i2c_host *host = find_low_i2c_host(np); 1002 int rc;
499 1003
500 if (!host) 1004 WARN_ON(!bus->opened);
501 return -ENODEV;
502 1005
503 host->is_open = 0; 1006 DBG("xfer() chan=%d, addrdir=0x%x, mode=%d, subsize=%d, subaddr=0x%x,"
504 up(&host->mutex); 1007 " %d bytes, bus %s\n", bus->channel, addrdir, bus->mode, subsize,
1008 subaddr, len, bus->busnode->full_name);
505 1009
506 return 0; 1010 rc = bus->xfer(bus, addrdir, subsize, subaddr, data, len);
1011
1012#ifdef DEBUG
1013 if (rc)
1014 DBG("xfer error %d\n", rc);
1015#endif
1016 return rc;
507} 1017}
508EXPORT_SYMBOL(pmac_low_i2c_close); 1018EXPORT_SYMBOL_GPL(pmac_i2c_xfer);
509 1019
510int pmac_low_i2c_setmode(struct device_node *np, int mode) 1020/*
1021 * Initialize us: probe all i2c busses on the machine and instantiate
1022 * busses.
1023 */
1024/* This is non-static as it might be called early by smp code */
1025int __init pmac_i2c_init(void)
511{ 1026{
512 struct low_i2c_host *host = find_low_i2c_host(np); 1027 static int i2c_inited;
513 1028
514 if (!host) 1029 if (i2c_inited)
515 return -ENODEV; 1030 return 0;
516 WARN_ON(!host->is_open); 1031 i2c_inited = 1;
517 host->mode = mode;
518 1032
519 return 0; 1033 /* Probe keywest-i2c busses */
520} 1034 kw_i2c_probe();
521EXPORT_SYMBOL(pmac_low_i2c_setmode);
522 1035
523int pmac_low_i2c_xfer(struct device_node *np, u8 addrdir, u8 subaddr, u8 *data, int len) 1036#ifdef CONFIG_ADB_PMU
524{ 1037 pmu_i2c_probe();
525 struct low_i2c_host *host = find_low_i2c_host(np); 1038#endif
526 1039
527 if (!host) 1040#ifdef CONFIG_PMAC_SMU
528 return -ENODEV; 1041 smu_i2c_probe();
529 WARN_ON(!host->is_open); 1042#endif
530 1043
531 return host->func(host, addrdir, subaddr, data, len); 1044 return 0;
532} 1045}
533EXPORT_SYMBOL(pmac_low_i2c_xfer); 1046arch_initcall(pmac_i2c_init);
534 1047
diff --git a/arch/powerpc/platforms/powermac/setup.c b/arch/powerpc/platforms/powermac/setup.c
index e5a5bdbdda7a..dc5cdc1484e8 100644
--- a/arch/powerpc/platforms/powermac/setup.c
+++ b/arch/powerpc/platforms/powermac/setup.c
@@ -652,27 +652,22 @@ static int __init pmac_declare_of_platform_devices(void)
652{ 652{
653 struct device_node *np, *npp; 653 struct device_node *np, *npp;
654 654
655 np = find_devices("uni-n"); 655 np = of_find_node_by_name(NULL, "valkyrie");
656 if (np) {
657 for (np = np->child; np != NULL; np = np->sibling)
658 if (strncmp(np->name, "i2c", 3) == 0) {
659 of_platform_device_create(np, "uni-n-i2c",
660 NULL);
661 break;
662 }
663 }
664 np = find_devices("valkyrie");
665 if (np) 656 if (np)
666 of_platform_device_create(np, "valkyrie", NULL); 657 of_platform_device_create(np, "valkyrie", NULL);
667 np = find_devices("platinum"); 658 np = of_find_node_by_name(NULL, "platinum");
668 if (np) 659 if (np)
669 of_platform_device_create(np, "platinum", NULL); 660 of_platform_device_create(np, "platinum", NULL);
670 661 npp = of_find_node_by_name(NULL, "uni-n");
671 npp = of_find_node_by_name(NULL, "u3"); 662 if (npp == NULL)
663 npp = of_find_node_by_name(NULL, "u3");
664 if (npp == NULL)
665 npp = of_find_node_by_name(NULL, "u4");
672 if (npp) { 666 if (npp) {
673 for (np = NULL; (np = of_get_next_child(npp, np)) != NULL;) { 667 for (np = NULL; (np = of_get_next_child(npp, np)) != NULL;) {
674 if (strncmp(np->name, "i2c", 3) == 0) { 668 if (strncmp(np->name, "i2c", 3) == 0) {
675 of_platform_device_create(np, "u3-i2c", NULL); 669 of_platform_device_create(np, "uni-n-i2c",
670 NULL);
676 of_node_put(np); 671 of_node_put(np);
677 break; 672 break;
678 } 673 }
diff --git a/arch/powerpc/platforms/powermac/smp.c b/arch/powerpc/platforms/powermac/smp.c
index df01bb8feb16..ab72ba86be1e 100644
--- a/arch/powerpc/platforms/powermac/smp.c
+++ b/arch/powerpc/platforms/powermac/smp.c
@@ -482,7 +482,7 @@ static void __devinit smp_core99_take_timebase(void)
482/* 482/*
483 * G5s enable/disable the timebase via an i2c-connected clock chip. 483 * G5s enable/disable the timebase via an i2c-connected clock chip.
484 */ 484 */
485static struct device_node *pmac_tb_clock_chip_host; 485static struct pmac_i2c_bus *pmac_tb_clock_chip_host;
486static u8 pmac_tb_pulsar_addr; 486static u8 pmac_tb_pulsar_addr;
487 487
488static void smp_core99_cypress_tb_freeze(int freeze) 488static void smp_core99_cypress_tb_freeze(int freeze)
@@ -493,20 +493,20 @@ static void smp_core99_cypress_tb_freeze(int freeze)
493 /* Strangely, the device-tree says address is 0xd2, but darwin 493 /* Strangely, the device-tree says address is 0xd2, but darwin
494 * accesses 0xd0 ... 494 * accesses 0xd0 ...
495 */ 495 */
496 pmac_low_i2c_setmode(pmac_tb_clock_chip_host, 496 pmac_i2c_setmode(pmac_tb_clock_chip_host,
497 pmac_low_i2c_mode_combined); 497 pmac_i2c_mode_combined);
498 rc = pmac_low_i2c_xfer(pmac_tb_clock_chip_host, 498 rc = pmac_i2c_xfer(pmac_tb_clock_chip_host,
499 0xd0 | pmac_low_i2c_read, 499 0xd0 | pmac_i2c_read,
500 0x81, &data, 1); 500 1, 0x81, &data, 1);
501 if (rc != 0) 501 if (rc != 0)
502 goto bail; 502 goto bail;
503 503
504 data = (data & 0xf3) | (freeze ? 0x00 : 0x0c); 504 data = (data & 0xf3) | (freeze ? 0x00 : 0x0c);
505 505
506 pmac_low_i2c_setmode(pmac_tb_clock_chip_host, pmac_low_i2c_mode_stdsub); 506 pmac_i2c_setmode(pmac_tb_clock_chip_host, pmac_i2c_mode_stdsub);
507 rc = pmac_low_i2c_xfer(pmac_tb_clock_chip_host, 507 rc = pmac_i2c_xfer(pmac_tb_clock_chip_host,
508 0xd0 | pmac_low_i2c_write, 508 0xd0 | pmac_i2c_write,
509 0x81, &data, 1); 509 1, 0x81, &data, 1);
510 510
511 bail: 511 bail:
512 if (rc != 0) { 512 if (rc != 0) {
@@ -522,20 +522,20 @@ static void smp_core99_pulsar_tb_freeze(int freeze)
522 u8 data; 522 u8 data;
523 int rc; 523 int rc;
524 524
525 pmac_low_i2c_setmode(pmac_tb_clock_chip_host, 525 pmac_i2c_setmode(pmac_tb_clock_chip_host,
526 pmac_low_i2c_mode_combined); 526 pmac_i2c_mode_combined);
527 rc = pmac_low_i2c_xfer(pmac_tb_clock_chip_host, 527 rc = pmac_i2c_xfer(pmac_tb_clock_chip_host,
528 pmac_tb_pulsar_addr | pmac_low_i2c_read, 528 pmac_tb_pulsar_addr | pmac_i2c_read,
529 0x2e, &data, 1); 529 1, 0x2e, &data, 1);
530 if (rc != 0) 530 if (rc != 0)
531 goto bail; 531 goto bail;
532 532
533 data = (data & 0x88) | (freeze ? 0x11 : 0x22); 533 data = (data & 0x88) | (freeze ? 0x11 : 0x22);
534 534
535 pmac_low_i2c_setmode(pmac_tb_clock_chip_host, pmac_low_i2c_mode_stdsub); 535 pmac_i2c_setmode(pmac_tb_clock_chip_host, pmac_i2c_mode_stdsub);
536 rc = pmac_low_i2c_xfer(pmac_tb_clock_chip_host, 536 rc = pmac_i2c_xfer(pmac_tb_clock_chip_host,
537 pmac_tb_pulsar_addr | pmac_low_i2c_write, 537 pmac_tb_pulsar_addr | pmac_i2c_write,
538 0x2e, &data, 1); 538 1, 0x2e, &data, 1);
539 bail: 539 bail:
540 if (rc != 0) { 540 if (rc != 0) {
541 printk(KERN_ERR "Pulsar Timebase %s rc: %d\n", 541 printk(KERN_ERR "Pulsar Timebase %s rc: %d\n",
@@ -560,13 +560,15 @@ static void __init smp_core99_setup_i2c_hwsync(int ncpus)
560 if (!ok) 560 if (!ok)
561 continue; 561 continue;
562 562
563 pmac_tb_clock_chip_host = pmac_i2c_find_bus(cc);
564 if (pmac_tb_clock_chip_host == NULL)
565 continue;
563 reg = (u32 *)get_property(cc, "reg", NULL); 566 reg = (u32 *)get_property(cc, "reg", NULL);
564 if (reg == NULL) 567 if (reg == NULL)
565 continue; 568 continue;
566
567 switch (*reg) { 569 switch (*reg) {
568 case 0xd2: 570 case 0xd2:
569 if (device_is_compatible(cc, "pulsar-legacy-slewing")) { 571 if (device_is_compatible(cc,"pulsar-legacy-slewing")) {
570 pmac_tb_freeze = smp_core99_pulsar_tb_freeze; 572 pmac_tb_freeze = smp_core99_pulsar_tb_freeze;
571 pmac_tb_pulsar_addr = 0xd2; 573 pmac_tb_pulsar_addr = 0xd2;
572 name = "Pulsar"; 574 name = "Pulsar";
@@ -585,30 +587,19 @@ static void __init smp_core99_setup_i2c_hwsync(int ncpus)
585 break; 587 break;
586 } 588 }
587 if (pmac_tb_freeze != NULL) { 589 if (pmac_tb_freeze != NULL) {
588 struct device_node *p = of_get_parent(cc);
589 of_node_put(cc);
590 while(p && strcmp(p->type, "i2c")) {
591 cc = of_get_parent(p);
592 of_node_put(p);
593 p = cc;
594 }
595 if (p == NULL)
596 goto no_i2c_sync;
597 /* Open i2c bus for synchronous access */ 590 /* Open i2c bus for synchronous access */
598 if (pmac_low_i2c_open(p, 0)) { 591 if (pmac_i2c_open(pmac_tb_clock_chip_host, 1)) {
599 printk(KERN_ERR "Failed top open i2c bus %s for clock" 592 printk(KERN_ERR "Failed top open i2c bus for clock"
600 " sync, fallback to software sync !\n", 593 " sync, fallback to software sync !\n");
601 p->full_name);
602 of_node_put(p);
603 goto no_i2c_sync; 594 goto no_i2c_sync;
604 } 595 }
605 pmac_tb_clock_chip_host = p;
606 printk(KERN_INFO "Processor timebase sync using %s i2c clock\n", 596 printk(KERN_INFO "Processor timebase sync using %s i2c clock\n",
607 name); 597 name);
608 return; 598 return;
609 } 599 }
610 no_i2c_sync: 600 no_i2c_sync:
611 pmac_tb_freeze = NULL; 601 pmac_tb_freeze = NULL;
602 pmac_tb_clock_chip_host = NULL;
612} 603}
613 604
614#endif /* CONFIG_PPC64 */ 605#endif /* CONFIG_PPC64 */
@@ -752,8 +743,18 @@ static int __init smp_core99_probe(void)
752 if (ncpus <= 1) 743 if (ncpus <= 1)
753 return 1; 744 return 1;
754 745
746 /* We need to perform some early initialisations before we can start
747 * setting up SMP as we are running before initcalls
748 */
749 pmac_i2c_init();
750
751 /* Setup various bits like timebase sync method, ability to nap, ... */
755 smp_core99_setup(ncpus); 752 smp_core99_setup(ncpus);
753
754 /* Install IPIs */
756 mpic_request_ipis(); 755 mpic_request_ipis();
756
757 /* Collect l2cr and l3cr values from CPU 0 */
757 core99_init_caches(0); 758 core99_init_caches(0);
758 759
759 return ncpus; 760 return ncpus;
@@ -817,7 +818,7 @@ static void __devinit smp_core99_setup_cpu(int cpu_nr)
817 818
818 /* Close i2c bus if it was used for tb sync */ 819 /* Close i2c bus if it was used for tb sync */
819 if (pmac_tb_clock_chip_host) { 820 if (pmac_tb_clock_chip_host) {
820 pmac_low_i2c_close(pmac_tb_clock_chip_host); 821 pmac_i2c_close(pmac_tb_clock_chip_host);
821 pmac_tb_clock_chip_host = NULL; 822 pmac_tb_clock_chip_host = NULL;
822 } 823 }
823 824
diff --git a/drivers/i2c/busses/i2c-pmac-smu.c b/drivers/i2c/busses/i2c-pmac-smu.c
index bfefe7f7a53d..7d925be3fd4b 100644
--- a/drivers/i2c/busses/i2c-pmac-smu.c
+++ b/drivers/i2c/busses/i2c-pmac-smu.c
@@ -103,8 +103,8 @@ static s32 smu_smbus_xfer( struct i2c_adapter* adap,
103 cmd.info.subaddr[1] = 0; 103 cmd.info.subaddr[1] = 0;
104 cmd.info.subaddr[2] = 0; 104 cmd.info.subaddr[2] = 0;
105 if (!read) { 105 if (!read) {
106 cmd.info.data[0] = data->byte & 0xff; 106 cmd.info.data[0] = data->word & 0xff;
107 cmd.info.data[1] = (data->byte >> 8) & 0xff; 107 cmd.info.data[1] = (data->word >> 8) & 0xff;
108 } 108 }
109 break; 109 break;
110 /* Note that these are broken vs. the expected smbus API where 110 /* Note that these are broken vs. the expected smbus API where
@@ -116,7 +116,7 @@ static s32 smu_smbus_xfer( struct i2c_adapter* adap,
116 case I2C_SMBUS_BLOCK_DATA: 116 case I2C_SMBUS_BLOCK_DATA:
117 cmd.info.type = SMU_I2C_TRANSFER_STDSUB; 117 cmd.info.type = SMU_I2C_TRANSFER_STDSUB;
118 cmd.info.datalen = data->block[0] + 1; 118 cmd.info.datalen = data->block[0] + 1;
119 if (cmd.info.datalen > 6) 119 if (cmd.info.datalen > (SMU_I2C_WRITE_MAX + 1))
120 return -EINVAL; 120 return -EINVAL;
121 if (!read) 121 if (!read)
122 memcpy(cmd.info.data, data->block, cmd.info.datalen); 122 memcpy(cmd.info.data, data->block, cmd.info.datalen);
@@ -273,7 +273,13 @@ static int dispose_iface(struct device *dev)
273static int create_iface_of_platform(struct of_device* dev, 273static int create_iface_of_platform(struct of_device* dev,
274 const struct of_device_id *match) 274 const struct of_device_id *match)
275{ 275{
276 return create_iface(dev->node, &dev->dev); 276 struct device_node *node = dev->node;
277
278 if (device_is_compatible(node, "smu-i2c") ||
279 (node->parent != NULL &&
280 device_is_compatible(node->parent, "smu-i2c-control")))
281 return create_iface(node, &dev->dev);
282 return -ENODEV;
277} 283}
278 284
279 285
@@ -288,6 +294,9 @@ static struct of_device_id i2c_smu_match[] =
288 { 294 {
289 .compatible = "smu-i2c", 295 .compatible = "smu-i2c",
290 }, 296 },
297 {
298 .compatible = "i2c-bus",
299 },
291 {}, 300 {},
292}; 301};
293static struct of_platform_driver i2c_smu_of_platform_driver = 302static struct of_platform_driver i2c_smu_of_platform_driver =
diff --git a/drivers/macintosh/smu.c b/drivers/macintosh/smu.c
index 96226116a646..9ecd76849e35 100644
--- a/drivers/macintosh/smu.c
+++ b/drivers/macintosh/smu.c
@@ -94,6 +94,8 @@ struct smu_device {
94static struct smu_device *smu; 94static struct smu_device *smu;
95static DECLARE_MUTEX(smu_part_access); 95static DECLARE_MUTEX(smu_part_access);
96 96
97static void smu_i2c_retry(unsigned long data);
98
97/* 99/*
98 * SMU driver low level stuff 100 * SMU driver low level stuff
99 */ 101 */
@@ -469,7 +471,6 @@ int __init smu_init (void)
469 smu->of_node = np; 471 smu->of_node = np;
470 smu->db_irq = NO_IRQ; 472 smu->db_irq = NO_IRQ;
471 smu->msg_irq = NO_IRQ; 473 smu->msg_irq = NO_IRQ;
472 init_timer(&smu->i2c_timer);
473 474
474 /* smu_cmdbuf_abs is in the low 2G of RAM, can be converted to a 475 /* smu_cmdbuf_abs is in the low 2G of RAM, can be converted to a
475 * 32 bits value safely 476 * 32 bits value safely
@@ -544,6 +545,10 @@ static int smu_late_init(void)
544 if (!smu) 545 if (!smu)
545 return 0; 546 return 0;
546 547
548 init_timer(&smu->i2c_timer);
549 smu->i2c_timer.function = smu_i2c_retry;
550 smu->i2c_timer.data = (unsigned long)smu;
551
547 /* 552 /*
548 * Try to request the interrupts 553 * Try to request the interrupts
549 */ 554 */
@@ -570,28 +575,41 @@ static int smu_late_init(void)
570 575
571 return 0; 576 return 0;
572} 577}
573arch_initcall(smu_late_init); 578/* This has to be before arch_initcall as the low i2c stuff relies on the
579 * above having been done before we reach arch_initcalls
580 */
581core_initcall(smu_late_init);
574 582
575/* 583/*
576 * sysfs visibility 584 * sysfs visibility
577 */ 585 */
578 586
587static void smu_create_i2c(struct device_node *np)
588{
589 char name[32];
590 u32 *reg = (u32 *)get_property(np, "reg", NULL);
591
592 if (reg != NULL) {
593 sprintf(name, "smu-i2c-%02x", *reg);
594 of_platform_device_create(np, name, &smu->of_dev->dev);
595 }
596}
597
579static void smu_expose_childs(void *unused) 598static void smu_expose_childs(void *unused)
580{ 599{
581 struct device_node *np; 600 struct device_node *np, *gp;
582 601
583 for (np = NULL; (np = of_get_next_child(smu->of_node, np)) != NULL;) { 602 for (np = NULL; (np = of_get_next_child(smu->of_node, np)) != NULL;) {
584 if (device_is_compatible(np, "smu-i2c")) { 603 if (device_is_compatible(np, "smu-i2c-control")) {
585 char name[32]; 604 gp = NULL;
586 u32 *reg = (u32 *)get_property(np, "reg", NULL); 605 while ((gp = of_get_next_child(np, gp)) != NULL)
587 606 if (device_is_compatible(gp, "i2c-bus"))
588 if (reg == NULL) 607 smu_create_i2c(gp);
589 continue; 608 } else if (device_is_compatible(np, "smu-i2c"))
590 sprintf(name, "smu-i2c-%02x", *reg); 609 smu_create_i2c(np);
591 of_platform_device_create(np, name, &smu->of_dev->dev);
592 }
593 if (device_is_compatible(np, "smu-sensors")) 610 if (device_is_compatible(np, "smu-sensors"))
594 of_platform_device_create(np, "smu-sensors", &smu->of_dev->dev); 611 of_platform_device_create(np, "smu-sensors",
612 &smu->of_dev->dev);
595 } 613 }
596 614
597} 615}
@@ -712,13 +730,13 @@ static void smu_i2c_complete_command(struct smu_i2c_cmd *cmd, int fail)
712 730
713static void smu_i2c_retry(unsigned long data) 731static void smu_i2c_retry(unsigned long data)
714{ 732{
715 struct smu_i2c_cmd *cmd = (struct smu_i2c_cmd *)data; 733 struct smu_i2c_cmd *cmd = smu->cmd_i2c_cur;
716 734
717 DPRINTK("SMU: i2c failure, requeuing...\n"); 735 DPRINTK("SMU: i2c failure, requeuing...\n");
718 736
719 /* requeue command simply by resetting reply_len */ 737 /* requeue command simply by resetting reply_len */
720 cmd->pdata[0] = 0xff; 738 cmd->pdata[0] = 0xff;
721 cmd->scmd.reply_len = 0x10; 739 cmd->scmd.reply_len = sizeof(cmd->pdata);
722 smu_queue_cmd(&cmd->scmd); 740 smu_queue_cmd(&cmd->scmd);
723} 741}
724 742
@@ -747,10 +765,8 @@ static void smu_i2c_low_completion(struct smu_cmd *scmd, void *misc)
747 */ 765 */
748 if (fail && --cmd->retries > 0) { 766 if (fail && --cmd->retries > 0) {
749 DPRINTK("SMU: i2c failure, starting timer...\n"); 767 DPRINTK("SMU: i2c failure, starting timer...\n");
750 smu->i2c_timer.function = smu_i2c_retry; 768 BUG_ON(cmd != smu->cmd_i2c_cur);
751 smu->i2c_timer.data = (unsigned long)cmd; 769 mod_timer(&smu->i2c_timer, jiffies + msecs_to_jiffies(5));
752 smu->i2c_timer.expires = jiffies + msecs_to_jiffies(5);
753 add_timer(&smu->i2c_timer);
754 return; 770 return;
755 } 771 }
756 772
@@ -764,7 +780,7 @@ static void smu_i2c_low_completion(struct smu_cmd *scmd, void *misc)
764 780
765 /* Ok, initial command complete, now poll status */ 781 /* Ok, initial command complete, now poll status */
766 scmd->reply_buf = cmd->pdata; 782 scmd->reply_buf = cmd->pdata;
767 scmd->reply_len = 0x10; 783 scmd->reply_len = sizeof(cmd->pdata);
768 scmd->data_buf = cmd->pdata; 784 scmd->data_buf = cmd->pdata;
769 scmd->data_len = 1; 785 scmd->data_len = 1;
770 cmd->pdata[0] = 0; 786 cmd->pdata[0] = 0;
@@ -786,7 +802,7 @@ int smu_queue_i2c(struct smu_i2c_cmd *cmd)
786 cmd->scmd.done = smu_i2c_low_completion; 802 cmd->scmd.done = smu_i2c_low_completion;
787 cmd->scmd.misc = cmd; 803 cmd->scmd.misc = cmd;
788 cmd->scmd.reply_buf = cmd->pdata; 804 cmd->scmd.reply_buf = cmd->pdata;
789 cmd->scmd.reply_len = 0x10; 805 cmd->scmd.reply_len = sizeof(cmd->pdata);
790 cmd->scmd.data_buf = (u8 *)(char *)&cmd->info; 806 cmd->scmd.data_buf = (u8 *)(char *)&cmd->info;
791 cmd->scmd.status = 1; 807 cmd->scmd.status = 1;
792 cmd->stage = 0; 808 cmd->stage = 0;
diff --git a/drivers/macintosh/via-pmu.c b/drivers/macintosh/via-pmu.c
index 3c0552016b91..aa481a88ccab 100644
--- a/drivers/macintosh/via-pmu.c
+++ b/drivers/macintosh/via-pmu.c
@@ -197,7 +197,6 @@ static int pmu_adb_reset_bus(void);
197#endif /* CONFIG_ADB */ 197#endif /* CONFIG_ADB */
198 198
199static int init_pmu(void); 199static int init_pmu(void);
200static int pmu_queue_request(struct adb_request *req);
201static void pmu_start(void); 200static void pmu_start(void);
202static irqreturn_t via_pmu_interrupt(int irq, void *arg, struct pt_regs *regs); 201static irqreturn_t via_pmu_interrupt(int irq, void *arg, struct pt_regs *regs);
203static irqreturn_t gpio1_interrupt(int irq, void *arg, struct pt_regs *regs); 202static irqreturn_t gpio1_interrupt(int irq, void *arg, struct pt_regs *regs);
@@ -1802,258 +1801,6 @@ pmu_present(void)
1802 return via != 0; 1801 return via != 0;
1803} 1802}
1804 1803
1805struct pmu_i2c_hdr {
1806 u8 bus;
1807 u8 mode;
1808 u8 bus2;
1809 u8 address;
1810 u8 sub_addr;
1811 u8 comb_addr;
1812 u8 count;
1813};
1814
1815int
1816pmu_i2c_combined_read(int bus, int addr, int subaddr, u8* data, int len)
1817{
1818 struct adb_request req;
1819 struct pmu_i2c_hdr *hdr = (struct pmu_i2c_hdr *)&req.data[1];
1820 int retry;
1821 int rc;
1822
1823 for (retry=0; retry<16; retry++) {
1824 memset(&req, 0, sizeof(req));
1825
1826 hdr->bus = bus;
1827 hdr->address = addr & 0xfe;
1828 hdr->mode = PMU_I2C_MODE_COMBINED;
1829 hdr->bus2 = 0;
1830 hdr->sub_addr = subaddr;
1831 hdr->comb_addr = addr | 1;
1832 hdr->count = len;
1833
1834 req.nbytes = sizeof(struct pmu_i2c_hdr) + 1;
1835 req.reply_expected = 0;
1836 req.reply_len = 0;
1837 req.data[0] = PMU_I2C_CMD;
1838 req.reply[0] = 0xff;
1839 rc = pmu_queue_request(&req);
1840 if (rc)
1841 return rc;
1842 while(!req.complete)
1843 pmu_poll();
1844 if (req.reply[0] == PMU_I2C_STATUS_OK)
1845 break;
1846 mdelay(15);
1847 }
1848 if (req.reply[0] != PMU_I2C_STATUS_OK)
1849 return -1;
1850
1851 for (retry=0; retry<16; retry++) {
1852 memset(&req, 0, sizeof(req));
1853
1854 mdelay(15);
1855
1856 hdr->bus = PMU_I2C_BUS_STATUS;
1857 req.reply[0] = 0xff;
1858
1859 req.nbytes = 2;
1860 req.reply_expected = 0;
1861 req.reply_len = 0;
1862 req.data[0] = PMU_I2C_CMD;
1863 rc = pmu_queue_request(&req);
1864 if (rc)
1865 return rc;
1866 while(!req.complete)
1867 pmu_poll();
1868 if (req.reply[0] == PMU_I2C_STATUS_DATAREAD) {
1869 memcpy(data, &req.reply[1], req.reply_len - 1);
1870 return req.reply_len - 1;
1871 }
1872 }
1873 return -1;
1874}
1875
1876int
1877pmu_i2c_stdsub_write(int bus, int addr, int subaddr, u8* data, int len)
1878{
1879 struct adb_request req;
1880 struct pmu_i2c_hdr *hdr = (struct pmu_i2c_hdr *)&req.data[1];
1881 int retry;
1882 int rc;
1883
1884 for (retry=0; retry<16; retry++) {
1885 memset(&req, 0, sizeof(req));
1886
1887 hdr->bus = bus;
1888 hdr->address = addr & 0xfe;
1889 hdr->mode = PMU_I2C_MODE_STDSUB;
1890 hdr->bus2 = 0;
1891 hdr->sub_addr = subaddr;
1892 hdr->comb_addr = addr & 0xfe;
1893 hdr->count = len;
1894
1895 req.data[0] = PMU_I2C_CMD;
1896 memcpy(&req.data[sizeof(struct pmu_i2c_hdr) + 1], data, len);
1897 req.nbytes = sizeof(struct pmu_i2c_hdr) + len + 1;
1898 req.reply_expected = 0;
1899 req.reply_len = 0;
1900 req.reply[0] = 0xff;
1901 rc = pmu_queue_request(&req);
1902 if (rc)
1903 return rc;
1904 while(!req.complete)
1905 pmu_poll();
1906 if (req.reply[0] == PMU_I2C_STATUS_OK)
1907 break;
1908 mdelay(15);
1909 }
1910 if (req.reply[0] != PMU_I2C_STATUS_OK)
1911 return -1;
1912
1913 for (retry=0; retry<16; retry++) {
1914 memset(&req, 0, sizeof(req));
1915
1916 mdelay(15);
1917
1918 hdr->bus = PMU_I2C_BUS_STATUS;
1919 req.reply[0] = 0xff;
1920
1921 req.nbytes = 2;
1922 req.reply_expected = 0;
1923 req.reply_len = 0;
1924 req.data[0] = PMU_I2C_CMD;
1925 rc = pmu_queue_request(&req);
1926 if (rc)
1927 return rc;
1928 while(!req.complete)
1929 pmu_poll();
1930 if (req.reply[0] == PMU_I2C_STATUS_OK)
1931 return len;
1932 }
1933 return -1;
1934}
1935
1936int
1937pmu_i2c_simple_read(int bus, int addr, u8* data, int len)
1938{
1939 struct adb_request req;
1940 struct pmu_i2c_hdr *hdr = (struct pmu_i2c_hdr *)&req.data[1];
1941 int retry;
1942 int rc;
1943
1944 for (retry=0; retry<16; retry++) {
1945 memset(&req, 0, sizeof(req));
1946
1947 hdr->bus = bus;
1948 hdr->address = addr | 1;
1949 hdr->mode = PMU_I2C_MODE_SIMPLE;
1950 hdr->bus2 = 0;
1951 hdr->sub_addr = 0;
1952 hdr->comb_addr = 0;
1953 hdr->count = len;
1954
1955 req.data[0] = PMU_I2C_CMD;
1956 req.nbytes = sizeof(struct pmu_i2c_hdr) + 1;
1957 req.reply_expected = 0;
1958 req.reply_len = 0;
1959 req.reply[0] = 0xff;
1960 rc = pmu_queue_request(&req);
1961 if (rc)
1962 return rc;
1963 while(!req.complete)
1964 pmu_poll();
1965 if (req.reply[0] == PMU_I2C_STATUS_OK)
1966 break;
1967 mdelay(15);
1968 }
1969 if (req.reply[0] != PMU_I2C_STATUS_OK)
1970 return -1;
1971
1972 for (retry=0; retry<16; retry++) {
1973 memset(&req, 0, sizeof(req));
1974
1975 mdelay(15);
1976
1977 hdr->bus = PMU_I2C_BUS_STATUS;
1978 req.reply[0] = 0xff;
1979
1980 req.nbytes = 2;
1981 req.reply_expected = 0;
1982 req.reply_len = 0;
1983 req.data[0] = PMU_I2C_CMD;
1984 rc = pmu_queue_request(&req);
1985 if (rc)
1986 return rc;
1987 while(!req.complete)
1988 pmu_poll();
1989 if (req.reply[0] == PMU_I2C_STATUS_DATAREAD) {
1990 memcpy(data, &req.reply[1], req.reply_len - 1);
1991 return req.reply_len - 1;
1992 }
1993 }
1994 return -1;
1995}
1996
1997int
1998pmu_i2c_simple_write(int bus, int addr, u8* data, int len)
1999{
2000 struct adb_request req;
2001 struct pmu_i2c_hdr *hdr = (struct pmu_i2c_hdr *)&req.data[1];
2002 int retry;
2003 int rc;
2004
2005 for (retry=0; retry<16; retry++) {
2006 memset(&req, 0, sizeof(req));
2007
2008 hdr->bus = bus;
2009 hdr->address = addr & 0xfe;
2010 hdr->mode = PMU_I2C_MODE_SIMPLE;
2011 hdr->bus2 = 0;
2012 hdr->sub_addr = 0;
2013 hdr->comb_addr = 0;
2014 hdr->count = len;
2015
2016 req.data[0] = PMU_I2C_CMD;
2017 memcpy(&req.data[sizeof(struct pmu_i2c_hdr) + 1], data, len);
2018 req.nbytes = sizeof(struct pmu_i2c_hdr) + len + 1;
2019 req.reply_expected = 0;
2020 req.reply_len = 0;
2021 req.reply[0] = 0xff;
2022 rc = pmu_queue_request(&req);
2023 if (rc)
2024 return rc;
2025 while(!req.complete)
2026 pmu_poll();
2027 if (req.reply[0] == PMU_I2C_STATUS_OK)
2028 break;
2029 mdelay(15);
2030 }
2031 if (req.reply[0] != PMU_I2C_STATUS_OK)
2032 return -1;
2033
2034 for (retry=0; retry<16; retry++) {
2035 memset(&req, 0, sizeof(req));
2036
2037 mdelay(15);
2038
2039 hdr->bus = PMU_I2C_BUS_STATUS;
2040 req.reply[0] = 0xff;
2041
2042 req.nbytes = 2;
2043 req.reply_expected = 0;
2044 req.reply_len = 0;
2045 req.data[0] = PMU_I2C_CMD;
2046 rc = pmu_queue_request(&req);
2047 if (rc)
2048 return rc;
2049 while(!req.complete)
2050 pmu_poll();
2051 if (req.reply[0] == PMU_I2C_STATUS_OK)
2052 return len;
2053 }
2054 return -1;
2055}
2056
2057#ifdef CONFIG_PM 1804#ifdef CONFIG_PM
2058 1805
2059static LIST_HEAD(sleep_notifiers); 1806static LIST_HEAD(sleep_notifiers);
@@ -2358,9 +2105,6 @@ pmac_suspend_devices(void)
2358 return -EBUSY; 2105 return -EBUSY;
2359 } 2106 }
2360 2107
2361 /* Disable clock spreading on some machines */
2362 pmac_tweak_clock_spreading(0);
2363
2364 /* Stop preemption */ 2108 /* Stop preemption */
2365 preempt_disable(); 2109 preempt_disable();
2366 2110
@@ -2431,9 +2175,6 @@ pmac_wakeup_devices(void)
2431 mdelay(10); 2175 mdelay(10);
2432 preempt_enable(); 2176 preempt_enable();
2433 2177
2434 /* Re-enable clock spreading on some machines */
2435 pmac_tweak_clock_spreading(1);
2436
2437 /* Resume devices */ 2178 /* Resume devices */
2438 device_resume(); 2179 device_resume();
2439 2180
@@ -3150,16 +2891,13 @@ static int __init init_pmu_sysfs(void)
3150subsys_initcall(init_pmu_sysfs); 2891subsys_initcall(init_pmu_sysfs);
3151 2892
3152EXPORT_SYMBOL(pmu_request); 2893EXPORT_SYMBOL(pmu_request);
2894EXPORT_SYMBOL(pmu_queue_request);
3153EXPORT_SYMBOL(pmu_poll); 2895EXPORT_SYMBOL(pmu_poll);
3154EXPORT_SYMBOL(pmu_poll_adb); 2896EXPORT_SYMBOL(pmu_poll_adb);
3155EXPORT_SYMBOL(pmu_wait_complete); 2897EXPORT_SYMBOL(pmu_wait_complete);
3156EXPORT_SYMBOL(pmu_suspend); 2898EXPORT_SYMBOL(pmu_suspend);
3157EXPORT_SYMBOL(pmu_resume); 2899EXPORT_SYMBOL(pmu_resume);
3158EXPORT_SYMBOL(pmu_unlock); 2900EXPORT_SYMBOL(pmu_unlock);
3159EXPORT_SYMBOL(pmu_i2c_combined_read);
3160EXPORT_SYMBOL(pmu_i2c_stdsub_write);
3161EXPORT_SYMBOL(pmu_i2c_simple_read);
3162EXPORT_SYMBOL(pmu_i2c_simple_write);
3163#if defined(CONFIG_PM) && defined(CONFIG_PPC32) 2901#if defined(CONFIG_PM) && defined(CONFIG_PPC32)
3164EXPORT_SYMBOL(pmu_enable_irled); 2902EXPORT_SYMBOL(pmu_enable_irled);
3165EXPORT_SYMBOL(pmu_battery_count); 2903EXPORT_SYMBOL(pmu_battery_count);
diff --git a/include/asm-powerpc/pmac_feature.h b/include/asm-powerpc/pmac_feature.h
index f6997ed5179e..e654ad0e5b42 100644
--- a/include/asm-powerpc/pmac_feature.h
+++ b/include/asm-powerpc/pmac_feature.h
@@ -318,10 +318,6 @@ extern void pmac_register_agp_pm(struct pci_dev *bridge,
318extern void pmac_suspend_agp_for_card(struct pci_dev *dev); 318extern void pmac_suspend_agp_for_card(struct pci_dev *dev);
319extern void pmac_resume_agp_for_card(struct pci_dev *dev); 319extern void pmac_resume_agp_for_card(struct pci_dev *dev);
320 320
321/* Used by the via-pmu driver for suspend/resume
322 */
323extern void pmac_tweak_clock_spreading(int enable);
324
325/* 321/*
326 * The part below is for use by macio_asic.c only, do not rely 322 * The part below is for use by macio_asic.c only, do not rely
327 * on the data structures or constants below in a normal driver 323 * on the data structures or constants below in a normal driver
diff --git a/include/asm-powerpc/pmac_low_i2c.h b/include/asm-powerpc/pmac_low_i2c.h
index 3fb8d51540dd..adf4fa956572 100644
--- a/include/asm-powerpc/pmac_low_i2c.h
+++ b/include/asm-powerpc/pmac_low_i2c.h
@@ -15,30 +15,87 @@
15 15
16/* i2c mode (based on the platform functions format) */ 16/* i2c mode (based on the platform functions format) */
17enum { 17enum {
18 pmac_low_i2c_mode_dumb = 1, 18 pmac_i2c_mode_dumb = 1,
19 pmac_low_i2c_mode_std = 2, 19 pmac_i2c_mode_std = 2,
20 pmac_low_i2c_mode_stdsub = 3, 20 pmac_i2c_mode_stdsub = 3,
21 pmac_low_i2c_mode_combined = 4, 21 pmac_i2c_mode_combined = 4,
22}; 22};
23 23
24/* RW bit in address */ 24/* RW bit in address */
25enum { 25enum {
26 pmac_low_i2c_read = 0x01, 26 pmac_i2c_read = 0x01,
27 pmac_low_i2c_write = 0x00 27 pmac_i2c_write = 0x00
28}; 28};
29 29
30/* i2c bus type */
31enum {
32 pmac_i2c_bus_keywest = 0,
33 pmac_i2c_bus_pmu = 1,
34 pmac_i2c_bus_smu = 2,
35};
36
37/* i2c bus features */
38enum {
39 /* can_largesub : supports >1 byte subaddresses (SMU only) */
40 pmac_i2c_can_largesub = 0x00000001u,
41
42 /* multibus : device node holds multiple busses, bus number is
43 * encoded in bits 0xff00 of "reg" of a given device
44 */
45 pmac_i2c_multibus = 0x00000002u,
46};
47
48/* i2c busses in the system */
49struct pmac_i2c_bus;
50struct i2c_adapter;
51
30/* Init, called early during boot */ 52/* Init, called early during boot */
31extern void pmac_init_low_i2c(void); 53extern int pmac_i2c_init(void);
54
55/* Lookup an i2c bus for a device-node. The node can be either the bus
56 * node itself or a device below it. In the case of a multibus, the bus
57 * node itself is the controller node, else, it's a child of the controller
58 * node
59 */
60extern struct pmac_i2c_bus *pmac_i2c_find_bus(struct device_node *node);
61
62/* Get the address for an i2c device. This strips the bus number if
63 * necessary. The 7 bits address is returned 1 bit right shifted so that the
64 * direction can be directly ored in
65 */
66extern u8 pmac_i2c_get_dev_addr(struct device_node *device);
67
68/* Get infos about a bus */
69extern struct device_node *pmac_i2c_get_controller(struct pmac_i2c_bus *bus);
70extern struct device_node *pmac_i2c_get_bus_node(struct pmac_i2c_bus *bus);
71extern int pmac_i2c_get_type(struct pmac_i2c_bus *bus);
72extern int pmac_i2c_get_flags(struct pmac_i2c_bus *bus);
73
74/* i2c layer adapter attach/detach */
75extern void pmac_i2c_attach_adapter(struct pmac_i2c_bus *bus,
76 struct i2c_adapter *adapter);
77extern void pmac_i2c_detach_adapter(struct pmac_i2c_bus *bus,
78 struct i2c_adapter *adapter);
79extern struct i2c_adapter *pmac_i2c_get_adapter(struct pmac_i2c_bus *bus);
80
81/* March a device or bus with an i2c adapter structure, to be used by drivers
82 * to match device-tree nodes with i2c adapters during adapter discovery
83 * callbacks
84 */
85extern int pmac_i2c_match_adapter(struct device_node *dev,
86 struct i2c_adapter *adapter);
87
32 88
33/* Locking functions exposed to i2c-keywest */ 89/* (legacy) Locking functions exposed to i2c-keywest */
34int pmac_low_i2c_lock(struct device_node *np); 90extern int pmac_low_i2c_lock(struct device_node *np);
35int pmac_low_i2c_unlock(struct device_node *np); 91extern int pmac_low_i2c_unlock(struct device_node *np);
36 92
37/* Access functions for platform code */ 93/* Access functions for platform code */
38int pmac_low_i2c_open(struct device_node *np, int channel); 94extern int pmac_i2c_open(struct pmac_i2c_bus *bus, int polled);
39int pmac_low_i2c_close(struct device_node *np); 95extern void pmac_i2c_close(struct pmac_i2c_bus *bus);
40int pmac_low_i2c_setmode(struct device_node *np, int mode); 96extern int pmac_i2c_setmode(struct pmac_i2c_bus *bus, int mode);
41int pmac_low_i2c_xfer(struct device_node *np, u8 addrdir, u8 subaddr, u8 *data, int len); 97extern int pmac_i2c_xfer(struct pmac_i2c_bus *bus, u8 addrdir, int subsize,
98 u32 subaddr, u8 *data, int len);
42 99
43 100
44#endif /* __KERNEL__ */ 101#endif /* __KERNEL__ */
diff --git a/include/asm-powerpc/smu.h b/include/asm-powerpc/smu.h
index 7fae3ce9a8c1..134c2b5be0f2 100644
--- a/include/asm-powerpc/smu.h
+++ b/include/asm-powerpc/smu.h
@@ -358,6 +358,9 @@ extern unsigned long smu_cmdbuf_abs;
358 * Kenrel asynchronous i2c interface 358 * Kenrel asynchronous i2c interface
359 */ 359 */
360 360
361#define SMU_I2C_READ_MAX 0x1d
362#define SMU_I2C_WRITE_MAX 0x15
363
361/* SMU i2c header, exactly matches i2c header on wire */ 364/* SMU i2c header, exactly matches i2c header on wire */
362struct smu_i2c_param 365struct smu_i2c_param
363{ 366{
@@ -368,12 +371,9 @@ struct smu_i2c_param
368 u8 subaddr[3]; /* subaddress */ 371 u8 subaddr[3]; /* subaddress */
369 u8 caddr; /* combined address, filled by SMU driver */ 372 u8 caddr; /* combined address, filled by SMU driver */
370 u8 datalen; /* length of transfer */ 373 u8 datalen; /* length of transfer */
371 u8 data[7]; /* data */ 374 u8 data[SMU_I2C_READ_MAX]; /* data */
372}; 375};
373 376
374#define SMU_I2C_READ_MAX 0x0d
375#define SMU_I2C_WRITE_MAX 0x05
376
377struct smu_i2c_cmd 377struct smu_i2c_cmd
378{ 378{
379 /* public */ 379 /* public */
@@ -387,7 +387,7 @@ struct smu_i2c_cmd
387 int read; 387 int read;
388 int stage; 388 int stage;
389 int retries; 389 int retries;
390 u8 pdata[0x10]; 390 u8 pdata[32];
391 struct list_head link; 391 struct list_head link;
392}; 392};
393 393
@@ -519,7 +519,7 @@ struct smu_sdbp_cpupiddata {
519 * if not found. The data format is described below 519 * if not found. The data format is described below
520 */ 520 */
521extern struct smu_sdbp_header *smu_get_sdb_partition(int id, 521extern struct smu_sdbp_header *smu_get_sdb_partition(int id,
522 unsigned int *size); 522 unsigned int *size);
523 523
524#endif /* __KERNEL__ */ 524#endif /* __KERNEL__ */
525 525
diff --git a/include/linux/pmu.h b/include/linux/pmu.h
index 373bd3b9b330..217d3daf7336 100644
--- a/include/linux/pmu.h
+++ b/include/linux/pmu.h
@@ -140,7 +140,7 @@ extern int find_via_pmu(void);
140 140
141extern int pmu_request(struct adb_request *req, 141extern int pmu_request(struct adb_request *req,
142 void (*done)(struct adb_request *), int nbytes, ...); 142 void (*done)(struct adb_request *), int nbytes, ...);
143 143extern int pmu_queue_request(struct adb_request *req);
144extern void pmu_poll(void); 144extern void pmu_poll(void);
145extern void pmu_poll_adb(void); /* For use by xmon */ 145extern void pmu_poll_adb(void); /* For use by xmon */
146extern void pmu_wait_complete(struct adb_request *req); 146extern void pmu_wait_complete(struct adb_request *req);
@@ -160,12 +160,6 @@ extern void pmu_unlock(void);
160extern int pmu_present(void); 160extern int pmu_present(void);
161extern int pmu_get_model(void); 161extern int pmu_get_model(void);
162 162
163extern int pmu_i2c_combined_read(int bus, int addr, int subaddr, u8* data, int len);
164extern int pmu_i2c_stdsub_write(int bus, int addr, int subaddr, u8* data, int len);
165extern int pmu_i2c_simple_read(int bus, int addr, u8* data, int len);
166extern int pmu_i2c_simple_write(int bus, int addr, u8* data, int len);
167
168
169#ifdef CONFIG_PM 163#ifdef CONFIG_PM
170/* 164/*
171 * Stuff for putting the powerbook to sleep and waking it again. 165 * Stuff for putting the powerbook to sleep and waking it again.
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-19 03:15:52 -0500