Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * Linux I2C core SMBus and SMBus emulation code
4 : : *
5 : : * This file contains the SMBus functions which are always included in the I2C
6 : : * core because they can be emulated via I2C. SMBus specific extensions
7 : : * (e.g. smbalert) are handled in a seperate i2c-smbus module.
8 : : *
9 : : * All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
10 : : * SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
11 : : * Jean Delvare <jdelvare@suse.de>
12 : : */
13 : : #include <linux/device.h>
14 : : #include <linux/err.h>
15 : : #include <linux/i2c.h>
16 : : #include <linux/i2c-smbus.h>
17 : : #include <linux/slab.h>
18 : :
19 : : #include "i2c-core.h"
20 : :
21 : : #define CREATE_TRACE_POINTS
22 : : #include <trace/events/smbus.h>
23 : :
24 : :
25 : : /* The SMBus parts */
26 : :
27 : : #define POLY (0x1070U << 3)
28 : 0 : static u8 crc8(u16 data)
29 : : {
30 : 0 : int i;
31 : :
32 [ # # # # ]: 0 : for (i = 0; i < 8; i++) {
33 [ # # # # ]: 0 : if (data & 0x8000)
34 : 0 : data = data ^ POLY;
35 : 0 : data = data << 1;
36 : : }
37 : 0 : return (u8)(data >> 8);
38 : : }
39 : :
40 : : /* Incremental CRC8 over count bytes in the array pointed to by p */
41 : 0 : static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
42 : : {
43 : : int i;
44 : :
45 [ # # # # ]: 0 : for (i = 0; i < count; i++)
46 : 0 : crc = crc8((crc ^ p[i]) << 8);
47 : 0 : return crc;
48 : : }
49 : :
50 : : /* Assume a 7-bit address, which is reasonable for SMBus */
51 : 0 : static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
52 : : {
53 : : /* The address will be sent first */
54 : 0 : u8 addr = i2c_8bit_addr_from_msg(msg);
55 : 0 : pec = i2c_smbus_pec(pec, &addr, 1);
56 : :
57 : : /* The data buffer follows */
58 : 0 : return i2c_smbus_pec(pec, msg->buf, msg->len);
59 : : }
60 : :
61 : : /* Used for write only transactions */
62 : 0 : static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
63 : : {
64 : 0 : msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
65 : 0 : msg->len++;
66 : 0 : }
67 : :
68 : : /* Return <0 on CRC error
69 : : If there was a write before this read (most cases) we need to take the
70 : : partial CRC from the write part into account.
71 : : Note that this function does modify the message (we need to decrease the
72 : : message length to hide the CRC byte from the caller). */
73 : 0 : static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
74 : : {
75 : 0 : u8 rpec = msg->buf[--msg->len];
76 : 0 : cpec = i2c_smbus_msg_pec(cpec, msg);
77 : :
78 [ # # ]: 0 : if (rpec != cpec) {
79 : 0 : pr_debug("Bad PEC 0x%02x vs. 0x%02x\n",
80 : : rpec, cpec);
81 : 0 : return -EBADMSG;
82 : : }
83 : : return 0;
84 : : }
85 : :
86 : : /**
87 : : * i2c_smbus_read_byte - SMBus "receive byte" protocol
88 : : * @client: Handle to slave device
89 : : *
90 : : * This executes the SMBus "receive byte" protocol, returning negative errno
91 : : * else the byte received from the device.
92 : : */
93 : 0 : s32 i2c_smbus_read_byte(const struct i2c_client *client)
94 : : {
95 : 0 : union i2c_smbus_data data;
96 : 0 : int status;
97 : :
98 : 0 : status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
99 : : I2C_SMBUS_READ, 0,
100 : : I2C_SMBUS_BYTE, &data);
101 [ # # ]: 0 : return (status < 0) ? status : data.byte;
102 : : }
103 : : EXPORT_SYMBOL(i2c_smbus_read_byte);
104 : :
105 : : /**
106 : : * i2c_smbus_write_byte - SMBus "send byte" protocol
107 : : * @client: Handle to slave device
108 : : * @value: Byte to be sent
109 : : *
110 : : * This executes the SMBus "send byte" protocol, returning negative errno
111 : : * else zero on success.
112 : : */
113 : 0 : s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
114 : : {
115 : 0 : return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
116 : : I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
117 : : }
118 : : EXPORT_SYMBOL(i2c_smbus_write_byte);
119 : :
120 : : /**
121 : : * i2c_smbus_read_byte_data - SMBus "read byte" protocol
122 : : * @client: Handle to slave device
123 : : * @command: Byte interpreted by slave
124 : : *
125 : : * This executes the SMBus "read byte" protocol, returning negative errno
126 : : * else a data byte received from the device.
127 : : */
128 : 0 : s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
129 : : {
130 : 0 : union i2c_smbus_data data;
131 : 0 : int status;
132 : :
133 : 0 : status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
134 : : I2C_SMBUS_READ, command,
135 : : I2C_SMBUS_BYTE_DATA, &data);
136 [ # # ]: 0 : return (status < 0) ? status : data.byte;
137 : : }
138 : : EXPORT_SYMBOL(i2c_smbus_read_byte_data);
139 : :
140 : : /**
141 : : * i2c_smbus_write_byte_data - SMBus "write byte" protocol
142 : : * @client: Handle to slave device
143 : : * @command: Byte interpreted by slave
144 : : * @value: Byte being written
145 : : *
146 : : * This executes the SMBus "write byte" protocol, returning negative errno
147 : : * else zero on success.
148 : : */
149 : 0 : s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
150 : : u8 value)
151 : : {
152 : 0 : union i2c_smbus_data data;
153 : 0 : data.byte = value;
154 : 0 : return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
155 : : I2C_SMBUS_WRITE, command,
156 : : I2C_SMBUS_BYTE_DATA, &data);
157 : : }
158 : : EXPORT_SYMBOL(i2c_smbus_write_byte_data);
159 : :
160 : : /**
161 : : * i2c_smbus_read_word_data - SMBus "read word" protocol
162 : : * @client: Handle to slave device
163 : : * @command: Byte interpreted by slave
164 : : *
165 : : * This executes the SMBus "read word" protocol, returning negative errno
166 : : * else a 16-bit unsigned "word" received from the device.
167 : : */
168 : 0 : s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
169 : : {
170 : 0 : union i2c_smbus_data data;
171 : 0 : int status;
172 : :
173 : 0 : status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
174 : : I2C_SMBUS_READ, command,
175 : : I2C_SMBUS_WORD_DATA, &data);
176 [ # # ]: 0 : return (status < 0) ? status : data.word;
177 : : }
178 : : EXPORT_SYMBOL(i2c_smbus_read_word_data);
179 : :
180 : : /**
181 : : * i2c_smbus_write_word_data - SMBus "write word" protocol
182 : : * @client: Handle to slave device
183 : : * @command: Byte interpreted by slave
184 : : * @value: 16-bit "word" being written
185 : : *
186 : : * This executes the SMBus "write word" protocol, returning negative errno
187 : : * else zero on success.
188 : : */
189 : 0 : s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
190 : : u16 value)
191 : : {
192 : 0 : union i2c_smbus_data data;
193 : 0 : data.word = value;
194 : 0 : return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
195 : : I2C_SMBUS_WRITE, command,
196 : : I2C_SMBUS_WORD_DATA, &data);
197 : : }
198 : : EXPORT_SYMBOL(i2c_smbus_write_word_data);
199 : :
200 : : /**
201 : : * i2c_smbus_read_block_data - SMBus "block read" protocol
202 : : * @client: Handle to slave device
203 : : * @command: Byte interpreted by slave
204 : : * @values: Byte array into which data will be read; big enough to hold
205 : : * the data returned by the slave. SMBus allows at most 32 bytes.
206 : : *
207 : : * This executes the SMBus "block read" protocol, returning negative errno
208 : : * else the number of data bytes in the slave's response.
209 : : *
210 : : * Note that using this function requires that the client's adapter support
211 : : * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers
212 : : * support this; its emulation through I2C messaging relies on a specific
213 : : * mechanism (I2C_M_RECV_LEN) which may not be implemented.
214 : : */
215 : 0 : s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
216 : : u8 *values)
217 : : {
218 : 0 : union i2c_smbus_data data;
219 : 0 : int status;
220 : :
221 : 0 : status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
222 : : I2C_SMBUS_READ, command,
223 : : I2C_SMBUS_BLOCK_DATA, &data);
224 [ # # ]: 0 : if (status)
225 : : return status;
226 : :
227 : 0 : memcpy(values, &data.block[1], data.block[0]);
228 : 0 : return data.block[0];
229 : : }
230 : : EXPORT_SYMBOL(i2c_smbus_read_block_data);
231 : :
232 : : /**
233 : : * i2c_smbus_write_block_data - SMBus "block write" protocol
234 : : * @client: Handle to slave device
235 : : * @command: Byte interpreted by slave
236 : : * @length: Size of data block; SMBus allows at most 32 bytes
237 : : * @values: Byte array which will be written.
238 : : *
239 : : * This executes the SMBus "block write" protocol, returning negative errno
240 : : * else zero on success.
241 : : */
242 : 0 : s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
243 : : u8 length, const u8 *values)
244 : : {
245 : 0 : union i2c_smbus_data data;
246 : :
247 : 0 : if (length > I2C_SMBUS_BLOCK_MAX)
248 : : length = I2C_SMBUS_BLOCK_MAX;
249 : 0 : data.block[0] = length;
250 : 0 : memcpy(&data.block[1], values, length);
251 : 0 : return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
252 : : I2C_SMBUS_WRITE, command,
253 : : I2C_SMBUS_BLOCK_DATA, &data);
254 : : }
255 : : EXPORT_SYMBOL(i2c_smbus_write_block_data);
256 : :
257 : : /* Returns the number of read bytes */
258 : 0 : s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
259 : : u8 length, u8 *values)
260 : : {
261 : 0 : union i2c_smbus_data data;
262 : 0 : int status;
263 : :
264 : 0 : if (length > I2C_SMBUS_BLOCK_MAX)
265 : : length = I2C_SMBUS_BLOCK_MAX;
266 : 0 : data.block[0] = length;
267 : 0 : status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
268 : : I2C_SMBUS_READ, command,
269 : : I2C_SMBUS_I2C_BLOCK_DATA, &data);
270 [ # # ]: 0 : if (status < 0)
271 : : return status;
272 : :
273 : 0 : memcpy(values, &data.block[1], data.block[0]);
274 : 0 : return data.block[0];
275 : : }
276 : : EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
277 : :
278 : 0 : s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
279 : : u8 length, const u8 *values)
280 : : {
281 : 0 : union i2c_smbus_data data;
282 : :
283 : 0 : if (length > I2C_SMBUS_BLOCK_MAX)
284 : : length = I2C_SMBUS_BLOCK_MAX;
285 : 0 : data.block[0] = length;
286 : 0 : memcpy(data.block + 1, values, length);
287 : 0 : return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
288 : : I2C_SMBUS_WRITE, command,
289 : : I2C_SMBUS_I2C_BLOCK_DATA, &data);
290 : : }
291 : : EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
292 : :
293 : 0 : static void i2c_smbus_try_get_dmabuf(struct i2c_msg *msg, u8 init_val)
294 : : {
295 : 0 : bool is_read = msg->flags & I2C_M_RD;
296 : 0 : unsigned char *dma_buf;
297 : :
298 : 0 : dma_buf = kzalloc(I2C_SMBUS_BLOCK_MAX + (is_read ? 2 : 3), GFP_KERNEL);
299 [ # # ]: 0 : if (!dma_buf)
300 : : return;
301 : :
302 : 0 : msg->buf = dma_buf;
303 : 0 : msg->flags |= I2C_M_DMA_SAFE;
304 : :
305 [ # # ]: 0 : if (init_val)
306 : 0 : msg->buf[0] = init_val;
307 : : }
308 : :
309 : : /*
310 : : * Simulate a SMBus command using the I2C protocol.
311 : : * No checking of parameters is done!
312 : : */
313 : 0 : static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
314 : : unsigned short flags,
315 : : char read_write, u8 command, int size,
316 : : union i2c_smbus_data *data)
317 : : {
318 : : /*
319 : : * So we need to generate a series of msgs. In the case of writing, we
320 : : * need to use only one message; when reading, we need two. We
321 : : * initialize most things with sane defaults, to keep the code below
322 : : * somewhat simpler.
323 : : */
324 : 0 : unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
325 : 0 : unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
326 [ # # ]: 0 : int num = read_write == I2C_SMBUS_READ ? 2 : 1;
327 : 0 : int i;
328 : 0 : u8 partial_pec = 0;
329 : 0 : int status;
330 : 0 : struct i2c_msg msg[2] = {
331 : : {
332 : : .addr = addr,
333 : : .flags = flags,
334 : : .len = 1,
335 : : .buf = msgbuf0,
336 : : }, {
337 : : .addr = addr,
338 : : .flags = flags | I2C_M_RD,
339 : : .len = 0,
340 : : .buf = msgbuf1,
341 : : },
342 : : };
343 : :
344 : 0 : msgbuf0[0] = command;
345 [ # # # # : 0 : switch (size) {
# # # #
# ]
346 : 0 : case I2C_SMBUS_QUICK:
347 : 0 : msg[0].len = 0;
348 : : /* Special case: The read/write field is used as data */
349 : 0 : msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
350 : 0 : I2C_M_RD : 0);
351 : 0 : num = 1;
352 : 0 : break;
353 : 0 : case I2C_SMBUS_BYTE:
354 [ # # ]: 0 : if (read_write == I2C_SMBUS_READ) {
355 : : /* Special case: only a read! */
356 : 0 : msg[0].flags = I2C_M_RD | flags;
357 : 0 : num = 1;
358 : : }
359 : : break;
360 : 0 : case I2C_SMBUS_BYTE_DATA:
361 [ # # ]: 0 : if (read_write == I2C_SMBUS_READ)
362 : 0 : msg[1].len = 1;
363 : : else {
364 : 0 : msg[0].len = 2;
365 : 0 : msgbuf0[1] = data->byte;
366 : : }
367 : : break;
368 : 0 : case I2C_SMBUS_WORD_DATA:
369 [ # # ]: 0 : if (read_write == I2C_SMBUS_READ)
370 : 0 : msg[1].len = 2;
371 : : else {
372 : 0 : msg[0].len = 3;
373 : 0 : msgbuf0[1] = data->word & 0xff;
374 : 0 : msgbuf0[2] = data->word >> 8;
375 : : }
376 : : break;
377 : 0 : case I2C_SMBUS_PROC_CALL:
378 : 0 : num = 2; /* Special case */
379 : 0 : read_write = I2C_SMBUS_READ;
380 : 0 : msg[0].len = 3;
381 : 0 : msg[1].len = 2;
382 : 0 : msgbuf0[1] = data->word & 0xff;
383 : 0 : msgbuf0[2] = data->word >> 8;
384 : 0 : break;
385 : 0 : case I2C_SMBUS_BLOCK_DATA:
386 [ # # ]: 0 : if (read_write == I2C_SMBUS_READ) {
387 : 0 : msg[1].flags |= I2C_M_RECV_LEN;
388 : 0 : msg[1].len = 1; /* block length will be added by
389 : : the underlying bus driver */
390 : 0 : i2c_smbus_try_get_dmabuf(&msg[1], 0);
391 : : } else {
392 : 0 : msg[0].len = data->block[0] + 2;
393 [ # # ]: 0 : if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
394 : 0 : dev_err(&adapter->dev,
395 : : "Invalid block write size %d\n",
396 : : data->block[0]);
397 : 0 : return -EINVAL;
398 : : }
399 : :
400 : 0 : i2c_smbus_try_get_dmabuf(&msg[0], command);
401 [ # # ]: 0 : for (i = 1; i < msg[0].len; i++)
402 : 0 : msg[0].buf[i] = data->block[i - 1];
403 : : }
404 : : break;
405 : 0 : case I2C_SMBUS_BLOCK_PROC_CALL:
406 : 0 : num = 2; /* Another special case */
407 : 0 : read_write = I2C_SMBUS_READ;
408 [ # # ]: 0 : if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
409 : 0 : dev_err(&adapter->dev,
410 : : "Invalid block write size %d\n",
411 : : data->block[0]);
412 : 0 : return -EINVAL;
413 : : }
414 : :
415 : 0 : msg[0].len = data->block[0] + 2;
416 : 0 : i2c_smbus_try_get_dmabuf(&msg[0], command);
417 [ # # ]: 0 : for (i = 1; i < msg[0].len; i++)
418 : 0 : msg[0].buf[i] = data->block[i - 1];
419 : :
420 : 0 : msg[1].flags |= I2C_M_RECV_LEN;
421 : 0 : msg[1].len = 1; /* block length will be added by
422 : : the underlying bus driver */
423 : 0 : i2c_smbus_try_get_dmabuf(&msg[1], 0);
424 : 0 : break;
425 : 0 : case I2C_SMBUS_I2C_BLOCK_DATA:
426 [ # # ]: 0 : if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
427 [ # # ]: 0 : dev_err(&adapter->dev, "Invalid block %s size %d\n",
428 : : read_write == I2C_SMBUS_READ ? "read" : "write",
429 : : data->block[0]);
430 : 0 : return -EINVAL;
431 : : }
432 : :
433 [ # # ]: 0 : if (read_write == I2C_SMBUS_READ) {
434 : 0 : msg[1].len = data->block[0];
435 : 0 : i2c_smbus_try_get_dmabuf(&msg[1], 0);
436 : : } else {
437 : 0 : msg[0].len = data->block[0] + 1;
438 : :
439 : 0 : i2c_smbus_try_get_dmabuf(&msg[0], command);
440 [ # # ]: 0 : for (i = 1; i <= data->block[0]; i++)
441 : 0 : msg[0].buf[i] = data->block[i];
442 : : }
443 : : break;
444 : 0 : default:
445 : 0 : dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
446 : 0 : return -EOPNOTSUPP;
447 : : }
448 : :
449 : 0 : i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
450 [ # # # # ]: 0 : && size != I2C_SMBUS_I2C_BLOCK_DATA);
451 : 0 : if (i) {
452 : : /* Compute PEC if first message is a write */
453 [ # # ]: 0 : if (!(msg[0].flags & I2C_M_RD)) {
454 [ # # ]: 0 : if (num == 1) /* Write only */
455 : 0 : i2c_smbus_add_pec(&msg[0]);
456 : : else /* Write followed by read */
457 : 0 : partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
458 : : }
459 : : /* Ask for PEC if last message is a read */
460 [ # # ]: 0 : if (msg[num-1].flags & I2C_M_RD)
461 : 0 : msg[num-1].len++;
462 : : }
463 : :
464 : 0 : status = __i2c_transfer(adapter, msg, num);
465 [ # # ]: 0 : if (status < 0)
466 : 0 : goto cleanup;
467 [ # # ]: 0 : if (status != num) {
468 : 0 : status = -EIO;
469 : 0 : goto cleanup;
470 : : }
471 : 0 : status = 0;
472 : :
473 : : /* Check PEC if last message is a read */
474 [ # # # # ]: 0 : if (i && (msg[num-1].flags & I2C_M_RD)) {
475 : 0 : status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
476 : 0 : if (status < 0)
477 : 0 : goto cleanup;
478 : : }
479 : :
480 [ # # ]: 0 : if (read_write == I2C_SMBUS_READ)
481 [ # # # # : 0 : switch (size) {
# # ]
482 : 0 : case I2C_SMBUS_BYTE:
483 : 0 : data->byte = msgbuf0[0];
484 : 0 : break;
485 : 0 : case I2C_SMBUS_BYTE_DATA:
486 : 0 : data->byte = msgbuf1[0];
487 : 0 : break;
488 : 0 : case I2C_SMBUS_WORD_DATA:
489 : : case I2C_SMBUS_PROC_CALL:
490 : 0 : data->word = msgbuf1[0] | (msgbuf1[1] << 8);
491 : 0 : break;
492 : : case I2C_SMBUS_I2C_BLOCK_DATA:
493 [ # # ]: 0 : for (i = 0; i < data->block[0]; i++)
494 : 0 : data->block[i + 1] = msg[1].buf[i];
495 : : break;
496 : : case I2C_SMBUS_BLOCK_DATA:
497 : : case I2C_SMBUS_BLOCK_PROC_CALL:
498 [ # # ]: 0 : for (i = 0; i < msg[1].buf[0] + 1; i++)
499 : 0 : data->block[i] = msg[1].buf[i];
500 : : break;
501 : : }
502 : :
503 : 0 : cleanup:
504 [ # # ]: 0 : if (msg[0].flags & I2C_M_DMA_SAFE)
505 : 0 : kfree(msg[0].buf);
506 [ # # ]: 0 : if (msg[1].flags & I2C_M_DMA_SAFE)
507 : 0 : kfree(msg[1].buf);
508 : :
509 : : return status;
510 : : }
511 : :
512 : : /**
513 : : * i2c_smbus_xfer - execute SMBus protocol operations
514 : : * @adapter: Handle to I2C bus
515 : : * @addr: Address of SMBus slave on that bus
516 : : * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
517 : : * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
518 : : * @command: Byte interpreted by slave, for protocols which use such bytes
519 : : * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
520 : : * @data: Data to be read or written
521 : : *
522 : : * This executes an SMBus protocol operation, and returns a negative
523 : : * errno code else zero on success.
524 : : */
525 : 0 : s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
526 : : unsigned short flags, char read_write,
527 : : u8 command, int protocol, union i2c_smbus_data *data)
528 : : {
529 : 0 : s32 res;
530 : :
531 : 0 : res = __i2c_lock_bus_helper(adapter);
532 [ # # ]: 0 : if (res)
533 : : return res;
534 : :
535 : 0 : res = __i2c_smbus_xfer(adapter, addr, flags, read_write,
536 : : command, protocol, data);
537 : 0 : i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
538 : :
539 : 0 : return res;
540 : : }
541 : : EXPORT_SYMBOL(i2c_smbus_xfer);
542 : :
543 : 0 : s32 __i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
544 : : unsigned short flags, char read_write,
545 : : u8 command, int protocol, union i2c_smbus_data *data)
546 : : {
547 : 0 : int (*xfer_func)(struct i2c_adapter *adap, u16 addr,
548 : : unsigned short flags, char read_write,
549 : : u8 command, int size, union i2c_smbus_data *data);
550 : 0 : unsigned long orig_jiffies;
551 : 0 : int try;
552 : 0 : s32 res;
553 : :
554 : 0 : res = __i2c_check_suspended(adapter);
555 [ # # ]: 0 : if (res)
556 : : return res;
557 : :
558 : : /* If enabled, the following two tracepoints are conditional on
559 : : * read_write and protocol.
560 : : */
561 : 0 : trace_smbus_write(adapter, addr, flags, read_write,
562 : : command, protocol, data);
563 : 0 : trace_smbus_read(adapter, addr, flags, read_write,
564 : : command, protocol);
565 : :
566 : 0 : flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
567 : :
568 : 0 : xfer_func = adapter->algo->smbus_xfer;
569 [ # # # # ]: 0 : if (i2c_in_atomic_xfer_mode()) {
570 [ # # ]: 0 : if (adapter->algo->smbus_xfer_atomic)
571 : : xfer_func = adapter->algo->smbus_xfer_atomic;
572 [ # # ]: 0 : else if (adapter->algo->master_xfer_atomic)
573 : : xfer_func = NULL; /* fallback to I2C emulation */
574 : : }
575 : :
576 [ # # ]: 0 : if (xfer_func) {
577 : : /* Retry automatically on arbitration loss */
578 : 0 : orig_jiffies = jiffies;
579 [ # # ]: 0 : for (res = 0, try = 0; try <= adapter->retries; try++) {
580 : 0 : res = xfer_func(adapter, addr, flags, read_write,
581 : : command, protocol, data);
582 [ # # ]: 0 : if (res != -EAGAIN)
583 : : break;
584 [ # # ]: 0 : if (time_after(jiffies,
585 : : orig_jiffies + adapter->timeout))
586 : : break;
587 : : }
588 : :
589 [ # # # # ]: 0 : if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
590 : 0 : goto trace;
591 : : /*
592 : : * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
593 : : * implement native support for the SMBus operation.
594 : : */
595 : : }
596 : :
597 : 0 : res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
598 : : command, protocol, data);
599 : :
600 : 0 : trace:
601 : : /* If enabled, the reply tracepoint is conditional on read_write. */
602 : 0 : trace_smbus_reply(adapter, addr, flags, read_write,
603 : : command, protocol, data, res);
604 : 0 : trace_smbus_result(adapter, addr, flags, read_write,
605 : : command, protocol, res);
606 : :
607 : 0 : return res;
608 : : }
609 : : EXPORT_SYMBOL(__i2c_smbus_xfer);
610 : :
611 : : /**
612 : : * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
613 : : * @client: Handle to slave device
614 : : * @command: Byte interpreted by slave
615 : : * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
616 : : * @values: Byte array into which data will be read; big enough to hold
617 : : * the data returned by the slave. SMBus allows at most
618 : : * I2C_SMBUS_BLOCK_MAX bytes.
619 : : *
620 : : * This executes the SMBus "block read" protocol if supported by the adapter.
621 : : * If block read is not supported, it emulates it using either word or byte
622 : : * read protocols depending on availability.
623 : : *
624 : : * The addresses of the I2C slave device that are accessed with this function
625 : : * must be mapped to a linear region, so that a block read will have the same
626 : : * effect as a byte read. Before using this function you must double-check
627 : : * if the I2C slave does support exchanging a block transfer with a byte
628 : : * transfer.
629 : : */
630 : 0 : s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
631 : : u8 command, u8 length, u8 *values)
632 : : {
633 : 0 : u8 i = 0;
634 : 0 : int status;
635 : :
636 : 0 : if (length > I2C_SMBUS_BLOCK_MAX)
637 : : length = I2C_SMBUS_BLOCK_MAX;
638 : :
639 [ # # ]: 0 : if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
640 : 0 : return i2c_smbus_read_i2c_block_data(client, command, length, values);
641 : :
642 [ # # ]: 0 : if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
643 : : return -EOPNOTSUPP;
644 : :
645 [ # # ]: 0 : if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
646 [ # # ]: 0 : while ((i + 2) <= length) {
647 : 0 : status = i2c_smbus_read_word_data(client, command + i);
648 [ # # ]: 0 : if (status < 0)
649 : 0 : return status;
650 : 0 : values[i] = status & 0xff;
651 : 0 : values[i + 1] = status >> 8;
652 : 0 : i += 2;
653 : : }
654 : : }
655 : :
656 [ # # ]: 0 : while (i < length) {
657 : 0 : status = i2c_smbus_read_byte_data(client, command + i);
658 [ # # ]: 0 : if (status < 0)
659 : 0 : return status;
660 : 0 : values[i] = status;
661 : 0 : i++;
662 : : }
663 : :
664 : 0 : return i;
665 : : }
666 : : EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
667 : :
668 : : /**
669 : : * i2c_setup_smbus_alert - Setup SMBus alert support
670 : : * @adapter: the target adapter
671 : : * @setup: setup data for the SMBus alert handler
672 : : * Context: can sleep
673 : : *
674 : : * Setup handling of the SMBus alert protocol on a given I2C bus segment.
675 : : *
676 : : * Handling can be done either through our IRQ handler, or by the
677 : : * adapter (from its handler, periodic polling, or whatever).
678 : : *
679 : : * NOTE that if we manage the IRQ, we *MUST* know if it's level or
680 : : * edge triggered in order to hand it to the workqueue correctly.
681 : : * If triggering the alert seems to wedge the system, you probably
682 : : * should have said it's level triggered.
683 : : *
684 : : * This returns the ara client, which should be saved for later use with
685 : : * i2c_handle_smbus_alert() and ultimately i2c_unregister_device(); or NULL
686 : : * to indicate an error.
687 : : */
688 : 0 : struct i2c_client *i2c_setup_smbus_alert(struct i2c_adapter *adapter,
689 : : struct i2c_smbus_alert_setup *setup)
690 : : {
691 : 0 : struct i2c_board_info ara_board_info = {
692 : : I2C_BOARD_INFO("smbus_alert", 0x0c),
693 : : .platform_data = setup,
694 : : };
695 : :
696 : 0 : return i2c_new_device(adapter, &ara_board_info);
697 : : }
698 : : EXPORT_SYMBOL_GPL(i2c_setup_smbus_alert);
699 : :
700 : : #if IS_ENABLED(CONFIG_I2C_SMBUS) && IS_ENABLED(CONFIG_OF)
701 : : int of_i2c_setup_smbus_alert(struct i2c_adapter *adapter)
702 : : {
703 : : struct i2c_client *client;
704 : : int irq;
705 : :
706 : : irq = of_property_match_string(adapter->dev.of_node, "interrupt-names",
707 : : "smbus_alert");
708 : : if (irq == -EINVAL || irq == -ENODATA)
709 : : return 0;
710 : : else if (irq < 0)
711 : : return irq;
712 : :
713 : : client = i2c_setup_smbus_alert(adapter, NULL);
714 : : if (!client)
715 : : return -ENODEV;
716 : :
717 : : return 0;
718 : : }
719 : : EXPORT_SYMBOL_GPL(of_i2c_setup_smbus_alert);
720 : : #endif
|
