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 seperate 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 /* Incremental CRC8 over count bytes in the array pointed to by p */
i2c_smbus_pec(u8 crc,u8 * p,size_t count)41 static 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 */
i2c_smbus_msg_pec(u8 pec,struct i2c_msg * msg)51 static 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 */
i2c_smbus_add_pec(struct i2c_msg * msg)62 static 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). */
i2c_smbus_check_pec(u8 cpec,struct i2c_msg * msg)73 static 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 */
i2c_smbus_read_byte(const struct i2c_client * client)93 s32 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 }
103 EXPORT_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 */
i2c_smbus_write_byte(const struct i2c_client * client,u8 value)113 s32 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 }
118 EXPORT_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 */
i2c_smbus_read_byte_data(const struct i2c_client * client,u8 command)128 s32 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 }
138 EXPORT_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 */
i2c_smbus_write_byte_data(const struct i2c_client * client,u8 command,u8 value)149 s32 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 }
158 EXPORT_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 */
i2c_smbus_read_word_data(const struct i2c_client * client,u8 command)168 s32 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 }
178 EXPORT_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 */
i2c_smbus_write_word_data(const struct i2c_client * client,u8 command,u16 value)189 s32 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 }
198 EXPORT_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 */
i2c_smbus_read_block_data(const struct i2c_client * client,u8 command,u8 * values)215 s32 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 }
230 EXPORT_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 */
i2c_smbus_write_block_data(const struct i2c_client * client,u8 command,u8 length,const u8 * values)242 s32 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 }
255 EXPORT_SYMBOL(i2c_smbus_write_block_data);
256
257 /* Returns the number of read bytes */
i2c_smbus_read_i2c_block_data(const struct i2c_client * client,u8 command,u8 length,u8 * values)258 s32 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 }
276 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
277
i2c_smbus_write_i2c_block_data(const struct i2c_client * client,u8 command,u8 length,const u8 * values)278 s32 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 }
291 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
292
i2c_smbus_try_get_dmabuf(struct i2c_msg * msg,u8 init_val)293 static 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 */
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)313 static 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 for (i = 0; i < msg[1].buf[0] + 1; i++)
499 data->block[i] = msg[1].buf[i];
500 break;
501 }
502
503 cleanup:
504 if (msg[0].flags & I2C_M_DMA_SAFE)
505 kfree(msg[0].buf);
506 if (msg[1].flags & I2C_M_DMA_SAFE)
507 kfree(msg[1].buf);
508
509 return status;
510 }
511
512 /**
513 * i2c_smbus_xfer - execute SMBus protocol operations
514 * @adapter: Handle to I2C bus
515 * @addr: Address of SMBus slave on that bus
516 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
517 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
518 * @command: Byte interpreted by slave, for protocols which use such bytes
519 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
520 * @data: Data to be read or written
521 *
522 * This executes an SMBus protocol operation, and returns a negative
523 * errno code else zero on success.
524 */
i2c_smbus_xfer(struct i2c_adapter * adapter,u16 addr,unsigned short flags,char read_write,u8 command,int protocol,union i2c_smbus_data * data)525 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
526 unsigned short flags, char read_write,
527 u8 command, int protocol, union i2c_smbus_data *data)
528 {
529 s32 res;
530
531 res = __i2c_lock_bus_helper(adapter);
532 if (res)
533 return res;
534
535 res = __i2c_smbus_xfer(adapter, addr, flags, read_write,
536 command, protocol, data);
537 i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
538
539 return res;
540 }
541 EXPORT_SYMBOL(i2c_smbus_xfer);
542
__i2c_smbus_xfer(struct i2c_adapter * adapter,u16 addr,unsigned short flags,char read_write,u8 command,int protocol,union i2c_smbus_data * data)543 s32 __i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
544 unsigned short flags, char read_write,
545 u8 command, int protocol, union i2c_smbus_data *data)
546 {
547 int (*xfer_func)(struct i2c_adapter *adap, u16 addr,
548 unsigned short flags, char read_write,
549 u8 command, int size, union i2c_smbus_data *data);
550 unsigned long orig_jiffies;
551 int try;
552 s32 res;
553
554 res = __i2c_check_suspended(adapter);
555 if (res)
556 return res;
557
558 /* If enabled, the following two tracepoints are conditional on
559 * read_write and protocol.
560 */
561 trace_smbus_write(adapter, addr, flags, read_write,
562 command, protocol, data);
563 trace_smbus_read(adapter, addr, flags, read_write,
564 command, protocol);
565
566 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
567
568 xfer_func = adapter->algo->smbus_xfer;
569 if (i2c_in_atomic_xfer_mode()) {
570 if (adapter->algo->smbus_xfer_atomic)
571 xfer_func = adapter->algo->smbus_xfer_atomic;
572 else if (adapter->algo->master_xfer_atomic)
573 xfer_func = NULL; /* fallback to I2C emulation */
574 }
575
576 if (xfer_func) {
577 /* Retry automatically on arbitration loss */
578 orig_jiffies = jiffies;
579 for (res = 0, try = 0; try <= adapter->retries; try++) {
580 res = xfer_func(adapter, addr, flags, read_write,
581 command, protocol, data);
582 if (res != -EAGAIN)
583 break;
584 if (time_after(jiffies,
585 orig_jiffies + adapter->timeout))
586 break;
587 }
588
589 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
590 goto trace;
591 /*
592 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
593 * implement native support for the SMBus operation.
594 */
595 }
596
597 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
598 command, protocol, data);
599
600 trace:
601 /* If enabled, the reply tracepoint is conditional on read_write. */
602 trace_smbus_reply(adapter, addr, flags, read_write,
603 command, protocol, data, res);
604 trace_smbus_result(adapter, addr, flags, read_write,
605 command, protocol, res);
606
607 return res;
608 }
609 EXPORT_SYMBOL(__i2c_smbus_xfer);
610
611 /**
612 * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
613 * @client: Handle to slave device
614 * @command: Byte interpreted by slave
615 * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
616 * @values: Byte array into which data will be read; big enough to hold
617 * the data returned by the slave. SMBus allows at most
618 * I2C_SMBUS_BLOCK_MAX bytes.
619 *
620 * This executes the SMBus "block read" protocol if supported by the adapter.
621 * If block read is not supported, it emulates it using either word or byte
622 * read protocols depending on availability.
623 *
624 * The addresses of the I2C slave device that are accessed with this function
625 * must be mapped to a linear region, so that a block read will have the same
626 * effect as a byte read. Before using this function you must double-check
627 * if the I2C slave does support exchanging a block transfer with a byte
628 * transfer.
629 */
i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client * client,u8 command,u8 length,u8 * values)630 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
631 u8 command, u8 length, u8 *values)
632 {
633 u8 i = 0;
634 int status;
635
636 if (length > I2C_SMBUS_BLOCK_MAX)
637 length = I2C_SMBUS_BLOCK_MAX;
638
639 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
640 return i2c_smbus_read_i2c_block_data(client, command, length, values);
641
642 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
643 return -EOPNOTSUPP;
644
645 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
646 while ((i + 2) <= length) {
647 status = i2c_smbus_read_word_data(client, command + i);
648 if (status < 0)
649 return status;
650 values[i] = status & 0xff;
651 values[i + 1] = status >> 8;
652 i += 2;
653 }
654 }
655
656 while (i < length) {
657 status = i2c_smbus_read_byte_data(client, command + i);
658 if (status < 0)
659 return status;
660 values[i] = status;
661 i++;
662 }
663
664 return i;
665 }
666 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
667
668 /**
669 * i2c_setup_smbus_alert - Setup SMBus alert support
670 * @adapter: the target adapter
671 * @setup: setup data for the SMBus alert handler
672 * Context: can sleep
673 *
674 * Setup handling of the SMBus alert protocol on a given I2C bus segment.
675 *
676 * Handling can be done either through our IRQ handler, or by the
677 * adapter (from its handler, periodic polling, or whatever).
678 *
679 * NOTE that if we manage the IRQ, we *MUST* know if it's level or
680 * edge triggered in order to hand it to the workqueue correctly.
681 * If triggering the alert seems to wedge the system, you probably
682 * should have said it's level triggered.
683 *
684 * This returns the ara client, which should be saved for later use with
685 * i2c_handle_smbus_alert() and ultimately i2c_unregister_device(); or NULL
686 * to indicate an error.
687 */
i2c_setup_smbus_alert(struct i2c_adapter * adapter,struct i2c_smbus_alert_setup * setup)688 struct i2c_client *i2c_setup_smbus_alert(struct i2c_adapter *adapter,
689 struct i2c_smbus_alert_setup *setup)
690 {
691 struct i2c_board_info ara_board_info = {
692 I2C_BOARD_INFO("smbus_alert", 0x0c),
693 .platform_data = setup,
694 };
695
696 return i2c_new_device(adapter, &ara_board_info);
697 }
698 EXPORT_SYMBOL_GPL(i2c_setup_smbus_alert);
699
700 #if IS_ENABLED(CONFIG_I2C_SMBUS) && IS_ENABLED(CONFIG_OF)
of_i2c_setup_smbus_alert(struct i2c_adapter * adapter)701 int of_i2c_setup_smbus_alert(struct i2c_adapter *adapter)
702 {
703 struct i2c_client *client;
704 int irq;
705
706 irq = of_property_match_string(adapter->dev.of_node, "interrupt-names",
707 "smbus_alert");
708 if (irq == -EINVAL || irq == -ENODATA)
709 return 0;
710 else if (irq < 0)
711 return irq;
712
713 client = i2c_setup_smbus_alert(adapter, NULL);
714 if (!client)
715 return -ENODEV;
716
717 return 0;
718 }
719 EXPORT_SYMBOL_GPL(of_i2c_setup_smbus_alert);
720 #endif
721