diff options
Diffstat (limited to 'drivers/i2c/algos/i2c-algo-pcf.c')
-rw-r--r-- | drivers/i2c/algos/i2c-algo-pcf.c | 261 |
1 files changed, 121 insertions, 140 deletions
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 | */ |
49 | static int i2c_debug; | 49 | static 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 | ||
62 | static void i2c_start(struct i2c_algo_pcf_data *adap) | 62 | static 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 | ||
68 | static void i2c_repstart(struct i2c_algo_pcf_data *adap) | 68 | static 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 | 74 | static void i2c_stop(struct i2c_algo_pcf_data *adap) | |
75 | static 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 | ||
111 | static int wait_for_bb(struct i2c_algo_pcf_data *adap) { | 110 | static 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 | ||
131 | static int wait_for_pin(struct i2c_algo_pcf_data *adap, int *status) { | 131 | static 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 | |||
220 | static int pcf_sendbytes(struct i2c_adapter *i2c_adap, const char *buf, | 220 | static 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 | |||
259 | static int pcf_readbytes(struct i2c_adapter *i2c_adap, char *buf, | 253 | static 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 | ||
325 | static int pcf_xfer(struct i2c_adapter *i2c_adap, | 313 | static 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, | |||
413 | out: | 396 | out: |
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 | ||
419 | static u32 pcf_func(struct i2c_adapter *adap) | 402 | static 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 | |||
427 | static const struct i2c_algorithm pcf_algo = { | 409 | static 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 | */ |
435 | int i2c_pcf_add_bus(struct i2c_adapter *adap) | 417 | int 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 | ||
459 | module_param(i2c_debug, int, S_IRUGO | S_IWUSR); | 440 | module_param(i2c_debug, int, S_IRUGO | S_IWUSR); |
460 | MODULE_PARM_DESC(i2c_debug, | 441 | MODULE_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"); |