Move per-transition delays from generic bit-bashing layer to i2c layer
[people/xl0/gpxe.git] / src / drivers / bitbash / i2c_bit.c
1 /*
2  * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 #include <stddef.h>
20 #include <stdint.h>
21 #include <errno.h>
22 #include <assert.h>
23 #include <gpxe/bitbash.h>
24 #include <gpxe/i2c.h>
25
26 /** @file
27  *
28  * I2C bit-bashing interface
29  *
30  * This implements a simple I2C master via a bit-bashing interface
31  * that provides two lines: SCL (clock) and SDA (data).
32  */
33
34 /**
35  * Delay between output state changes
36  *
37  * Max rated i2c speed (for the basic i2c protocol) is 100kbps,
38  * i.e. 200k clock transitions per second.
39  */
40 static void i2c_delay ( void ) {
41         udelay ( I2C_UDELAY );
42 }
43
44 /**
45  * Set state of I2C SCL line
46  *
47  * @v basher            Bit-bashing interface
48  * @v state             New state of SCL
49  */
50 static void setscl ( struct bit_basher *basher, int state ) {
51         write_bit ( basher, I2C_BIT_SCL, state );
52         i2c_delay();
53 }
54
55 /**
56  * Set state of I2C SDA line
57  *
58  * @v basher            Bit-bashing interface
59  * @v state             New state of SDA
60  */
61 static void setsda ( struct bit_basher *basher, int state ) {
62         write_bit ( basher, I2C_BIT_SDA, state );
63         i2c_delay();
64 }
65
66 /**
67  * Get state of I2C SDA line
68  *
69  * @v basher            Bit-bashing interface
70  * @ret state           State of SDA
71  */
72 static int getsda ( struct bit_basher *basher ) {
73         return read_bit ( basher, I2C_BIT_SDA );
74 }
75
76 /**
77  * Send an I2C start condition
78  *
79  * @v basher            Bit-bashing interface
80  */
81 static void i2c_start ( struct bit_basher *basher ) {
82         setscl ( basher, 1 );
83         setsda ( basher, 0 );
84         setscl ( basher, 0 );
85         setsda ( basher, 1 );
86 }
87
88 /**
89  * Send an I2C data bit
90  *
91  * @v basher            Bit-bashing interface
92  * @v bit               Bit to send
93  */
94 static void i2c_send_bit ( struct bit_basher *basher, int bit ) {
95         setsda ( basher, bit );
96         setscl ( basher, 1 );
97         setscl ( basher, 0 );
98         setsda ( basher, 1 );
99 }
100
101 /**
102  * Receive an I2C data bit
103  *
104  * @v basher            Bit-bashing interface
105  * @ret bit             Received bit
106  */
107 static int i2c_recv_bit ( struct bit_basher *basher ) {
108         int bit;
109
110         setscl ( basher, 1 );
111         bit = getsda ( basher );
112         setscl ( basher, 0 );
113         return bit;
114 }
115
116 /**
117  * Send an I2C stop condition
118  *
119  * @v basher            Bit-bashing interface
120  */
121 static void i2c_stop ( struct bit_basher *basher ) {
122         setsda ( basher, 0 );
123         setscl ( basher, 1 );
124         setsda ( basher, 1 );
125 }
126
127 /**
128  * Send byte via I2C bus and check for acknowledgement
129  *
130  * @v basher            Bit-bashing interface
131  * @v byte              Byte to send
132  * @ret rc              Return status code
133  *
134  * Sends a byte via the I2C bus and checks for an acknowledgement from
135  * the slave device.
136  */
137 static int i2c_send_byte ( struct bit_basher *basher, uint8_t byte ) {
138         int i;
139         
140         /* Send byte */
141         for ( i = 8 ; i ; i-- ) {
142                 i2c_send_bit ( basher, byte & 0x80 );
143                 byte <<= 1;
144         }
145
146         /* Check for acknowledgement from slave */
147         return ( i2c_recv_bit ( basher ) == 0 ? 0 : -EIO );
148 }
149
150 /**
151  * Receive byte via I2C bus
152  *
153  * @v basher            Bit-bashing interface
154  * @ret byte            Received byte
155  *
156  * Receives a byte via the I2C bus and sends NACK to the slave device.
157  */
158 static uint8_t i2c_recv_byte ( struct bit_basher *basher ) {
159         uint8_t value = 0;
160         int i;
161
162         /* Receive byte */
163         for ( i = 8 ; i ; i-- ) {
164                 value <<= 1;
165                 value |= ( i2c_recv_bit ( basher ) & 0x1 );
166         }
167
168         /* Send NACK */
169         i2c_send_bit ( basher, 1 );
170
171         return value;
172 }
173
174 /**
175  * Select I2C device for reading or writing
176  *
177  * @v basher            Bit-bashing interface
178  * @v i2cdev            I2C device
179  * @v direction         I2C_READ or I2C_WRITE
180  * @ret rc              Return status code
181  */
182 static int i2c_select ( struct bit_basher *basher, struct i2c_device *i2cdev,
183                         unsigned int direction ) {
184         unsigned int address;
185         int rc;
186
187         i2c_start ( basher );
188
189         /* First byte of the address */
190         address = i2cdev->address;
191         if ( i2cdev->tenbit ) {
192                 address |= I2C_TENBIT_ADDRESS;
193                 address >>= 8;
194         }
195         if ( ( rc = i2c_send_byte ( basher, 
196                                     ( ( address << 1 ) | direction ) ) ) != 0 )
197                 return rc;
198
199         /* Second byte of the address (10-bit addresses only) */
200         if ( i2cdev->tenbit ) {
201                 if ( ( rc = i2c_send_byte ( basher,
202                                             ( i2cdev->address & 0xff ) ) ) !=0)
203                         return rc;
204         }
205
206         return 0;
207 }
208
209 /**
210  * Read data from I2C device via bit-bashing interface
211  *
212  * @v i2c               I2C interface
213  * @v i2cdev            I2C device
214  * @v offset            Starting offset within the device
215  * @v data              Data buffer
216  * @v len               Length of data buffer
217  * @ret rc              Return status code
218  *
219  * Note that attempting to read zero bytes of data is a valid way to
220  * check for I2C device presence.
221  */
222 static int i2c_bit_read ( struct i2c_interface *i2c,
223                           struct i2c_device *i2cdev, unsigned int offset,
224                           uint8_t *data, unsigned int len ) {
225         struct i2c_bit_basher *i2cbit
226                 = container_of ( i2c, struct i2c_bit_basher, i2c );
227         struct bit_basher *basher = &i2cbit->basher;
228         int rc = 0;
229
230         DBG ( "Reading from I2C device %x: ", i2cdev->address );
231
232         while ( 1 ) {
233
234                 /* Select device for writing */
235                 if ( ( rc = i2c_select ( basher, i2cdev, I2C_WRITE ) ) != 0 )
236                         break;
237
238                 /* Abort at end of data */
239                 if ( ! ( len-- ) )
240                         break;
241
242                 /* Select offset */
243                 if ( ( rc = i2c_send_byte ( basher, offset++ ) ) != 0 )
244                         break;
245                 
246                 /* Select device for reading */
247                 if ( ( rc = i2c_select ( basher, i2cdev, I2C_READ ) ) != 0 )
248                         break;
249
250                 /* Read byte */
251                 *data++ = i2c_recv_byte ( basher );
252                 DBG ( "%02x ", *(data - 1) );
253         }
254         
255         DBG ( "%s\n", ( rc ? "failed" : "" ) );
256         i2c_stop ( basher );
257         return rc;
258 }
259
260 /**
261  * Write data to I2C device via bit-bashing interface
262  *
263  * @v i2c               I2C interface
264  * @v i2cdev            I2C device
265  * @v offset            Starting offset within the device
266  * @v data              Data buffer
267  * @v len               Length of data buffer
268  * @ret rc              Return status code
269  *
270  * Note that attempting to write zero bytes of data is a valid way to
271  * check for I2C device presence.
272  */
273 static int i2c_bit_write ( struct i2c_interface *i2c,
274                            struct i2c_device *i2cdev, unsigned int offset,
275                            const uint8_t *data, unsigned int len ) {
276         struct i2c_bit_basher *i2cbit
277                 = container_of ( i2c, struct i2c_bit_basher, i2c );
278         struct bit_basher *basher = &i2cbit->basher;
279         int rc = 0;
280
281         DBG ( "Writing to I2C device %x: ", i2cdev->address );
282
283         while ( 1 ) {
284
285                 /* Select device for writing */
286                 if ( ( rc = i2c_select ( basher, i2cdev, I2C_WRITE ) ) != 0 )
287                         break;
288                 
289                 /* Abort at end of data */
290                 if ( ! ( len-- ) )
291                         break;
292
293                 /* Select offset */
294                 if ( ( rc = i2c_send_byte ( basher, offset++ ) ) != 0 )
295                         break;
296                 
297                 /* Write data to device */
298                 DBG ( "%02x ", *data );
299                 if ( ( rc = i2c_send_byte ( basher, *data++ ) ) != 0 )
300                         break;
301         }
302         
303         DBG ( "%s\n", ( rc ? "failed" : "" ) );
304         i2c_stop ( basher );
305         return rc;
306 }
307
308 /**
309  * Initialise I2C bit-bashing interface
310  *
311  * @v i2cbit            I2C bit-bashing interface
312  */
313 void init_i2c_bit_basher ( struct i2c_bit_basher *i2cbit ) {
314         struct bit_basher *basher = &i2cbit->basher;
315         
316         assert ( basher->read != NULL );
317         assert ( basher->write != NULL );
318         i2cbit->i2c.read = i2c_bit_read;
319         i2cbit->i2c.write = i2c_bit_write;
320         i2c_stop ( basher );
321 }