xref: /openbmc/linux/drivers/i2c/i2c-core-smbus.c (revision 8302532f)
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)
crc8(u16 data)29 static 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  */
i2c_smbus_pec(u8 crc,u8 * p,size_t count)49 u8 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 }
57 EXPORT_SYMBOL(i2c_smbus_pec);
58 
59 /* Assume a 7-bit address, which is reasonable for SMBus */
i2c_smbus_msg_pec(u8 pec,struct i2c_msg * msg)60 static 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 */
i2c_smbus_add_pec(struct i2c_msg * msg)71 static 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). */
i2c_smbus_check_pec(u8 cpec,struct i2c_msg * msg)82 static 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  */
i2c_smbus_read_byte(const struct i2c_client * client)102 s32 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 }
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  */
i2c_smbus_write_byte(const struct i2c_client * client,u8 value)122 s32 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 }
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  */
i2c_smbus_read_byte_data(const struct i2c_client * client,u8 command)137 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 	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 }
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  */
i2c_smbus_write_byte_data(const struct i2c_client * client,u8 command,u8 value)158 s32 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 }
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  */
i2c_smbus_read_word_data(const struct i2c_client * client,u8 command)177 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 	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 }
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  */
i2c_smbus_write_word_data(const struct i2c_client * client,u8 command,u16 value)198 s32 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 }
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  */
i2c_smbus_read_block_data(const struct i2c_client * client,u8 command,u8 * values)224 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 	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 }
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  */
i2c_smbus_write_block_data(const struct i2c_client * client,u8 command,u8 length,const u8 * values)251 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 	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 }
264 EXPORT_SYMBOL(i2c_smbus_write_block_data);
265 
266 /* Returns the number of read bytes */
i2c_smbus_read_i2c_block_data(const struct i2c_client * client,u8 command,u8 length,u8 * values)267 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 	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 }
285 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
286 
i2c_smbus_write_i2c_block_data(const struct i2c_client * client,u8 command,u8 length,const u8 * values)287 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 	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 }
300 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
301 
i2c_smbus_try_get_dmabuf(struct i2c_msg * msg,u8 init_val)302 static 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  */
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)322 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 	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 
513 cleanup:
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  */
i2c_smbus_xfer(struct i2c_adapter * adapter,u16 addr,unsigned short flags,char read_write,u8 command,int protocol,union i2c_smbus_data * data)535 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 	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 }
551 EXPORT_SYMBOL(i2c_smbus_xfer);
552 
__i2c_smbus_xfer(struct i2c_adapter * adapter,u16 addr,unsigned short flags,char read_write,u8 command,int protocol,union i2c_smbus_data * data)553 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 	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 
610 trace:
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 }
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  */
i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client * client,u8 command,u8 length,u8 * values)640 s32 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 }
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  */
i2c_new_smbus_alert_device(struct i2c_adapter * adapter,struct i2c_smbus_alert_setup * setup)693 struct 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 }
703 EXPORT_SYMBOL_GPL(i2c_new_smbus_alert_device);
704 
705 #if IS_ENABLED(CONFIG_I2C_SMBUS)
i2c_setup_smbus_alert(struct i2c_adapter * adapter)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
724