aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/feature-removal-schedule.txt3
-rw-r--r--Documentation/i2c/busses/i2c-nforce212
-rw-r--r--Documentation/i2c/busses/i2c-piix42
-rw-r--r--Documentation/i2c/instantiating-devices167
-rw-r--r--Documentation/i2c/writing-clients19
-rw-r--r--arch/sh/boards/board-sh7785lcr.c2
-rw-r--r--drivers/i2c/algos/i2c-algo-bit.c4
-rw-r--r--drivers/i2c/algos/i2c-algo-pca.c250
-rw-r--r--drivers/i2c/algos/i2c-algo-pcf.c261
-rw-r--r--drivers/i2c/busses/Kconfig9
-rw-r--r--drivers/i2c/busses/i2c-davinci.c8
-rw-r--r--drivers/i2c/busses/i2c-ibm_iic.c6
-rw-r--r--drivers/i2c/busses/i2c-iop3xx.c2
-rw-r--r--drivers/i2c/busses/i2c-mpc.c4
-rw-r--r--drivers/i2c/busses/i2c-mv64xxx.c7
-rw-r--r--drivers/i2c/busses/i2c-nforce2.c12
-rw-r--r--drivers/i2c/busses/i2c-pca-isa.c39
-rw-r--r--drivers/i2c/busses/i2c-pca-platform.c48
-rw-r--r--drivers/i2c/busses/i2c-piix4.c77
-rw-r--r--drivers/i2c/busses/i2c-powermac.c3
-rw-r--r--drivers/i2c/busses/i2c-pxa.c9
-rw-r--r--drivers/i2c/i2c-core.c36
-rw-r--r--drivers/misc/eeprom/Kconfig2
-rw-r--r--include/linux/i2c-algo-pca.h33
-rw-r--r--include/linux/i2c-pca-platform.h2
-rw-r--r--include/linux/pci_ids.h5
26 files changed, 746 insertions, 276 deletions
diff --git a/Documentation/feature-removal-schedule.txt b/Documentation/feature-removal-schedule.txt
index 02ea3773535e..7907586c6e08 100644
--- a/Documentation/feature-removal-schedule.txt
+++ b/Documentation/feature-removal-schedule.txt
@@ -340,7 +340,8 @@ Who: Krzysztof Piotr Oledzki <ole@ans.pl>
340--------------------------- 340---------------------------
341 341
342What: i2c_attach_client(), i2c_detach_client(), i2c_driver->detach_client() 342What: i2c_attach_client(), i2c_detach_client(), i2c_driver->detach_client()
343When: 2.6.29 (ideally) or 2.6.30 (more likely) 343When: 2.6.30
344Check: i2c_attach_client i2c_detach_client
344Why: Deprecated by the new (standard) device driver binding model. Use 345Why: Deprecated by the new (standard) device driver binding model. Use
345 i2c_driver->probe() and ->remove() instead. 346 i2c_driver->probe() and ->remove() instead.
346Who: Jean Delvare <khali@linux-fr.org> 347Who: Jean Delvare <khali@linux-fr.org>
diff --git a/Documentation/i2c/busses/i2c-nforce2 b/Documentation/i2c/busses/i2c-nforce2
index fae3495bcbaf..9698c396b830 100644
--- a/Documentation/i2c/busses/i2c-nforce2
+++ b/Documentation/i2c/busses/i2c-nforce2
@@ -7,10 +7,14 @@ Supported adapters:
7 * nForce3 250Gb MCP 10de:00E4 7 * nForce3 250Gb MCP 10de:00E4
8 * nForce4 MCP 10de:0052 8 * nForce4 MCP 10de:0052
9 * nForce4 MCP-04 10de:0034 9 * nForce4 MCP-04 10de:0034
10 * nForce4 MCP51 10de:0264 10 * nForce MCP51 10de:0264
11 * nForce4 MCP55 10de:0368 11 * nForce MCP55 10de:0368
12 * nForce4 MCP61 10de:03EB 12 * nForce MCP61 10de:03EB
13 * nForce4 MCP65 10de:0446 13 * nForce MCP65 10de:0446
14 * nForce MCP67 10de:0542
15 * nForce MCP73 10de:07D8
16 * nForce MCP78S 10de:0752
17 * nForce MCP79 10de:0AA2
14 18
15Datasheet: not publicly available, but seems to be similar to the 19Datasheet: not publicly available, but seems to be similar to the
16 AMD-8111 SMBus 2.0 adapter. 20 AMD-8111 SMBus 2.0 adapter.
diff --git a/Documentation/i2c/busses/i2c-piix4 b/Documentation/i2c/busses/i2c-piix4
index ef1efa79b1df..f889481762b5 100644
--- a/Documentation/i2c/busses/i2c-piix4
+++ b/Documentation/i2c/busses/i2c-piix4
@@ -4,7 +4,7 @@ Supported adapters:
4 * Intel 82371AB PIIX4 and PIIX4E 4 * Intel 82371AB PIIX4 and PIIX4E
5 * Intel 82443MX (440MX) 5 * Intel 82443MX (440MX)
6 Datasheet: Publicly available at the Intel website 6 Datasheet: Publicly available at the Intel website
7 * ServerWorks OSB4, CSB5, CSB6 and HT-1000 southbridges 7 * ServerWorks OSB4, CSB5, CSB6, HT-1000 and HT-1100 southbridges
8 Datasheet: Only available via NDA from ServerWorks 8 Datasheet: Only available via NDA from ServerWorks
9 * ATI IXP200, IXP300, IXP400, SB600, SB700 and SB800 southbridges 9 * ATI IXP200, IXP300, IXP400, SB600, SB700 and SB800 southbridges
10 Datasheet: Not publicly available 10 Datasheet: Not publicly available
diff --git a/Documentation/i2c/instantiating-devices b/Documentation/i2c/instantiating-devices
new file mode 100644
index 000000000000..b55ce57a84db
--- /dev/null
+++ b/Documentation/i2c/instantiating-devices
@@ -0,0 +1,167 @@
1How to instantiate I2C devices
2==============================
3
4Unlike PCI or USB devices, I2C devices are not enumerated at the hardware
5level. Instead, the software must know which devices are connected on each
6I2C bus segment, and what address these devices are using. For this
7reason, the kernel code must instantiate I2C devices explicitly. There are
8several ways to achieve this, depending on the context and requirements.
9
10
11Method 1: Declare the I2C devices by bus number
12-----------------------------------------------
13
14This method is appropriate when the I2C bus is a system bus as is the case
15for many embedded systems. On such systems, each I2C bus has a number
16which is known in advance. It is thus possible to pre-declare the I2C
17devices which live on this bus. This is done with an array of struct
18i2c_board_info which is registered by calling i2c_register_board_info().
19
20Example (from omap2 h4):
21
22static struct i2c_board_info __initdata h4_i2c_board_info[] = {
23 {
24 I2C_BOARD_INFO("isp1301_omap", 0x2d),
25 .irq = OMAP_GPIO_IRQ(125),
26 },
27 { /* EEPROM on mainboard */
28 I2C_BOARD_INFO("24c01", 0x52),
29 .platform_data = &m24c01,
30 },
31 { /* EEPROM on cpu card */
32 I2C_BOARD_INFO("24c01", 0x57),
33 .platform_data = &m24c01,
34 },
35};
36
37static void __init omap_h4_init(void)
38{
39 (...)
40 i2c_register_board_info(1, h4_i2c_board_info,
41 ARRAY_SIZE(h4_i2c_board_info));
42 (...)
43}
44
45The above code declares 3 devices on I2C bus 1, including their respective
46addresses and custom data needed by their drivers. When the I2C bus in
47question is registered, the I2C devices will be instantiated automatically
48by i2c-core.
49
50The devices will be automatically unbound and destroyed when the I2C bus
51they sit on goes away (if ever.)
52
53
54Method 2: Instantiate the devices explicitly
55--------------------------------------------
56
57This method is appropriate when a larger device uses an I2C bus for
58internal communication. A typical case is TV adapters. These can have a
59tuner, a video decoder, an audio decoder, etc. usually connected to the
60main chip by the means of an I2C bus. You won't know the number of the I2C
61bus in advance, so the method 1 described above can't be used. Instead,
62you can instantiate your I2C devices explicitly. This is done by filling
63a struct i2c_board_info and calling i2c_new_device().
64
65Example (from the sfe4001 network driver):
66
67static struct i2c_board_info sfe4001_hwmon_info = {
68 I2C_BOARD_INFO("max6647", 0x4e),
69};
70
71int sfe4001_init(struct efx_nic *efx)
72{
73 (...)
74 efx->board_info.hwmon_client =
75 i2c_new_device(&efx->i2c_adap, &sfe4001_hwmon_info);
76
77 (...)
78}
79
80The above code instantiates 1 I2C device on the I2C bus which is on the
81network adapter in question.
82
83A variant of this is when you don't know for sure if an I2C device is
84present or not (for example for an optional feature which is not present
85on cheap variants of a board but you have no way to tell them apart), or
86it may have different addresses from one board to the next (manufacturer
87changing its design without notice). In this case, you can call
88i2c_new_probed_device() instead of i2c_new_device().
89
90Example (from the pnx4008 OHCI driver):
91
92static const unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END };
93
94static int __devinit usb_hcd_pnx4008_probe(struct platform_device *pdev)
95{
96 (...)
97 struct i2c_adapter *i2c_adap;
98 struct i2c_board_info i2c_info;
99
100 (...)
101 i2c_adap = i2c_get_adapter(2);
102 memset(&i2c_info, 0, sizeof(struct i2c_board_info));
103 strlcpy(i2c_info.name, "isp1301_pnx", I2C_NAME_SIZE);
104 isp1301_i2c_client = i2c_new_probed_device(i2c_adap, &i2c_info,
105 normal_i2c);
106 i2c_put_adapter(i2c_adap);
107 (...)
108}
109
110The above code instantiates up to 1 I2C device on the I2C bus which is on
111the OHCI adapter in question. It first tries at address 0x2c, if nothing
112is found there it tries address 0x2d, and if still nothing is found, it
113simply gives up.
114
115The driver which instantiated the I2C device is responsible for destroying
116it on cleanup. This is done by calling i2c_unregister_device() on the
117pointer that was earlier returned by i2c_new_device() or
118i2c_new_probed_device().
119
120
121Method 3: Probe an I2C bus for certain devices
122----------------------------------------------
123
124Sometimes you do not have enough information about an I2C device, not even
125to call i2c_new_probed_device(). The typical case is hardware monitoring
126chips on PC mainboards. There are several dozen models, which can live
127at 25 different addresses. Given the huge number of mainboards out there,
128it is next to impossible to build an exhaustive list of the hardware
129monitoring chips being used. Fortunately, most of these chips have
130manufacturer and device ID registers, so they can be identified by
131probing.
132
133In that case, I2C devices are neither declared nor instantiated
134explicitly. Instead, i2c-core will probe for such devices as soon as their
135drivers are loaded, and if any is found, an I2C device will be
136instantiated automatically. In order to prevent any misbehavior of this
137mechanism, the following restrictions apply:
138* The I2C device driver must implement the detect() method, which
139 identifies a supported device by reading from arbitrary registers.
140* Only buses which are likely to have a supported device and agree to be
141 probed, will be probed. For example this avoids probing for hardware
142 monitoring chips on a TV adapter.
143
144Example:
145See lm90_driver and lm90_detect() in drivers/hwmon/lm90.c
146
147I2C devices instantiated as a result of such a successful probe will be
148destroyed automatically when the driver which detected them is removed,
149or when the underlying I2C bus is itself destroyed, whichever happens
150first.
151
152Those of you familiar with the i2c subsystem of 2.4 kernels and early 2.6
153kernels will find out that this method 3 is essentially similar to what
154was done there. Two significant differences are:
155* Probing is only one way to instantiate I2C devices now, while it was the
156 only way back then. Where possible, methods 1 and 2 should be preferred.
157 Method 3 should only be used when there is no other way, as it can have
158 undesirable side effects.
159* I2C buses must now explicitly say which I2C driver classes can probe
160 them (by the means of the class bitfield), while all I2C buses were
161 probed by default back then. The default is an empty class which means
162 that no probing happens. The purpose of the class bitfield is to limit
163 the aforementioned undesirable side effects.
164
165Once again, method 3 should be avoided wherever possible. Explicit device
166instantiation (methods 1 and 2) is much preferred for it is safer and
167faster.
diff --git a/Documentation/i2c/writing-clients b/Documentation/i2c/writing-clients
index 6b9af7d479c2..c1a06f989cf7 100644
--- a/Documentation/i2c/writing-clients
+++ b/Documentation/i2c/writing-clients
@@ -207,15 +207,26 @@ You simply have to define a detect callback which will attempt to
207identify supported devices (returning 0 for supported ones and -ENODEV 207identify supported devices (returning 0 for supported ones and -ENODEV
208for unsupported ones), a list of addresses to probe, and a device type 208for unsupported ones), a list of addresses to probe, and a device type
209(or class) so that only I2C buses which may have that type of device 209(or class) so that only I2C buses which may have that type of device
210connected (and not otherwise enumerated) will be probed. The i2c 210connected (and not otherwise enumerated) will be probed. For example,
211core will then call you back as needed and will instantiate a device 211a driver for a hardware monitoring chip for which auto-detection is
212for you for every successful detection. 212needed would set its class to I2C_CLASS_HWMON, and only I2C adapters
213with a class including I2C_CLASS_HWMON would be probed by this driver.
214Note that the absence of matching classes does not prevent the use of
215a device of that type on the given I2C adapter. All it prevents is
216auto-detection; explicit instantiation of devices is still possible.
213 217
214Note that this mechanism is purely optional and not suitable for all 218Note that this mechanism is purely optional and not suitable for all
215devices. You need some reliable way to identify the supported devices 219devices. You need some reliable way to identify the supported devices
216(typically using device-specific, dedicated identification registers), 220(typically using device-specific, dedicated identification registers),
217otherwise misdetections are likely to occur and things can get wrong 221otherwise misdetections are likely to occur and things can get wrong
218quickly. 222quickly. Keep in mind that the I2C protocol doesn't include any
223standard way to detect the presence of a chip at a given address, let
224alone a standard way to identify devices. Even worse is the lack of
225semantics associated to bus transfers, which means that the same
226transfer can be seen as a read operation by a chip and as a write
227operation by another chip. For these reasons, explicit device
228instantiation should always be preferred to auto-detection where
229possible.
219 230
220 231
221Device Deletion 232Device Deletion
diff --git a/arch/sh/boards/board-sh7785lcr.c b/arch/sh/boards/board-sh7785lcr.c
index 94c0296bc35d..6f94f17adc46 100644
--- a/arch/sh/boards/board-sh7785lcr.c
+++ b/arch/sh/boards/board-sh7785lcr.c
@@ -229,7 +229,7 @@ static struct resource i2c_resources[] = {
229static struct i2c_pca9564_pf_platform_data i2c_platform_data = { 229static struct i2c_pca9564_pf_platform_data i2c_platform_data = {
230 .gpio = 0, 230 .gpio = 0,
231 .i2c_clock_speed = I2C_PCA_CON_330kHz, 231 .i2c_clock_speed = I2C_PCA_CON_330kHz,
232 .timeout = 100, 232 .timeout = HZ,
233}; 233};
234 234
235static struct platform_device i2c_device = { 235static struct platform_device i2c_device = {
diff --git a/drivers/i2c/algos/i2c-algo-bit.c b/drivers/i2c/algos/i2c-algo-bit.c
index eb8f72ca02f4..d420cc5f5633 100644
--- a/drivers/i2c/algos/i2c-algo-bit.c
+++ b/drivers/i2c/algos/i2c-algo-bit.c
@@ -604,9 +604,7 @@ static int i2c_bit_prepare_bus(struct i2c_adapter *adap)
604 604
605 /* register new adapter to i2c module... */ 605 /* register new adapter to i2c module... */
606 adap->algo = &i2c_bit_algo; 606 adap->algo = &i2c_bit_algo;
607 607 adap->retries = 3;
608 adap->timeout = 100; /* default values, should */
609 adap->retries = 3; /* be replaced by defines */
610 608
611 return 0; 609 return 0;
612} 610}
diff --git a/drivers/i2c/algos/i2c-algo-pca.c b/drivers/i2c/algos/i2c-algo-pca.c
index d50b329a3c94..f68e5f8e23ee 100644
--- a/drivers/i2c/algos/i2c-algo-pca.c
+++ b/drivers/i2c/algos/i2c-algo-pca.c
@@ -22,14 +22,18 @@
22#include <linux/module.h> 22#include <linux/module.h>
23#include <linux/moduleparam.h> 23#include <linux/moduleparam.h>
24#include <linux/delay.h> 24#include <linux/delay.h>
25#include <linux/jiffies.h>
25#include <linux/init.h> 26#include <linux/init.h>
26#include <linux/errno.h> 27#include <linux/errno.h>
27#include <linux/i2c.h> 28#include <linux/i2c.h>
28#include <linux/i2c-algo-pca.h> 29#include <linux/i2c-algo-pca.h>
29 30
30#define DEB1(fmt, args...) do { if (i2c_debug>=1) printk(fmt, ## args); } while(0) 31#define DEB1(fmt, args...) do { if (i2c_debug >= 1) \
31#define DEB2(fmt, args...) do { if (i2c_debug>=2) printk(fmt, ## args); } while(0) 32 printk(KERN_DEBUG fmt, ## args); } while (0)
32#define DEB3(fmt, args...) do { if (i2c_debug>=3) printk(fmt, ## args); } while(0) 33#define DEB2(fmt, args...) do { if (i2c_debug >= 2) \
34 printk(KERN_DEBUG fmt, ## args); } while (0)
35#define DEB3(fmt, args...) do { if (i2c_debug >= 3) \
36 printk(KERN_DEBUG fmt, ## args); } while (0)
33 37
34static int i2c_debug; 38static int i2c_debug;
35 39
@@ -43,19 +47,27 @@ static int i2c_debug;
43#define pca_wait(adap) adap->wait_for_completion(adap->data) 47#define pca_wait(adap) adap->wait_for_completion(adap->data)
44#define pca_reset(adap) adap->reset_chip(adap->data) 48#define pca_reset(adap) adap->reset_chip(adap->data)
45 49
50static void pca9665_reset(void *pd)
51{
52 struct i2c_algo_pca_data *adap = pd;
53 pca_outw(adap, I2C_PCA_INDPTR, I2C_PCA_IPRESET);
54 pca_outw(adap, I2C_PCA_IND, 0xA5);
55 pca_outw(adap, I2C_PCA_IND, 0x5A);
56}
57
46/* 58/*
47 * Generate a start condition on the i2c bus. 59 * Generate a start condition on the i2c bus.
48 * 60 *
49 * returns after the start condition has occurred 61 * returns after the start condition has occurred
50 */ 62 */
51static void pca_start(struct i2c_algo_pca_data *adap) 63static int pca_start(struct i2c_algo_pca_data *adap)
52{ 64{
53 int sta = pca_get_con(adap); 65 int sta = pca_get_con(adap);
54 DEB2("=== START\n"); 66 DEB2("=== START\n");
55 sta |= I2C_PCA_CON_STA; 67 sta |= I2C_PCA_CON_STA;
56 sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_SI); 68 sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_SI);
57 pca_set_con(adap, sta); 69 pca_set_con(adap, sta);
58 pca_wait(adap); 70 return pca_wait(adap);
59} 71}
60 72
61/* 73/*
@@ -63,14 +75,14 @@ static void pca_start(struct i2c_algo_pca_data *adap)
63 * 75 *
64 * return after the repeated start condition has occurred 76 * return after the repeated start condition has occurred
65 */ 77 */
66static void pca_repeated_start(struct i2c_algo_pca_data *adap) 78static int pca_repeated_start(struct i2c_algo_pca_data *adap)
67{ 79{
68 int sta = pca_get_con(adap); 80 int sta = pca_get_con(adap);
69 DEB2("=== REPEATED START\n"); 81 DEB2("=== REPEATED START\n");
70 sta |= I2C_PCA_CON_STA; 82 sta |= I2C_PCA_CON_STA;
71 sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_SI); 83 sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_SI);
72 pca_set_con(adap, sta); 84 pca_set_con(adap, sta);
73 pca_wait(adap); 85 return pca_wait(adap);
74} 86}
75 87
76/* 88/*
@@ -96,7 +108,7 @@ static void pca_stop(struct i2c_algo_pca_data *adap)
96 * 108 *
97 * returns after the address has been sent 109 * returns after the address has been sent
98 */ 110 */
99static void pca_address(struct i2c_algo_pca_data *adap, 111static int pca_address(struct i2c_algo_pca_data *adap,
100 struct i2c_msg *msg) 112 struct i2c_msg *msg)
101{ 113{
102 int sta = pca_get_con(adap); 114 int sta = pca_get_con(adap);
@@ -113,7 +125,7 @@ static void pca_address(struct i2c_algo_pca_data *adap,
113 sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI); 125 sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI);
114 pca_set_con(adap, sta); 126 pca_set_con(adap, sta);
115 127
116 pca_wait(adap); 128 return pca_wait(adap);
117} 129}
118 130
119/* 131/*
@@ -121,7 +133,7 @@ static void pca_address(struct i2c_algo_pca_data *adap,
121 * 133 *
122 * Returns after the byte has been transmitted 134 * Returns after the byte has been transmitted
123 */ 135 */
124static void pca_tx_byte(struct i2c_algo_pca_data *adap, 136static int pca_tx_byte(struct i2c_algo_pca_data *adap,
125 __u8 b) 137 __u8 b)
126{ 138{
127 int sta = pca_get_con(adap); 139 int sta = pca_get_con(adap);
@@ -131,7 +143,7 @@ static void pca_tx_byte(struct i2c_algo_pca_data *adap,
131 sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI); 143 sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI);
132 pca_set_con(adap, sta); 144 pca_set_con(adap, sta);
133 145
134 pca_wait(adap); 146 return pca_wait(adap);
135} 147}
136 148
137/* 149/*
@@ -151,7 +163,7 @@ static void pca_rx_byte(struct i2c_algo_pca_data *adap,
151 * 163 *
152 * Returns after next byte has arrived. 164 * Returns after next byte has arrived.
153 */ 165 */
154static void pca_rx_ack(struct i2c_algo_pca_data *adap, 166static int pca_rx_ack(struct i2c_algo_pca_data *adap,
155 int ack) 167 int ack)
156{ 168{
157 int sta = pca_get_con(adap); 169 int sta = pca_get_con(adap);
@@ -162,7 +174,7 @@ static void pca_rx_ack(struct i2c_algo_pca_data *adap,
162 sta |= I2C_PCA_CON_AA; 174 sta |= I2C_PCA_CON_AA;
163 175
164 pca_set_con(adap, sta); 176 pca_set_con(adap, sta);
165 pca_wait(adap); 177 return pca_wait(adap);
166} 178}
167 179
168static int pca_xfer(struct i2c_adapter *i2c_adap, 180static int pca_xfer(struct i2c_adapter *i2c_adap,
@@ -175,14 +187,17 @@ static int pca_xfer(struct i2c_adapter *i2c_adap,
175 int numbytes = 0; 187 int numbytes = 0;
176 int state; 188 int state;
177 int ret; 189 int ret;
178 int timeout = i2c_adap->timeout; 190 int completed = 1;
179 191 unsigned long timeout = jiffies + i2c_adap->timeout;
180 while ((state = pca_status(adap)) != 0xf8 && timeout--) { 192
181 msleep(10); 193 while (pca_status(adap) != 0xf8) {
182 } 194 if (time_before(jiffies, timeout)) {
183 if (state != 0xf8) { 195 msleep(10);
184 dev_dbg(&i2c_adap->dev, "bus is not idle. status is %#04x\n", state); 196 } else {
185 return -EAGAIN; 197 dev_dbg(&i2c_adap->dev, "bus is not idle. status is "
198 "%#04x\n", state);
199 return -EAGAIN;
200 }
186 } 201 }
187 202
188 DEB1("{{{ XFER %d messages\n", num); 203 DEB1("{{{ XFER %d messages\n", num);
@@ -218,18 +233,19 @@ static int pca_xfer(struct i2c_adapter *i2c_adap,
218 233
219 switch (state) { 234 switch (state) {
220 case 0xf8: /* On reset or stop the bus is idle */ 235 case 0xf8: /* On reset or stop the bus is idle */
221 pca_start(adap); 236 completed = pca_start(adap);
222 break; 237 break;
223 238
224 case 0x08: /* A START condition has been transmitted */ 239 case 0x08: /* A START condition has been transmitted */
225 case 0x10: /* A repeated start condition has been transmitted */ 240 case 0x10: /* A repeated start condition has been transmitted */
226 pca_address(adap, msg); 241 completed = pca_address(adap, msg);
227 break; 242 break;
228 243
229 case 0x18: /* SLA+W has been transmitted; ACK has been received */ 244 case 0x18: /* SLA+W has been transmitted; ACK has been received */
230 case 0x28: /* Data byte in I2CDAT has been transmitted; ACK has been received */ 245 case 0x28: /* Data byte in I2CDAT has been transmitted; ACK has been received */
231 if (numbytes < msg->len) { 246 if (numbytes < msg->len) {
232 pca_tx_byte(adap, msg->buf[numbytes]); 247 completed = pca_tx_byte(adap,
248 msg->buf[numbytes]);
233 numbytes++; 249 numbytes++;
234 break; 250 break;
235 } 251 }
@@ -237,7 +253,7 @@ static int pca_xfer(struct i2c_adapter *i2c_adap,
237 if (curmsg == num) 253 if (curmsg == num)
238 pca_stop(adap); 254 pca_stop(adap);
239 else 255 else
240 pca_repeated_start(adap); 256 completed = pca_repeated_start(adap);
241 break; 257 break;
242 258
243 case 0x20: /* SLA+W has been transmitted; NOT ACK has been received */ 259 case 0x20: /* SLA+W has been transmitted; NOT ACK has been received */
@@ -246,21 +262,22 @@ static int pca_xfer(struct i2c_adapter *i2c_adap,
246 goto out; 262 goto out;
247 263
248 case 0x40: /* SLA+R has been transmitted; ACK has been received */ 264 case 0x40: /* SLA+R has been transmitted; ACK has been received */
249 pca_rx_ack(adap, msg->len > 1); 265 completed = pca_rx_ack(adap, msg->len > 1);
250 break; 266 break;
251 267
252 case 0x50: /* Data bytes has been received; ACK has been returned */ 268 case 0x50: /* Data bytes has been received; ACK has been returned */
253 if (numbytes < msg->len) { 269 if (numbytes < msg->len) {
254 pca_rx_byte(adap, &msg->buf[numbytes], 1); 270 pca_rx_byte(adap, &msg->buf[numbytes], 1);
255 numbytes++; 271 numbytes++;
256 pca_rx_ack(adap, numbytes < msg->len - 1); 272 completed = pca_rx_ack(adap,
273 numbytes < msg->len - 1);
257 break; 274 break;
258 } 275 }
259 curmsg++; numbytes = 0; 276 curmsg++; numbytes = 0;
260 if (curmsg == num) 277 if (curmsg == num)
261 pca_stop(adap); 278 pca_stop(adap);
262 else 279 else
263 pca_repeated_start(adap); 280 completed = pca_repeated_start(adap);
264 break; 281 break;
265 282
266 case 0x48: /* SLA+R has been transmitted; NOT ACK has been received */ 283 case 0x48: /* SLA+R has been transmitted; NOT ACK has been received */
@@ -283,7 +300,7 @@ static int pca_xfer(struct i2c_adapter *i2c_adap,
283 if (curmsg == num) 300 if (curmsg == num)
284 pca_stop(adap); 301 pca_stop(adap);
285 else 302 else
286 pca_repeated_start(adap); 303 completed = pca_repeated_start(adap);
287 } else { 304 } else {
288 DEB2("NOT ACK sent after data byte received. " 305 DEB2("NOT ACK sent after data byte received. "
289 "Not final byte. numbytes %d. len %d\n", 306 "Not final byte. numbytes %d. len %d\n",
@@ -309,11 +326,13 @@ static int pca_xfer(struct i2c_adapter *i2c_adap,
309 break; 326 break;
310 } 327 }
311 328
329 if (!completed)
330 goto out;
312 } 331 }
313 332
314 ret = curmsg; 333 ret = curmsg;
315 out: 334 out:
316 DEB1(KERN_CRIT "}}} transfered %d/%d messages. " 335 DEB1("}}} transfered %d/%d messages. "
317 "status is %#04x. control is %#04x\n", 336 "status is %#04x. control is %#04x\n",
318 curmsg, num, pca_status(adap), 337 curmsg, num, pca_status(adap),
319 pca_get_con(adap)); 338 pca_get_con(adap));
@@ -330,26 +349,171 @@ static const struct i2c_algorithm pca_algo = {
330 .functionality = pca_func, 349 .functionality = pca_func,
331}; 350};
332 351
333static int pca_init(struct i2c_adapter *adap) 352static unsigned int pca_probe_chip(struct i2c_adapter *adap)
334{ 353{
335 static int freqs[] = {330,288,217,146,88,59,44,36};
336 int clock;
337 struct i2c_algo_pca_data *pca_data = adap->algo_data; 354 struct i2c_algo_pca_data *pca_data = adap->algo_data;
338 355 /* The trick here is to check if there is an indirect register
339 if (pca_data->i2c_clock > 7) { 356 * available. If there is one, we will read the value we first
340 printk(KERN_WARNING "%s: Invalid I2C clock speed selected. Trying default.\n", 357 * wrote on I2C_PCA_IADR. Otherwise, we will read the last value
341 adap->name); 358 * we wrote on I2C_PCA_ADR
342 pca_data->i2c_clock = I2C_PCA_CON_59kHz; 359 */
360 pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_IADR);
361 pca_outw(pca_data, I2C_PCA_IND, 0xAA);
362 pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_ITO);
363 pca_outw(pca_data, I2C_PCA_IND, 0x00);
364 pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_IADR);
365 if (pca_inw(pca_data, I2C_PCA_IND) == 0xAA) {
366 printk(KERN_INFO "%s: PCA9665 detected.\n", adap->name);
367 return I2C_PCA_CHIP_9665;
368 } else {
369 printk(KERN_INFO "%s: PCA9564 detected.\n", adap->name);
370 return I2C_PCA_CHIP_9564;
343 } 371 }
372}
373
374static int pca_init(struct i2c_adapter *adap)
375{
376 struct i2c_algo_pca_data *pca_data = adap->algo_data;
344 377
345 adap->algo = &pca_algo; 378 adap->algo = &pca_algo;
346 379
347 pca_reset(pca_data); 380 if (pca_probe_chip(adap) == I2C_PCA_CHIP_9564) {
381 static int freqs[] = {330, 288, 217, 146, 88, 59, 44, 36};
382 int clock;
383
384 if (pca_data->i2c_clock > 7) {
385 switch (pca_data->i2c_clock) {
386 case 330000:
387 pca_data->i2c_clock = I2C_PCA_CON_330kHz;
388 break;
389 case 288000:
390 pca_data->i2c_clock = I2C_PCA_CON_288kHz;
391 break;
392 case 217000:
393 pca_data->i2c_clock = I2C_PCA_CON_217kHz;
394 break;
395 case 146000:
396 pca_data->i2c_clock = I2C_PCA_CON_146kHz;
397 break;
398 case 88000:
399 pca_data->i2c_clock = I2C_PCA_CON_88kHz;
400 break;
401 case 59000:
402 pca_data->i2c_clock = I2C_PCA_CON_59kHz;
403 break;
404 case 44000:
405 pca_data->i2c_clock = I2C_PCA_CON_44kHz;
406 break;
407 case 36000:
408 pca_data->i2c_clock = I2C_PCA_CON_36kHz;
409 break;
410 default:
411 printk(KERN_WARNING
412 "%s: Invalid I2C clock speed selected."
413 " Using default 59kHz.\n", adap->name);
414 pca_data->i2c_clock = I2C_PCA_CON_59kHz;
415 }
416 } else {
417 printk(KERN_WARNING "%s: "
418 "Choosing the clock frequency based on "
419 "index is deprecated."
420 " Use the nominal frequency.\n", adap->name);
421 }
422
423 pca_reset(pca_data);
424
425 clock = pca_clock(pca_data);
426 printk(KERN_INFO "%s: Clock frequency is %dkHz\n",
427 adap->name, freqs[clock]);
428
429 pca_set_con(pca_data, I2C_PCA_CON_ENSIO | clock);
430 } else {
431 int clock;
432 int mode;
433 int tlow, thi;
434 /* Values can be found on PCA9665 datasheet section 7.3.2.6 */
435 int min_tlow, min_thi;
436 /* These values are the maximum raise and fall values allowed
437 * by the I2C operation mode (Standard, Fast or Fast+)
438 * They are used (added) below to calculate the clock dividers
439 * of PCA9665. Note that they are slightly different of the
440 * real maximum, to allow the change on mode exactly on the
441 * maximum clock rate for each mode
442 */
443 int raise_fall_time;
444
445 struct i2c_algo_pca_data *pca_data = adap->algo_data;
446
447 /* Ignore the reset function from the module,
448 * we can use the parallel bus reset
449 */
450 pca_data->reset_chip = pca9665_reset;
451
452 if (pca_data->i2c_clock > 1265800) {
453 printk(KERN_WARNING "%s: I2C clock speed too high."
454 " Using 1265.8kHz.\n", adap->name);
455 pca_data->i2c_clock = 1265800;
456 }
457
458 if (pca_data->i2c_clock < 60300) {
459 printk(KERN_WARNING "%s: I2C clock speed too low."
460 " Using 60.3kHz.\n", adap->name);
461 pca_data->i2c_clock = 60300;
462 }
348 463
349 clock = pca_clock(pca_data); 464 /* To avoid integer overflow, use clock/100 for calculations */
350 DEB1(KERN_INFO "%s: Clock frequency is %dkHz\n", adap->name, freqs[clock]); 465 clock = pca_clock(pca_data) / 100;
466
467 if (pca_data->i2c_clock > 10000) {
468 mode = I2C_PCA_MODE_TURBO;
469 min_tlow = 14;
470 min_thi = 5;
471 raise_fall_time = 22; /* Raise 11e-8s, Fall 11e-8s */
472 } else if (pca_data->i2c_clock > 4000) {
473 mode = I2C_PCA_MODE_FASTP;
474 min_tlow = 17;
475 min_thi = 9;
476 raise_fall_time = 22; /* Raise 11e-8s, Fall 11e-8s */
477 } else if (pca_data->i2c_clock > 1000) {
478 mode = I2C_PCA_MODE_FAST;
479 min_tlow = 44;
480 min_thi = 20;
481 raise_fall_time = 58; /* Raise 29e-8s, Fall 29e-8s */
482 } else {
483 mode = I2C_PCA_MODE_STD;
484 min_tlow = 157;
485 min_thi = 134;
486 raise_fall_time = 127; /* Raise 29e-8s, Fall 98e-8s */
487 }
488
489 /* The minimum clock that respects the thi/tlow = 134/157 is
490 * 64800 Hz. Below that, we have to fix the tlow to 255 and
491 * calculate the thi factor.
492 */
493 if (clock < 648) {
494 tlow = 255;
495 thi = 1000000 - clock * raise_fall_time;
496 thi /= (I2C_PCA_OSC_PER * clock) - tlow;
497 } else {
498 tlow = (1000000 - clock * raise_fall_time) * min_tlow;
499 tlow /= I2C_PCA_OSC_PER * clock * (min_thi + min_tlow);
500 thi = tlow * min_thi / min_tlow;
501 }
351 502
352 pca_set_con(pca_data, I2C_PCA_CON_ENSIO | clock); 503 pca_reset(pca_data);
504
505 printk(KERN_INFO
506 "%s: Clock frequency is %dHz\n", adap->name, clock * 100);
507
508 pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_IMODE);
509 pca_outw(pca_data, I2C_PCA_IND, mode);
510 pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_ISCLL);
511 pca_outw(pca_data, I2C_PCA_IND, tlow);
512 pca_outw(pca_data, I2C_PCA_INDPTR, I2C_PCA_ISCLH);
513 pca_outw(pca_data, I2C_PCA_IND, thi);
514
515 pca_set_con(pca_data, I2C_PCA_CON_ENSIO);
516 }
353 udelay(500); /* 500 us for oscilator to stabilise */ 517 udelay(500); /* 500 us for oscilator to stabilise */
354 518
355 return 0; 519 return 0;
@@ -384,7 +548,7 @@ EXPORT_SYMBOL(i2c_pca_add_numbered_bus);
384 548
385MODULE_AUTHOR("Ian Campbell <icampbell@arcom.com>, " 549MODULE_AUTHOR("Ian Campbell <icampbell@arcom.com>, "
386 "Wolfram Sang <w.sang@pengutronix.de>"); 550 "Wolfram Sang <w.sang@pengutronix.de>");
387MODULE_DESCRIPTION("I2C-Bus PCA9564 algorithm"); 551MODULE_DESCRIPTION("I2C-Bus PCA9564/PCA9665 algorithm");
388MODULE_LICENSE("GPL"); 552MODULE_LICENSE("GPL");
389 553
390module_param(i2c_debug, int, 0); 554module_param(i2c_debug, int, 0);
diff --git a/drivers/i2c/algos/i2c-algo-pcf.c b/drivers/i2c/algos/i2c-algo-pcf.c
index 3e01992230b8..7ce75775ec73 100644
--- a/drivers/i2c/algos/i2c-algo-pcf.c
+++ b/drivers/i2c/algos/i2c-algo-pcf.c
@@ -1,31 +1,30 @@
1/* ------------------------------------------------------------------------- */ 1/*
2/* i2c-algo-pcf.c i2c driver algorithms for PCF8584 adapters */ 2 * i2c-algo-pcf.c i2c driver algorithms for PCF8584 adapters
3/* ------------------------------------------------------------------------- */ 3 *
4/* Copyright (C) 1995-1997 Simon G. Vogl 4 * Copyright (C) 1995-1997 Simon G. Vogl
5 1998-2000 Hans Berglund 5 * 1998-2000 Hans Berglund
6 6 *
7 This program is free software; you can redistribute it and/or modify 7 * This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by 8 * it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or 9 * the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version. 10 * (at your option) any later version.
11 11 *
12 This program is distributed in the hope that it will be useful, 12 * This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details. 15 * GNU General Public License for more details.
16 16 *
17 You should have received a copy of the GNU General Public License 17 * You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software 18 * along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ 19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20/* ------------------------------------------------------------------------- */ 20 *
21 21 * With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and
22/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and 22 * Frodo Looijaard <frodol@dds.nl>, and also from Martin Bailey
23 Frodo Looijaard <frodol@dds.nl> ,and also from Martin Bailey 23 * <mbailey@littlefeet-inc.com>
24 <mbailey@littlefeet-inc.com> */ 24 *
25 25 * Partially rewriten by Oleg I. Vdovikin <vdovikin@jscc.ru> to handle multiple
26/* Partially rewriten by Oleg I. Vdovikin <vdovikin@jscc.ru> to handle multiple 26 * messages, proper stop/repstart signaling during receive, added detect code
27 messages, proper stop/repstart signaling during receive, 27 */
28 added detect code */
29 28
30#include <linux/kernel.h> 29#include <linux/kernel.h>
31#include <linux/module.h> 30#include <linux/module.h>
@@ -38,17 +37,18 @@
38#include "i2c-algo-pcf.h" 37#include "i2c-algo-pcf.h"
39 38
40 39
41#define DEB2(x) if (i2c_debug>=2) x 40#define DEB2(x) if (i2c_debug >= 2) x
42#define DEB3(x) if (i2c_debug>=3) x /* print several statistical values*/ 41#define DEB3(x) if (i2c_debug >= 3) x /* print several statistical values */
43#define DEBPROTO(x) if (i2c_debug>=9) x; 42#define DEBPROTO(x) if (i2c_debug >= 9) x;
44 /* debug the protocol by showing transferred bits */ 43 /* debug the protocol by showing transferred bits */
45#define DEF_TIMEOUT 16 44#define DEF_TIMEOUT 16
46 45
47/* module parameters: 46/*
47 * module parameters:
48 */ 48 */
49static int i2c_debug; 49static int i2c_debug;
50 50
51/* --- setting states on the bus with the right timing: --------------- */ 51/* setting states on the bus with the right timing: */
52 52
53#define set_pcf(adap, ctl, val) adap->setpcf(adap->data, ctl, val) 53#define set_pcf(adap, ctl, val) adap->setpcf(adap->data, ctl, val)
54#define get_pcf(adap, ctl) adap->getpcf(adap->data, ctl) 54#define get_pcf(adap, ctl) adap->getpcf(adap->data, ctl)
@@ -57,22 +57,21 @@ static int i2c_debug;
57#define i2c_outb(adap, val) adap->setpcf(adap->data, 0, val) 57#define i2c_outb(adap, val) adap->setpcf(adap->data, 0, val)
58#define i2c_inb(adap) adap->getpcf(adap->data, 0) 58#define i2c_inb(adap) adap->getpcf(adap->data, 0)
59 59
60/* --- other auxiliary functions -------------------------------------- */ 60/* other auxiliary functions */
61 61
62static void i2c_start(struct i2c_algo_pcf_data *adap) 62static void i2c_start(struct i2c_algo_pcf_data *adap)
63{ 63{
64 DEBPROTO(printk("S ")); 64 DEBPROTO(printk(KERN_DEBUG "S "));
65 set_pcf(adap, 1, I2C_PCF_START); 65 set_pcf(adap, 1, I2C_PCF_START);
66} 66}
67 67
68static void i2c_repstart(struct i2c_algo_pcf_data *adap) 68static void i2c_repstart(struct i2c_algo_pcf_data *adap)
69{ 69{
70 DEBPROTO(printk(" Sr ")); 70 DEBPROTO(printk(" Sr "));
71 set_pcf(adap, 1, I2C_PCF_REPSTART); 71 set_pcf(adap, 1, I2C_PCF_REPSTART);
72} 72}
73 73
74 74static void i2c_stop(struct i2c_algo_pcf_data *adap)
75static void i2c_stop(struct i2c_algo_pcf_data *adap)
76{ 75{
77 DEBPROTO(printk("P\n")); 76 DEBPROTO(printk("P\n"));
78 set_pcf(adap, 1, I2C_PCF_STOP); 77 set_pcf(adap, 1, I2C_PCF_STOP);
@@ -82,17 +81,17 @@ static void handle_lab(struct i2c_algo_pcf_data *adap, const int *status)
82{ 81{
83 DEB2(printk(KERN_INFO 82 DEB2(printk(KERN_INFO
84 "i2c-algo-pcf.o: lost arbitration (CSR 0x%02x)\n", 83 "i2c-algo-pcf.o: lost arbitration (CSR 0x%02x)\n",
85 *status)); 84 *status));
86 85 /*
87 /* Cleanup from LAB -- reset and enable ESO. 86 * Cleanup from LAB -- reset and enable ESO.
88 * This resets the PCF8584; since we've lost the bus, no 87 * This resets the PCF8584; since we've lost the bus, no
89 * further attempts should be made by callers to clean up 88 * further attempts should be made by callers to clean up
90 * (no i2c_stop() etc.) 89 * (no i2c_stop() etc.)
91 */ 90 */
92 set_pcf(adap, 1, I2C_PCF_PIN); 91 set_pcf(adap, 1, I2C_PCF_PIN);
93 set_pcf(adap, 1, I2C_PCF_ESO); 92 set_pcf(adap, 1, I2C_PCF_ESO);
94 93 /*
95 /* We pause for a time period sufficient for any running 94 * We pause for a time period sufficient for any running
96 * I2C transaction to complete -- the arbitration logic won't 95 * I2C transaction to complete -- the arbitration logic won't
97 * work properly until the next START is seen. 96 * work properly until the next START is seen.
98 * It is assumed the bus driver or client has set a proper value. 97 * It is assumed the bus driver or client has set a proper value.
@@ -108,48 +107,50 @@ static void handle_lab(struct i2c_algo_pcf_data *adap, const int *status)
108 get_pcf(adap, 1))); 107 get_pcf(adap, 1)));
109} 108}
110 109
111static int wait_for_bb(struct i2c_algo_pcf_data *adap) { 110static int wait_for_bb(struct i2c_algo_pcf_data *adap)
111{
112 112
113 int timeout = DEF_TIMEOUT; 113 int timeout = DEF_TIMEOUT;
114 int status; 114 int status;
115 115
116 status = get_pcf(adap, 1); 116 status = get_pcf(adap, 1);
117#ifndef STUB_I2C 117
118 while (timeout-- && !(status & I2C_PCF_BB)) { 118 while (!(status & I2C_PCF_BB) && --timeout) {
119 udelay(100); /* wait for 100 us */ 119 udelay(100); /* wait for 100 us */
120 status = get_pcf(adap, 1); 120 status = get_pcf(adap, 1);
121 } 121 }
122#endif 122
123 if (timeout <= 0) { 123 if (timeout == 0) {
124 printk(KERN_ERR "Timeout waiting for Bus Busy\n"); 124 printk(KERN_ERR "Timeout waiting for Bus Busy\n");
125 return -ETIMEDOUT;
125 } 126 }
126
127 return (timeout<=0);
128}
129 127
128 return 0;
129}
130 130
131static int wait_for_pin(struct i2c_algo_pcf_data *adap, int *status) { 131static int wait_for_pin(struct i2c_algo_pcf_data *adap, int *status)
132{
132 133
133 int timeout = DEF_TIMEOUT; 134 int timeout = DEF_TIMEOUT;
134 135
135 *status = get_pcf(adap, 1); 136 *status = get_pcf(adap, 1);
136#ifndef STUB_I2C 137
137 while (timeout-- && (*status & I2C_PCF_PIN)) { 138 while ((*status & I2C_PCF_PIN) && --timeout) {
138 adap->waitforpin(adap->data); 139 adap->waitforpin(adap->data);
139 *status = get_pcf(adap, 1); 140 *status = get_pcf(adap, 1);
140 } 141 }
141 if (*status & I2C_PCF_LAB) { 142 if (*status & I2C_PCF_LAB) {
142 handle_lab(adap, status); 143 handle_lab(adap, status);
143 return(-EINTR); 144 return -EINTR;
144 } 145 }
145#endif 146
146 if (timeout <= 0) 147 if (timeout == 0)
147 return(-1); 148 return -ETIMEDOUT;
148 else 149
149 return(0); 150 return 0;
150} 151}
151 152
152/* 153/*
153 * This should perform the 'PCF8584 initialization sequence' as described 154 * This should perform the 'PCF8584 initialization sequence' as described
154 * in the Philips IC12 data book (1995, Aug 29). 155 * in the Philips IC12 data book (1995, Aug 29).
155 * There should be a 30 clock cycle wait after reset, I assume this 156 * There should be a 30 clock cycle wait after reset, I assume this
@@ -164,18 +165,21 @@ static int pcf_init_8584 (struct i2c_algo_pcf_data *adap)
164{ 165{
165 unsigned char temp; 166 unsigned char temp;
166 167
167 DEB3(printk(KERN_DEBUG "i2c-algo-pcf.o: PCF state 0x%02x\n", get_pcf(adap, 1))); 168 DEB3(printk(KERN_DEBUG "i2c-algo-pcf.o: PCF state 0x%02x\n",
169 get_pcf(adap, 1)));
168 170
169 /* S1=0x80: S0 selected, serial interface off */ 171 /* S1=0x80: S0 selected, serial interface off */
170 set_pcf(adap, 1, I2C_PCF_PIN); 172 set_pcf(adap, 1, I2C_PCF_PIN);
171 /* check to see S1 now used as R/W ctrl - 173 /*
172 PCF8584 does that when ESO is zero */ 174 * check to see S1 now used as R/W ctrl -
175 * PCF8584 does that when ESO is zero
176 */
173 if (((temp = get_pcf(adap, 1)) & 0x7f) != (0)) { 177 if (((temp = get_pcf(adap, 1)) & 0x7f) != (0)) {
174 DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S0 (0x%02x).\n", temp)); 178 DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S0 (0x%02x).\n", temp));
175 return -ENXIO; /* definetly not PCF8584 */ 179 return -ENXIO; /* definetly not PCF8584 */
176 } 180 }
177 181
178 /* load own address in S0, effective address is (own << 1) */ 182 /* load own address in S0, effective address is (own << 1) */
179 i2c_outb(adap, get_own(adap)); 183 i2c_outb(adap, get_own(adap));
180 /* check it's really written */ 184 /* check it's really written */
181 if ((temp = i2c_inb(adap)) != get_own(adap)) { 185 if ((temp = i2c_inb(adap)) != get_own(adap)) {
@@ -183,7 +187,7 @@ static int pcf_init_8584 (struct i2c_algo_pcf_data *adap)
183 return -ENXIO; 187 return -ENXIO;
184 } 188 }
185 189
186 /* S1=0xA0, next byte in S2 */ 190 /* S1=0xA0, next byte in S2 */
187 set_pcf(adap, 1, I2C_PCF_PIN | I2C_PCF_ES1); 191 set_pcf(adap, 1, I2C_PCF_PIN | I2C_PCF_ES1);
188 /* check to see S2 now selected */ 192 /* check to see S2 now selected */
189 if (((temp = get_pcf(adap, 1)) & 0x7f) != I2C_PCF_ES1) { 193 if (((temp = get_pcf(adap, 1)) & 0x7f) != I2C_PCF_ES1) {
@@ -191,7 +195,7 @@ static int pcf_init_8584 (struct i2c_algo_pcf_data *adap)
191 return -ENXIO; 195 return -ENXIO;
192 } 196 }
193 197
194 /* load clock register S2 */ 198 /* load clock register S2 */
195 i2c_outb(adap, get_clock(adap)); 199 i2c_outb(adap, get_clock(adap));
196 /* check it's really written, the only 5 lowest bits does matter */ 200 /* check it's really written, the only 5 lowest bits does matter */
197 if (((temp = i2c_inb(adap)) & 0x1f) != get_clock(adap)) { 201 if (((temp = i2c_inb(adap)) & 0x1f) != get_clock(adap)) {
@@ -199,7 +203,7 @@ static int pcf_init_8584 (struct i2c_algo_pcf_data *adap)
199 return -ENXIO; 203 return -ENXIO;
200 } 204 }
201 205
202 /* Enable serial interface, idle, S0 selected */ 206 /* Enable serial interface, idle, S0 selected */
203 set_pcf(adap, 1, I2C_PCF_IDLE); 207 set_pcf(adap, 1, I2C_PCF_IDLE);
204 208
205 /* check to see PCF is really idled and we can access status register */ 209 /* check to see PCF is really idled and we can access status register */
@@ -207,57 +211,47 @@ static int pcf_init_8584 (struct i2c_algo_pcf_data *adap)
207 DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S1` (0x%02x).\n", temp)); 211 DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S1` (0x%02x).\n", temp));
208 return -ENXIO; 212 return -ENXIO;
209 } 213 }
210 214
211 printk(KERN_DEBUG "i2c-algo-pcf.o: detected and initialized PCF8584.\n"); 215 printk(KERN_DEBUG "i2c-algo-pcf.o: detected and initialized PCF8584.\n");
212 216
213 return 0; 217 return 0;
214} 218}
215 219
216
217/* ----- Utility functions
218 */
219
220static int pcf_sendbytes(struct i2c_adapter *i2c_adap, const char *buf, 220static int pcf_sendbytes(struct i2c_adapter *i2c_adap, const char *buf,
221 int count, int last) 221 int count, int last)
222{ 222{
223 struct i2c_algo_pcf_data *adap = i2c_adap->algo_data; 223 struct i2c_algo_pcf_data *adap = i2c_adap->algo_data;
224 int wrcount, status, timeout; 224 int wrcount, status, timeout;
225 225
226 for (wrcount=0; wrcount<count; ++wrcount) { 226 for (wrcount=0; wrcount<count; ++wrcount) {
227 DEB2(dev_dbg(&i2c_adap->dev, "i2c_write: writing %2.2X\n", 227 DEB2(dev_dbg(&i2c_adap->dev, "i2c_write: writing %2.2X\n",
228 buf[wrcount]&0xff)); 228 buf[wrcount] & 0xff));
229 i2c_outb(adap, buf[wrcount]); 229 i2c_outb(adap, buf[wrcount]);
230 timeout = wait_for_pin(adap, &status); 230 timeout = wait_for_pin(adap, &status);
231 if (timeout) { 231 if (timeout) {
232 if (timeout == -EINTR) { 232 if (timeout == -EINTR)
233 /* arbitration lost */ 233 return -EINTR; /* arbitration lost */
234 return -EINTR; 234
235 }
236 i2c_stop(adap); 235 i2c_stop(adap);
237 dev_err(&i2c_adap->dev, "i2c_write: error - timeout.\n"); 236 dev_err(&i2c_adap->dev, "i2c_write: error - timeout.\n");
238 return -EREMOTEIO; /* got a better one ?? */ 237 return -EREMOTEIO; /* got a better one ?? */
239 } 238 }
240#ifndef STUB_I2C
241 if (status & I2C_PCF_LRB) { 239 if (status & I2C_PCF_LRB) {
242 i2c_stop(adap); 240 i2c_stop(adap);
243 dev_err(&i2c_adap->dev, "i2c_write: error - no ack.\n"); 241 dev_err(&i2c_adap->dev, "i2c_write: error - no ack.\n");
244 return -EREMOTEIO; /* got a better one ?? */ 242 return -EREMOTEIO; /* got a better one ?? */
245 } 243 }
246#endif
247 } 244 }
248 if (last) { 245 if (last)
249 i2c_stop(adap); 246 i2c_stop(adap);
250 } 247 else
251 else {
252 i2c_repstart(adap); 248 i2c_repstart(adap);
253 }
254 249
255 return (wrcount); 250 return wrcount;
256} 251}
257 252
258
259static int pcf_readbytes(struct i2c_adapter *i2c_adap, char *buf, 253static int pcf_readbytes(struct i2c_adapter *i2c_adap, char *buf,
260 int count, int last) 254 int count, int last)
261{ 255{
262 int i, status; 256 int i, status;
263 struct i2c_algo_pcf_data *adap = i2c_adap->algo_data; 257 struct i2c_algo_pcf_data *adap = i2c_adap->algo_data;
@@ -267,42 +261,36 @@ static int pcf_readbytes(struct i2c_adapter *i2c_adap, char *buf,
267 for (i = 0; i <= count; i++) { 261 for (i = 0; i <= count; i++) {
268 262
269 if ((wfp = wait_for_pin(adap, &status))) { 263 if ((wfp = wait_for_pin(adap, &status))) {
270 if (wfp == -EINTR) { 264 if (wfp == -EINTR)
271 /* arbitration lost */ 265 return -EINTR; /* arbitration lost */
272 return -EINTR; 266
273 }
274 i2c_stop(adap); 267 i2c_stop(adap);
275 dev_err(&i2c_adap->dev, "pcf_readbytes timed out.\n"); 268 dev_err(&i2c_adap->dev, "pcf_readbytes timed out.\n");
276 return (-1); 269 return -1;
277 } 270 }
278 271
279#ifndef STUB_I2C
280 if ((status & I2C_PCF_LRB) && (i != count)) { 272 if ((status & I2C_PCF_LRB) && (i != count)) {
281 i2c_stop(adap); 273 i2c_stop(adap);
282 dev_err(&i2c_adap->dev, "i2c_read: i2c_inb, No ack.\n"); 274 dev_err(&i2c_adap->dev, "i2c_read: i2c_inb, No ack.\n");
283 return (-1); 275 return -1;
284 } 276 }
285#endif 277
286
287 if (i == count - 1) { 278 if (i == count - 1) {
288 set_pcf(adap, 1, I2C_PCF_ESO); 279 set_pcf(adap, 1, I2C_PCF_ESO);
289 } else 280 } else if (i == count) {
290 if (i == count) { 281 if (last)
291 if (last) {
292 i2c_stop(adap); 282 i2c_stop(adap);
293 } else { 283 else
294 i2c_repstart(adap); 284 i2c_repstart(adap);
295 } 285 }
296 };
297 286
298 if (i) { 287 if (i)
299 buf[i - 1] = i2c_inb(adap); 288 buf[i - 1] = i2c_inb(adap);
300 } else { 289 else
301 i2c_inb(adap); /* dummy read */ 290 i2c_inb(adap); /* dummy read */
302 }
303 } 291 }
304 292
305 return (i - 1); 293 return i - 1;
306} 294}
307 295
308 296
@@ -323,14 +311,14 @@ static int pcf_doAddress(struct i2c_algo_pcf_data *adap,
323} 311}
324 312
325static int pcf_xfer(struct i2c_adapter *i2c_adap, 313static int pcf_xfer(struct i2c_adapter *i2c_adap,
326 struct i2c_msg *msgs, 314 struct i2c_msg *msgs,
327 int num) 315 int num)
328{ 316{
329 struct i2c_algo_pcf_data *adap = i2c_adap->algo_data; 317 struct i2c_algo_pcf_data *adap = i2c_adap->algo_data;
330 struct i2c_msg *pmsg; 318 struct i2c_msg *pmsg;
331 int i; 319 int i;
332 int ret=0, timeout, status; 320 int ret=0, timeout, status;
333 321
334 if (adap->xfer_begin) 322 if (adap->xfer_begin)
335 adap->xfer_begin(adap->data); 323 adap->xfer_begin(adap->data);
336 324
@@ -338,25 +326,24 @@ static int pcf_xfer(struct i2c_adapter *i2c_adap,
338 timeout = wait_for_bb(adap); 326 timeout = wait_for_bb(adap);
339 if (timeout) { 327 if (timeout) {
340 DEB2(printk(KERN_ERR "i2c-algo-pcf.o: " 328 DEB2(printk(KERN_ERR "i2c-algo-pcf.o: "
341 "Timeout waiting for BB in pcf_xfer\n");) 329 "Timeout waiting for BB in pcf_xfer\n");)
342 i = -EIO; 330 i = -EIO;
343 goto out; 331 goto out;
344 } 332 }
345 333
346 for (i = 0;ret >= 0 && i < num; i++) { 334 for (i = 0;ret >= 0 && i < num; i++) {
347 pmsg = &msgs[i]; 335 pmsg = &msgs[i];
348 336
349 DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: Doing %s %d bytes to 0x%02x - %d of %d messages\n", 337 DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: Doing %s %d bytes to 0x%02x - %d of %d messages\n",
350 pmsg->flags & I2C_M_RD ? "read" : "write", 338 pmsg->flags & I2C_M_RD ? "read" : "write",
351 pmsg->len, pmsg->addr, i + 1, num);) 339 pmsg->len, pmsg->addr, i + 1, num);)
352 340
353 ret = pcf_doAddress(adap, pmsg); 341 ret = pcf_doAddress(adap, pmsg);
354 342
355 /* Send START */ 343 /* Send START */
356 if (i == 0) { 344 if (i == 0)
357 i2c_start(adap); 345 i2c_start(adap);
358 } 346
359
360 /* Wait for PIN (pending interrupt NOT) */ 347 /* Wait for PIN (pending interrupt NOT) */
361 timeout = wait_for_pin(adap, &status); 348 timeout = wait_for_pin(adap, &status);
362 if (timeout) { 349 if (timeout) {
@@ -371,8 +358,7 @@ static int pcf_xfer(struct i2c_adapter *i2c_adap,
371 i = -EREMOTEIO; 358 i = -EREMOTEIO;
372 goto out; 359 goto out;
373 } 360 }
374 361
375#ifndef STUB_I2C
376 /* Check LRB (last rcvd bit - slave ack) */ 362 /* Check LRB (last rcvd bit - slave ack) */
377 if (status & I2C_PCF_LRB) { 363 if (status & I2C_PCF_LRB) {
378 i2c_stop(adap); 364 i2c_stop(adap);
@@ -380,27 +366,24 @@ static int pcf_xfer(struct i2c_adapter *i2c_adap,
380 i = -EREMOTEIO; 366 i = -EREMOTEIO;
381 goto out; 367 goto out;
382 } 368 }
383#endif 369
384
385 DEB3(printk(KERN_DEBUG "i2c-algo-pcf.o: Msg %d, addr=0x%x, flags=0x%x, len=%d\n", 370 DEB3(printk(KERN_DEBUG "i2c-algo-pcf.o: Msg %d, addr=0x%x, flags=0x%x, len=%d\n",
386 i, msgs[i].addr, msgs[i].flags, msgs[i].len);) 371 i, msgs[i].addr, msgs[i].flags, msgs[i].len);)
387 372
388 /* Read */
389 if (pmsg->flags & I2C_M_RD) { 373 if (pmsg->flags & I2C_M_RD) {
390 /* read bytes into buffer*/
391 ret = pcf_readbytes(i2c_adap, pmsg->buf, pmsg->len, 374 ret = pcf_readbytes(i2c_adap, pmsg->buf, pmsg->len,
392 (i + 1 == num)); 375 (i + 1 == num));
393 376
394 if (ret != pmsg->len) { 377 if (ret != pmsg->len) {
395 DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: fail: " 378 DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: fail: "
396 "only read %d bytes.\n",ret)); 379 "only read %d bytes.\n",ret));
397 } else { 380 } else {
398 DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: read %d bytes.\n",ret)); 381 DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: read %d bytes.\n",ret));
399 } 382 }
400 } else { /* Write */ 383 } else {
401 ret = pcf_sendbytes(i2c_adap, pmsg->buf, pmsg->len, 384 ret = pcf_sendbytes(i2c_adap, pmsg->buf, pmsg->len,
402 (i + 1 == num)); 385 (i + 1 == num));
403 386
404 if (ret != pmsg->len) { 387 if (ret != pmsg->len) {
405 DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: fail: " 388 DEB2(printk(KERN_DEBUG "i2c-algo-pcf.o: fail: "
406 "only wrote %d bytes.\n",ret)); 389 "only wrote %d bytes.\n",ret));
@@ -413,24 +396,23 @@ static int pcf_xfer(struct i2c_adapter *i2c_adap,
413out: 396out:
414 if (adap->xfer_end) 397 if (adap->xfer_end)
415 adap->xfer_end(adap->data); 398 adap->xfer_end(adap->data);
416 return (i); 399 return i;
417} 400}
418 401
419static u32 pcf_func(struct i2c_adapter *adap) 402static u32 pcf_func(struct i2c_adapter *adap)
420{ 403{
421 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | 404 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL |
422 I2C_FUNC_PROTOCOL_MANGLING; 405 I2C_FUNC_PROTOCOL_MANGLING;
423} 406}
424 407
425/* -----exported algorithm data: ------------------------------------- */ 408/* exported algorithm data: */
426
427static const struct i2c_algorithm pcf_algo = { 409static const struct i2c_algorithm pcf_algo = {
428 .master_xfer = pcf_xfer, 410 .master_xfer = pcf_xfer,
429 .functionality = pcf_func, 411 .functionality = pcf_func,
430}; 412};
431 413
432/* 414/*
433 * registering functions to load algorithms at runtime 415 * registering functions to load algorithms at runtime
434 */ 416 */
435int i2c_pcf_add_bus(struct i2c_adapter *adap) 417int i2c_pcf_add_bus(struct i2c_adapter *adap)
436{ 418{
@@ -441,7 +423,6 @@ int i2c_pcf_add_bus(struct i2c_adapter *adap)
441 423
442 /* register new adapter to i2c module... */ 424 /* register new adapter to i2c module... */
443 adap->algo = &pcf_algo; 425 adap->algo = &pcf_algo;
444 adap->timeout = 100;
445 426
446 if ((rval = pcf_init_8584(pcf_adap))) 427 if ((rval = pcf_init_8584(pcf_adap)))
447 return rval; 428 return rval;
@@ -458,4 +439,4 @@ MODULE_LICENSE("GPL");
458 439
459module_param(i2c_debug, int, S_IRUGO | S_IWUSR); 440module_param(i2c_debug, int, S_IRUGO | S_IWUSR);
460MODULE_PARM_DESC(i2c_debug, 441MODULE_PARM_DESC(i2c_debug,
461 "debug level - 0 off; 1 normal; 2,3 more verbose; 9 pcf-protocol"); 442 "debug level - 0 off; 1 normal; 2,3 more verbose; 9 pcf-protocol");
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index 7f95905bbb9d..da809ad0996a 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -132,6 +132,7 @@ config I2C_PIIX4
132 Serverworks CSB5 132 Serverworks CSB5
133 Serverworks CSB6 133 Serverworks CSB6
134 Serverworks HT-1000 134 Serverworks HT-1000
135 Serverworks HT-1100
135 SMSC Victory66 136 SMSC Victory66
136 137
137 This driver can also be built as a module. If so, the module 138 This driver can also be built as a module. If so, the module
@@ -617,12 +618,12 @@ config I2C_ELEKTOR
617 will be called i2c-elektor. 618 will be called i2c-elektor.
618 619
619config I2C_PCA_ISA 620config I2C_PCA_ISA
620 tristate "PCA9564 on an ISA bus" 621 tristate "PCA9564/PCA9665 on an ISA bus"
621 depends on ISA 622 depends on ISA
622 select I2C_ALGOPCA 623 select I2C_ALGOPCA
623 default n 624 default n
624 help 625 help
625 This driver supports ISA boards using the Philips PCA9564 626 This driver supports ISA boards using the Philips PCA9564/PCA9665
626 parallel bus to I2C bus controller. 627 parallel bus to I2C bus controller.
627 628
628 This driver can also be built as a module. If so, the module 629 This driver can also be built as a module. If so, the module
@@ -634,11 +635,11 @@ config I2C_PCA_ISA
634 time). If unsure, say N. 635 time). If unsure, say N.
635 636
636config I2C_PCA_PLATFORM 637config I2C_PCA_PLATFORM
637 tristate "PCA9564 as platform device" 638 tristate "PCA9564/PCA9665 as platform device"
638 select I2C_ALGOPCA 639 select I2C_ALGOPCA
639 default n 640 default n
640 help 641 help
641 This driver supports a memory mapped Philips PCA9564 642 This driver supports a memory mapped Philips PCA9564/PCA9665
642 parallel bus to I2C bus controller. 643 parallel bus to I2C bus controller.
643 644
644 This driver can also be built as a module. If so, the module 645 This driver can also be built as a module. If so, the module
diff --git a/drivers/i2c/busses/i2c-davinci.c b/drivers/i2c/busses/i2c-davinci.c
index 5d7789834b95..3fae3a91ce5b 100644
--- a/drivers/i2c/busses/i2c-davinci.c
+++ b/drivers/i2c/busses/i2c-davinci.c
@@ -216,7 +216,7 @@ static int i2c_davinci_wait_bus_not_busy(struct davinci_i2c_dev *dev,
216{ 216{
217 unsigned long timeout; 217 unsigned long timeout;
218 218
219 timeout = jiffies + DAVINCI_I2C_TIMEOUT; 219 timeout = jiffies + dev->adapter.timeout;
220 while (davinci_i2c_read_reg(dev, DAVINCI_I2C_STR_REG) 220 while (davinci_i2c_read_reg(dev, DAVINCI_I2C_STR_REG)
221 & DAVINCI_I2C_STR_BB) { 221 & DAVINCI_I2C_STR_BB) {
222 if (time_after(jiffies, timeout)) { 222 if (time_after(jiffies, timeout)) {
@@ -289,7 +289,7 @@ i2c_davinci_xfer_msg(struct i2c_adapter *adap, struct i2c_msg *msg, int stop)
289 davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag); 289 davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag);
290 290
291 r = wait_for_completion_interruptible_timeout(&dev->cmd_complete, 291 r = wait_for_completion_interruptible_timeout(&dev->cmd_complete,
292 DAVINCI_I2C_TIMEOUT); 292 dev->adapter.timeout);
293 if (r == 0) { 293 if (r == 0) {
294 dev_err(dev->dev, "controller timed out\n"); 294 dev_err(dev->dev, "controller timed out\n");
295 i2c_davinci_init(dev); 295 i2c_davinci_init(dev);
@@ -546,9 +546,7 @@ static int davinci_i2c_probe(struct platform_device *pdev)
546 strlcpy(adap->name, "DaVinci I2C adapter", sizeof(adap->name)); 546 strlcpy(adap->name, "DaVinci I2C adapter", sizeof(adap->name));
547 adap->algo = &i2c_davinci_algo; 547 adap->algo = &i2c_davinci_algo;
548 adap->dev.parent = &pdev->dev; 548 adap->dev.parent = &pdev->dev;
549 549 adap->timeout = DAVINCI_I2C_TIMEOUT;
550 /* FIXME */
551 adap->timeout = 1;
552 550
553 adap->nr = pdev->id; 551 adap->nr = pdev->id;
554 r = i2c_add_numbered_adapter(adap); 552 r = i2c_add_numbered_adapter(adap);
diff --git a/drivers/i2c/busses/i2c-ibm_iic.c b/drivers/i2c/busses/i2c-ibm_iic.c
index 88f0db73b364..8b92a4666e02 100644
--- a/drivers/i2c/busses/i2c-ibm_iic.c
+++ b/drivers/i2c/busses/i2c-ibm_iic.c
@@ -415,7 +415,7 @@ static int iic_wait_for_tc(struct ibm_iic_private* dev){
415 if (dev->irq >= 0){ 415 if (dev->irq >= 0){
416 /* Interrupt mode */ 416 /* Interrupt mode */
417 ret = wait_event_interruptible_timeout(dev->wq, 417 ret = wait_event_interruptible_timeout(dev->wq,
418 !(in_8(&iic->sts) & STS_PT), dev->adap.timeout * HZ); 418 !(in_8(&iic->sts) & STS_PT), dev->adap.timeout);
419 419
420 if (unlikely(ret < 0)) 420 if (unlikely(ret < 0))
421 DBG("%d: wait interrupted\n", dev->idx); 421 DBG("%d: wait interrupted\n", dev->idx);
@@ -426,7 +426,7 @@ static int iic_wait_for_tc(struct ibm_iic_private* dev){
426 } 426 }
427 else { 427 else {
428 /* Polling mode */ 428 /* Polling mode */
429 unsigned long x = jiffies + dev->adap.timeout * HZ; 429 unsigned long x = jiffies + dev->adap.timeout;
430 430
431 while (in_8(&iic->sts) & STS_PT){ 431 while (in_8(&iic->sts) & STS_PT){
432 if (unlikely(time_after(jiffies, x))){ 432 if (unlikely(time_after(jiffies, x))){
@@ -748,7 +748,7 @@ static int __devinit iic_probe(struct of_device *ofdev,
748 i2c_set_adapdata(adap, dev); 748 i2c_set_adapdata(adap, dev);
749 adap->class = I2C_CLASS_HWMON | I2C_CLASS_SPD; 749 adap->class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
750 adap->algo = &iic_algo; 750 adap->algo = &iic_algo;
751 adap->timeout = 1; 751 adap->timeout = HZ;
752 752
753 ret = i2c_add_adapter(adap); 753 ret = i2c_add_adapter(adap);
754 if (ret < 0) { 754 if (ret < 0) {
diff --git a/drivers/i2c/busses/i2c-iop3xx.c b/drivers/i2c/busses/i2c-iop3xx.c
index 3190690c26ce..a75c75e77b92 100644
--- a/drivers/i2c/busses/i2c-iop3xx.c
+++ b/drivers/i2c/busses/i2c-iop3xx.c
@@ -488,7 +488,7 @@ iop3xx_i2c_probe(struct platform_device *pdev)
488 /* 488 /*
489 * Default values...should these come in from board code? 489 * Default values...should these come in from board code?
490 */ 490 */
491 new_adapter->timeout = 100; 491 new_adapter->timeout = HZ;
492 new_adapter->algo = &iop3xx_i2c_algo; 492 new_adapter->algo = &iop3xx_i2c_algo;
493 493
494 init_waitqueue_head(&adapter_data->waitq); 494 init_waitqueue_head(&adapter_data->waitq);
diff --git a/drivers/i2c/busses/i2c-mpc.c b/drivers/i2c/busses/i2c-mpc.c
index aedbbe6618db..2b847d875946 100644
--- a/drivers/i2c/busses/i2c-mpc.c
+++ b/drivers/i2c/busses/i2c-mpc.c
@@ -116,7 +116,7 @@ static int i2c_wait(struct mpc_i2c *i2c, unsigned timeout, int writing)
116 } else { 116 } else {
117 /* Interrupt mode */ 117 /* Interrupt mode */
118 result = wait_event_interruptible_timeout(i2c->queue, 118 result = wait_event_interruptible_timeout(i2c->queue,
119 (i2c->interrupt & CSR_MIF), timeout * HZ); 119 (i2c->interrupt & CSR_MIF), timeout);
120 120
121 if (unlikely(result < 0)) { 121 if (unlikely(result < 0)) {
122 pr_debug("I2C: wait interrupted\n"); 122 pr_debug("I2C: wait interrupted\n");
@@ -311,7 +311,7 @@ static struct i2c_adapter mpc_ops = {
311 .owner = THIS_MODULE, 311 .owner = THIS_MODULE,
312 .name = "MPC adapter", 312 .name = "MPC adapter",
313 .algo = &mpc_algo, 313 .algo = &mpc_algo,
314 .timeout = 1, 314 .timeout = HZ,
315}; 315};
316 316
317static int __devinit fsl_i2c_probe(struct of_device *op, const struct of_device_id *match) 317static int __devinit fsl_i2c_probe(struct of_device *op, const struct of_device_id *match)
diff --git a/drivers/i2c/busses/i2c-mv64xxx.c b/drivers/i2c/busses/i2c-mv64xxx.c
index 7f186bbcb99d..5a4945d1dba4 100644
--- a/drivers/i2c/busses/i2c-mv64xxx.c
+++ b/drivers/i2c/busses/i2c-mv64xxx.c
@@ -358,7 +358,7 @@ mv64xxx_i2c_wait_for_completion(struct mv64xxx_i2c_data *drv_data)
358 char abort = 0; 358 char abort = 0;
359 359
360 time_left = wait_event_interruptible_timeout(drv_data->waitq, 360 time_left = wait_event_interruptible_timeout(drv_data->waitq,
361 !drv_data->block, msecs_to_jiffies(drv_data->adapter.timeout)); 361 !drv_data->block, drv_data->adapter.timeout);
362 362
363 spin_lock_irqsave(&drv_data->lock, flags); 363 spin_lock_irqsave(&drv_data->lock, flags);
364 if (!time_left) { /* Timed out */ 364 if (!time_left) { /* Timed out */
@@ -374,8 +374,7 @@ mv64xxx_i2c_wait_for_completion(struct mv64xxx_i2c_data *drv_data)
374 spin_unlock_irqrestore(&drv_data->lock, flags); 374 spin_unlock_irqrestore(&drv_data->lock, flags);
375 375
376 time_left = wait_event_timeout(drv_data->waitq, 376 time_left = wait_event_timeout(drv_data->waitq,
377 !drv_data->block, 377 !drv_data->block, drv_data->adapter.timeout);
378 msecs_to_jiffies(drv_data->adapter.timeout));
379 378
380 if ((time_left <= 0) && drv_data->block) { 379 if ((time_left <= 0) && drv_data->block) {
381 drv_data->state = MV64XXX_I2C_STATE_IDLE; 380 drv_data->state = MV64XXX_I2C_STATE_IDLE;
@@ -530,7 +529,7 @@ mv64xxx_i2c_probe(struct platform_device *pd)
530 drv_data->adapter.algo = &mv64xxx_i2c_algo; 529 drv_data->adapter.algo = &mv64xxx_i2c_algo;
531 drv_data->adapter.owner = THIS_MODULE; 530 drv_data->adapter.owner = THIS_MODULE;
532 drv_data->adapter.class = I2C_CLASS_HWMON | I2C_CLASS_SPD; 531 drv_data->adapter.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
533 drv_data->adapter.timeout = pdata->timeout; 532 drv_data->adapter.timeout = msecs_to_jiffies(pdata->timeout);
534 drv_data->adapter.nr = pd->id; 533 drv_data->adapter.nr = pd->id;
535 platform_set_drvdata(pd, drv_data); 534 platform_set_drvdata(pd, drv_data);
536 i2c_set_adapdata(&drv_data->adapter, drv_data); 535 i2c_set_adapdata(&drv_data->adapter, drv_data);
diff --git a/drivers/i2c/busses/i2c-nforce2.c b/drivers/i2c/busses/i2c-nforce2.c
index 05af6cd7f270..2ff4683703a8 100644
--- a/drivers/i2c/busses/i2c-nforce2.c
+++ b/drivers/i2c/busses/i2c-nforce2.c
@@ -31,10 +31,14 @@
31 nForce3 250Gb MCP 00E4 31 nForce3 250Gb MCP 00E4
32 nForce4 MCP 0052 32 nForce4 MCP 0052
33 nForce4 MCP-04 0034 33 nForce4 MCP-04 0034
34 nForce4 MCP51 0264 34 nForce MCP51 0264
35 nForce4 MCP55 0368 35 nForce MCP55 0368
36 nForce MCP61 03EB 36 nForce MCP61 03EB
37 nForce MCP65 0446 37 nForce MCP65 0446
38 nForce MCP67 0542
39 nForce MCP73 07D8
40 nForce MCP78S 0752
41 nForce MCP79 0AA2
38 42
39 This driver supports the 2 SMBuses that are included in the MCP of the 43 This driver supports the 2 SMBuses that are included in the MCP of the
40 nForce2/3/4/5xx chipsets. 44 nForce2/3/4/5xx chipsets.
@@ -315,6 +319,10 @@ static struct pci_device_id nforce2_ids[] = {
315 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SMBUS) }, 319 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SMBUS) },
316 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SMBUS) }, 320 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SMBUS) },
317 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP65_SMBUS) }, 321 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP65_SMBUS) },
322 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP67_SMBUS) },
323 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP73_SMBUS) },
324 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP78S_SMBUS) },
325 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP79_SMBUS) },
318 { 0 } 326 { 0 }
319}; 327};
320 328
diff --git a/drivers/i2c/busses/i2c-pca-isa.c b/drivers/i2c/busses/i2c-pca-isa.c
index 4aa8138cb0a9..0ed68e2ccd22 100644
--- a/drivers/i2c/busses/i2c-pca-isa.c
+++ b/drivers/i2c/busses/i2c-pca-isa.c
@@ -23,6 +23,7 @@
23#include <linux/module.h> 23#include <linux/module.h>
24#include <linux/moduleparam.h> 24#include <linux/moduleparam.h>
25#include <linux/delay.h> 25#include <linux/delay.h>
26#include <linux/jiffies.h>
26#include <linux/init.h> 27#include <linux/init.h>
27#include <linux/interrupt.h> 28#include <linux/interrupt.h>
28#include <linux/wait.h> 29#include <linux/wait.h>
@@ -41,15 +42,17 @@ static int irq = -1;
41 42
42/* Data sheet recommends 59kHz for 100kHz operation due to variation 43/* Data sheet recommends 59kHz for 100kHz operation due to variation
43 * in the actual clock rate */ 44 * in the actual clock rate */
44static int clock = I2C_PCA_CON_59kHz; 45static int clock = 59000;
45 46
47static struct i2c_adapter pca_isa_ops;
46static wait_queue_head_t pca_wait; 48static wait_queue_head_t pca_wait;
47 49
48static void pca_isa_writebyte(void *pd, int reg, int val) 50static void pca_isa_writebyte(void *pd, int reg, int val)
49{ 51{
50#ifdef DEBUG_IO 52#ifdef DEBUG_IO
51 static char *names[] = { "T/O", "DAT", "ADR", "CON" }; 53 static char *names[] = { "T/O", "DAT", "ADR", "CON" };
52 printk("*** write %s at %#lx <= %#04x\n", names[reg], base+reg, val); 54 printk(KERN_DEBUG "*** write %s at %#lx <= %#04x\n", names[reg],
55 base+reg, val);
53#endif 56#endif
54 outb(val, base+reg); 57 outb(val, base+reg);
55} 58}
@@ -60,7 +63,7 @@ static int pca_isa_readbyte(void *pd, int reg)
60#ifdef DEBUG_IO 63#ifdef DEBUG_IO
61 { 64 {
62 static char *names[] = { "STA", "DAT", "ADR", "CON" }; 65 static char *names[] = { "STA", "DAT", "ADR", "CON" };
63 printk("*** read %s => %#04x\n", names[reg], res); 66 printk(KERN_DEBUG "*** read %s => %#04x\n", names[reg], res);
64 } 67 }
65#endif 68#endif
66 return res; 69 return res;
@@ -68,16 +71,22 @@ static int pca_isa_readbyte(void *pd, int reg)
68 71
69static int pca_isa_waitforcompletion(void *pd) 72static int pca_isa_waitforcompletion(void *pd)
70{ 73{
71 int ret = 0; 74 long ret = ~0;
75 unsigned long timeout;
72 76
73 if (irq > -1) { 77 if (irq > -1) {
74 ret = wait_event_interruptible(pca_wait, 78 ret = wait_event_interruptible_timeout(pca_wait,
75 pca_isa_readbyte(pd, I2C_PCA_CON) & I2C_PCA_CON_SI); 79 pca_isa_readbyte(pd, I2C_PCA_CON)
80 & I2C_PCA_CON_SI, pca_isa_ops.timeout);
76 } else { 81 } else {
77 while ((pca_isa_readbyte(pd, I2C_PCA_CON) & I2C_PCA_CON_SI) == 0) 82 /* Do polling */
83 timeout = jiffies + pca_isa_ops.timeout;
84 while (((pca_isa_readbyte(pd, I2C_PCA_CON)
85 & I2C_PCA_CON_SI) == 0)
86 && (ret = time_before(jiffies, timeout)))
78 udelay(100); 87 udelay(100);
79 } 88 }
80 return ret; 89 return ret > 0;
81} 90}
82 91
83static void pca_isa_resetchip(void *pd) 92static void pca_isa_resetchip(void *pd)
@@ -102,8 +111,8 @@ static struct i2c_algo_pca_data pca_isa_data = {
102static struct i2c_adapter pca_isa_ops = { 111static struct i2c_adapter pca_isa_ops = {
103 .owner = THIS_MODULE, 112 .owner = THIS_MODULE,
104 .algo_data = &pca_isa_data, 113 .algo_data = &pca_isa_data,
105 .name = "PCA9564 ISA Adapter", 114 .name = "PCA9564/PCA9665 ISA Adapter",
106 .timeout = 100, 115 .timeout = HZ,
107}; 116};
108 117
109static int __devinit pca_isa_match(struct device *dev, unsigned int id) 118static int __devinit pca_isa_match(struct device *dev, unsigned int id)
@@ -195,7 +204,7 @@ static void __exit pca_isa_exit(void)
195} 204}
196 205
197MODULE_AUTHOR("Ian Campbell <icampbell@arcom.com>"); 206MODULE_AUTHOR("Ian Campbell <icampbell@arcom.com>");
198MODULE_DESCRIPTION("ISA base PCA9564 driver"); 207MODULE_DESCRIPTION("ISA base PCA9564/PCA9665 driver");
199MODULE_LICENSE("GPL"); 208MODULE_LICENSE("GPL");
200 209
201module_param(base, ulong, 0); 210module_param(base, ulong, 0);
@@ -204,7 +213,13 @@ MODULE_PARM_DESC(base, "I/O base address");
204module_param(irq, int, 0); 213module_param(irq, int, 0);
205MODULE_PARM_DESC(irq, "IRQ"); 214MODULE_PARM_DESC(irq, "IRQ");
206module_param(clock, int, 0); 215module_param(clock, int, 0);
207MODULE_PARM_DESC(clock, "Clock rate as described in table 1 of PCA9564 datasheet"); 216MODULE_PARM_DESC(clock, "Clock rate in hertz.\n\t\t"
217 "For PCA9564: 330000,288000,217000,146000,"
218 "88000,59000,44000,36000\n"
219 "\t\tFor PCA9665:\tStandard: 60300 - 100099\n"
220 "\t\t\t\tFast: 100100 - 400099\n"
221 "\t\t\t\tFast+: 400100 - 10000099\n"
222 "\t\t\t\tTurbo: Up to 1265800");
208 223
209module_init(pca_isa_init); 224module_init(pca_isa_init);
210module_exit(pca_isa_exit); 225module_exit(pca_isa_exit);
diff --git a/drivers/i2c/busses/i2c-pca-platform.c b/drivers/i2c/busses/i2c-pca-platform.c
index 6bb15ad0a6b6..7b23891b7d59 100644
--- a/drivers/i2c/busses/i2c-pca-platform.c
+++ b/drivers/i2c/busses/i2c-pca-platform.c
@@ -15,6 +15,7 @@
15#include <linux/init.h> 15#include <linux/init.h>
16#include <linux/slab.h> 16#include <linux/slab.h>
17#include <linux/delay.h> 17#include <linux/delay.h>
18#include <linux/jiffies.h>
18#include <linux/errno.h> 19#include <linux/errno.h>
19#include <linux/i2c.h> 20#include <linux/i2c.h>
20#include <linux/interrupt.h> 21#include <linux/interrupt.h>
@@ -81,24 +82,23 @@ static void i2c_pca_pf_writebyte32(void *pd, int reg, int val)
81static int i2c_pca_pf_waitforcompletion(void *pd) 82static int i2c_pca_pf_waitforcompletion(void *pd)
82{ 83{
83 struct i2c_pca_pf_data *i2c = pd; 84 struct i2c_pca_pf_data *i2c = pd;
84 int ret = 0; 85 long ret = ~0;
86 unsigned long timeout;
85 87
86 if (i2c->irq) { 88 if (i2c->irq) {
87 ret = wait_event_interruptible(i2c->wait, 89 ret = wait_event_interruptible_timeout(i2c->wait,
88 i2c->algo_data.read_byte(i2c, I2C_PCA_CON) 90 i2c->algo_data.read_byte(i2c, I2C_PCA_CON)
89 & I2C_PCA_CON_SI); 91 & I2C_PCA_CON_SI, i2c->adap.timeout);
90 } else { 92 } else {
91 /* 93 /* Do polling */
92 * Do polling... 94 timeout = jiffies + i2c->adap.timeout;
93 * XXX: Could get stuck in extreme cases! 95 while (((i2c->algo_data.read_byte(i2c, I2C_PCA_CON)
94 * Maybe add timeout, but using irqs is preferred anyhow.
95 */
96 while ((i2c->algo_data.read_byte(i2c, I2C_PCA_CON)
97 & I2C_PCA_CON_SI) == 0) 96 & I2C_PCA_CON_SI) == 0)
97 && (ret = time_before(jiffies, timeout)))
98 udelay(100); 98 udelay(100);
99 } 99 }
100 100
101 return ret; 101 return ret > 0;
102} 102}
103 103
104static void i2c_pca_pf_dummyreset(void *pd) 104static void i2c_pca_pf_dummyreset(void *pd)
@@ -172,14 +172,25 @@ static int __devinit i2c_pca_pf_probe(struct platform_device *pdev)
172 172
173 i2c->adap.nr = pdev->id >= 0 ? pdev->id : 0; 173 i2c->adap.nr = pdev->id >= 0 ? pdev->id : 0;
174 i2c->adap.owner = THIS_MODULE; 174 i2c->adap.owner = THIS_MODULE;
175 snprintf(i2c->adap.name, sizeof(i2c->adap.name), "PCA9564 at 0x%08lx", 175 snprintf(i2c->adap.name, sizeof(i2c->adap.name),
176 (unsigned long) res->start); 176 "PCA9564/PCA9665 at 0x%08lx",
177 (unsigned long) res->start);
177 i2c->adap.algo_data = &i2c->algo_data; 178 i2c->adap.algo_data = &i2c->algo_data;
178 i2c->adap.dev.parent = &pdev->dev; 179 i2c->adap.dev.parent = &pdev->dev;
179 i2c->adap.timeout = platform_data->timeout;
180 180
181 i2c->algo_data.i2c_clock = platform_data->i2c_clock_speed; 181 if (platform_data) {
182 i2c->adap.timeout = platform_data->timeout;
183 i2c->algo_data.i2c_clock = platform_data->i2c_clock_speed;
184 i2c->gpio = platform_data->gpio;
185 } else {
186 i2c->adap.timeout = HZ;
187 i2c->algo_data.i2c_clock = 59000;
188 i2c->gpio = -1;
189 }
190
182 i2c->algo_data.data = i2c; 191 i2c->algo_data.data = i2c;
192 i2c->algo_data.wait_for_completion = i2c_pca_pf_waitforcompletion;
193 i2c->algo_data.reset_chip = i2c_pca_pf_dummyreset;
183 194
184 switch (res->flags & IORESOURCE_MEM_TYPE_MASK) { 195 switch (res->flags & IORESOURCE_MEM_TYPE_MASK) {
185 case IORESOURCE_MEM_32BIT: 196 case IORESOURCE_MEM_32BIT:
@@ -197,11 +208,6 @@ static int __devinit i2c_pca_pf_probe(struct platform_device *pdev)
197 break; 208 break;
198 } 209 }
199 210
200 i2c->algo_data.wait_for_completion = i2c_pca_pf_waitforcompletion;
201
202 i2c->gpio = platform_data->gpio;
203 i2c->algo_data.reset_chip = i2c_pca_pf_dummyreset;
204
205 /* Use gpio_is_valid() when in mainline */ 211 /* Use gpio_is_valid() when in mainline */
206 if (i2c->gpio > -1) { 212 if (i2c->gpio > -1) {
207 ret = gpio_request(i2c->gpio, i2c->adap.name); 213 ret = gpio_request(i2c->gpio, i2c->adap.name);
@@ -246,7 +252,7 @@ e_remap:
246e_alloc: 252e_alloc:
247 release_mem_region(res->start, res_len(res)); 253 release_mem_region(res->start, res_len(res));
248e_print: 254e_print:
249 printk(KERN_ERR "Registering PCA9564 FAILED! (%d)\n", ret); 255 printk(KERN_ERR "Registering PCA9564/PCA9665 FAILED! (%d)\n", ret);
250 return ret; 256 return ret;
251} 257}
252 258
@@ -290,7 +296,7 @@ static void __exit i2c_pca_pf_exit(void)
290} 296}
291 297
292MODULE_AUTHOR("Wolfram Sang <w.sang@pengutronix.de>"); 298MODULE_AUTHOR("Wolfram Sang <w.sang@pengutronix.de>");
293MODULE_DESCRIPTION("I2C-PCA9564 platform driver"); 299MODULE_DESCRIPTION("I2C-PCA9564/PCA9665 platform driver");
294MODULE_LICENSE("GPL"); 300MODULE_LICENSE("GPL");
295 301
296module_init(i2c_pca_pf_init); 302module_init(i2c_pca_pf_init);
diff --git a/drivers/i2c/busses/i2c-piix4.c b/drivers/i2c/busses/i2c-piix4.c
index 761f9dd53620..0249a7d762b9 100644
--- a/drivers/i2c/busses/i2c-piix4.c
+++ b/drivers/i2c/busses/i2c-piix4.c
@@ -20,7 +20,7 @@
20/* 20/*
21 Supports: 21 Supports:
22 Intel PIIX4, 440MX 22 Intel PIIX4, 440MX
23 Serverworks OSB4, CSB5, CSB6, HT-1000 23 Serverworks OSB4, CSB5, CSB6, HT-1000, HT-1100
24 ATI IXP200, IXP300, IXP400, SB600, SB700, SB800 24 ATI IXP200, IXP300, IXP400, SB600, SB700, SB800
25 SMSC Victory66 25 SMSC Victory66
26 26
@@ -226,6 +226,70 @@ static int __devinit piix4_setup(struct pci_dev *PIIX4_dev,
226 return 0; 226 return 0;
227} 227}
228 228
229static int __devinit piix4_setup_sb800(struct pci_dev *PIIX4_dev,
230 const struct pci_device_id *id)
231{
232 unsigned short smba_idx = 0xcd6;
233 u8 smba_en_lo, smba_en_hi, i2ccfg, i2ccfg_offset = 0x10, smb_en = 0x2c;
234
235 /* SB800 SMBus does not support forcing address */
236 if (force || force_addr) {
237 dev_err(&PIIX4_dev->dev, "SB800 SMBus does not support "
238 "forcing address!\n");
239 return -EINVAL;
240 }
241
242 /* Determine the address of the SMBus areas */
243 if (!request_region(smba_idx, 2, "smba_idx")) {
244 dev_err(&PIIX4_dev->dev, "SMBus base address index region "
245 "0x%x already in use!\n", smba_idx);
246 return -EBUSY;
247 }
248 outb_p(smb_en, smba_idx);
249 smba_en_lo = inb_p(smba_idx + 1);
250 outb_p(smb_en + 1, smba_idx);
251 smba_en_hi = inb_p(smba_idx + 1);
252 release_region(smba_idx, 2);
253
254 if ((smba_en_lo & 1) == 0) {
255 dev_err(&PIIX4_dev->dev,
256 "Host SMBus controller not enabled!\n");
257 return -ENODEV;
258 }
259
260 piix4_smba = ((smba_en_hi << 8) | smba_en_lo) & 0xffe0;
261 if (acpi_check_region(piix4_smba, SMBIOSIZE, piix4_driver.name))
262 return -EBUSY;
263
264 if (!request_region(piix4_smba, SMBIOSIZE, piix4_driver.name)) {
265 dev_err(&PIIX4_dev->dev, "SMBus region 0x%x already in use!\n",
266 piix4_smba);
267 return -EBUSY;
268 }
269
270 /* Request the SMBus I2C bus config region */
271 if (!request_region(piix4_smba + i2ccfg_offset, 1, "i2ccfg")) {
272 dev_err(&PIIX4_dev->dev, "SMBus I2C bus config region "
273 "0x%x already in use!\n", piix4_smba + i2ccfg_offset);
274 release_region(piix4_smba, SMBIOSIZE);
275 piix4_smba = 0;
276 return -EBUSY;
277 }
278 i2ccfg = inb_p(piix4_smba + i2ccfg_offset);
279 release_region(piix4_smba + i2ccfg_offset, 1);
280
281 if (i2ccfg & 1)
282 dev_dbg(&PIIX4_dev->dev, "Using IRQ for SMBus.\n");
283 else
284 dev_dbg(&PIIX4_dev->dev, "Using SMI# for SMBus.\n");
285
286 dev_info(&PIIX4_dev->dev,
287 "SMBus Host Controller at 0x%x, revision %d\n",
288 piix4_smba, i2ccfg >> 4);
289
290 return 0;
291}
292
229static int piix4_transaction(void) 293static int piix4_transaction(void)
230{ 294{
231 int temp; 295 int temp;
@@ -423,6 +487,8 @@ static struct pci_device_id piix4_ids[] = {
423 PCI_DEVICE_ID_SERVERWORKS_CSB6) }, 487 PCI_DEVICE_ID_SERVERWORKS_CSB6) },
424 { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, 488 { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS,
425 PCI_DEVICE_ID_SERVERWORKS_HT1000SB) }, 489 PCI_DEVICE_ID_SERVERWORKS_HT1000SB) },
490 { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS,
491 PCI_DEVICE_ID_SERVERWORKS_HT1100LD) },
426 { 0, } 492 { 0, }
427}; 493};
428 494
@@ -433,7 +499,14 @@ static int __devinit piix4_probe(struct pci_dev *dev,
433{ 499{
434 int retval; 500 int retval;
435 501
436 retval = piix4_setup(dev, id); 502 if ((dev->vendor == PCI_VENDOR_ID_ATI) &&
503 (dev->device == PCI_DEVICE_ID_ATI_SBX00_SMBUS) &&
504 (dev->revision >= 0x40))
505 /* base address location etc changed in SB800 */
506 retval = piix4_setup_sb800(dev, id);
507 else
508 retval = piix4_setup(dev, id);
509
437 if (retval) 510 if (retval)
438 return retval; 511 return retval;
439 512
diff --git a/drivers/i2c/busses/i2c-powermac.c b/drivers/i2c/busses/i2c-powermac.c
index 60ca91745e55..3c9d71f60187 100644
--- a/drivers/i2c/busses/i2c-powermac.c
+++ b/drivers/i2c/busses/i2c-powermac.c
@@ -191,7 +191,8 @@ static int __devexit i2c_powermac_remove(struct platform_device *dev)
191 i2c_set_adapdata(adapter, NULL); 191 i2c_set_adapdata(adapter, NULL);
192 /* We aren't that prepared to deal with this... */ 192 /* We aren't that prepared to deal with this... */
193 if (rc) 193 if (rc)
194 printk("i2c-powermac.c: Failed to remove bus %s !\n", 194 printk(KERN_WARNING
195 "i2c-powermac.c: Failed to remove bus %s !\n",
195 adapter->name); 196 adapter->name);
196 platform_set_drvdata(dev, NULL); 197 platform_set_drvdata(dev, NULL);
197 kfree(adapter); 198 kfree(adapter);
diff --git a/drivers/i2c/busses/i2c-pxa.c b/drivers/i2c/busses/i2c-pxa.c
index bdb1f7510e91..c1405c8f6ba5 100644
--- a/drivers/i2c/busses/i2c-pxa.c
+++ b/drivers/i2c/busses/i2c-pxa.c
@@ -210,11 +210,12 @@ static irqreturn_t i2c_pxa_handler(int this_irq, void *dev_id);
210static void i2c_pxa_scream_blue_murder(struct pxa_i2c *i2c, const char *why) 210static void i2c_pxa_scream_blue_murder(struct pxa_i2c *i2c, const char *why)
211{ 211{
212 unsigned int i; 212 unsigned int i;
213 printk("i2c: error: %s\n", why); 213 printk(KERN_ERR "i2c: error: %s\n", why);
214 printk("i2c: msg_num: %d msg_idx: %d msg_ptr: %d\n", 214 printk(KERN_ERR "i2c: msg_num: %d msg_idx: %d msg_ptr: %d\n",
215 i2c->msg_num, i2c->msg_idx, i2c->msg_ptr); 215 i2c->msg_num, i2c->msg_idx, i2c->msg_ptr);
216 printk("i2c: ICR: %08x ISR: %08x\n" 216 printk(KERN_ERR "i2c: ICR: %08x ISR: %08x\n",
217 "i2c: log: ", readl(_ICR(i2c)), readl(_ISR(i2c))); 217 readl(_ICR(i2c)), readl(_ISR(i2c)));
218 printk(KERN_DEBUG "i2c: log: ");
218 for (i = 0; i < i2c->irqlogidx; i++) 219 for (i = 0; i < i2c->irqlogidx; i++)
219 printk("[%08x:%08x] ", i2c->isrlog[i], i2c->icrlog[i]); 220 printk("[%08x:%08x] ", i2c->isrlog[i], i2c->icrlog[i]);
220 printk("\n"); 221 printk("\n");
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index fbb9030b68a5..b6f3a0de6ca2 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -152,7 +152,7 @@ static void i2c_device_shutdown(struct device *dev)
152 driver->shutdown(to_i2c_client(dev)); 152 driver->shutdown(to_i2c_client(dev));
153} 153}
154 154
155static int i2c_device_suspend(struct device * dev, pm_message_t mesg) 155static int i2c_device_suspend(struct device *dev, pm_message_t mesg)
156{ 156{
157 struct i2c_driver *driver; 157 struct i2c_driver *driver;
158 158
@@ -164,7 +164,7 @@ static int i2c_device_suspend(struct device * dev, pm_message_t mesg)
164 return driver->suspend(to_i2c_client(dev), mesg); 164 return driver->suspend(to_i2c_client(dev), mesg);
165} 165}
166 166
167static int i2c_device_resume(struct device * dev) 167static int i2c_device_resume(struct device *dev)
168{ 168{
169 struct i2c_driver *driver; 169 struct i2c_driver *driver;
170 170
@@ -187,13 +187,15 @@ static void i2c_client_dev_release(struct device *dev)
187 kfree(to_i2c_client(dev)); 187 kfree(to_i2c_client(dev));
188} 188}
189 189
190static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf) 190static ssize_t
191show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
191{ 192{
192 struct i2c_client *client = to_i2c_client(dev); 193 struct i2c_client *client = to_i2c_client(dev);
193 return sprintf(buf, "%s\n", client->name); 194 return sprintf(buf, "%s\n", client->name);
194} 195}
195 196
196static ssize_t show_modalias(struct device *dev, struct device_attribute *attr, char *buf) 197static ssize_t
198show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
197{ 199{
198 struct i2c_client *client = to_i2c_client(dev); 200 struct i2c_client *client = to_i2c_client(dev);
199 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name); 201 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
@@ -365,8 +367,7 @@ static struct i2c_driver dummy_driver = {
365 * This returns the new i2c client, which should be saved for later use with 367 * This returns the new i2c client, which should be saved for later use with
366 * i2c_unregister_device(); or NULL to indicate an error. 368 * i2c_unregister_device(); or NULL to indicate an error.
367 */ 369 */
368struct i2c_client * 370struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
369i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
370{ 371{
371 struct i2c_board_info info = { 372 struct i2c_board_info info = {
372 I2C_BOARD_INFO("dummy", address), 373 I2C_BOARD_INFO("dummy", address),
@@ -413,8 +414,8 @@ static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
413 if (devinfo->busnum == adapter->nr 414 if (devinfo->busnum == adapter->nr
414 && !i2c_new_device(adapter, 415 && !i2c_new_device(adapter,
415 &devinfo->board_info)) 416 &devinfo->board_info))
416 printk(KERN_ERR "i2c-core: can't create i2c%d-%04x\n", 417 dev_err(&adapter->dev,
417 i2c_adapter_id(adapter), 418 "Can't create device at 0x%02x\n",
418 devinfo->board_info.addr); 419 devinfo->board_info.addr);
419 } 420 }
420 mutex_unlock(&__i2c_board_lock); 421 mutex_unlock(&__i2c_board_lock);
@@ -459,6 +460,11 @@ static int i2c_register_adapter(struct i2c_adapter *adap)
459 pr_debug("I2C adapter driver [%s] forgot to specify " 460 pr_debug("I2C adapter driver [%s] forgot to specify "
460 "physical device\n", adap->name); 461 "physical device\n", adap->name);
461 } 462 }
463
464 /* Set default timeout to 1 second if not already set */
465 if (adap->timeout == 0)
466 adap->timeout = HZ;
467
462 dev_set_name(&adap->dev, "i2c-%d", adap->nr); 468 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
463 adap->dev.release = &i2c_adapter_dev_release; 469 adap->dev.release = &i2c_adapter_dev_release;
464 adap->dev.class = &i2c_adapter_class; 470 adap->dev.class = &i2c_adapter_class;
@@ -581,7 +587,8 @@ static int i2c_do_del_adapter(struct device_driver *d, void *data)
581 struct i2c_client *client, *_n; 587 struct i2c_client *client, *_n;
582 int res; 588 int res;
583 589
584 /* Remove the devices we created ourselves */ 590 /* Remove the devices we created ourselves as the result of hardware
591 * probing (using a driver's detect method) */
585 list_for_each_entry_safe(client, _n, &driver->clients, detected) { 592 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
586 if (client->adapter == adapter) { 593 if (client->adapter == adapter) {
587 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n", 594 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
@@ -749,6 +756,8 @@ static int __detach_adapter(struct device *dev, void *data)
749 struct i2c_driver *driver = data; 756 struct i2c_driver *driver = data;
750 struct i2c_client *client, *_n; 757 struct i2c_client *client, *_n;
751 758
759 /* Remove the devices we created ourselves as the result of hardware
760 * probing (using a driver's detect method) */
752 list_for_each_entry_safe(client, _n, &driver->clients, detected) { 761 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
753 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n", 762 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
754 client->name, client->addr); 763 client->name, client->addr);
@@ -1012,7 +1021,7 @@ module_exit(i2c_exit);
1012 * Note that there is no requirement that each message be sent to 1021 * Note that there is no requirement that each message be sent to
1013 * the same slave address, although that is the most common model. 1022 * the same slave address, although that is the most common model.
1014 */ 1023 */
1015int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num) 1024int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1016{ 1025{
1017 int ret; 1026 int ret;
1018 1027
@@ -1519,8 +1528,7 @@ EXPORT_SYMBOL(i2c_put_adapter);
1519/* The SMBus parts */ 1528/* The SMBus parts */
1520 1529
1521#define POLY (0x1070U << 3) 1530#define POLY (0x1070U << 3)
1522static u8 1531static u8 crc8(u16 data)
1523crc8(u16 data)
1524{ 1532{
1525 int i; 1533 int i;
1526 1534
@@ -1984,9 +1992,9 @@ static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1984 * This executes an SMBus protocol operation, and returns a negative 1992 * This executes an SMBus protocol operation, and returns a negative
1985 * errno code else zero on success. 1993 * errno code else zero on success.
1986 */ 1994 */
1987s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags, 1995s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
1988 char read_write, u8 command, int protocol, 1996 char read_write, u8 command, int protocol,
1989 union i2c_smbus_data * data) 1997 union i2c_smbus_data *data)
1990{ 1998{
1991 s32 res; 1999 s32 res;
1992 2000
diff --git a/drivers/misc/eeprom/Kconfig b/drivers/misc/eeprom/Kconfig
index c76df8cda5ef..89fec052f3b4 100644
--- a/drivers/misc/eeprom/Kconfig
+++ b/drivers/misc/eeprom/Kconfig
@@ -2,7 +2,7 @@ menu "EEPROM support"
2 2
3config EEPROM_AT24 3config EEPROM_AT24
4 tristate "I2C EEPROMs from most vendors" 4 tristate "I2C EEPROMs from most vendors"
5 depends on I2C && SYSFS && EXPERIMENTAL 5 depends on I2C && SYSFS
6 help 6 help
7 Enable this driver to get read/write support to most I2C EEPROMs, 7 Enable this driver to get read/write support to most I2C EEPROMs,
8 after you configure the driver to know about each EEPROM on 8 after you configure the driver to know about each EEPROM on
diff --git a/include/linux/i2c-algo-pca.h b/include/linux/i2c-algo-pca.h
index adcb3dc7ac26..1364d62e2fbe 100644
--- a/include/linux/i2c-algo-pca.h
+++ b/include/linux/i2c-algo-pca.h
@@ -1,7 +1,14 @@
1#ifndef _LINUX_I2C_ALGO_PCA_H 1#ifndef _LINUX_I2C_ALGO_PCA_H
2#define _LINUX_I2C_ALGO_PCA_H 2#define _LINUX_I2C_ALGO_PCA_H
3 3
4/* Clock speeds for the bus */ 4/* Chips known to the pca algo */
5#define I2C_PCA_CHIP_9564 0x00
6#define I2C_PCA_CHIP_9665 0x01
7
8/* Internal period for PCA9665 oscilator */
9#define I2C_PCA_OSC_PER 3 /* e10-8s */
10
11/* Clock speeds for the bus for PCA9564*/
5#define I2C_PCA_CON_330kHz 0x00 12#define I2C_PCA_CON_330kHz 0x00
6#define I2C_PCA_CON_288kHz 0x01 13#define I2C_PCA_CON_288kHz 0x01
7#define I2C_PCA_CON_217kHz 0x02 14#define I2C_PCA_CON_217kHz 0x02
@@ -18,6 +25,26 @@
18#define I2C_PCA_ADR 0x02 /* OWN ADR Read/Write */ 25#define I2C_PCA_ADR 0x02 /* OWN ADR Read/Write */
19#define I2C_PCA_CON 0x03 /* CONTROL Read/Write */ 26#define I2C_PCA_CON 0x03 /* CONTROL Read/Write */
20 27
28/* PCA9665 registers */
29#define I2C_PCA_INDPTR 0x00 /* INDIRECT Pointer Write Only */
30#define I2C_PCA_IND 0x02 /* INDIRECT Read/Write */
31
32/* PCA9665 indirect registers */
33#define I2C_PCA_ICOUNT 0x00 /* Byte Count for buffered mode */
34#define I2C_PCA_IADR 0x01 /* OWN ADR */
35#define I2C_PCA_ISCLL 0x02 /* SCL LOW period */
36#define I2C_PCA_ISCLH 0x03 /* SCL HIGH period */
37#define I2C_PCA_ITO 0x04 /* TIMEOUT */
38#define I2C_PCA_IPRESET 0x05 /* Parallel bus reset */
39#define I2C_PCA_IMODE 0x06 /* I2C Bus mode */
40
41/* PCA9665 I2C bus mode */
42#define I2C_PCA_MODE_STD 0x00 /* Standard mode */
43#define I2C_PCA_MODE_FAST 0x01 /* Fast mode */
44#define I2C_PCA_MODE_FASTP 0x02 /* Fast Plus mode */
45#define I2C_PCA_MODE_TURBO 0x03 /* Turbo mode */
46
47
21#define I2C_PCA_CON_AA 0x80 /* Assert Acknowledge */ 48#define I2C_PCA_CON_AA 0x80 /* Assert Acknowledge */
22#define I2C_PCA_CON_ENSIO 0x40 /* Enable */ 49#define I2C_PCA_CON_ENSIO 0x40 /* Enable */
23#define I2C_PCA_CON_STA 0x20 /* Start */ 50#define I2C_PCA_CON_STA 0x20 /* Start */
@@ -31,7 +58,9 @@ struct i2c_algo_pca_data {
31 int (*read_byte) (void *data, int reg); 58 int (*read_byte) (void *data, int reg);
32 int (*wait_for_completion) (void *data); 59 int (*wait_for_completion) (void *data);
33 void (*reset_chip) (void *data); 60 void (*reset_chip) (void *data);
34 /* i2c_clock values are defined in linux/i2c-algo-pca.h */ 61 /* For PCA9564, use one of the predefined frequencies:
62 * 330000, 288000, 217000, 146000, 88000, 59000, 44000, 36000
63 * For PCA9665, use the frequency you want here. */
35 unsigned int i2c_clock; 64 unsigned int i2c_clock;
36}; 65};
37 66
diff --git a/include/linux/i2c-pca-platform.h b/include/linux/i2c-pca-platform.h
index 3d191873f2d1..aba33759dec4 100644
--- a/include/linux/i2c-pca-platform.h
+++ b/include/linux/i2c-pca-platform.h
@@ -6,7 +6,7 @@ struct i2c_pca9564_pf_platform_data {
6 * not supplied (negative value), but it 6 * not supplied (negative value), but it
7 * cannot exit some error conditions then */ 7 * cannot exit some error conditions then */
8 int i2c_clock_speed; /* values are defined in linux/i2c-algo-pca.h */ 8 int i2c_clock_speed; /* values are defined in linux/i2c-algo-pca.h */
9 int timeout; /* timeout = this value * 10us */ 9 int timeout; /* timeout in jiffies */
10}; 10};
11 11
12#endif /* I2C_PCA9564_PLATFORM_H */ 12#endif /* I2C_PCA9564_PLATFORM_H */
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 05dfa7c4fb64..2c9e8080da5e 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -1237,6 +1237,7 @@
1237#define PCI_DEVICE_ID_NVIDIA_NVENET_21 0x0451 1237#define PCI_DEVICE_ID_NVIDIA_NVENET_21 0x0451
1238#define PCI_DEVICE_ID_NVIDIA_NVENET_22 0x0452 1238#define PCI_DEVICE_ID_NVIDIA_NVENET_22 0x0452
1239#define PCI_DEVICE_ID_NVIDIA_NVENET_23 0x0453 1239#define PCI_DEVICE_ID_NVIDIA_NVENET_23 0x0453
1240#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP67_SMBUS 0x0542
1240#define PCI_DEVICE_ID_NVIDIA_NVENET_24 0x054C 1241#define PCI_DEVICE_ID_NVIDIA_NVENET_24 0x054C
1241#define PCI_DEVICE_ID_NVIDIA_NVENET_25 0x054D 1242#define PCI_DEVICE_ID_NVIDIA_NVENET_25 0x054D
1242#define PCI_DEVICE_ID_NVIDIA_NVENET_26 0x054E 1243#define PCI_DEVICE_ID_NVIDIA_NVENET_26 0x054E
@@ -1247,11 +1248,14 @@
1247#define PCI_DEVICE_ID_NVIDIA_NVENET_31 0x07DF 1248#define PCI_DEVICE_ID_NVIDIA_NVENET_31 0x07DF
1248#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP67_IDE 0x0560 1249#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP67_IDE 0x0560
1249#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP73_IDE 0x056C 1250#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP73_IDE 0x056C
1251#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP78S_SMBUS 0x0752
1250#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP77_IDE 0x0759 1252#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP77_IDE 0x0759
1251#define PCI_DEVICE_ID_NVIDIA_NVENET_32 0x0760 1253#define PCI_DEVICE_ID_NVIDIA_NVENET_32 0x0760
1252#define PCI_DEVICE_ID_NVIDIA_NVENET_33 0x0761 1254#define PCI_DEVICE_ID_NVIDIA_NVENET_33 0x0761
1253#define PCI_DEVICE_ID_NVIDIA_NVENET_34 0x0762 1255#define PCI_DEVICE_ID_NVIDIA_NVENET_34 0x0762
1254#define PCI_DEVICE_ID_NVIDIA_NVENET_35 0x0763 1256#define PCI_DEVICE_ID_NVIDIA_NVENET_35 0x0763
1257#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP73_SMBUS 0x07D8
1258#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP79_SMBUS 0x0AA2
1255#define PCI_DEVICE_ID_NVIDIA_NVENET_36 0x0AB0 1259#define PCI_DEVICE_ID_NVIDIA_NVENET_36 0x0AB0
1256#define PCI_DEVICE_ID_NVIDIA_NVENET_37 0x0AB1 1260#define PCI_DEVICE_ID_NVIDIA_NVENET_37 0x0AB1
1257#define PCI_DEVICE_ID_NVIDIA_NVENET_38 0x0AB2 1261#define PCI_DEVICE_ID_NVIDIA_NVENET_38 0x0AB2
@@ -1475,6 +1479,7 @@
1475#define PCI_DEVICE_ID_SERVERWORKS_HT1000IDE 0x0214 1479#define PCI_DEVICE_ID_SERVERWORKS_HT1000IDE 0x0214
1476#define PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2 0x0217 1480#define PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2 0x0217
1477#define PCI_DEVICE_ID_SERVERWORKS_CSB6LPC 0x0227 1481#define PCI_DEVICE_ID_SERVERWORKS_CSB6LPC 0x0227
1482#define PCI_DEVICE_ID_SERVERWORKS_HT1100LD 0x0408
1478 1483
1479#define PCI_VENDOR_ID_SBE 0x1176 1484#define PCI_VENDOR_ID_SBE 0x1176
1480#define PCI_DEVICE_ID_SBE_WANXL100 0x0301 1485#define PCI_DEVICE_ID_SBE_WANXL100 0x0301
generated by cgit v1.2.2 (git 2.25.0) at 2025-11-29 20:58:49 -0500