[golan] Add various new PCI device IDs
[ipxe.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., 51 Franklin Street, Fifth Floor, Boston, MA
17 * 02110-1301, USA.
18 *
19 * You can also choose to distribute this program under the terms of
20 * the Unmodified Binary Distribution Licence (as given in the file
21 * COPYING.UBDL), provided that you have satisfied its requirements.
22 */
23
24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
25
26 #include <stddef.h>
27 #include <stdint.h>
28 #include <errno.h>
29 #include <string.h>
30 #include <assert.h>
31 #include <unistd.h>
32 #include <ipxe/bitbash.h>
33 #include <ipxe/i2c.h>
34
35 /** @file
36 *
37 * I2C bit-bashing interface
38 *
39 * This implements a simple I2C master via a bit-bashing interface
40 * that provides two lines: SCL (clock) and SDA (data).
41 */
42
43 /**
44 * Delay between output state changes
45 *
46 * Max rated i2c speed (for the basic i2c protocol) is 100kbps,
47 * i.e. 200k clock transitions per second.
48 */
49 static void i2c_delay ( void ) {
50 udelay ( I2C_UDELAY );
51 }
52
53 /**
54 * Set state of I2C SCL line
55 *
56 * @v basher Bit-bashing interface
57 * @v state New state of SCL
58 */
59 static void setscl ( struct bit_basher *basher, int state ) {
60 DBG2 ( "%c", ( state ? '/' : '\\' ) );
61 write_bit ( basher, I2C_BIT_SCL, state );
62 i2c_delay();
63 }
64
65 /**
66 * Set state of I2C SDA line
67 *
68 * @v basher Bit-bashing interface
69 * @v state New state of SDA
70 */
71 static void setsda ( struct bit_basher *basher, int state ) {
72 DBG2 ( "%c", ( state ? '1' : '0' ) );
73 write_bit ( basher, I2C_BIT_SDA, state );
74 i2c_delay();
75 }
76
77 /**
78 * Get state of I2C SDA line
79 *
80 * @v basher Bit-bashing interface
81 * @ret state State of SDA
82 */
83 static int getsda ( struct bit_basher *basher ) {
84 int state;
85 state = read_bit ( basher, I2C_BIT_SDA );
86 DBG2 ( "%c", ( state ? '+' : '-' ) );
87 return state;
88 }
89
90 /**
91 * Send an I2C start condition
92 *
93 * @v basher Bit-bashing interface
94 */
95 static void i2c_start ( struct bit_basher *basher ) {
96 setscl ( basher, 1 );
97 setsda ( basher, 0 );
98 setscl ( basher, 0 );
99 setsda ( basher, 1 );
100 }
101
102 /**
103 * Send an I2C data bit
104 *
105 * @v basher Bit-bashing interface
106 * @v bit Bit to send
107 */
108 static void i2c_send_bit ( struct bit_basher *basher, int bit ) {
109 setsda ( basher, bit );
110 setscl ( basher, 1 );
111 setscl ( basher, 0 );
112 setsda ( basher, 1 );
113 }
114
115 /**
116 * Receive an I2C data bit
117 *
118 * @v basher Bit-bashing interface
119 * @ret bit Received bit
120 */
121 static int i2c_recv_bit ( struct bit_basher *basher ) {
122 int bit;
123
124 setscl ( basher, 1 );
125 bit = getsda ( basher );
126 setscl ( basher, 0 );
127 return bit;
128 }
129
130 /**
131 * Send an I2C stop condition
132 *
133 * @v basher Bit-bashing interface
134 */
135 static void i2c_stop ( struct bit_basher *basher ) {
136 setsda ( basher, 0 );
137 setscl ( basher, 1 );
138 setsda ( basher, 1 );
139 }
140
141 /**
142 * Send byte via I2C bus and check for acknowledgement
143 *
144 * @v basher Bit-bashing interface
145 * @v byte Byte to send
146 * @ret rc Return status code
147 *
148 * Sends a byte via the I2C bus and checks for an acknowledgement from
149 * the slave device.
150 */
151 static int i2c_send_byte ( struct bit_basher *basher, uint8_t byte ) {
152 int i;
153 int ack;
154
155 /* Send byte */
156 DBG2 ( "[send %02x]", byte );
157 for ( i = 8 ; i ; i-- ) {
158 i2c_send_bit ( basher, byte & 0x80 );
159 byte <<= 1;
160 }
161
162 /* Check for acknowledgement from slave */
163 ack = ( i2c_recv_bit ( basher ) == 0 );
164 DBG2 ( "%s", ( ack ? "[acked]" : "[not acked]" ) );
165
166 return ( ack ? 0 : -EIO );
167 }
168
169 /**
170 * Receive byte via I2C bus
171 *
172 * @v basher Bit-bashing interface
173 * @ret byte Received byte
174 *
175 * Receives a byte via the I2C bus and sends NACK to the slave device.
176 */
177 static uint8_t i2c_recv_byte ( struct bit_basher *basher ) {
178 uint8_t byte = 0;
179 int i;
180
181 /* Receive byte */
182 for ( i = 8 ; i ; i-- ) {
183 byte <<= 1;
184 byte |= ( i2c_recv_bit ( basher ) & 0x1 );
185 }
186
187 /* Send NACK */
188 i2c_send_bit ( basher, 1 );
189
190 DBG2 ( "[rcvd %02x]", byte );
191 return byte;
192 }
193
194 /**
195 * Select I2C device for reading or writing
196 *
197 * @v basher Bit-bashing interface
198 * @v i2cdev I2C device
199 * @v offset Starting offset within the device
200 * @v direction I2C_READ or I2C_WRITE
201 * @ret rc Return status code
202 */
203 static int i2c_select ( struct bit_basher *basher, struct i2c_device *i2cdev,
204 unsigned int offset, unsigned int direction ) {
205 unsigned int address;
206 int shift;
207 unsigned int byte;
208 int rc;
209
210 i2c_start ( basher );
211
212 /* Calculate address to appear on bus */
213 address = ( ( ( i2cdev->dev_addr |
214 ( offset >> ( 8 * i2cdev->word_addr_len ) ) ) << 1 )
215 | direction );
216
217 /* Send address a byte at a time */
218 for ( shift = ( 8 * ( i2cdev->dev_addr_len - 1 ) ) ;
219 shift >= 0 ; shift -= 8 ) {
220 byte = ( ( address >> shift ) & 0xff );
221 if ( ( rc = i2c_send_byte ( basher, byte ) ) != 0 )
222 return rc;
223 }
224
225 return 0;
226 }
227
228 /**
229 * Reset I2C bus
230 *
231 * @v basher Bit-bashing interface
232 * @ret rc Return status code
233 *
234 * i2c devices often don't have a reset line, so even a reboot or
235 * system power cycle is sometimes not enough to bring them back to a
236 * known state.
237 */
238 static int i2c_reset ( struct bit_basher *basher ) {
239 unsigned int i;
240 int sda;
241
242 /* Clock through several cycles, waiting for an opportunity to
243 * pull SDA low while SCL is high (which creates a start
244 * condition).
245 */
246 open_bit ( basher );
247 setscl ( basher, 0 );
248 setsda ( basher, 1 );
249 for ( i = 0 ; i < I2C_RESET_MAX_CYCLES ; i++ ) {
250 setscl ( basher, 1 );
251 sda = getsda ( basher );
252 if ( sda ) {
253 /* Now that the device will see a start, issue it */
254 i2c_start ( basher );
255 /* Stop the bus to leave it in a known good state */
256 i2c_stop ( basher );
257 DBGC ( basher, "I2CBIT %p reset after %d attempts\n",
258 basher, ( i + 1 ) );
259 close_bit ( basher );
260 return 0;
261 }
262 setscl ( basher, 0 );
263 }
264
265 DBGC ( basher, "I2CBIT %p could not reset after %d attempts\n",
266 basher, i );
267 close_bit ( basher );
268 return -ETIMEDOUT;
269 }
270
271 /**
272 * Read data from I2C device via bit-bashing interface
273 *
274 * @v i2c I2C interface
275 * @v i2cdev I2C device
276 * @v offset Starting offset within the device
277 * @v data Data buffer
278 * @v len Length of data buffer
279 * @ret rc Return status code
280 *
281 * Note that attempting to read zero bytes of data is a valid way to
282 * check for I2C device presence.
283 */
284 static int i2c_bit_read ( struct i2c_interface *i2c,
285 struct i2c_device *i2cdev, unsigned int offset,
286 uint8_t *data, unsigned int len ) {
287 struct i2c_bit_basher *i2cbit
288 = container_of ( i2c, struct i2c_bit_basher, i2c );
289 struct bit_basher *basher = &i2cbit->basher;
290 int rc = 0;
291
292 DBGC ( basher, "I2CBIT %p reading from device %x: ",
293 basher, i2cdev->dev_addr );
294
295 open_bit ( basher );
296
297 for ( ; ; data++, offset++ ) {
298
299 /* Select device for writing */
300 if ( ( rc = i2c_select ( basher, i2cdev, offset,
301 I2C_WRITE ) ) != 0 )
302 break;
303
304 /* Abort at end of data */
305 if ( ! ( len-- ) )
306 break;
307
308 /* Select offset */
309 if ( ( rc = i2c_send_byte ( basher, offset ) ) != 0 )
310 break;
311
312 /* Select device for reading */
313 if ( ( rc = i2c_select ( basher, i2cdev, offset,
314 I2C_READ ) ) != 0 )
315 break;
316
317 /* Read byte */
318 *data = i2c_recv_byte ( basher );
319 DBGC ( basher, "%02x ", *data );
320 }
321
322 DBGC ( basher, "%s\n", ( rc ? "failed" : "" ) );
323 i2c_stop ( basher );
324 close_bit ( basher );
325 return rc;
326 }
327
328 /**
329 * Write data to I2C device via bit-bashing interface
330 *
331 * @v i2c I2C interface
332 * @v i2cdev I2C device
333 * @v offset Starting offset within the device
334 * @v data Data buffer
335 * @v len Length of data buffer
336 * @ret rc Return status code
337 *
338 * Note that attempting to write zero bytes of data is a valid way to
339 * check for I2C device presence.
340 */
341 static int i2c_bit_write ( struct i2c_interface *i2c,
342 struct i2c_device *i2cdev, unsigned int offset,
343 const uint8_t *data, unsigned int len ) {
344 struct i2c_bit_basher *i2cbit
345 = container_of ( i2c, struct i2c_bit_basher, i2c );
346 struct bit_basher *basher = &i2cbit->basher;
347 int rc = 0;
348
349 DBGC ( basher, "I2CBIT %p writing to device %x: ",
350 basher, i2cdev->dev_addr );
351
352 open_bit ( basher );
353
354 for ( ; ; data++, offset++ ) {
355
356 /* Select device for writing */
357 if ( ( rc = i2c_select ( basher, i2cdev, offset,
358 I2C_WRITE ) ) != 0 )
359 break;
360
361 /* Abort at end of data */
362 if ( ! ( len-- ) )
363 break;
364
365 /* Select offset */
366 if ( ( rc = i2c_send_byte ( basher, offset ) ) != 0 )
367 break;
368
369 /* Write data to device */
370 DBGC ( basher, "%02x ", *data );
371 if ( ( rc = i2c_send_byte ( basher, *data ) ) != 0 )
372 break;
373 }
374
375 DBGC ( basher, "%s\n", ( rc ? "failed" : "" ) );
376 i2c_stop ( basher );
377 close_bit ( basher );
378 return rc;
379 }
380
381 /**
382 * Initialise I2C bit-bashing interface
383 *
384 * @v i2cbit I2C bit-bashing interface
385 * @v bash_op Bit-basher operations
386 */
387 int init_i2c_bit_basher ( struct i2c_bit_basher *i2cbit,
388 struct bit_basher_operations *bash_op ) {
389 struct bit_basher *basher = &i2cbit->basher;
390 int rc;
391
392 /* Initialise data structures */
393 basher->op = bash_op;
394 assert ( basher->op->read != NULL );
395 assert ( basher->op->write != NULL );
396 i2cbit->i2c.read = i2c_bit_read;
397 i2cbit->i2c.write = i2c_bit_write;
398
399 /* Reset I2C bus */
400 if ( ( rc = i2c_reset ( basher ) ) != 0 ) {
401 DBGC ( basher, "I2CBIT %p could not reset I2C bus: %s\n",
402 basher, strerror ( rc ) );
403 return rc;
404 }
405
406 return 0;
407 }