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