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