]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | Usually, i2c devices are controlled by a kernel driver. But it is also |
2 | possible to access all devices on an adapter from userspace, through | |
3 | the /dev interface. You need to load module i2c-dev for this. | |
4 | ||
5 | Each registered i2c adapter gets a number, counting from 0. You can | |
6 | examine /sys/class/i2c-dev/ to see what number corresponds to which adapter. | |
7 | I2C device files are character device files with major device number 89 | |
8 | and a minor device number corresponding to the number assigned as | |
9 | explained above. They should be called "i2c-%d" (i2c-0, i2c-1, ..., | |
10 | i2c-10, ...). All 256 minor device numbers are reserved for i2c. | |
11 | ||
12 | ||
13 | C example | |
14 | ========= | |
15 | ||
16 | So let's say you want to access an i2c adapter from a C program. The | |
17 | first thing to do is `#include <linux/i2c.h>" and "#include <linux/i2c-dev.h>. | |
18 | Yes, I know, you should never include kernel header files, but until glibc | |
19 | knows about i2c, there is not much choice. | |
20 | ||
21 | Now, you have to decide which adapter you want to access. You should | |
22 | inspect /sys/class/i2c-dev/ to decide this. Adapter numbers are assigned | |
23 | somewhat dynamically, so you can not even assume /dev/i2c-0 is the | |
24 | first adapter. | |
25 | ||
26 | Next thing, open the device file, as follows: | |
27 | int file; | |
28 | int adapter_nr = 2; /* probably dynamically determined */ | |
29 | char filename[20]; | |
30 | ||
31 | sprintf(filename,"/dev/i2c-%d",adapter_nr); | |
32 | if ((file = open(filename,O_RDWR)) < 0) { | |
33 | /* ERROR HANDLING; you can check errno to see what went wrong */ | |
34 | exit(1); | |
35 | } | |
36 | ||
37 | When you have opened the device, you must specify with what device | |
38 | address you want to communicate: | |
39 | int addr = 0x40; /* The I2C address */ | |
40 | if (ioctl(file,I2C_SLAVE,addr) < 0) { | |
41 | /* ERROR HANDLING; you can check errno to see what went wrong */ | |
42 | exit(1); | |
43 | } | |
44 | ||
45 | Well, you are all set up now. You can now use SMBus commands or plain | |
46 | I2C to communicate with your device. SMBus commands are preferred if | |
47 | the device supports them. Both are illustrated below. | |
48 | __u8 register = 0x10; /* Device register to access */ | |
49 | __s32 res; | |
50 | char buf[10]; | |
51 | /* Using SMBus commands */ | |
52 | res = i2c_smbus_read_word_data(file,register); | |
53 | if (res < 0) { | |
54 | /* ERROR HANDLING: i2c transaction failed */ | |
55 | } else { | |
56 | /* res contains the read word */ | |
57 | } | |
58 | /* Using I2C Write, equivalent of | |
59 | i2c_smbus_write_word_data(file,register,0x6543) */ | |
60 | buf[0] = register; | |
61 | buf[1] = 0x43; | |
62 | buf[2] = 0x65; | |
63 | if ( write(file,buf,3) != 3) { | |
64 | /* ERROR HANDLING: i2c transaction failed */ | |
65 | } | |
66 | /* Using I2C Read, equivalent of i2c_smbus_read_byte(file) */ | |
67 | if (read(file,buf,1) != 1) { | |
68 | /* ERROR HANDLING: i2c transaction failed */ | |
69 | } else { | |
70 | /* buf[0] contains the read byte */ | |
71 | } | |
72 | ||
73 | IMPORTANT: because of the use of inline functions, you *have* to use | |
74 | '-O' or some variation when you compile your program! | |
75 | ||
76 | ||
77 | Full interface description | |
78 | ========================== | |
79 | ||
80 | The following IOCTLs are defined and fully supported | |
81 | (see also i2c-dev.h and i2c.h): | |
82 | ||
83 | ioctl(file,I2C_SLAVE,long addr) | |
84 | Change slave address. The address is passed in the 7 lower bits of the | |
85 | argument (except for 10 bit addresses, passed in the 10 lower bits in this | |
86 | case). | |
87 | ||
88 | ioctl(file,I2C_TENBIT,long select) | |
89 | Selects ten bit addresses if select not equals 0, selects normal 7 bit | |
90 | addresses if select equals 0. Default 0. | |
91 | ||
92 | ioctl(file,I2C_PEC,long select) | |
93 | Selects SMBus PEC (packet error checking) generation and verification | |
94 | if select not equals 0, disables if select equals 0. Default 0. | |
95 | Used only for SMBus transactions. | |
96 | ||
97 | ioctl(file,I2C_FUNCS,unsigned long *funcs) | |
98 | Gets the adapter functionality and puts it in *funcs. | |
99 | ||
100 | ioctl(file,I2C_RDWR,struct i2c_ioctl_rdwr_data *msgset) | |
101 | ||
102 | Do combined read/write transaction without stop in between. | |
103 | The argument is a pointer to a struct i2c_ioctl_rdwr_data { | |
104 | ||
105 | struct i2c_msg *msgs; /* ptr to array of simple messages */ | |
106 | int nmsgs; /* number of messages to exchange */ | |
107 | } | |
108 | ||
109 | The msgs[] themselves contain further pointers into data buffers. | |
110 | The function will write or read data to or from that buffers depending | |
111 | on whether the I2C_M_RD flag is set in a particular message or not. | |
112 | The slave address and whether to use ten bit address mode has to be | |
113 | set in each message, overriding the values set with the above ioctl's. | |
114 | ||
115 | ||
116 | Other values are NOT supported at this moment, except for I2C_SMBUS, | |
117 | which you should never directly call; instead, use the access functions | |
118 | below. | |
119 | ||
120 | You can do plain i2c transactions by using read(2) and write(2) calls. | |
121 | You do not need to pass the address byte; instead, set it through | |
122 | ioctl I2C_SLAVE before you try to access the device. | |
123 | ||
124 | You can do SMBus level transactions (see documentation file smbus-protocol | |
125 | for details) through the following functions: | |
126 | __s32 i2c_smbus_write_quick(int file, __u8 value); | |
127 | __s32 i2c_smbus_read_byte(int file); | |
128 | __s32 i2c_smbus_write_byte(int file, __u8 value); | |
129 | __s32 i2c_smbus_read_byte_data(int file, __u8 command); | |
130 | __s32 i2c_smbus_write_byte_data(int file, __u8 command, __u8 value); | |
131 | __s32 i2c_smbus_read_word_data(int file, __u8 command); | |
132 | __s32 i2c_smbus_write_word_data(int file, __u8 command, __u16 value); | |
133 | __s32 i2c_smbus_process_call(int file, __u8 command, __u16 value); | |
134 | __s32 i2c_smbus_read_block_data(int file, __u8 command, __u8 *values); | |
135 | __s32 i2c_smbus_write_block_data(int file, __u8 command, __u8 length, | |
136 | __u8 *values); | |
137 | All these transactions return -1 on failure; you can read errno to see | |
138 | what happened. The 'write' transactions return 0 on success; the | |
139 | 'read' transactions return the read value, except for read_block, which | |
140 | returns the number of values read. The block buffers need not be longer | |
141 | than 32 bytes. | |
142 | ||
143 | The above functions are all macros, that resolve to calls to the | |
144 | i2c_smbus_access function, that on its turn calls a specific ioctl | |
145 | with the data in a specific format. Read the source code if you | |
146 | want to know what happens behind the screens. |