Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jbarnes...
[linux-2.6] / drivers / net / sfc / i2c-direct.c
1 /****************************************************************************
2  * Driver for Solarflare Solarstorm network controllers and boards
3  * Copyright 2005 Fen Systems Ltd.
4  * Copyright 2006-2008 Solarflare Communications Inc.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License version 2 as published
8  * by the Free Software Foundation, incorporated herein by reference.
9  */
10
11 #include <linux/delay.h>
12 #include "net_driver.h"
13 #include "i2c-direct.h"
14
15 /*
16  * I2C data (SDA) and clock (SCL) line read/writes with appropriate
17  * delays.
18  */
19
20 static inline void setsda(struct efx_i2c_interface *i2c, int state)
21 {
22         udelay(i2c->op->udelay);
23         i2c->sda = state;
24         i2c->op->setsda(i2c);
25         udelay(i2c->op->udelay);
26 }
27
28 static inline void setscl(struct efx_i2c_interface *i2c, int state)
29 {
30         udelay(i2c->op->udelay);
31         i2c->scl = state;
32         i2c->op->setscl(i2c);
33         udelay(i2c->op->udelay);
34 }
35
36 static inline int getsda(struct efx_i2c_interface *i2c)
37 {
38         int sda;
39
40         udelay(i2c->op->udelay);
41         sda = i2c->op->getsda(i2c);
42         udelay(i2c->op->udelay);
43         return sda;
44 }
45
46 static inline int getscl(struct efx_i2c_interface *i2c)
47 {
48         int scl;
49
50         udelay(i2c->op->udelay);
51         scl = i2c->op->getscl(i2c);
52         udelay(i2c->op->udelay);
53         return scl;
54 }
55
56 /*
57  * I2C low-level protocol operations
58  *
59  */
60
61 static inline void i2c_release(struct efx_i2c_interface *i2c)
62 {
63         EFX_WARN_ON_PARANOID(!i2c->scl);
64         EFX_WARN_ON_PARANOID(!i2c->sda);
65         /* Devices may time out if operations do not end */
66         setscl(i2c, 1);
67         setsda(i2c, 1);
68         EFX_BUG_ON_PARANOID(getsda(i2c) != 1);
69         EFX_BUG_ON_PARANOID(getscl(i2c) != 1);
70 }
71
72 static inline void i2c_start(struct efx_i2c_interface *i2c)
73 {
74         /* We may be restarting immediately after a {send,recv}_bit,
75          * so SCL will not necessarily already be high.
76          */
77         EFX_WARN_ON_PARANOID(!i2c->sda);
78         setscl(i2c, 1);
79         setsda(i2c, 0);
80         setscl(i2c, 0);
81         setsda(i2c, 1);
82 }
83
84 static inline void i2c_send_bit(struct efx_i2c_interface *i2c, int bit)
85 {
86         EFX_WARN_ON_PARANOID(i2c->scl != 0);
87         setsda(i2c, bit);
88         setscl(i2c, 1);
89         setscl(i2c, 0);
90         setsda(i2c, 1);
91 }
92
93 static inline int i2c_recv_bit(struct efx_i2c_interface *i2c)
94 {
95         int bit;
96
97         EFX_WARN_ON_PARANOID(i2c->scl != 0);
98         EFX_WARN_ON_PARANOID(!i2c->sda);
99         setscl(i2c, 1);
100         bit = getsda(i2c);
101         setscl(i2c, 0);
102         return bit;
103 }
104
105 static inline void i2c_stop(struct efx_i2c_interface *i2c)
106 {
107         EFX_WARN_ON_PARANOID(i2c->scl != 0);
108         setsda(i2c, 0);
109         setscl(i2c, 1);
110         setsda(i2c, 1);
111 }
112
113 /*
114  * I2C mid-level protocol operations
115  *
116  */
117
118 /* Sends a byte via the I2C bus and checks for an acknowledgement from
119  * the slave device.
120  */
121 static int i2c_send_byte(struct efx_i2c_interface *i2c, u8 byte)
122 {
123         int i;
124
125         /* Send byte */
126         for (i = 0; i < 8; i++) {
127                 i2c_send_bit(i2c, !!(byte & 0x80));
128                 byte <<= 1;
129         }
130
131         /* Check for acknowledgement from slave */
132         return (i2c_recv_bit(i2c) == 0 ? 0 : -EIO);
133 }
134
135 /* Receives a byte via the I2C bus and sends ACK/NACK to the slave device. */
136 static u8 i2c_recv_byte(struct efx_i2c_interface *i2c, int ack)
137 {
138         u8 value = 0;
139         int i;
140
141         /* Receive byte */
142         for (i = 0; i < 8; i++)
143                 value = (value << 1) | i2c_recv_bit(i2c);
144
145         /* Send ACK/NACK */
146         i2c_send_bit(i2c, (ack ? 0 : 1));
147
148         return value;
149 }
150
151 /* Calculate command byte for a read operation */
152 static inline u8 i2c_read_cmd(u8 device_id)
153 {
154         return ((device_id << 1) | 1);
155 }
156
157 /* Calculate command byte for a write operation */
158 static inline u8 i2c_write_cmd(u8 device_id)
159 {
160         return ((device_id << 1) | 0);
161 }
162
163 int efx_i2c_check_presence(struct efx_i2c_interface *i2c, u8 device_id)
164 {
165         int rc;
166
167         /* If someone is driving the bus low we just give up. */
168         if (getsda(i2c) == 0 || getscl(i2c) == 0) {
169                 EFX_ERR(i2c->efx, "%s someone is holding the I2C bus low."
170                         " Giving up.\n", __func__);
171                 return -EFAULT;
172         }
173
174         /* Pretend to initiate a device write */
175         i2c_start(i2c);
176         rc = i2c_send_byte(i2c, i2c_write_cmd(device_id));
177         if (rc)
178                 goto out;
179
180  out:
181         i2c_stop(i2c);
182         i2c_release(i2c);
183
184         return rc;
185 }
186
187 /* This performs a fast read of one or more consecutive bytes from an
188  * I2C device.  Not all devices support consecutive reads of more than
189  * one byte; for these devices use efx_i2c_read() instead.
190  */
191 int efx_i2c_fast_read(struct efx_i2c_interface *i2c,
192                       u8 device_id, u8 offset, u8 *data, unsigned int len)
193 {
194         int i;
195         int rc;
196
197         EFX_WARN_ON_PARANOID(getsda(i2c) != 1);
198         EFX_WARN_ON_PARANOID(getscl(i2c) != 1);
199         EFX_WARN_ON_PARANOID(data == NULL);
200         EFX_WARN_ON_PARANOID(len < 1);
201
202         /* Select device and starting offset */
203         i2c_start(i2c);
204         rc = i2c_send_byte(i2c, i2c_write_cmd(device_id));
205         if (rc)
206                 goto out;
207         rc = i2c_send_byte(i2c, offset);
208         if (rc)
209                 goto out;
210
211         /* Read data from device */
212         i2c_start(i2c);
213         rc = i2c_send_byte(i2c, i2c_read_cmd(device_id));
214         if (rc)
215                 goto out;
216         for (i = 0; i < (len - 1); i++)
217                 /* Read and acknowledge all but the last byte */
218                 data[i] = i2c_recv_byte(i2c, 1);
219         /* Read last byte with no acknowledgement */
220         data[i] = i2c_recv_byte(i2c, 0);
221
222  out:
223         i2c_stop(i2c);
224         i2c_release(i2c);
225
226         return rc;
227 }
228
229 /* This performs a fast write of one or more consecutive bytes to an
230  * I2C device.  Not all devices support consecutive writes of more
231  * than one byte; for these devices use efx_i2c_write() instead.
232  */
233 int efx_i2c_fast_write(struct efx_i2c_interface *i2c,
234                        u8 device_id, u8 offset,
235                        const u8 *data, unsigned int len)
236 {
237         int i;
238         int rc;
239
240         EFX_WARN_ON_PARANOID(getsda(i2c) != 1);
241         EFX_WARN_ON_PARANOID(getscl(i2c) != 1);
242         EFX_WARN_ON_PARANOID(len < 1);
243
244         /* Select device and starting offset */
245         i2c_start(i2c);
246         rc = i2c_send_byte(i2c, i2c_write_cmd(device_id));
247         if (rc)
248                 goto out;
249         rc = i2c_send_byte(i2c, offset);
250         if (rc)
251                 goto out;
252
253         /* Write data to device */
254         for (i = 0; i < len; i++) {
255                 rc = i2c_send_byte(i2c, data[i]);
256                 if (rc)
257                         goto out;
258         }
259
260  out:
261         i2c_stop(i2c);
262         i2c_release(i2c);
263
264         return rc;
265 }
266
267 /* I2C byte-by-byte read */
268 int efx_i2c_read(struct efx_i2c_interface *i2c,
269                  u8 device_id, u8 offset, u8 *data, unsigned int len)
270 {
271         int rc;
272
273         /* i2c_fast_read with length 1 is a single byte read */
274         for (; len > 0; offset++, data++, len--) {
275                 rc = efx_i2c_fast_read(i2c, device_id, offset, data, 1);
276                 if (rc)
277                         return rc;
278         }
279
280         return 0;
281 }
282
283 /* I2C byte-by-byte write */
284 int efx_i2c_write(struct efx_i2c_interface *i2c,
285                   u8 device_id, u8 offset, const u8 *data, unsigned int len)
286 {
287         int rc;
288
289         /* i2c_fast_write with length 1 is a single byte write */
290         for (; len > 0; offset++, data++, len--) {
291                 rc = efx_i2c_fast_write(i2c, device_id, offset, data, 1);
292                 if (rc)
293                         return rc;
294                 mdelay(i2c->op->mdelay);
295         }
296
297         return 0;
298 }
299
300
301 /* This is just a slightly neater wrapper round efx_i2c_fast_write
302  * in the case where the target doesn't take an offset
303  */
304 int efx_i2c_send_bytes(struct efx_i2c_interface *i2c,
305                        u8 device_id, const u8 *data, unsigned int len)
306 {
307         return efx_i2c_fast_write(i2c, device_id, data[0], data + 1, len - 1);
308 }
309
310 /* I2C receiving of bytes - does not send an offset byte */
311 int efx_i2c_recv_bytes(struct efx_i2c_interface *i2c, u8 device_id,
312                        u8 *bytes, unsigned int len)
313 {
314         int i;
315         int rc;
316
317         EFX_WARN_ON_PARANOID(getsda(i2c) != 1);
318         EFX_WARN_ON_PARANOID(getscl(i2c) != 1);
319         EFX_WARN_ON_PARANOID(len < 1);
320
321         /* Select device */
322         i2c_start(i2c);
323
324         /* Read data from device */
325         rc = i2c_send_byte(i2c, i2c_read_cmd(device_id));
326         if (rc)
327                 goto out;
328
329         for (i = 0; i < (len - 1); i++)
330                 /* Read and acknowledge all but the last byte */
331                 bytes[i] = i2c_recv_byte(i2c, 1);
332         /* Read last byte with no acknowledgement */
333         bytes[i] = i2c_recv_byte(i2c, 0);
334
335  out:
336         i2c_stop(i2c);
337         i2c_release(i2c);
338
339         return rc;
340 }
341
342 /* SMBus and some I2C devices will time out if the I2C clock is
343  * held low for too long. This is most likely to happen in virtualised
344  * systems (when the entire domain is descheduled) but could in
345  * principle happen due to preemption on any busy system (and given the
346  * potential length of an I2C operation turning preemption off is not
347  * a sensible option). The following functions deal with the failure by
348  * retrying up to a fixed number of times.
349   */
350
351 #define I2C_MAX_RETRIES (10)
352
353 /* The timeout problem will result in -EIO. If the wrapped function
354  * returns any other error, pass this up and do not retry. */
355 #define RETRY_WRAPPER(_f) \
356         int retries = I2C_MAX_RETRIES; \
357         int rc; \
358         while (retries) { \
359                 rc = _f; \
360                 if (rc != -EIO) \
361                         return rc; \
362                 retries--; \
363         } \
364         return rc; \
365
366 int efx_i2c_check_presence_retry(struct efx_i2c_interface *i2c, u8 device_id)
367 {
368         RETRY_WRAPPER(efx_i2c_check_presence(i2c, device_id))
369 }
370
371 int efx_i2c_read_retry(struct efx_i2c_interface *i2c,
372                  u8 device_id, u8 offset, u8 *data, unsigned int len)
373 {
374         RETRY_WRAPPER(efx_i2c_read(i2c, device_id, offset, data, len))
375 }
376
377 int efx_i2c_write_retry(struct efx_i2c_interface *i2c,
378                   u8 device_id, u8 offset, const u8 *data, unsigned int len)
379 {
380         RETRY_WRAPPER(efx_i2c_write(i2c, device_id, offset, data, len))
381 }