i2c-core-smbus.c

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