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