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
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
293 /* Simulate a SMBus command using the i2c protocol
294 No checking of parameters is done! */
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)295 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
296 unsigned short flags,
297 char read_write, u8 command, int size,
298 union i2c_smbus_data *data)
299 {
300 /* So we need to generate a series of msgs. In the case of writing, we
301 need to use only one message; when reading, we need two. We initialize
302 most things with sane defaults, to keep the code below somewhat
303 simpler. */
304 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
305 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
306 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
307 int i;
308 u8 partial_pec = 0;
309 int status;
310 struct i2c_msg msg[2] = {
311 {
312 .addr = addr,
313 .flags = flags,
314 .len = 1,
315 .buf = msgbuf0,
316 }, {
317 .addr = addr,
318 .flags = flags | I2C_M_RD,
319 .len = 0,
320 .buf = msgbuf1,
321 },
322 };
323
324 msgbuf0[0] = command;
325 switch (size) {
326 case I2C_SMBUS_QUICK:
327 msg[0].len = 0;
328 /* Special case: The read/write field is used as data */
329 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
330 I2C_M_RD : 0);
331 num = 1;
332 break;
333 case I2C_SMBUS_BYTE:
334 if (read_write == I2C_SMBUS_READ) {
335 /* Special case: only a read! */
336 msg[0].flags = I2C_M_RD | flags;
337 num = 1;
338 }
339 break;
340 case I2C_SMBUS_BYTE_DATA:
341 if (read_write == I2C_SMBUS_READ)
342 msg[1].len = 1;
343 else {
344 msg[0].len = 2;
345 msgbuf0[1] = data->byte;
346 }
347 break;
348 case I2C_SMBUS_WORD_DATA:
349 if (read_write == I2C_SMBUS_READ)
350 msg[1].len = 2;
351 else {
352 msg[0].len = 3;
353 msgbuf0[1] = data->word & 0xff;
354 msgbuf0[2] = data->word >> 8;
355 }
356 break;
357 case I2C_SMBUS_PROC_CALL:
358 num = 2; /* Special case */
359 read_write = I2C_SMBUS_READ;
360 msg[0].len = 3;
361 msg[1].len = 2;
362 msgbuf0[1] = data->word & 0xff;
363 msgbuf0[2] = data->word >> 8;
364 break;
365 case I2C_SMBUS_BLOCK_DATA:
366 if (read_write == I2C_SMBUS_READ) {
367 msg[1].flags |= I2C_M_RECV_LEN;
368 msg[1].len = 1; /* block length will be added by
369 the underlying bus driver */
370 } else {
371 msg[0].len = data->block[0] + 2;
372 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
373 dev_err(&adapter->dev,
374 "Invalid block write size %d\n",
375 data->block[0]);
376 return -EINVAL;
377 }
378 for (i = 1; i < msg[0].len; i++)
379 msgbuf0[i] = data->block[i-1];
380 }
381 break;
382 case I2C_SMBUS_BLOCK_PROC_CALL:
383 num = 2; /* Another special case */
384 read_write = I2C_SMBUS_READ;
385 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
386 dev_err(&adapter->dev,
387 "Invalid block write size %d\n",
388 data->block[0]);
389 return -EINVAL;
390 }
391 msg[0].len = data->block[0] + 2;
392 for (i = 1; i < msg[0].len; i++)
393 msgbuf0[i] = data->block[i-1];
394 msg[1].flags |= I2C_M_RECV_LEN;
395 msg[1].len = 1; /* block length will be added by
396 the underlying bus driver */
397 break;
398 case I2C_SMBUS_I2C_BLOCK_DATA:
399 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
400 dev_err(&adapter->dev, "Invalid block %s size %d\n",
401 read_write == I2C_SMBUS_READ ? "read" : "write",
402 data->block[0]);
403 return -EINVAL;
404 }
405
406 if (read_write == I2C_SMBUS_READ) {
407 msg[1].len = data->block[0];
408 } else {
409 msg[0].len = data->block[0] + 1;
410 for (i = 1; i <= data->block[0]; i++)
411 msgbuf0[i] = data->block[i];
412 }
413 break;
414 default:
415 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
416 return -EOPNOTSUPP;
417 }
418
419 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
420 && size != I2C_SMBUS_I2C_BLOCK_DATA);
421 if (i) {
422 /* Compute PEC if first message is a write */
423 if (!(msg[0].flags & I2C_M_RD)) {
424 if (num == 1) /* Write only */
425 i2c_smbus_add_pec(&msg[0]);
426 else /* Write followed by read */
427 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
428 }
429 /* Ask for PEC if last message is a read */
430 if (msg[num-1].flags & I2C_M_RD)
431 msg[num-1].len++;
432 }
433
434 status = i2c_transfer(adapter, msg, num);
435 if (status < 0)
436 return status;
437
438 /* Check PEC if last message is a read */
439 if (i && (msg[num-1].flags & I2C_M_RD)) {
440 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
441 if (status < 0)
442 return status;
443 }
444
445 if (read_write == I2C_SMBUS_READ)
446 switch (size) {
447 case I2C_SMBUS_BYTE:
448 data->byte = msgbuf0[0];
449 break;
450 case I2C_SMBUS_BYTE_DATA:
451 data->byte = msgbuf1[0];
452 break;
453 case I2C_SMBUS_WORD_DATA:
454 case I2C_SMBUS_PROC_CALL:
455 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
456 break;
457 case I2C_SMBUS_I2C_BLOCK_DATA:
458 for (i = 0; i < data->block[0]; i++)
459 data->block[i+1] = msgbuf1[i];
460 break;
461 case I2C_SMBUS_BLOCK_DATA:
462 case I2C_SMBUS_BLOCK_PROC_CALL:
463 for (i = 0; i < msgbuf1[0] + 1; i++)
464 data->block[i] = msgbuf1[i];
465 break;
466 }
467 return 0;
468 }
469
470 /**
471 * i2c_smbus_xfer - execute SMBus protocol operations
472 * @adapter: Handle to I2C bus
473 * @addr: Address of SMBus slave on that bus
474 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
475 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
476 * @command: Byte interpreted by slave, for protocols which use such bytes
477 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
478 * @data: Data to be read or written
479 *
480 * This executes an SMBus protocol operation, and returns a negative
481 * errno code else zero on success.
482 */
i2c_smbus_xfer(struct i2c_adapter * adapter,u16 addr,unsigned short flags,char read_write,u8 command,int protocol,union i2c_smbus_data * data)483 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
484 char read_write, u8 command, int protocol,
485 union i2c_smbus_data *data)
486 {
487 unsigned long orig_jiffies;
488 int try;
489 s32 res;
490
491 /* If enabled, the following two tracepoints are conditional on
492 * read_write and protocol.
493 */
494 trace_smbus_write(adapter, addr, flags, read_write,
495 command, protocol, data);
496 trace_smbus_read(adapter, addr, flags, read_write,
497 command, protocol);
498
499 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
500
501 if (adapter->algo->smbus_xfer) {
502 i2c_lock_bus(adapter, I2C_LOCK_SEGMENT);
503
504 /* Retry automatically on arbitration loss */
505 orig_jiffies = jiffies;
506 for (res = 0, try = 0; try <= adapter->retries; try++) {
507 res = adapter->algo->smbus_xfer(adapter, addr, flags,
508 read_write, command,
509 protocol, data);
510 if (res != -EAGAIN)
511 break;
512 if (time_after(jiffies,
513 orig_jiffies + adapter->timeout))
514 break;
515 }
516 i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
517
518 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
519 goto trace;
520 /*
521 * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
522 * implement native support for the SMBus operation.
523 */
524 }
525
526 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
527 command, protocol, data);
528
529 trace:
530 /* If enabled, the reply tracepoint is conditional on read_write. */
531 trace_smbus_reply(adapter, addr, flags, read_write,
532 command, protocol, data);
533 trace_smbus_result(adapter, addr, flags, read_write,
534 command, protocol, res);
535
536 return res;
537 }
538 EXPORT_SYMBOL(i2c_smbus_xfer);
539
540 /**
541 * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
542 * @client: Handle to slave device
543 * @command: Byte interpreted by slave
544 * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
545 * @values: Byte array into which data will be read; big enough to hold
546 * the data returned by the slave. SMBus allows at most
547 * I2C_SMBUS_BLOCK_MAX bytes.
548 *
549 * This executes the SMBus "block read" protocol if supported by the adapter.
550 * If block read is not supported, it emulates it using either word or byte
551 * read protocols depending on availability.
552 *
553 * The addresses of the I2C slave device that are accessed with this function
554 * must be mapped to a linear region, so that a block read will have the same
555 * effect as a byte read. Before using this function you must double-check
556 * if the I2C slave does support exchanging a block transfer with a byte
557 * transfer.
558 */
i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client * client,u8 command,u8 length,u8 * values)559 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
560 u8 command, u8 length, u8 *values)
561 {
562 u8 i = 0;
563 int status;
564
565 if (length > I2C_SMBUS_BLOCK_MAX)
566 length = I2C_SMBUS_BLOCK_MAX;
567
568 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
569 return i2c_smbus_read_i2c_block_data(client, command, length, values);
570
571 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
572 return -EOPNOTSUPP;
573
574 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
575 while ((i + 2) <= length) {
576 status = i2c_smbus_read_word_data(client, command + i);
577 if (status < 0)
578 return status;
579 values[i] = status & 0xff;
580 values[i + 1] = status >> 8;
581 i += 2;
582 }
583 }
584
585 while (i < length) {
586 status = i2c_smbus_read_byte_data(client, command + i);
587 if (status < 0)
588 return status;
589 values[i] = status;
590 i++;
591 }
592
593 return i;
594 }
595 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
596