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