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