1
2
3
4
5
6
7
8
9
10
11
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
26
27#define POLY (0x1070U << 3)
28static 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
41
42
43
44
45
46
47
48u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
49{
50 int i;
51
52 for (i = 0; i < count; i++)
53 crc = crc8((crc ^ p[i]) << 8);
54 return crc;
55}
56EXPORT_SYMBOL(i2c_smbus_pec);
57
58
59static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
60{
61
62 u8 addr = i2c_8bit_addr_from_msg(msg);
63 pec = i2c_smbus_pec(pec, &addr, 1);
64
65
66 return i2c_smbus_pec(pec, msg->buf, msg->len);
67}
68
69
70static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
71{
72 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
73 msg->len++;
74}
75
76
77
78
79
80
81static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
82{
83 u8 rpec = msg->buf[--msg->len];
84 cpec = i2c_smbus_msg_pec(cpec, msg);
85
86 if (rpec != cpec) {
87 pr_debug("Bad PEC 0x%02x vs. 0x%02x\n",
88 rpec, cpec);
89 return -EBADMSG;
90 }
91 return 0;
92}
93
94
95
96
97
98
99
100
101s32 i2c_smbus_read_byte(const struct i2c_client *client)
102{
103 union i2c_smbus_data data;
104 int status;
105
106 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
107 I2C_SMBUS_READ, 0,
108 I2C_SMBUS_BYTE, &data);
109 return (status < 0) ? status : data.byte;
110}
111EXPORT_SYMBOL(i2c_smbus_read_byte);
112
113
114
115
116
117
118
119
120
121s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
122{
123 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
124 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
125}
126EXPORT_SYMBOL(i2c_smbus_write_byte);
127
128
129
130
131
132
133
134
135
136s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
137{
138 union i2c_smbus_data data;
139 int status;
140
141 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
142 I2C_SMBUS_READ, command,
143 I2C_SMBUS_BYTE_DATA, &data);
144 return (status < 0) ? status : data.byte;
145}
146EXPORT_SYMBOL(i2c_smbus_read_byte_data);
147
148
149
150
151
152
153
154
155
156
157s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
158 u8 value)
159{
160 union i2c_smbus_data data;
161 data.byte = value;
162 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
163 I2C_SMBUS_WRITE, command,
164 I2C_SMBUS_BYTE_DATA, &data);
165}
166EXPORT_SYMBOL(i2c_smbus_write_byte_data);
167
168
169
170
171
172
173
174
175
176s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
177{
178 union i2c_smbus_data data;
179 int status;
180
181 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
182 I2C_SMBUS_READ, command,
183 I2C_SMBUS_WORD_DATA, &data);
184 return (status < 0) ? status : data.word;
185}
186EXPORT_SYMBOL(i2c_smbus_read_word_data);
187
188
189
190
191
192
193
194
195
196
197s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
198 u16 value)
199{
200 union i2c_smbus_data data;
201 data.word = value;
202 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
203 I2C_SMBUS_WRITE, command,
204 I2C_SMBUS_WORD_DATA, &data);
205}
206EXPORT_SYMBOL(i2c_smbus_write_word_data);
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
224 u8 *values)
225{
226 union i2c_smbus_data data;
227 int status;
228
229 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
230 I2C_SMBUS_READ, command,
231 I2C_SMBUS_BLOCK_DATA, &data);
232 if (status)
233 return status;
234
235 memcpy(values, &data.block[1], data.block[0]);
236 return data.block[0];
237}
238EXPORT_SYMBOL(i2c_smbus_read_block_data);
239
240
241
242
243
244
245
246
247
248
249
250s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
251 u8 length, const u8 *values)
252{
253 union i2c_smbus_data data;
254
255 if (length > I2C_SMBUS_BLOCK_MAX)
256 length = I2C_SMBUS_BLOCK_MAX;
257 data.block[0] = length;
258 memcpy(&data.block[1], values, length);
259 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
260 I2C_SMBUS_WRITE, command,
261 I2C_SMBUS_BLOCK_DATA, &data);
262}
263EXPORT_SYMBOL(i2c_smbus_write_block_data);
264
265
266s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
267 u8 length, u8 *values)
268{
269 union i2c_smbus_data data;
270 int status;
271
272 if (length > I2C_SMBUS_BLOCK_MAX)
273 length = I2C_SMBUS_BLOCK_MAX;
274 data.block[0] = length;
275 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
276 I2C_SMBUS_READ, command,
277 I2C_SMBUS_I2C_BLOCK_DATA, &data);
278 if (status < 0)
279 return status;
280
281 memcpy(values, &data.block[1], data.block[0]);
282 return data.block[0];
283}
284EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
285
286s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
287 u8 length, const u8 *values)
288{
289 union i2c_smbus_data data;
290
291 if (length > I2C_SMBUS_BLOCK_MAX)
292 length = I2C_SMBUS_BLOCK_MAX;
293 data.block[0] = length;
294 memcpy(data.block + 1, values, length);
295 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
296 I2C_SMBUS_WRITE, command,
297 I2C_SMBUS_I2C_BLOCK_DATA, &data);
298}
299EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
300
301static void i2c_smbus_try_get_dmabuf(struct i2c_msg *msg, u8 init_val)
302{
303 bool is_read = msg->flags & I2C_M_RD;
304 unsigned char *dma_buf;
305
306 dma_buf = kzalloc(I2C_SMBUS_BLOCK_MAX + (is_read ? 2 : 3), GFP_KERNEL);
307 if (!dma_buf)
308 return;
309
310 msg->buf = dma_buf;
311 msg->flags |= I2C_M_DMA_SAFE;
312
313 if (init_val)
314 msg->buf[0] = init_val;
315}
316
317
318
319
320
321static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
322 unsigned short flags,
323 char read_write, u8 command, int size,
324 union i2c_smbus_data *data)
325{
326
327
328
329
330
331
332 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
333 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
334 int nmsgs = read_write == I2C_SMBUS_READ ? 2 : 1;
335 u8 partial_pec = 0;
336 int status;
337 struct i2c_msg msg[2] = {
338 {
339 .addr = addr,
340 .flags = flags,
341 .len = 1,
342 .buf = msgbuf0,
343 }, {
344 .addr = addr,
345 .flags = flags | I2C_M_RD,
346 .len = 0,
347 .buf = msgbuf1,
348 },
349 };
350 bool wants_pec = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
351 && size != I2C_SMBUS_I2C_BLOCK_DATA);
352
353 msgbuf0[0] = command;
354 switch (size) {
355 case I2C_SMBUS_QUICK:
356 msg[0].len = 0;
357
358 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
359 I2C_M_RD : 0);
360 nmsgs = 1;
361 break;
362 case I2C_SMBUS_BYTE:
363 if (read_write == I2C_SMBUS_READ) {
364
365 msg[0].flags = I2C_M_RD | flags;
366 nmsgs = 1;
367 }
368 break;
369 case I2C_SMBUS_BYTE_DATA:
370 if (read_write == I2C_SMBUS_READ)
371 msg[1].len = 1;
372 else {
373 msg[0].len = 2;
374 msgbuf0[1] = data->byte;
375 }
376 break;
377 case I2C_SMBUS_WORD_DATA:
378 if (read_write == I2C_SMBUS_READ)
379 msg[1].len = 2;
380 else {
381 msg[0].len = 3;
382 msgbuf0[1] = data->word & 0xff;
383 msgbuf0[2] = data->word >> 8;
384 }
385 break;
386 case I2C_SMBUS_PROC_CALL:
387 nmsgs = 2;
388 read_write = I2C_SMBUS_READ;
389 msg[0].len = 3;
390 msg[1].len = 2;
391 msgbuf0[1] = data->word & 0xff;
392 msgbuf0[2] = data->word >> 8;
393 break;
394 case I2C_SMBUS_BLOCK_DATA:
395 if (read_write == I2C_SMBUS_READ) {
396 msg[1].flags |= I2C_M_RECV_LEN;
397 msg[1].len = 1;
398
399 i2c_smbus_try_get_dmabuf(&msg[1], 0);
400 } else {
401 msg[0].len = data->block[0] + 2;
402 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
403 dev_err(&adapter->dev,
404 "Invalid block write size %d\n",
405 data->block[0]);
406 return -EINVAL;
407 }
408
409 i2c_smbus_try_get_dmabuf(&msg[0], command);
410 memcpy(msg[0].buf + 1, data->block, msg[0].len - 1);
411 }
412 break;
413 case I2C_SMBUS_BLOCK_PROC_CALL:
414 nmsgs = 2;
415 read_write = I2C_SMBUS_READ;
416 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
417 dev_err(&adapter->dev,
418 "Invalid block write size %d\n",
419 data->block[0]);
420 return -EINVAL;
421 }
422
423 msg[0].len = data->block[0] + 2;
424 i2c_smbus_try_get_dmabuf(&msg[0], command);
425 memcpy(msg[0].buf + 1, data->block, msg[0].len - 1);
426
427 msg[1].flags |= I2C_M_RECV_LEN;
428 msg[1].len = 1;
429
430 i2c_smbus_try_get_dmabuf(&msg[1], 0);
431 break;
432 case I2C_SMBUS_I2C_BLOCK_DATA:
433 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
434 dev_err(&adapter->dev, "Invalid block %s size %d\n",
435 read_write == I2C_SMBUS_READ ? "read" : "write",
436 data->block[0]);
437 return -EINVAL;
438 }
439
440 if (read_write == I2C_SMBUS_READ) {
441 msg[1].len = data->block[0];
442 i2c_smbus_try_get_dmabuf(&msg[1], 0);
443 } else {
444 msg[0].len = data->block[0] + 1;
445
446 i2c_smbus_try_get_dmabuf(&msg[0], command);
447 memcpy(msg[0].buf + 1, data->block + 1, data->block[0]);
448 }
449 break;
450 default:
451 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
452 return -EOPNOTSUPP;
453 }
454
455 if (wants_pec) {
456
457 if (!(msg[0].flags & I2C_M_RD)) {
458 if (nmsgs == 1)
459 i2c_smbus_add_pec(&msg[0]);
460 else
461 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
462 }
463
464 if (msg[nmsgs - 1].flags & I2C_M_RD)
465 msg[nmsgs - 1].len++;
466 }
467
468 status = __i2c_transfer(adapter, msg, nmsgs);
469 if (status < 0)
470 goto cleanup;
471 if (status != nmsgs) {
472 status = -EIO;
473 goto cleanup;
474 }
475 status = 0;
476
477
478 if (wants_pec && (msg[nmsgs - 1].flags & I2C_M_RD)) {
479 status = i2c_smbus_check_pec(partial_pec, &msg[nmsgs - 1]);
480 if (status < 0)
481 goto cleanup;
482 }
483
484 if (read_write == I2C_SMBUS_READ)
485 switch (size) {
486 case I2C_SMBUS_BYTE:
487 data->byte = msgbuf0[0];
488 break;
489 case I2C_SMBUS_BYTE_DATA:
490 data->byte = msgbuf1[0];
491 break;
492 case I2C_SMBUS_WORD_DATA:
493 case I2C_SMBUS_PROC_CALL:
494 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
495 break;
496 case I2C_SMBUS_I2C_BLOCK_DATA:
497 memcpy(data->block + 1, msg[1].buf, data->block[0]);
498 break;
499 case I2C_SMBUS_BLOCK_DATA:
500 case I2C_SMBUS_BLOCK_PROC_CALL:
501 if (msg[1].buf[0] > I2C_SMBUS_BLOCK_MAX) {
502 dev_err(&adapter->dev,
503 "Invalid block size returned: %d\n",
504 msg[1].buf[0]);
505 status = -EPROTO;
506 goto cleanup;
507 }
508 memcpy(data->block, msg[1].buf, msg[1].buf[0] + 1);
509 break;
510 }
511
512cleanup:
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
523
524
525
526
527
528
529
530
531
532
533
534s32 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 res = __i2c_lock_bus_helper(adapter);
541 if (res)
542 return res;
543
544 res = __i2c_smbus_xfer(adapter, addr, flags, read_write,
545 command, protocol, data);
546 i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
547
548 return res;
549}
550EXPORT_SYMBOL(i2c_smbus_xfer);
551
552s32 __i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
553 unsigned short flags, char read_write,
554 u8 command, int protocol, union i2c_smbus_data *data)
555{
556 int (*xfer_func)(struct i2c_adapter *adap, u16 addr,
557 unsigned short flags, char read_write,
558 u8 command, int size, union i2c_smbus_data *data);
559 unsigned long orig_jiffies;
560 int try;
561 s32 res;
562
563 res = __i2c_check_suspended(adapter);
564 if (res)
565 return res;
566
567
568
569
570 trace_smbus_write(adapter, addr, flags, read_write,
571 command, protocol, data);
572 trace_smbus_read(adapter, addr, flags, read_write,
573 command, protocol);
574
575 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
576
577 xfer_func = adapter->algo->smbus_xfer;
578 if (i2c_in_atomic_xfer_mode()) {
579 if (adapter->algo->smbus_xfer_atomic)
580 xfer_func = adapter->algo->smbus_xfer_atomic;
581 else if (adapter->algo->master_xfer_atomic)
582 xfer_func = NULL;
583 }
584
585 if (xfer_func) {
586
587 orig_jiffies = jiffies;
588 for (res = 0, try = 0; try <= adapter->retries; try++) {
589 res = xfer_func(adapter, addr, flags, read_write,
590 command, protocol, data);
591 if (res != -EAGAIN)
592 break;
593 if (time_after(jiffies,
594 orig_jiffies + adapter->timeout))
595 break;
596 }
597
598 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
599 goto trace;
600
601
602
603
604 }
605
606 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
607 command, protocol, data);
608
609trace:
610
611 trace_smbus_reply(adapter, addr, flags, read_write,
612 command, protocol, data, res);
613 trace_smbus_result(adapter, addr, flags, read_write,
614 command, protocol, res);
615
616 return res;
617}
618EXPORT_SYMBOL(__i2c_smbus_xfer);
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
640 u8 command, u8 length, u8 *values)
641{
642 u8 i = 0;
643 int status;
644
645 if (length > I2C_SMBUS_BLOCK_MAX)
646 length = I2C_SMBUS_BLOCK_MAX;
647
648 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
649 return i2c_smbus_read_i2c_block_data(client, command, length, values);
650
651 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
652 return -EOPNOTSUPP;
653
654 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
655 while ((i + 2) <= length) {
656 status = i2c_smbus_read_word_data(client, command + i);
657 if (status < 0)
658 return status;
659 values[i] = status & 0xff;
660 values[i + 1] = status >> 8;
661 i += 2;
662 }
663 }
664
665 while (i < length) {
666 status = i2c_smbus_read_byte_data(client, command + i);
667 if (status < 0)
668 return status;
669 values[i] = status;
670 i++;
671 }
672
673 return i;
674}
675EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692struct i2c_client *i2c_new_smbus_alert_device(struct i2c_adapter *adapter,
693 struct i2c_smbus_alert_setup *setup)
694{
695 struct i2c_board_info ara_board_info = {
696 I2C_BOARD_INFO("smbus_alert", 0x0c),
697 .platform_data = setup,
698 };
699
700 return i2c_new_client_device(adapter, &ara_board_info);
701}
702EXPORT_SYMBOL_GPL(i2c_new_smbus_alert_device);
703
704#if IS_ENABLED(CONFIG_I2C_SMBUS) && IS_ENABLED(CONFIG_OF)
705int of_i2c_setup_smbus_alert(struct i2c_adapter *adapter)
706{
707 int irq;
708
709 irq = of_property_match_string(adapter->dev.of_node, "interrupt-names",
710 "smbus_alert");
711 if (irq == -EINVAL || irq == -ENODATA)
712 return 0;
713 else if (irq < 0)
714 return irq;
715
716 return PTR_ERR_OR_ZERO(i2c_new_smbus_alert_device(adapter, NULL));
717}
718EXPORT_SYMBOL_GPL(of_i2c_setup_smbus_alert);
719#endif
720